Include rerolls in history

Author: Craig-Macomber

src/lib.rs

@@ -760,9 +760,9 @@ mod tests {
         let as_string = numeric.to_string(false);
 
         assert_eq!(numeric.get_total(), 1);
-        assert_eq!(as_string, "[1] = 1");
-        // Rerolls are currently not displayed in the history
-        assert_eq!(history, "[1]");
+        assert_eq!(as_string, "[1 -> 1] -> [1] = 1");
+        // Rerolls are now displayed in the history
+        assert_eq!(history, "[1 -> 1] -> [1]");
     }
 
     #[test]

src/parser.rs

@@ -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();
 
-    // Original roll is not included in history, so add the result, regardless of if a reroll occurred.
-    rolls.add_history(res.clone(), false);
+    if has_rerolled {
+        rolls.add_rerolled_history(rerolls);
+    }
+    rolls.add_history(res_new.clone(), false);
 
-    (TotalModifier::None(Rule::reroll), res)
+    (TotalModifier::None(Rule::reroll), res_new)
 }
 
 fn compute_i_reroll<RNG: DiceRollSource>(

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);