Fix tests and add a bunch of tracing

Author: LiptonB

Cargo.lock

@@ -19,6 +19,7 @@ nom = "5.1.2"
 thiserror = "1.0.30"
 tracing = "0.1.30"
 tracing-subscriber = { version = "0.3.8", features = ["env-filter"] }
+derivative = "2.2.0"
 
 [features]
 

Cargo.toml

@@ -12,14 +12,18 @@ use std::path::{Path, PathBuf};
 use anyhow::{anyhow, bail, Result};
 use cookie_factory as cf;
 use crypto::sha1::Sha1;
+use derivative::Derivative;
 
 use self::checksum::*;
 use crate::lockfile::*;
 use crate::workspace::*;
 
+#[derive(Derivative)]
+#[derivative(Debug)]
 pub struct Index {
     entries: BTreeMap<PathBuf, Entry>,
     parents: HashMap<PathBuf, HashSet<PathBuf>>,
+    #[derivative(Debug = "ignore")]
     file: Option<ChecksummedFile<Lockfile, Sha1>>,
     changed: bool,
 }
@@ -103,6 +107,7 @@ impl Index {
         Ok(index)
     }
 
+    #[tracing::instrument]
     pub fn add(&mut self, file: &WorkspacePath, oid: &str) -> Result<()> {
         let metadata = file.stat()?;
         let entry = Entry::new(file, oid, &metadata);
@@ -113,18 +118,53 @@ impl Index {
         Ok(())
     }
 
+    #[tracing::instrument]
     fn store_entry(&mut self, entry_path: &Path, entry: Entry) {
         for path in entry_path.ancestors() {
             let paths_for_parent = self.parents.entry(path.to_owned()).or_default();
             paths_for_parent.insert(entry_path.to_owned());
         }
         self.entries.insert(entry_path.to_owned(), entry);
+        tracing::debug!(?entry_path, entries = ?self.entries, parents = ?self.parents, "entry stored");
     }
 
+    #[tracing::instrument]
+    fn remove_entry(&mut self, entry_path: &Path) {
+        if self.entries.remove(entry_path).is_some() {
+            for parent in entry_path.ancestors() {
+                if let Some(paths_for_parent) = self.parents.get_mut(parent) {
+                    paths_for_parent.remove(entry_path);
+                    if paths_for_parent.is_empty() {
+                        self.parents.remove(parent);
+                    }
+                }
+            }
+            tracing::debug!(
+                ?entry_path,
+                entries = ?self.entries,
+                parents = ?self.parents,
+                "entry removed and parents updated"
+            );
+        }
+    }
+
+    #[tracing::instrument]
+    fn remove_children(&mut self, entry_path: &Path) {
+        if let Some(children) = self.parents.get(entry_path) {
+            let children = children.clone();
+            for child in children {
+                self.remove_entry(&child);
+            }
+            tracing::debug!(?entry_path, entries = ?self.entries, "children removed");
+        }
+    }
+
+    #[tracing::instrument]
     fn discard_conflicts(&mut self, path: &Path) {
         for parent in path.ancestors() {
-            self.entries.remove(parent);
+            self.remove_entry(parent);
         }
+        self.remove_children(path);
     }
 
     fn serialize_entries<'a, W: Write + 'a>(
@@ -533,7 +573,7 @@ mod tests {
 
         // Assert
         let index_paths = index.iter().map(|entry| &entry.path).collect::<Vec<_>>();
-        assert_eq!(index_paths, ["alice.txt/nested.txt", "bob.txt"]);
+        assert_eq!(index_paths, ["alice.txt", "nested"]);
     }
 
     #[test]
@@ -582,6 +622,6 @@ mod tests {
 
         // Assert
         let index_paths = index.iter().map(|entry| &entry.path).collect::<Vec<_>>();
-        assert_eq!(index_paths, ["alice.txt/nested.txt", "bob.txt"]);
+        assert_eq!(index_paths, ["alice.txt", "nested"]);
     }
 }

src/index.rs

@@ -3,9 +3,13 @@ use std::iter;
 
 use anyhow::{Context, Error};
 use crypto::digest::Digest;
+use derivative::Derivative;
 
+#[derive(Derivative)]
+#[derivative(Debug)]
 pub struct ChecksummedFile<I, D: Digest> {
     inner: I,
+    #[derivative(Debug = "ignore")]
     hasher: D,
 }
 

src/index/checksum.rs

@@ -5,6 +5,7 @@ use std::path::PathBuf;
 
 use anyhow::{bail, Result};
 
+#[derive(Debug)]
 pub struct Lockfile {
     path: PathBuf,
     lock_path: PathBuf,
@@ -53,9 +54,7 @@ impl Write for Lockfile {
 
 impl Drop for Lockfile {
     fn drop(&mut self) {
-        fs::remove_file(&self.lock_path).unwrap_or_else(|_| panic!(
-            "Failed to remove lock file: {}",
-            self.lock_path.display()
-        ));
+        fs::remove_file(&self.lock_path)
+            .unwrap_or_else(|_| panic!("Failed to remove lock file: {}", self.lock_path.display()));
     }
 }

src/lockfile.rs

@@ -2,6 +2,7 @@ mod database;
 mod index;
 mod lockfile;
 mod refs;
+mod telemetry;
 mod workspace;
 
 use std::env;
@@ -120,10 +121,7 @@ fn add(paths: Vec<PathBuf>) -> Result<()> {
 }
 
 fn main() -> Result<()> {
-    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
-    }
-    tracing_subscriber::fmt::init();
+    telemetry::init();
 
     let opt = Opt::from_args();
     match opt {

src/main.rs

@@ -0,0 +1,12 @@
+use tracing_subscriber::fmt::format;
+use tracing_subscriber::EnvFilter;
+
+pub fn init() {
+    if std::env::var("RUST_LOG").is_err() {
+        std::env::set_var("RUST_LOG", "info");
+    }
+    tracing_subscriber::fmt::fmt()
+        .event_format(format().pretty())
+        .with_env_filter(EnvFilter::from_default_env())
+        .init();
+}