refactor

- split corpus modules out into files

Author: Byron

gitoxide-core/src/corpus/mod.rs

@@ -38,100 +38,5 @@ pub(crate) struct Run {
     error: Option<String>,
 }
 
-pub(crate) mod trace {
-    use rusqlite::params;
-    use std::path::Path;
-    use std::sync::atomic::{AtomicU32, Ordering};
-    use std::sync::{Arc, Mutex};
-    use tracing_forest::tree::Tree;
-    use tracing_subscriber::layer::SubscriberExt;
-
-    pub fn override_thread_subscriber(
-        db_path: impl AsRef<Path>,
-    ) -> anyhow::Result<(tracing::subscriber::DefaultGuard, Arc<AtomicU32>)> {
-        let current_id = Arc::new(AtomicU32::default());
-        let processor = tracing_forest::Printer::new().formatter(StoreTreeToDb {
-            con: Arc::new(Mutex::new(rusqlite::Connection::open(&db_path)?)),
-            run_id: current_id.clone(),
-        });
-        let subscriber = tracing_subscriber::Registry::default().with(tracing_forest::ForestLayer::from(processor));
-        let guard = tracing::subscriber::set_default(subscriber);
-        Ok((guard, current_id))
-    }
-
-    pub struct StoreTreeToDb {
-        pub con: Arc<Mutex<rusqlite::Connection>>,
-        pub run_id: Arc<AtomicU32>,
-    }
-    impl tracing_forest::printer::Formatter for StoreTreeToDb {
-        type Error = rusqlite::Error;
-
-        fn fmt(&self, tree: &Tree) -> Result<String, Self::Error> {
-            let json = serde_json::to_string_pretty(&tree).expect("serialization to string always works");
-            let run_id = self.run_id.load(Ordering::SeqCst);
-            self.con
-                .lock()
-                .unwrap()
-                .execute("UPDATE run SET spans_json = ?1 WHERE id = ?2", params![json, run_id])?;
-            Ok(String::new())
-        }
-    }
-}
-
-pub(crate) mod run {
-    use crate::corpus;
-    use crate::corpus::{Run, Task};
-    use std::path::Path;
-    use std::sync::atomic::AtomicBool;
-
-    impl Task {
-        pub fn perform(
-            &self,
-            run: &mut Run,
-            repo: &Path,
-            progress: &mut corpus::Progress,
-            threads: Option<usize>,
-            should_interrupt: &AtomicBool,
-        ) {
-            let start = std::time::Instant::now();
-            if let Err(err) = self.execute.execute(repo, progress, threads, should_interrupt) {
-                run.error = Some(format!("{err:#?}"))
-            }
-            run.duration = start.elapsed();
-        }
-    }
-
-    /// Note that once runs have been recorded, the implementation must not change anymore to keep it comparable.
-    /// If changes have be done, rather change the name of the owning task to start a new kind of task.
-    pub(crate) trait Execute {
-        fn execute(
-            &self,
-            repo: &Path,
-            progress: &mut corpus::Progress,
-            threads: Option<usize>,
-            should_interrupt: &AtomicBool,
-        ) -> anyhow::Result<()>;
-    }
-
-    pub(crate) static ALL: &[Task] = &[Task {
-        short_name: "OPNR",
-        description: "open repository (isolated)",
-        execute_exclusive: false,
-        execute: &OpenRepo,
-    }];
-
-    struct OpenRepo;
-
-    impl Execute for OpenRepo {
-        fn execute(
-            &self,
-            repo: &Path,
-            _progress: &mut corpus::Progress,
-            _threads: Option<usize>,
-            _should_interrupt: &AtomicBool,
-        ) -> anyhow::Result<()> {
-            gix::open_opts(repo, gix::open::Options::isolated())?;
-            Ok(())
-        }
-    }
-}
+pub(crate) mod run;
+pub(crate) mod trace;

gitoxide-core/src/corpus/run.rs

@@ -0,0 +1,55 @@
+use crate::corpus;
+use crate::corpus::{Run, Task};
+use std::path::Path;
+use std::sync::atomic::AtomicBool;
+
+impl Task {
+    pub fn perform(
+        &self,
+        run: &mut Run,
+        repo: &Path,
+        progress: &mut corpus::Progress,
+        threads: Option<usize>,
+        should_interrupt: &AtomicBool,
+    ) {
+        let start = std::time::Instant::now();
+        if let Err(err) = self.execute.execute(repo, progress, threads, should_interrupt) {
+            run.error = Some(format!("{err:#?}"))
+        }
+        run.duration = start.elapsed();
+    }
+}
+
+/// Note that once runs have been recorded, the implementation must not change anymore to keep it comparable.
+/// If changes have be done, rather change the name of the owning task to start a new kind of task.
+pub(crate) trait Execute {
+    fn execute(
+        &self,
+        repo: &Path,
+        progress: &mut corpus::Progress,
+        threads: Option<usize>,
+        should_interrupt: &AtomicBool,
+    ) -> anyhow::Result<()>;
+}
+
+pub(crate) static ALL: &[Task] = &[Task {
+    short_name: "OPNR",
+    description: "open repository (isolated)",
+    execute_exclusive: false,
+    execute: &OpenRepo,
+}];
+
+struct OpenRepo;
+
+impl Execute for OpenRepo {
+    fn execute(
+        &self,
+        repo: &Path,
+        _progress: &mut corpus::Progress,
+        _threads: Option<usize>,
+        _should_interrupt: &AtomicBool,
+    ) -> anyhow::Result<()> {
+        gix::open_opts(repo, gix::open::Options::isolated())?;
+        Ok(())
+    }
+}

gitoxide-core/src/corpus/trace.rs

@@ -0,0 +1,38 @@
+use rusqlite::params;
+use std::path::Path;
+use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::{Arc, Mutex};
+use tracing_forest::tree::Tree;
+use tracing_subscriber::layer::SubscriberExt;
+
+pub fn override_thread_subscriber(
+    db_path: impl AsRef<Path>,
+) -> anyhow::Result<(tracing::subscriber::DefaultGuard, Arc<AtomicU32>)> {
+    let current_id = Arc::new(AtomicU32::default());
+    let processor = tracing_forest::Printer::new().formatter(StoreTreeToDb {
+        con: Arc::new(Mutex::new(rusqlite::Connection::open(&db_path)?)),
+        run_id: current_id.clone(),
+    });
+    let subscriber = tracing_subscriber::Registry::default().with(tracing_forest::ForestLayer::from(processor));
+    let guard = tracing::subscriber::set_default(subscriber);
+    Ok((guard, current_id))
+}
+
+pub struct StoreTreeToDb {
+    pub con: Arc<Mutex<rusqlite::Connection>>,
+    pub run_id: Arc<AtomicU32>,
+}
+
+impl tracing_forest::printer::Formatter for StoreTreeToDb {
+    type Error = rusqlite::Error;
+
+    fn fmt(&self, tree: &Tree) -> Result<String, Self::Error> {
+        let json = serde_json::to_string_pretty(&tree).expect("serialization to string always works");
+        let run_id = self.run_id.load(Ordering::SeqCst);
+        self.con
+            .lock()
+            .unwrap()
+            .execute("UPDATE run SET spans_json = ?1 WHERE id = ?2", params![json, run_id])?;
+        Ok(String::new())
+    }
+}