refactor: split out lib from cli

Author: ckoehler

Cargo.lock

@@ -1,43 +1,37 @@
-[package]
-name = "buddy-up"
+[workspace]
+members = ["crates/cli", "crates/lib"]
+resolver = "3"
+
+[workspace.package]
 version = "0.1.2"
 authors = ["Christoph Koehler <christoph@zerodeviation.net>"]
-description = "Buddy up a changing group of people into unique pairs over time."
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/ckoehler/buddy-up"
 readme = "README.md"
-publish = true
-
 
-[dependencies]
-anyhow = "1.0.96"
-chrono = "0.4.40"
-clap = { version = "4.5.31", features = ["derive"] }
-comfy-table = "7.1.4"
-csv = "1.3.1"
-genetic_algorithm = "0.18.1"
-glob = "0.3.2"
-serde = { version = "1.0.218", features = ["derive"] }
-serde_json = "1.0.139"
+[workspace.dependencies]
+buddy-up-lib = { version = "0.1.2", path = "crates/lib"}
 tracing = { version = "0.1.41", features = ["log"] }
 tracing-subscriber = { version = "0.3.19", features = ["env-filter", "ansi"] }
 tracing-error = "0.2.1"
 
-[[bin]]
-name = "buddy"
-path = "src/main.rs"
-
-
 [workspace.lints.clippy]
-pedantic = { level = "deny", priority = -1 }
+# pedantic = { level = "deny", priority = -1 }
 cast_precision_loss = "allow"
 similar_names = "allow"
 
-[lints]
-workspace = true
-
 # The profile that 'cargo dist' will build with
 [profile.dist]
 inherits = "release"
 lto = "thin"
+
+[profile.wasm-dev]
+inherits = "dev"
+opt-level = 1
+
+[profile.server-dev]
+inherits = "dev"
+
+[profile.android-dev]
+inherits = "dev"

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "buddy-up"
+description = "Buddy up a changing group of people into unique pairs over time."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = true
+
+
+[dependencies]
+anyhow = "1.0.96"
+clap = { version = "4.5.31", features = ["derive"] }
+glob = "0.3.2"
+serde = { version = "1.0.218", features = ["derive"] }
+serde_json = "1.0.139"
+buddy-up-lib.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+tracing-error.workspace = true
+
+[[bin]]
+name = "buddy"
+path = "src/main.rs"
+
+[lints]
+workspace = true

crates/cli/Cargo.toml

@@ -1,14 +1,9 @@
-mod algorithm;
-mod input;
-mod output;
-
-use algorithm::History;
-use algorithm::Person;
-use algorithm::merge;
 use anyhow::Context;
 use anyhow::Result;
+use buddy_up_lib::History;
+use buddy_up_lib::Person;
+use buddy_up_lib::{json_history, print_table, process};
 use clap::{Parser, Subcommand};
-use glob::glob;
 use std::path::Path;
 use std::path::PathBuf;
 use tracing::{debug, info};
@@ -62,26 +57,17 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn pair(input: &Path, output_dir: &Path) -> Result<()> {
-    let output_dir = output_dir.to_string_lossy();
+fn pair(input: &Path, history_dir: &Path) -> Result<()> {
+    let output_dir = history_dir.to_string_lossy();
 
-    let people = input::process(input)?;
+    let people = process(input)?;
 
     // generate history from pair files
-    let mut history = History::new();
-    // read pairs from dir of files
-    let pattern = format!("{output_dir}/*.json");
-    let mut tr_history_files = 0;
-    for path in glob(&pattern).expect("Glob pattern works") {
-        debug!("Reading history file {path:?}");
-        let pairs = std::fs::read_to_string(path?)?;
-        let pairs: Vec<(Person, Person)> = serde_json::from_str(&pairs)?;
-        let pairs = pairs.iter().map(|p| (p.0.id, p.1.id)).collect();
-        tr_history_files += 1;
-        merge(&mut history, &pairs);
-    }
-    let tr_num_pairs = history.len();
+    let history = History::from_dir(&output_dir)?;
+
+    let tr_num_pairs = history.stats().pairs;
     let tr_max_num_pairs = (people.len().pow(2) - people.len()) / 2;
+    let tr_history_files = history.stats().files_read;
     info!(
         "Read {tr_history_files} history files, found {tr_num_pairs} existing pairs (max possible: {tr_max_num_pairs})."
     );
@@ -91,7 +77,7 @@ fn pair(input: &Path, output_dir: &Path) -> Result<()> {
     // the algorithm only operates on ids, so get those only. We can map them back to names for
     // output later.
     let people_ids = people.keys().copied().collect();
-    let pairs = algorithm::pair(people_ids, &history);
+    let pairs = buddy_up_lib::pair(people_ids, &history);
 
     // put names back into the pairs for saving
     let pairs: Vec<(Person, Person)> = pairs
@@ -106,10 +92,10 @@ fn pair(input: &Path, output_dir: &Path) -> Result<()> {
 
     // serialize to json and save
     // TODO: that type gymnastic tho
-    output::json_history(&pairs, output_dir.into_owned().into()).context("Saving history")?;
+    json_history(&pairs, output_dir.into_owned().into()).context("Saving history")?;
 
     // now print the pairs
-    output::print_table(&pairs);
+    print_table(&pairs);
     Ok(())
 }
 

src/main.rs crates/cli/src/main.rssrc/main.rs renamed to crates/cli/src/main.rs

@@ -0,0 +1,25 @@
+[package]
+name = "buddy-up-lib"
+description = "The brains behind the buddy-up crate."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+publish = true
+
+[dependencies]
+anyhow = "1.0.96"
+chrono = "0.4.40"
+comfy-table = "7.1.4"
+csv = "1.3.1"
+genetic_algorithm = "0.18.1"
+glob = "0.3.2"
+serde = { version = "1.0.218", features = ["derive"] }
+serde_json = "1.0.139"
+tracing = { version = "0.1.41", features = ["log"] }
+tracing-subscriber = { version = "0.3.19", features = ["env-filter", "ansi"] }
+tracing-error = "0.2.1"
+
+[lints]
+workspace = true

crates/lib/Cargo.toml

@@ -1,60 +1,98 @@
+use crate::Person;
+use anyhow::Result;
+use glob::glob;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
+use tracing::debug;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct History(HashMap<(usize, usize), usize>);
+pub struct History {
+    map: HashMap<(usize, usize), usize>,
+    #[serde(skip)]
+    stats: HistoryStats,
+}
+
+impl Default for History {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
 impl History {
+    pub fn from_dir(dir: &str) -> Result<Self> {
+        let mut history = Self::new();
+
+        // read pairs from dir of files
+        let pattern = format!("{dir}/*.json");
+        for path in glob(&pattern).expect("Glob pattern works") {
+            debug!("Reading history file {path:?}");
+            let pairs = std::fs::read_to_string(path?)?;
+            let pairs: Vec<(Person, Person)> = serde_json::from_str(&pairs)?;
+            let pairs = pairs.iter().map(|p| (p.0.id, p.1.id)).collect();
+            history.stats.files_read += 1;
+            merge(&mut history, &pairs);
+        }
+        history.stats.pairs = history.len();
+        Ok(history)
+    }
+
     #[allow(dead_code)]
     fn max_iteration(&self) -> usize {
-        *self.0.values().max().unwrap_or(&0)
+        *self.map.values().max().unwrap_or(&0)
     }
 
-    pub fn new() -> Self {
+    fn new() -> Self {
         let scores = HashMap::new();
-        Self(scores)
+        Self {
+            map: scores,
+            stats: HistoryStats::default(),
+        }
+    }
+
+    pub fn stats(&self) -> HistoryStats {
+        self.stats
     }
 
     fn insert(&mut self, pair: (usize, usize), iteration: usize) {
         // if the first variation of the pair exists, insert it there; if not
         // it doesn't really matter if the other one exists, just insert it as the other.
         // Whether that one exists or not, it'll insert there.
-        if self.0.contains_key(&pair) {
-            self.0.insert(pair, iteration);
+        if self.map.contains_key(&pair) {
+            self.map.insert(pair, iteration);
         } else {
-            self.0.insert((pair.1, pair.0), iteration);
+            self.map.insert((pair.1, pair.0), iteration);
         }
     }
 
     pub fn len(&self) -> usize {
-        self.0.len()
+        self.map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
     }
 
     fn contains(&self, pair: &(usize, usize)) -> bool {
-        self.0.contains_key(pair) || self.0.contains_key(&(pair.1, pair.0))
+        self.map.contains_key(pair) || self.map.contains_key(&(pair.1, pair.0))
     }
 
     pub fn get(&self, pair: (usize, usize)) -> Option<usize> {
-        Some(match self.0.get(&pair) {
+        Some(match self.map.get(&pair) {
             Some(x) => *x,
-            None => *self.0.get(&(pair.1, pair.0))?,
+            None => *self.map.get(&(pair.1, pair.0))?,
         })
     }
 
-    //pub fn values(&self) -> Vec<usize> {
-    //    self.0.values().copied().collect()
-    //}
-
     pub fn min(&self) -> usize {
-        *self.0.values().min().unwrap_or(&0)
+        *self.map.values().min().unwrap_or(&0)
     }
     pub fn max(&self) -> usize {
-        *self.0.values().max().unwrap_or(&0)
+        *self.map.values().max().unwrap_or(&0)
     }
 }
 
-pub fn merge(history: &mut History, pairs: &Vec<(usize, usize)>) {
+fn merge(history: &mut History, pairs: &Vec<(usize, usize)>) {
     for p in pairs {
         if history.contains(p) {
             let it = history.get(*p).unwrap();
@@ -66,6 +104,12 @@ pub fn merge(history: &mut History, pairs: &Vec<(usize, usize)>) {
     }
 }
 
+#[derive(Debug, Copy, Clone, Default)]
+pub struct HistoryStats {
+    pub files_read: usize,
+    pub pairs: usize,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

src/algorithm/history.rs crates/lib/src/algorithm/history.rssrc/algorithm/history.rs renamed to crates/lib/src/algorithm/history.rs

@@ -1,31 +1,8 @@
-mod history;
+pub mod history;
 use genetic_algorithm::{chromosome::GenesOwner, strategy::evolve::prelude::*};
-use serde::Deserialize;
-use serde::Serialize;
+use history::History;
 use tracing::{debug, trace};
 
-pub use history::History;
-pub use history::merge;
-
-#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
-pub struct Person {
-    pub id: usize,
-    name: String,
-}
-
-impl std::fmt::Display for Person {
-    // This trait requires `fmt` with this exact signature.
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}", self.name)
-    }
-}
-
-impl Person {
-    pub fn new(id: usize, name: String) -> Self {
-        Self { id, name }
-    }
-}
-
 pub fn pair(ids: Vec<usize>, last: &History) -> Vec<(usize, usize)> {
     //let len = ids.len();
     let genotype = UniqueGenotype::builder()

src/algorithm/mod.rs crates/lib/src/algorithm/mod.rssrc/algorithm/mod.rs renamed to crates/lib/src/algorithm/mod.rs

@@ -11,7 +11,6 @@ pub fn process(input: &Path) -> Result<HashMap<usize, String>> {
     let mut rdr = csv::ReaderBuilder::new()
         .has_headers(false)
         .from_reader(reader);
-    // TODO: check for unique ids somewhere here
     let mut people = HashMap::new();
     let mut tr_input_len = 0;
     for rec in rdr.records() {