Merge fix for #5

Author: Geobert

src/lib.rs

@@ -733,4 +733,50 @@ mod tests {
 
         eprintln!("{}\n{}", r.as_str(), r.roll().unwrap());
     }
+
+    #[test]
+    fn caith_minimal() {
+        // This should deterministically roll a 1
+        let roller = Roller::new(&"1d1").unwrap();
+
+        let result = roller.roll().unwrap();
+        let numeric = result.as_single().unwrap();
+        let history = numeric.to_string_history();
+        let as_string = numeric.to_string(false);
+
+        assert_eq!(numeric.get_total(), 1);
+        assert_eq!(as_string, "[1] = 1");
+        assert_eq!(history, "[1]");
+    }
+
+    #[test]
+    fn caith_reroll() {
+        // This should deterministically roll a 1, then reroll 1
+        let roller = Roller::new(&"1d1 r1").unwrap();
+
+        let result = roller.roll().unwrap();
+        let numeric = result.as_single().unwrap();
+        let history = numeric.to_string_history();
+        let as_string = numeric.to_string(false);
+
+        assert_eq!(numeric.get_total(), 1);
+        assert_eq!(as_string, "[1 -> 1] -> [1] = 1");
+        // Rerolls are now displayed in the history
+        assert_eq!(history, "[1 -> 1] -> [1]");
+    }
+
+    #[test]
+    fn caith_no_reroll() {
+        // This should deterministically roll a 1, then not reroll anything since 1 > 0
+        let roller = Roller::new(&"1d1 r0").unwrap();
+
+        let result = roller.roll().unwrap();
+        let numeric = result.as_single().unwrap();
+        let history = numeric.to_string_history();
+        let as_string = numeric.to_string(false);
+
+        assert_eq!(numeric.get_total(), 1);
+        assert_eq!(as_string, "[1] = 1");
+        assert_eq!(history, "[1]");
+    }
 }

src/parser.rs

@@ -18,7 +18,7 @@ pub(crate) struct RollParser;
 
 // arbitrary limit to avoid OOM
 const MAX_DICE_SIDES: u64 = 5000;
-const MAX_NB_DICE: u64 = 5000;
+const MAX_NUMBER_OF_DICE: u64 = 5000;
 
 // number represent nb dice to keep/drop
 #[derive(Clone, PartialEq)]
@@ -144,22 +144,30 @@ fn compute_reroll<RNG: DiceRollSource>(
 ) -> (TotalModifier, Vec<DiceResult>) {
     let value = extract_option_value(option).unwrap();
     let mut has_rerolled = false;
-    let res: Vec<DiceResult> = res
-        .into_iter()
+    let mut rerolls: Vec<Vec<DiceResult>> = vec![];
+    let res_new: Vec<DiceResult> = res
+        .iter()
         .map(|x| {
-            if x.res <= value {
+            let mut inner = vec![*x];
+            let result = if x.res <= value {
                 has_rerolled = true;
-                roll_dice(1, sides, rng)[0]
+                let rerolled = roll_dice(1, sides, rng)[0];
+                inner.push(rerolled);
+                rerolled
             } else {
-                x
-            }
+                *x
+            };
+            rerolls.push(inner);
+            result
         })
         .collect();
 
     if has_rerolled {
-        rolls.add_history(res.clone(), false);
+        rolls.add_rerolled_history(rerolls);
     }
-    (TotalModifier::None(Rule::reroll), res)
+    rolls.add_history(res_new.clone(), false);
+
+    (TotalModifier::None(Rule::reroll), res_new)
 }
 
 fn compute_i_reroll<RNG: DiceRollSource>(
@@ -301,20 +309,22 @@ fn compute_roll<RNG: DiceRollSource>(
     rng: &mut RNG,
 ) -> Result<SingleRollResult> {
     let mut rolls = SingleRollResult::new();
-    let maybe_nb = dice.next().unwrap();
-    let nb = match maybe_nb.as_rule() {
+    let number_of_dice = dice.next().unwrap();
+    let number_of_dice = match number_of_dice.as_rule() {
         Rule::nb_dice => {
             dice.next(); // skip `d` token
-            let n = maybe_nb.as_str().parse::<u64>().unwrap();
-            if n > MAX_NB_DICE {
-                return Err(
-                    format!("Exceed maximum allowed number of dices ({})", MAX_NB_DICE).into(),
-                );
+            let n = number_of_dice.as_str().parse::<u64>().unwrap();
+            if n > MAX_NUMBER_OF_DICE {
+                return Err(format!(
+                    "Exceed maximum allowed number of dices ({})",
+                    MAX_NUMBER_OF_DICE
+                )
+                .into());
             }
             n
         }
         Rule::roll => 1, // no number before `d`, assume 1 dice
-        _ => unreachable!("{:?}", maybe_nb),
+        _ => unreachable!("{:?}", number_of_dice),
     };
 
     let pair = dice.next().unwrap();
@@ -330,7 +340,7 @@ fn compute_roll<RNG: DiceRollSource>(
         return Err(format!("Dice can't have more than {}", MAX_DICE_SIDES).into());
     }
 
-    let mut res = roll_dice(nb, sides, rng);
+    let mut res = roll_dice(number_of_dice, sides, rng);
     let mut modifier = TotalModifier::None(Rule::expr);
     let mut next_option = dice.next();
     if !is_fudge {

src/rollresult/rollhistory.rs

@@ -39,6 +39,9 @@ impl Display for Value {
 #[non_exhaustive]
 #[derive(Debug, Clone)]
 pub enum RollHistory {
+    /// Rolls which include rerolls.
+    /// Should be followed by a Roll with the final results.
+    ReRolls(Vec<Vec<DiceResult>>),
     /// A roll with normal dices
     Roll(Vec<DiceResult>),
     /// A roll with Fudge dices
@@ -56,18 +59,26 @@ pub enum RollHistory {
 impl Display for RollHistory {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let s = match self {
+            RollHistory::ReRolls(v) => {
+                let s2 = v
+                    .iter()
+                    .map(|r| {
+                        r.iter()
+                            .map(|r| r.res.to_string())
+                            .collect::<Vec<_>>()
+                            .join(" -> ")
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("[{}] -> ", s2)
+            }
             RollHistory::Roll(v) => {
-                let mut s = String::new();
-                s.push('[');
-                let len = v.len();
-                v.iter().enumerate().for_each(|(i, r)| {
-                    s.push_str(&r.res.to_string());
-                    if i < len - 1 {
-                        s.push_str(", ");
-                    }
-                });
-                s.push(']');
-                s
+                let s2 = v
+                    .iter()
+                    .map(|r| r.res.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("[{}]", s2)
             }
             RollHistory::Fudge(v) => {
                 let mut s = String::new();

src/rollresult/singlerollresult.rs

@@ -76,6 +76,12 @@ impl SingleRollResult {
         });
     }
 
+    pub(crate) fn add_rerolled_history(&mut self, mut history: Vec<Vec<DiceResult>>) {
+        self.dirty = true;
+        history.sort_unstable_by(|a, b| b.cmp(a));
+        self.history.push(RollHistory::ReRolls(history));
+    }
+
     pub(crate) fn add_parenthesis(&mut self) {
         self.history.insert(0, RollHistory::OpenParenthesis);
         self.history.push(RollHistory::CloseParenthesis);