Add simple json output.

Prints the internal Vec<Diff> as json. We
might want to fix some format in the future, since
the output is currently quite verbose.

Author: Dragyx

src/diff.rs

@@ -33,6 +33,7 @@ use pathfinding::{
   kuhn_munkres,
   matrix::Matrix,
 };
+#[cfg(feature = "json")] use serde::Serialize;
 use size::Size;
 use unicode_width::UnicodeWidthStr as _;
 use yansi::{
@@ -53,7 +54,7 @@ use crate::{
   },
 };
 
-fn create_backend<'a>(
+pub(crate) fn create_backend<'a>(
   force_correctness: bool,
 ) -> store::CombinedStoreBackend<'a> {
   if force_correctness {
@@ -64,6 +65,7 @@ fn create_backend<'a>(
 }
 
 #[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "json", derive(Serialize))]
 pub struct Diff<T = Vec<Version>> {
   pub name:                String,
   pub old:                 T,
@@ -90,13 +92,15 @@ where
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "json", derive(Serialize))]
 pub enum Change {
   UpgradeDowngrade,
   Upgraded,
   Downgraded,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "json", derive(Serialize))]
 pub enum DiffStatus {
   Changed(Change),
   Added,
@@ -146,6 +150,7 @@ impl cmp::Ord for DiffStatus {
 /// Documents if the derivation is a system package and if
 /// it was added / removed as such.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "json", derive(Serialize))]
 pub enum DerivationSelectionStatus {
   /// The derivation is a system package, status unchanged.
   Selected,
@@ -522,7 +527,7 @@ pub fn write_packages_diffln(
 ///
 /// Takes an iterator of store paths and extracts the package names,
 /// filtering out any that cannot be parsed. Logs warnings for parse failures.
-fn collect_system_names(
+pub(crate) fn collect_system_names(
   paths: impl Iterator<Item = StorePath>,
   context: &str,
 ) -> HashSet<String> {
@@ -544,7 +549,7 @@ fn collect_system_names(
 /// Creates a mapping from package names to their versions in old and new paths.
 /// For each package, stores a tuple of (`old_versions`, `new_versions`).
 /// Handles parsing errors by logging warnings and skipping problematic entries.
-fn collect_path_versions(
+pub(crate) fn collect_path_versions(
   old: impl Iterator<Item = StorePath>,
   new: impl Iterator<Item = StorePath>,
 ) -> HashMap<String, (Vec<Version>, Vec<Version>)> {

src/json.rs

@@ -1,11 +1,89 @@
 use std::path::PathBuf;
 
-use anyhow::Result;
+use anyhow::{
+  Context as _,
+  Result,
+};
+use serde::Serialize;
+
+use crate::{
+  diff::{
+    Diff,
+    add_selection_status,
+    collect_path_versions,
+    collect_system_names,
+    create_backend,
+  },
+  generate_diffs_from_paths,
+  store::StoreBackend as _,
+};
 
 pub fn display_diff(
-  old_path: &PathBuf,
-  new_path: &PathBuf,
+  path_old: &PathBuf,
+  path_new: &PathBuf,
   force_correctness: bool,
 ) -> Result<()> {
+  let mut connection = create_backend(force_correctness);
+  connection.connect()?;
+
+  // Query dependencies for old path
+  let paths_old = connection.query_dependents(path_old).with_context(|| {
+    format!("failed to query dependencies of '{}'", path_old.display())
+  })?;
+
+  // Query dependencies for new path
+  let paths_new = connection.query_dependents(path_new).with_context(|| {
+    format!("failed to query dependencies of '{}'", path_new.display())
+  })?;
+
+  // Query system derivations for old path
+  let system_derivations_old = connection
+    .query_system_derivations(path_old)
+    .with_context(|| {
+      format!(
+        "failed to query system derivations of '{}'",
+        path_old.display()
+      )
+    })?;
+
+  // Query system derivations for new path
+  let system_derivations_new = connection
+    .query_system_derivations(path_new)
+    .with_context(|| {
+      format!(
+        "failed to query system derivations of '{}'",
+        path_new.display()
+      )
+    })?;
+
+  let paths_map = collect_path_versions(paths_old, paths_new);
+  let sys_old_set = collect_system_names(system_derivations_old, "old");
+  let sys_new_set = collect_system_names(system_derivations_new, "new");
+
+  let mut diffs = generate_diffs_from_paths(paths_map);
+  add_selection_status(&mut diffs, &sys_old_set, &sys_new_set);
+  let size_old = connection.query_closure_size(path_old)?.bytes();
+  let size_new = connection.query_closure_size(path_new)?.bytes();
+
+  let json = report_to_json(JsonReport {
+    diffs,
+    size_old,
+    size_new,
+  })?;
+  print!("{json}");
   Ok(())
 }
+
+#[derive(Serialize)]
+pub struct JsonReport {
+  /// package changes
+  diffs:    Vec<Diff>,
+  /// old closure size (in bytes)
+  size_old: i64,
+  /// new closure size (in bytes)
+  size_new: i64,
+}
+
+pub fn report_to_json(diffs: JsonReport) -> Result<String> {
+  serde_json::to_string(&diffs).map_err(|e| e.into())
+}

src/version.rs

@@ -10,6 +10,7 @@ use derive_more::{
   Display,
   From,
 };
+#[cfg(feature = "json")] use serde::Serialize;
 
 /// A type representing a version string.
 ///
@@ -21,6 +22,7 @@ pub const VERSION_SEPARATORS: &[char] =
   &['.', '-', '_', '+', '*', '=', '×', ' '];
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "json", derive(Serialize))]
 pub struct Version {
   pub name:   String,
   pub amount: usize,