feat(interactive): show total diff when computing summary

Author: aawsome

src/commands/tui/diff.rs

@@ -51,7 +51,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:
@@ -233,48 +233,61 @@ impl<'a, P: ProgressBars, S: IndexedFull> Diff<'a, P, S> {
         !self.ignore_identical || !self.node_changed(node).is_identical()
     }
 
-    fn ls_row(&self, node: &DiffNode, stat: &mut DiffStatistics) -> Vec<Text<'static>> {
+    #[allow(clippy::type_complexity)]
+    fn sizes(
+        &self,
+        node: &DiffNode,
+    ) -> (
+        Option<u64>,
+        Option<u64>,
+        Option<u64>,
+        Option<u64>,
+        Option<u64>,
+    ) {
         let node_info = |node: &Node| {
-            let size = node.subtree.map_or(node.meta.size, |id| {
+            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 (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 (left_only, right_only, both) =
+            BlobInfoRef::size_diff(&left_blobs, &right_blobs, self.repo).unwrap_or_default();
 
+        let left_size = left.map(node_info);
+        let right_size = right.map(node_info);
+
+        (left_size, left_only, right_size, right_only, both)
+    }
+
+    fn ls_row(&self, node: &DiffNode, stat: &mut DiffStatistics) -> Vec<Text<'static>> {
+        let node_mtime = |node: &Node| {
+            node.meta.mtime.map_or_else(
+                || "?".to_string(),
+                |t| format!("{}", t.format("%Y-%m-%d %H:%M:%S")),
+            )
+        };
+
+        let (left_size, left_only, right_size, right_only, _) = self.sizes(node);
         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, right) = node.0.as_ref().left_and_right();
+        let left_mtime = left.map_or_else(String::new, node_mtime);
+        let right_mtime = right.map_or_else(String::new, node_mtime);
         [
             name,
             left_mtime,
-            left_size,
-            left_only,
+            left_size.map_or_else(String::new, bytes_size_to_string),
+            left_only.map_or_else(String::new, bytes_size_to_string),
             right_mtime,
-            right_size,
-            right_only,
+            right_size.map_or_else(String::new, bytes_size_to_string),
+            right_only.map_or_else(String::new, bytes_size_to_string),
         ]
         .into_iter()
         .map(Text::from)
@@ -381,7 +394,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 +412,58 @@ impl<'a, P: ProgressBars, S: IndexedFull> Diff<'a, P, S> {
 
         p.finish();
         self.update_table();
-        Ok(())
+
+        // Compute total sizes diff
+        let (left_size, left_only, right_size, right_only, both) = self.sizes(&self.node);
+        let left_repo_size = if let (Some(only), Some(both)) = (left_only, both) {
+            Some(only + both)
+        } else {
+            None
+        };
+        let right_repo_size = if let (Some(only), Some(both)) = (right_only, both) {
+            Some(only + both)
+        } else {
+            None
+        };
+        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_right),
+            Text::from(title_left),
+        ]);
+        rows.push(vec![
+            Text::from("total Size"),
+            Text::from(left_size.map_or_else(String::new, bytes_size_to_string)),
+            Text::from(right_size.map_or_else(String::new, bytes_size_to_string)),
+        ]);
+        rows.push(vec![
+            Text::from("total RepoSize"),
+            Text::from(left_repo_size.map_or_else(String::new, bytes_size_to_string)),
+            Text::from(right_repo_size.map_or_else(String::new, bytes_size_to_string)),
+        ]);
+        rows.push(vec![
+            Text::from("exclusive RepoSize"),
+            Text::from(left_only.map_or_else(String::new, bytes_size_to_string)),
+            Text::from(right_only.map_or_else(String::new, bytes_size_to_string)),
+        ]);
+        let both = both.map_or_else(String::new, bytes_size_to_string);
+        rows.push(vec![
+            Text::from("shared RepoSize"),
+            Text::from(both.clone()),
+            Text::from(both),
+        ]);
+
+        Ok(popup_table("diff total", rows))
     }
 
     pub fn snapshot_details(&self) -> PopUpTable {
@@ -448,7 +512,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());

src/commands/tui/summary.rs

@@ -6,7 +6,7 @@ use rustic_core::{
     repofile::{Metadata, Node, Tree},
 };
 
-use crate::{commands::ls::Summary, helpers::bytes_size_to_string};
+use crate::commands::ls::Summary;
 
 #[derive(Default)]
 pub struct SummaryMap(BTreeMap<TreeId, TreeSummary>);
@@ -121,23 +121,37 @@ impl<'a> BlobInfoRef<'a> {
         Self(node.content.iter().flatten().collect())
     }
 
-    pub fn text_diff<P, S: IndexedFull>(
+    pub fn size_diff<P, S: IndexedFull>(
         blobs1: &Option<Self>,
         blobs2: &Option<Self>,
         repo: &'a Repository<P, S>,
-    ) -> String {
+    ) -> Result<(Option<u64>, Option<u64>, Option<u64>)> {
         if let (Some(blobs1), Some(blobs2)) = (blobs1, blobs2) {
-            blobs1
+            let left_only = blobs1
                 .0
                 .difference(&blobs2.0)
                 .map(|id| repo.get_index_entry(*id))
                 .try_fold(0u64, |sum, b| -> Result<_> {
                     Ok(sum + u64::from(b?.length))
-                })
-                .ok()
-                .map_or_else(|| "?".to_string(), bytes_size_to_string)
+                })?;
+
+            let right_only = blobs2
+                .0
+                .difference(&blobs1.0)
+                .map(|id| repo.get_index_entry(*id))
+                .try_fold(0u64, |sum, b| -> Result<_> {
+                    Ok(sum + u64::from(b?.length))
+                })?;
+            let both = blobs2
+                .0
+                .intersection(&blobs1.0)
+                .map(|id| repo.get_index_entry(*id))
+                .try_fold(0u64, |sum, b| -> Result<_> {
+                    Ok(sum + u64::from(b?.length))
+                })?;
+            Ok((Some(left_only), Some(right_only), Some(both)))
         } else {
-            String::new()
+            Ok(Default::default())
         }
     }
 }