feat(interactive): show total diff when computing summary

Author: aawsome

src/commands/ls.rs

@@ -1,9 +1,6 @@
 //! `ls` subcommand
 
-use std::{
-    ops::{Add, AddAssign},
-    path::Path,
-};
+use std::{ops::AddAssign, path::Path};
 
 #[cfg(feature = "tui")]
 use crate::commands::tui;
@@ -12,6 +9,7 @@ use crate::{Application, RUSTIC_APP, repository::CliIndexedRepo, status_err};
 use abscissa_core::{Command, Runnable, Shutdown};
 use anyhow::Result;
 
+use derive_more::Add;
 use rustic_core::{
     LsOptions,
     repofile::{Node, NodeType},
@@ -82,7 +80,7 @@ impl Runnable for LsCmd {
 /// Summary of a ls command
 ///
 /// This struct is used to print a summary of the ls command.
-#[derive(Default, Clone, Copy)]
+#[derive(Default, Clone, Copy, Add)]
 pub struct Summary {
     pub files: usize,
     pub size: u64,
@@ -95,17 +93,6 @@ impl AddAssign for Summary {
     }
 }
 
-impl Add for Summary {
-    type Output = Self;
-    fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            files: self.files + rhs.files,
-            size: self.size + rhs.size,
-            dirs: self.dirs + rhs.dirs,
-        }
-    }
-}
-
 impl Summary {
     /// Update the summary with the node
     ///
@@ -121,6 +108,12 @@ impl Summary {
             self.size += node.meta.size;
         }
     }
+
+    pub fn from_node(node: &Node) -> Self {
+        let mut summary = Self::default();
+        summary.update(node);
+        summary
+    }
 }
 
 pub trait NodeLs {

src/commands/tui/diff.rs

@@ -17,12 +17,9 @@ use crate::{
     commands::{
         diff::{DiffStatistics, NodeDiff},
         snapshots::fill_table,
-        tui::{
-            summary::BlobInfoRef,
-            widgets::{
-                Draw, PopUpPrompt, PopUpText, ProcessEvent, PromptResult, SelectTable, WithBlock,
-                popup_prompt, popup_text,
-            },
+        tui::widgets::{
+            Draw, PopUpPrompt, PopUpText, ProcessEvent, PromptResult, SelectTable, WithBlock,
+            popup_prompt, popup_text,
         },
     },
     helpers::bytes_size_to_string,
@@ -51,7 +48,7 @@ Diff Commands:
 
           m : toggle ignoring metadata
           d : toggle show only different entries
-          s : compute information for (sub-)dirs
+          s : compute information for (sub-)dirs and show totals
           I : show information about snapshots
 
 General Commands:
@@ -64,7 +61,7 @@ General Commands:
  ";
 
 #[derive(Clone)]
-struct DiffNode(EitherOrBoth<Node>);
+pub struct DiffNode(pub EitherOrBoth<Node>);
 
 impl DiffNode {
     fn only_subtrees(&self) -> Option<Self> {
@@ -87,6 +84,24 @@ impl DiffNode {
     fn name(&self) -> OsString {
         self.0.as_ref().reduce(|l, _| l).name()
     }
+
+    pub fn map<'a, F, T>(&'a self, f: F) -> EitherOrBoth<T>
+    where
+        F: Fn(&'a Node) -> T,
+    {
+        self.0.as_ref().map_any(&f, &f)
+    }
+
+    pub fn try_map<'a, F, T>(&'a self, f: F) -> Result<EitherOrBoth<T>>
+    where
+        F: Fn(&'a Node) -> Result<T>,
+    {
+        Ok(match self.0.as_ref() {
+            EitherOrBoth::Left(a) => EitherOrBoth::Left(f(a)?),
+            EitherOrBoth::Right(b) => EitherOrBoth::Right(f(b)?),
+            EitherOrBoth::Both(a, b) => EitherOrBoth::Both(f(a)?, f(b)?),
+        })
+    }
 }
 
 #[derive(Default)]
@@ -234,45 +249,37 @@ impl<'a, P: ProgressBars, S: IndexedFull> Diff<'a, P, S> {
     }
 
     fn ls_row(&self, node: &DiffNode, stat: &mut DiffStatistics) -> Vec<Text<'static>> {
-        let node_info = |node: &Node| {
-            let size = node.subtree.map_or(node.meta.size, |id| {
-                self.summary_map
-                    .get(&id)
-                    .map_or(node.meta.size, |summary| summary.summary.size)
-            });
-            (
-                bytes_size_to_string(size),
-                node.meta.mtime.map_or_else(
-                    || "?".to_string(),
-                    |t| format!("{}", t.format("%Y-%m-%d %H:%M:%S")),
-                ),
+        let node_mtime = |node: &Node| {
+            node.meta.mtime.map_or_else(
+                || "?".to_string(),
+                |t| t.format("%Y-%m-%d %H:%M:%S").to_string(),
             )
         };
 
-        let (left, right) = node.0.as_ref().left_and_right();
-        let left_blobs = left.map(|node| BlobInfoRef::from_node_or_map(node, &self.summary_map));
-        let right_blobs = right.map(|node| BlobInfoRef::from_node_or_map(node, &self.summary_map));
-        let left_only = BlobInfoRef::text_diff(&left_blobs, &right_blobs, self.repo);
-        let right_only = BlobInfoRef::text_diff(&right_blobs, &left_blobs, self.repo);
+        let statistics = self
+            .summary_map
+            .compute_diff_statistics(node, self.repo)
+            .unwrap_or_default();
+
+        let (left, right) = statistics.stats.as_ref().left_and_right();
+
+        let left_size = left.map_or_else(String::new, |s| bytes_size_to_string(s.summary.size));
+        let right_size = right.map_or_else(String::new, |s| bytes_size_to_string(s.summary.size));
+        let left_only = left.map_or_else(String::new, |s| bytes_size_to_string(s.sizes.repo_size));
+        let right_only =
+            right.map_or_else(String::new, |s| bytes_size_to_string(s.sizes.repo_size));
 
         let changed = self.node_changed(node);
         stat.apply(changed);
         let name = node.name();
         let name = format!("{changed} {}", name.to_string_lossy());
-        let (left_size, left_mtime) = match &node.0 {
-            EitherOrBoth::Left(node) | EitherOrBoth::Both(node, _) => node_info(node),
-            _ => (String::new(), String::new()),
-        };
-        let (right_size, right_mtime) = match &node.0 {
-            EitherOrBoth::Right(node) | EitherOrBoth::Both(_, node) => node_info(node),
-            _ => (String::new(), String::new()),
-        };
+        let (left_mtime, right_mtime) = node.map(node_mtime).left_and_right();
         [
             name,
-            left_mtime,
+            left_mtime.unwrap_or_default(),
             left_size,
             left_only,
-            right_mtime,
+            right_mtime.unwrap_or_default(),
             right_size,
             right_only,
         ]
@@ -381,7 +388,7 @@ impl<'a, P: ProgressBars, S: IndexedFull> Diff<'a, P, S> {
         Ok(())
     }
 
-    pub fn compute_summary(&mut self) -> Result<()> {
+    pub fn compute_summary(&mut self) -> Result<PopUpTable> {
         let pb = self.repo.progress_bars();
         let p = pb.progress_counter("computing (sub)-dir information");
 
@@ -399,7 +406,72 @@ impl<'a, P: ProgressBars, S: IndexedFull> Diff<'a, P, S> {
 
         p.finish();
         self.update_table();
-        Ok(())
+
+        // Compute total sizes diff
+        let stats = self
+            .summary_map
+            .compute_diff_statistics(&self.node, self.repo)
+            .unwrap_or_default();
+
+        fn row_map<'a, T>(
+            title: &'static str,
+            n: EitherOrBoth<T>,
+            map: fn(T) -> String,
+        ) -> Vec<Text<'a>> {
+            let (left, right) = n.left_and_right();
+            vec![
+                Text::from(title),
+                Text::from(left.map_or_else(String::new, map)),
+                Text::from(right.map_or_else(String::new, map)),
+            ]
+        }
+
+        let row_bytes = |title, n: EitherOrBoth<u64>| row_map(title, n, bytes_size_to_string);
+        let row_count = |title, n: EitherOrBoth<usize>| row_map(title, n, |n| n.to_string());
+
+        let mut rows = Vec::new();
+        let title_left = if self.node.0.has_left() {
+            format!("{}:{}", self.snapshot_left.id, self.path_left.display())
+        } else {
+            format!("({})", self.snapshot_left.id)
+        };
+        let title_right = if self.node.0.has_right() {
+            format!("{}:{}", self.snapshot_right.id, self.path_right.display())
+        } else {
+            format!("({})", self.snapshot_right.id)
+        };
+        rows.push(vec![
+            Text::from(""),
+            Text::from(title_left),
+            Text::from(title_right),
+        ]);
+        rows.push(row_bytes("total Size", stats.summary().size()));
+        rows.push(row_count("total files", stats.summary().files()));
+        rows.push(row_count("total dirs", stats.summary().dirs()));
+        rows.push(vec![Text::from(String::new()); 3]);
+        rows.push(row_bytes(
+            "exclusive size after deduplication",
+            stats.sizes().dedup_size(),
+        ));
+        rows.push(row_bytes(
+            "shared size after deduplication",
+            stats.both_sizes().dedup_size(),
+        ));
+        rows.push(row_bytes(
+            "total size after deduplication",
+            stats.total_sizes().dedup_size(),
+        ));
+        rows.push(vec![Text::from(String::new()); 3]);
+        rows.push(row_bytes("exclusive RepoSize", stats.sizes().repo_size()));
+        rows.push(row_bytes("shared RepoSize", stats.both_sizes().repo_size()));
+        rows.push(row_bytes("total RepoSize", stats.total_sizes().repo_size()));
+        rows.push(row_map(
+            "compression ratio",
+            stats.total_sizes().compression_ratio(),
+            |r| format!("{r:.2}"),
+        ));
+
+        Ok(popup_table("diff total", rows))
     }
 
     pub fn snapshot_details(&self) -> PopUpTable {
@@ -448,7 +520,10 @@ impl<'a, P: ProgressBars, S: IndexedFull> ProcessEvent for Diff<'a, P, S> {
                     }
                     Char('m') => self.toggle_ignore_metadata(),
                     Char('d') => self.toggle_ignore_identical()?,
-                    Char('s') => self.compute_summary()?,
+                    Char('s') => {
+                        self.current_screen =
+                            CurrentScreen::SnapshotDetails(self.compute_summary()?);
+                    }
                     Char('I') => {
                         self.current_screen =
                             CurrentScreen::SnapshotDetails(self.snapshot_details());