feat(json)!: add optional shared-inodes

Author: KSXGitHub

src/app.rs

@@ -86,8 +86,8 @@ impl App {
             }
 
             let visualization = match unit_and_tree {
-                UnitAndTree::Bytes(reflection) => visualize!(reflection, bytes_format),
-                UnitAndTree::Blocks(reflection) => visualize!(reflection, ()),
+                UnitAndTree::Bytes(tree) => visualize!(tree.data, bytes_format),
+                UnitAndTree::Blocks(tree) => visualize!(tree.data, ()),
             };
 
             print!("{visualization}"); // it already ends with "\n", println! isn't needed here.

src/app/sub.rs

@@ -1,10 +1,10 @@
 use crate::{
     args::Fraction,
-    data_tree::{DataTree, DataTreeReflection},
+    data_tree::DataTree,
     fs_tree_builder::FsTreeBuilder,
     get_size::GetSize,
     hook,
-    json_data::{BinaryVersion, JsonData, SchemaVersion, UnitAndTree},
+    json_data::{BinaryVersion, JsonData, JsonTree, SchemaVersion, UnitAndTree},
     os_string_display::OsStringDisplay,
     reporter::ParallelReporter,
     runtime_error::RuntimeError,
@@ -22,7 +22,7 @@ where
     Size: size::Size + Into<u64> + Serialize + Send + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
     Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
-    DataTreeReflection<String, Size>: Into<UnitAndTree>,
+    JsonTree<Size>: Into<UnitAndTree>,
 {
     /// List of files and/or directories.
     pub files: Vec<PathBuf>,
@@ -58,7 +58,7 @@ where
     Report: ParallelReporter<Size> + Sync,
     SizeGetter: GetSize<Size = Size> + Copy + Sync,
     Hook: hook::Hook<Size, Report> + DeduplicateHardlinkSizes<Size> + Copy + Sync,
-    DataTreeReflection<String, Size>: Into<UnitAndTree>,
+    JsonTree<Size>: Into<UnitAndTree>,
 {
     /// Run the sub program.
     pub fn run(self) -> Result<(), RuntimeError> {
@@ -140,15 +140,18 @@ where
         GLOBAL_STATUS_BOARD.clear_line(0);
 
         if json_output {
-            let unit_and_tree: UnitAndTree = data_tree
+            let data = data_tree
                 .into_reflection() // I really want to use std::mem::transmute here but can't.
                 .par_convert_names_to_utf8() // TODO: allow non-UTF8 somehow.
-                .expect("convert all names from raw string to UTF-8")
-                .into();
+                .expect("convert all names from raw string to UTF-8");
+            let json_tree = JsonTree {
+                data,
+                shared_inodes: None, // TODO: somehow get data from `deduplication_record` above
+            };
             let json_data = JsonData {
                 schema_version: SchemaVersion,
                 binary_version: Some(BinaryVersion::current()),
-                unit_and_tree,
+                unit_and_tree: json_tree.into(),
             };
             return serde_json::to_writer(stdout(), &json_data)
                 .map_err(RuntimeError::SerializationFailure);

src/json_data.rs

@@ -5,24 +5,40 @@ pub use binary_version::BinaryVersion;
 pub use schema_version::SchemaVersion;
 
 use crate::{
-    data_tree::Reflection,
-    size::{Blocks, Bytes},
+    data_tree,
+    hardlink::hardlink_list,
+    size::{self, Blocks, Bytes},
 };
-use derive_more::{From, TryInto};
+use derive_more::{Deref, DerefMut, From, TryInto};
 
 #[cfg(feature = "json")]
 use serde::{Deserialize, Serialize};
 
+/// The `"tree"` field of [`JsonData`].
+#[derive(Debug, Clone, Deref, DerefMut)]
+#[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
+#[cfg_attr(feature = "json", serde(rename_all = "kebab-case"))]
+pub struct JsonTree<Size: size::Size> {
+    /// The main data of the tree.
+    #[deref]
+    #[deref_mut]
+    #[cfg_attr(feature = "json", serde(flatten))]
+    pub data: data_tree::Reflection<String, Size>,
+    /// Optional list of shared inodes, their sizes, and their many links.
+    #[cfg_attr(feature = "json", serde(skip_serializing_if = "Option::is_none"))]
+    pub shared_inodes: Option<hardlink_list::Reflection<Size>>,
+}
+
 /// The `"unit"` field and the `"tree"` field of [`JsonData`].
 #[derive(Debug, Clone, From, TryInto)]
 #[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
 #[cfg_attr(feature = "json", serde(tag = "unit", content = "tree"))]
 #[cfg_attr(feature = "json", serde(rename_all = "kebab-case"))]
 pub enum UnitAndTree {
     /// Tree where size is [bytes](Bytes).
-    Bytes(Reflection<String, Bytes>),
+    Bytes(JsonTree<Bytes>),
     /// Tree where size is [blocks](Blocks).
-    Blocks(Reflection<String, Blocks>),
+    Blocks(JsonTree<Blocks>),
 }
 
 /// Output of the program with `--json-output` flag as well as

tests/json.rs

@@ -7,11 +7,11 @@ pub use _utils::*;
 use command_extra::CommandExtra;
 use parallel_disk_usage::{
     bytes_format::BytesFormat,
-    data_tree::{DataTree, Reflection},
+    data_tree::DataTree,
     fs_tree_builder::FsTreeBuilder,
     get_size::GetApparentSize,
     hook,
-    json_data::{JsonData, SchemaVersion},
+    json_data::{JsonData, JsonTree, SchemaVersion},
     reporter::{ErrorOnlyReporter, ErrorReport},
     size::Bytes,
     visualizer::{BarAlignment, ColumnWidthDistribution, Direction, Visualizer},
@@ -26,7 +26,7 @@ use std::{
 
 type SampleName = String;
 type SampleData = Bytes;
-type SampleReflection = Reflection<SampleName, SampleData>;
+type SampleJsonTree = JsonTree<SampleData>;
 type SampleTree = DataTree<SampleName, SampleData>;
 
 fn sample_tree() -> SampleTree {
@@ -75,8 +75,9 @@ fn json_output() {
         .pipe_as_ref(serde_json::from_str::<JsonData>)
         .expect("parse stdout as JsonData")
         .unit_and_tree
-        .pipe(TryInto::<SampleReflection>::try_into)
+        .pipe(TryInto::<SampleJsonTree>::try_into)
         .expect("extract reflection")
+        .data
         .pipe(sanitize_tree_reflection);
     dbg!(&actual);
     let builder = FsTreeBuilder {
@@ -98,10 +99,14 @@ fn json_output() {
 
 #[test]
 fn json_input() {
+    let json_tree = JsonTree {
+        data: sample_tree().into_reflection(),
+        shared_inodes: None,
+    };
     let json_data = JsonData {
         schema_version: SchemaVersion,
         binary_version: None,
-        unit_and_tree: sample_tree().into_reflection().into(),
+        unit_and_tree: json_tree.into(),
     };
     let json = serde_json::to_string_pretty(&json_data).expect("convert sample tree to JSON");
     eprintln!("JSON: {json}\n");