chore: rename project and lib crate

01.workspace/oxidice_lib/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "oxidice_lib"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.2"

01.workspace/oxidice_lib/examples/roll_ose_stats.rs

@@ -0,0 +1,17 @@
+use oxidice_lib::dice::*;
+
+fn main() -> Result<(), FailedTo>{
+    let str = Dice::grab(3, 6).roll().sum()?;
+    let int = Dice::grab(3, 6).roll().sum()?;
+    let wis = Dice::grab(3, 6).roll().sum()?;
+    let dex = Dice::grab(3, 6).roll().sum()?;
+    let con = Dice::grab(3, 6).roll().sum()?;
+    let cha = Dice::grab(3, 6).roll().sum()?;
+    println!("STR: {str}");
+    println!("INT: {int}");
+    println!("WIS: {wis}");
+    println!("DEX: {dex}");
+    println!("CON: {con}");
+    println!("CHA: {cha}");
+    Ok(())
+}

01.workspace/oxidice_lib/src/fun/mod.rs

@@ -0,0 +1 @@
+

01.workspace/oxidice_lib/src/imp/dice_grab.rs

@@ -0,0 +1,20 @@
+use crate::*;
+
+impl Dice {
+    pub fn grab(dice: u16, sides: u16) -> Self {
+        let mut handful = Vec::<Die>::new();
+        for _ in 1..=dice {
+            handful.push(Die::new(sides));
+        }
+        Self {
+            handful,
+            roll_results: Vec::<u16>::new(),
+        }
+    }
+    pub fn and_grab(mut self, dice: u16, sides: u16) -> Self {
+        for _ in 1..=dice {
+            self.handful.push(Die::new(sides));
+        }
+        self
+    }
+}

01.workspace/oxidice_lib/src/imp/dice_roll.rs

@@ -0,0 +1,11 @@
+use crate::*;
+
+impl Dice {
+    pub fn roll(mut self) -> Self {
+        self.roll_results.clear();
+        for die in &self.handful {
+            self.roll_results.push(die.roll())
+        }
+        self
+    }
+}

01.workspace/oxidice_lib/src/imp/dice_sum.rs

@@ -0,0 +1,16 @@
+use crate::*;
+
+impl Dice {
+    pub fn sum(self) -> Result<Sum, FailedTo> {
+        let mut result = Sum::default();
+        for roll_result in self.roll_results {
+            result.roll_results.push(roll_result);
+            result.sum = result
+                .sum
+                .checked_add(roll_result.into())
+                .and_then(|r| r.checked_add(1u64))
+                .ok_or(FailedTo::Sum)?;
+        }
+        Ok(result)
+    }
+}

01.workspace/oxidice_lib/src/imp/die_roll.rs

@@ -0,0 +1,11 @@
+use crate::*;
+
+impl Die {
+    pub fn roll(&self) -> u16 {
+        let mut rng = rand::rng();
+        rng.random_range(0..self.sides)
+    }
+}
+
+// #[cfg(test)]
+// mod unit_tests { use super::*; }

01.workspace/oxidice_lib/src/imp/mod.rs

@@ -0,0 +1,5 @@
+pub mod dice_grab;
+pub mod dice_roll;
+pub mod dice_sum;
+pub mod die_roll;
+pub mod sum_display;

01.workspace/oxidice_lib/src/imp/sum_display.rs

@@ -0,0 +1,17 @@
+use crate::*;
+
+impl fmt::Display for Sum {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        let str_results: Vec<String> = self
+            .roll_results
+            .iter()
+            .map(|r| r.checked_add(1))
+            .map(|o| o.unwrap_or(0))
+            .map(|r| r.to_string())
+            .collect();
+        write!(f, "[{}]", str_results.join(", "))?;
+        write!(f, " -> ")?;
+        write!(f, "{}", self.sum)?;
+        Ok(())
+    }
+}

01.workspace/oxidice_lib/src/lib.rs

@@ -0,0 +1,21 @@
+use std::*;
+
+use rand::*;
+
+mod fun;
+mod imp;
+mod mcr;
+mod str;
+mod trt;
+mod tst;
+
+pub(crate) use crate::str::dice::O as Dice;
+pub(crate) use crate::str::die::O as Die;
+pub(crate) use crate::str::failed_to::E as FailedTo;
+pub(crate) use crate::str::sum::O as Sum;
+
+pub mod dice {
+    pub use crate::str::dice::O as Dice;
+    pub use crate::str::sum::O as Sum;
+    pub use crate::str::failed_to::E as FailedTo;
+}

01.workspace/oxidice_lib/src/mcr/mod.rs

@@ -0,0 +1 @@
+

01.workspace/oxidice_lib/src/str/dice.rs

@@ -0,0 +1,18 @@
+use crate::*;
+
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct O {
+    pub(crate) handful: Vec<Die>,
+    pub(crate) roll_results: Vec<u16>,
+}
+
+// impl std::fmt::Display for O {
+// fn fmt(&self, _f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+// todo!();
+// }
+// }
+
+// #[cfg(test)]
+// mod unit_tests {
+// use super::*;
+// }

01.workspace/oxidice_lib/src/str/die.rs

@@ -0,0 +1,12 @@
+use crate::*;
+
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct O {
+    pub(crate) sides: u16,
+}
+
+impl Die {
+    pub fn new(sides: u16) -> Self {
+        Self { sides }
+    }
+}

01.workspace/oxidice_lib/src/str/failed_to.rs

@@ -0,0 +1,51 @@
+// use crate::*;
+// use std::fmt::Display;
+// use std::str::FromStr;
+
+#[derive(Debug, PartialEq, PartialOrd, Eq, Ord, Clone, Copy, Hash)]
+pub enum E {
+    Sum,
+}
+
+// impl Display for E {
+// fn fmt(&self, f: &mut std::fmt::Formatter) -> std::result::Result<(), std::fmt::Error> {
+// match self {
+// Self::NoValue => write!(f, "NoValue"),
+// }
+// }
+// }
+
+// impl FromStr for E {
+// type Err = Box<dyn std::error::Error>;
+// fn from_str(value: &str) -> std::result::Result<Self, Box<dyn std::error::Error>> {
+// match value {
+// "NoValue" => Ok(Self::NoValue),
+// _ => unreachable!(),
+// }
+// }
+// }
+
+// #[cfg(test)]
+// mod unit_tests {
+// use super::*;
+// #[test]
+// fn check_001() {
+// for value in [E::NoValue] {
+// match value {
+// E::NoValue => assert_eq!(
+// E::NoValue,
+// E::from_str("NoValue").unwrap()
+// ),
+// }
+// }
+// }
+//
+// #[test]
+// fn check_002() {
+// for value in [E::NoValue] {
+// match value {
+// E::NoValue => assert_eq!(&E::NoValue.to_string(), "NoValue"),
+// }
+// }
+// }
+// }

01.workspace/oxidice_lib/src/str/mod.rs

@@ -0,0 +1,4 @@
+pub mod dice;
+pub mod die;
+pub mod failed_to;
+pub mod sum;

01.workspace/oxidice_lib/src/str/sum.rs

@@ -0,0 +1,18 @@
+use crate::*;
+
+#[derive(Debug, Default, PartialEq, Clone)]
+pub struct O {
+    pub(crate) roll_results: Vec<u16>,
+    pub(crate) sum: u64,
+}
+
+// impl std::fmt::Display for O {
+// fn fmt(&self, _f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+// todo!();
+// }
+// }
+
+// #[cfg(test)]
+// mod unit_tests {
+// use super::*;
+// }

01.workspace/oxidice_lib/src/trt/mod.rs

@@ -0,0 +1 @@
+

01.workspace/oxidice_lib/src/tst/dice_grab.rs

@@ -0,0 +1,28 @@
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    #[test]
+    pub fn grab_should_set_correct_number_of_dice() {
+        let dice = Dice::grab(3, 6);
+        assert_eq!(dice.handful.len(), 3);
+    }
+    #[test]
+    pub fn grab_should_set_correct_number_of_sides() {
+        let dice = Dice::grab(3, 6);
+        for idx in 0..=2 {
+            assert_eq!(dice.handful[idx].sides, 6);
+        }
+    }
+    #[test]
+    fn and_grab_should_add_correct_number_of_dice() {
+        let dice = Dice::grab(3, 6).and_grab(2, 8);
+        assert_eq!(dice.handful.len(), 5);
+    }
+    #[test]
+    fn and_grab_should_set_correct_number_of_sides() {
+        let dice = Dice::grab(3, 6).and_grab(2, 8);
+        for idx in 3..4 {
+            assert_eq!(dice.handful[idx].sides, 8);
+        }
+    }
+}

01.workspace/oxidice_lib/src/tst/dice_roll.rs

@@ -0,0 +1,15 @@
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    #[test]
+    pub fn roll_should_yield_correct_number_or_results() {
+        let dice = Dice::grab(3, 6);
+        let dice = dice.roll();
+        assert_eq!(dice.roll_results.len(), 3);
+    }
+    #[test]
+    fn reroll_should_yield_correct_number_of_results() {
+        let dice = Dice::grab(3, 6).roll().roll();
+        assert_eq!(dice.roll_results.len(), 3);
+    }
+}

01.workspace/oxidice_lib/src/tst/dice_sum.rs

@@ -0,0 +1,16 @@
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    #[test]
+    pub fn dice_sum_should_yield_the_correct_sum() {
+        let result = Dice::grab(6, 1).roll().sum().unwrap();
+        assert_eq!(result.sum, 6);
+    }
+    #[test]
+    fn dice_sum_should_list_the_correct_results() {
+        let result = Dice::grab(6, 1).roll().sum().unwrap();
+        for idx in 1..6 {
+            assert_eq!(result.roll_results[idx], 0);
+        }
+    }
+}

01.workspace/oxidice_lib/src/tst/die_roll.rs

@@ -0,0 +1,11 @@
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    #[test]
+    pub fn die_roll_should_always_stay_inside_range() {
+        let die = Die::new(6);
+        for _ in 1..=10000 {
+            assert!(die.roll() < 6);
+        }
+    }
+}

01.workspace/oxidice_lib/src/tst/mod.rs

@@ -0,0 +1,5 @@
+pub mod dice_grab;
+pub mod dice_roll;
+pub mod dice_sum;
+pub mod die_roll;
+pub mod sum_display;

01.workspace/oxidice_lib/src/tst/sum_display.rs

@@ -0,0 +1,9 @@
+#[cfg(test)]
+mod tests {
+    use crate::*;
+    #[test]
+    pub fn sum_display_format_should_be_correct() {
+        let result = Dice::grab(3, 1).roll().sum().unwrap();
+        assert_eq!(&result.to_string(), "[1, 1, 1] -> 3");
+    }
+}