Add force-correctness flag.

This flag is added in preparation for a later
inclusion of machine-readable output. It allows
the user to specify that the output should
prioritize correctness at all costs.


This rules out the use of immutable database
connections or lazy queries. The former have no
correctness guarantees and lazy queries could
(theoretically) raise an error for a later row e.g.
because the path returned from the store is not
a valid `StorePath`.

Author: Dragyx

src/diff.rs

@@ -53,6 +53,16 @@ use crate::{
   },
 };
 
+fn create_backend<'a>(
+  force_correctness: bool,
+) -> store::CombinedStoreBackend<'a> {
+  if force_correctness {
+    store::CombinedStoreBackend::default_eager()
+  } else {
+    store::CombinedStoreBackend::default_lazy()
+  }
+}
+
 #[derive(Debug, Eq, PartialEq)]
 pub struct Diff<T = Vec<Version>> {
   pub name:                String,
@@ -190,6 +200,7 @@ pub fn write_package_diff(
   writer: &mut impl fmt::Write,
   path_old: &Path,
   path_new: &Path,
+  force_correctness: bool,
 ) -> Result<usize> {
   let mut connection = create_backend(force_correctness);
   connection.connect()?;
@@ -252,7 +263,8 @@ pub fn write_paths_diffln(
   path_old: &Path,
   path_new: &Path,
 ) -> Result<usize> {
-  write_package_diff(writer, path_old, path_new)
+  // Setting `force_correctness` to false mimics the old behaviour.
+  write_package_diff(writer, path_old, path_new, false)
 }
 
 /// Computes the Levenshtein distance between two slices using dynamic
@@ -939,6 +951,7 @@ fn fmt_version_piece_pair(
 pub fn spawn_size_diff(
   path_old: PathBuf,
   path_new: PathBuf,
+  force_correctness: bool,
 ) -> thread::JoinHandle<Result<(Size, Size)>> {
   log::debug!("calculating closure sizes in background");
 

src/main.rs

@@ -46,6 +46,17 @@ struct Cli {
       global = true,
   )]
   color: clap::ColorChoice,
+
+  /// Fall back to a backend that is focused solely on absolutely guaranteeing
+  /// correct results at the cost of memory usage and query speed.
+  ///
+  /// This is relevant if the output of dix is to be used for more
+  /// critical applications and not just as human-readable overview.
+  ///
+  /// In the vast, vast majority of cases, the default backend should be
+  /// sufficient.
+  #[arg(long, default_value_t = false, global = true)]
+  force_correctness: bool,
 }
 
 fn real_main() -> Result<()> {
@@ -54,6 +65,7 @@ fn real_main() -> Result<()> {
     new_path,
     verbose,
     color,
+    force_correctness,
   } = Cli::parse();
 
   yansi::whenever(match color {
@@ -76,6 +88,12 @@ fn real_main() -> Result<()> {
       writeln!(out, "{header} {message}", message = arguments.args())
     })
     .init();
+  if force_correctness {
+    log::warn!(
+      "Falling back to slower but more robust backends (force_correctness is \
+       set)."
+    );
+  }
 
   let mut out = WriteFmt(io::stdout());
 
@@ -96,9 +114,10 @@ fn real_main() -> Result<()> {
 
   // Handle to the thread collecting closure size information.
   let closure_size_handle =
-    dix::spawn_size_diff(old_path.clone(), new_path.clone());
+    dix::spawn_size_diff(old_path.clone(), new_path.clone(), force_correctness);
 
-  let wrote = dix::write_package_diff(&mut out, &old_path, &new_path)?;
+  let wrote =
+    dix::write_package_diff(&mut out, &old_path, &new_path, force_correctness)?;
 
   let (size_old, size_new) = closure_size_handle.join().map_err(|_| {
     anyhow!(