games_dice 0.5.0 → 0.6.0

data/spec/games_dice/dice_mutation_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Dice, :aggregate_failures do
+  let(:dice) { GamesDice.create('2d6x.m:>=8,1,Success.+1d4') }
+
+  def failing_mutation_trigger
+    lambda do |_|
+      dice.bunch_multipliers.clear
+      raise RangeError, 'callback failed'
+    end
+  end
+
+  def mutation_trigger
+    lambda do |_|
+      yield
+      true
+    end
+  end
+
+  def populate(recipe)
+    recipe.roll
+    recipe.minmax
+    recipe.probabilities
+  end
+
+  it 'caches the full combined distribution until a multiplier changes' do
+    previous = dice.probabilities
+    expect(dice.probabilities).to equal(previous)
+    dice.bunch_multipliers[0] = 0
+    expect(dice.probabilities.to_h).to eq(GamesDice.create('1d4').probabilities.to_h)
+  end
+
+  it 'clears parent history but retains unchanged child history after a multiplier edit' do
+    populate(dice)
+    child = dice.bunches.first.result
+    dice.bunch_multipliers[0] = -1
+    expect(dice.result).to be_nil
+    expect(dice.bunches.first.result).to eq(child)
+  end
+
+  it 'clears affected child and parent histories after a rule replacement' do
+    populate(dice)
+    dice.bunches.first.rerolls[0] = GamesDice::RerollRule.new(6, :==, :reroll_replace, 1)
+    expect(dice.explain_result).to be_nil
+    expect(dice.bunches.first).to have_attributes(result: nil, result_details: nil, explain_result: nil)
+    expect(dice.bunches.first.single_die).to have_attributes(result: nil, explain_result: nil,
+                                                             probabilities_complete: nil)
+  end
+
+  it 'detects mutable map labels and permits rolling again after invalidation' do
+    populate(dice)
+    dice.bunches.first.maps.first.mapped_name.replace('Hit')
+    expect(dice.result).to be_nil
+    dice.roll
+    expect(dice.explain_result).to be_a(String)
+  end
+
+  it 'detects paired insertion and deletion without replacing the exposed arrays' do
+    original = dice.bunches
+    dice.bunches << GamesDice::Bunch.new(ndice: 1, sides: 1)
+    dice.bunch_multipliers << 2
+    expect(dice.bunches).to equal(original)
+    expect(dice.minmax).to eq([3, 8])
+  end
+
+  it 'rejects mismatched array lengths deliberately and permits later repair' do
+    dice.bunch_multipliers.pop
+    expect { dice.result }.to raise_error(ArgumentError, 'bunches and bunch_multipliers must have the same length')
+    dice.bunches.pop
+    expect(dice.minmax).to eq([0, 2])
+  end
+
+  it 'rejects invalid entry types and recovers when they are replaced' do
+    dice.bunches[0] = 'invalid'
+    expect { dice.probabilities }.to raise_error(TypeError, /Expected GamesDice::Bunch/)
+    dice.bunches[0] = GamesDice::Bunch.new(ndice: 1, sides: 1)
+    expect(dice.minmax).to eq([2, 5])
+  end
+
+  it 'invalidates every parent of a shared bunch' do
+    other = GamesDice.create('1d4')
+    other.bunches[0] = dice.bunches.first
+    [dice, other].each { |recipe| populate(recipe) }
+    dice.bunches.first.maps.clear
+    expect([dice.result, other.result]).to eq([nil, nil])
+  end
+
+  it 'tracks reorder and clear operations' do
+    dice.probabilities
+    dice.bunches.reverse!
+    dice.bunch_multipliers.replace([0, 1])
+    expect(dice.minmax).to eq([0, 2])
+  end
+
+  it 'tracks removal of every bunch' do
+    dice.bunches.clear
+    dice.bunch_multipliers.clear
+    expect(dice.probabilities.to_h).to eq({ 0 => 1.0 })
+  end
+
+  it 'invalidates bounds and histories after mutable bunch names change' do
+    name = +'Original'
+    dice.bunches[0] = GamesDice::Bunch.new(ndice: 1, sides: 6, name: name)
+    populate(dice)
+    name.replace('Changed')
+    expect(dice.result).to be_nil
+  end
+
+  it 'keeps clone cache metadata independent while retaining shared recipe arrays' do
+    copy = dice.clone
+    populate(dice)
+    populate(copy)
+    dice.bunch_multipliers[0] = -1
+    expect([dice.result, copy.result]).to eq([nil, nil])
+  end
+
+  it 'detects mutation from a custom predicate before publishing a result' do
+    trigger = mutation_trigger { dice.bunch_multipliers[0] = -1 }
+    dice.bunches.first.maps.replace([GamesDice::MapRule.new(trigger, :call, 1)])
+    expect { dice.probabilities }.to raise_error(RuntimeError, 'Dice recipe changed during calculation')
+    expect(dice.result).to be_nil
+  end
+
+  it 'detects rule-array edits from callbacks during a roll' do
+    die = dice.bunches.first.single_die
+    trigger = mutation_trigger { die.maps.clear }
+    die.maps.replace([GamesDice::MapRule.new(trigger, :call, 1)])
+    expect { dice.roll }.to raise_error(RuntimeError, 'Dice recipe changed during calculation')
+    expect(dice.result).to be_nil
+  end
+
+  it 'keeps returned roll records unchanged when a shared label changes' do
+    label = +'Original'
+    die = GamesDice::ComplexDie.new(1, maps: [[1, :==, 1, label]])
+    record = die.roll
+    label.replace('Changed')
+    expect(record.explain_value).to eq('1 Original')
+  end
+
+  it 'discards calculations when callbacks leave an invalid recipe' do
+    trigger = mutation_trigger { dice.bunch_multipliers.clear }
+    dice.bunches.first.maps.replace([GamesDice::MapRule.new(trigger, :call, 1)])
+    expect { dice.probabilities }.to raise_error(RuntimeError, 'Dice recipe changed during calculation')
+  end
+
+  it 'preserves callback exceptions even when the callback also changes the recipe' do
+    trigger = failing_mutation_trigger
+    dice.bunches.first.maps.replace([GamesDice::MapRule.new(trigger, :call, 1)])
+    expect { dice.probabilities }.to raise_error(RangeError, 'callback failed')
+  end
+
+  it 'recomputes unrecognized restored recipe metadata' do
+    populate(dice)
+    dice.instance_variable_set(:@recipe_cache, nil)
+    expect(marshal_round_trip(dice).result).to be_nil
+  end
+
+  it 'invalidates a restored parent when a child snapshot is missing' do
+    populate(dice)
+    dice.bunches.first.single_die.instance_variable_set(:@recipe_cache, nil)
+    expect(marshal_round_trip(dice).result).to be_nil
+  end
+end

data/spec/games_dice/dice_regressions_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Dice, :aggregate_failures do
+  let(:prng) { Random.new(1) }
+
+  { '-1d6+2' => [-4, 1], '2d6-1d4' => [-2, 11], '-2d6' => [-12, -2] }.each do |notation, bounds|
+    it "reverses negative terms in bounds for #{notation}" do
+      dice = GamesDice.create(notation)
+      expect(dice.minmax).to eq(bounds)
+      expect(dice.probabilities).to have_attributes(min: bounds.first, max: bounds.last)
+    end
+  end
+
+  it 'skips zero-weight components that cannot calculate a distribution' do
+    dice = described_class.new([{ ndice: 1, sides: 4, rerolls: [[3, :<=, :reroll_add]], multiplier: 0 }], 5)
+    expect(dice.minmax).to eq([5, 5])
+    expect(dice.probabilities.to_h).to eq({ 5 => 1.0 })
+  end
+
+  { '-1d6+2' => '1d6: 1. -1 + 2 = 1', '-1d6' => '1d6: 1. -1 = -1' }.each do |notation, explanation|
+    it "explains the weighted result for #{notation}" do
+      allow(prng).to receive(:rand).and_return(0)
+      dice = GamesDice.create(notation, prng)
+      dice.roll
+      expect(dice.explain_result).to eq(explanation)
+    end
+  end
+
+  it 'shares one truncation budget across repeated dice and negatively weighted bunches' do
+    dice = GamesDice.create('3d2x-2d2x')
+    expect(dice.probabilities.to_h).to be_valid_distribution
+    expect(dice.instance_variable_get(:@probability_error)).to be <= 1e-10
+  end
+
+  it 'preserves the default repeated shorthand reroll' do
+    allow(prng).to receive(:rand).and_return(0, 0, 4)
+    dice = GamesDice.create('1d6r1', prng)
+    expect(dice.roll).to eq(5)
+    expect(dice.bunches.first.result_details.first.rolls).to eq([1, 1, 5])
+  end
+
+  it 'supports an explicit single replacement reroll' do
+    allow(prng).to receive(:rand).and_return(0, 0, 4)
+    dice = GamesDice.create('1d6r:1,replace,1.', prng)
+    expect(dice.roll).to eq(1)
+    expect(dice.bunches.first.result_details.first.rolls).to eq([1, 1])
+  end
+end

data/spec/games_dice/dice_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Dice, :aggregate_failures do
+  describe 'dice scheme' do
+    before do
+      srand(67_809)
+    end
+
+    describe '1d10+2' do
+      let(:dice) { described_class.new([{ sides: 10, ndice: 1 }], 2) }
+
+      it 'simulate rolling a ten-sided die, and adding two to each result' do
+        [5, 4, 10, 10, 7, 5, 9].each do |expected_total|
+          expect(dice.roll).to eql expected_total
+          expect(dice.result).to eql expected_total
+        end
+      end
+    end
+
+    describe '2d6+6' do
+      let(:dice) { described_class.new([{ sides: 6, ndice: 2 }], 6) }
+
+      it 'simulate rolling two six-sided dice and adding six to the result' do
+        [15, 12, 17, 15, 13, 13, 16].each do |expected_total|
+          expect(dice.roll).to eql expected_total
+          expect(dice.result).to eql expected_total
+        end
+      end
+    end
+  end
+
+  it 'explains constant-only recipes' do
+    dice = described_class.new([], -3)
+    expect(dice.roll).to eq(-3)
+    expect(dice.explain_result).to eq('-3')
+    expect(dice.probabilities.to_h).to eq(-3 => 1.0)
+  end
+
+  it 'explains a single bunch with an offset' do
+    dice = described_class.new([{ sides: 6, ndice: 1, prng: TestPRNGMax.new }], 2)
+    expect(dice.roll).to eq(8)
+    expect(dice.explain_result).to eq('1d6: 6. 6 + 2 = 8')
+  end
+
+  describe 'multiple weighted bunch explanations' do
+    let(:bunches) do
+      [{ sides: 6, ndice: 1, prng: TestPRNGMax.new },
+       { sides: 4, ndice: 1, multiplier: -1, prng: TestPRNGMax.new }]
+    end
+
+    { 0 => '6 - 4 = 2', 3 => '6 - 4 + 3 = 5', -3 => '6 - 4 - 3 = -1' }.each do |offset, sum|
+      it "includes an offset of #{offset}" do
+        dice = described_class.new(bunches, offset)
+        expect(dice.roll).to eq(2 + offset)
+        expect(dice.explain_result).to eq("1d6: 6. 1d4: 4. #{sum}")
+      end
+    end
+  end
+end

data/spec/games_dice/die_result_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::DieResult, :aggregate_failures do
+  let(:seven_result) { described_class.new(7) }
+  let(:twelve_result) do
+    result = described_class.new(6)
+    result.add_roll(6, :reroll_add)
+    result
+  end
+
+  describe '.new' do
+    it "work without parameters to represent 'no results yet'" do
+      die_result = described_class.new
+      expect(die_result.value).to be_nil
+      expect(die_result.rolls).to eql []
+      expect(die_result.roll_reasons).to eql []
+    end
+
+    it 'work with a single Integer param to represent an initial result' do
+      die_result = described_class.new(8)
+      expect(die_result.value).to be 8
+      expect(die_result.rolls).to eql [8]
+      expect(die_result.roll_reasons).to eql [:basic]
+    end
+
+    it 'not accept a param that cannot be coerced to Integer' do
+      expect { described_class.new([]) }.to raise_error(TypeError)
+      expect { described_class.new('N') }.to raise_error(ArgumentError)
+    end
+
+    it 'not accept unknown reasons for making a roll' do
+      expect { described_class.new(8, 'wooo') }.to raise_error(ArgumentError)
+      expect { described_class.new(8, :frabulous) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#add_roll' do
+    context "when starting from 'no results yet'" do
+      let(:die_result) { described_class.new }
+
+      it 'create an initial result' do
+        die_result.add_roll(5)
+        expect(die_result.value).to be 5
+        expect(die_result.rolls).to eql [5]
+        expect(die_result.roll_reasons).to eql [:basic]
+      end
+
+      it 'accept non-basic reasons for the first roll' do
+        die_result.add_roll(4, :reroll_subtract)
+        expect(die_result.value).to be(-4)
+        expect(die_result.rolls).to eql [4]
+        expect(die_result.roll_reasons).to eql [:reroll_subtract]
+      end
+
+      it 'not accept a first param that cannot be coerced to Integer' do
+        expect { die_result.add_roll([]) }.to raise_error(TypeError)
+        expect { die_result.add_roll('N') }.to raise_error(ArgumentError)
+      end
+
+      it 'not accept an unsupported second param' do
+        expect { die_result.add_roll(5, []) }.to raise_error(ArgumentError)
+        expect { die_result.add_roll(15, :bam) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when starting with an initial result' do
+      let(:die_result) { described_class.new(7) }
+
+      it 'not accept a first param that cannot be coerced to Integer' do
+        expect { die_result.add_roll([]) }.to raise_error(TypeError)
+        expect { die_result.add_roll('N') }.to raise_error(ArgumentError)
+      end
+
+      it 'not accept an unsupported second param' do
+        expect { die_result.add_roll(5, []) }.to raise_error(ArgumentError)
+        expect { die_result.add_roll(15, :bam) }.to raise_error(ArgumentError)
+      end
+
+      it 'replace an initial result, as if the die were re-rolled' do
+        die_result.add_roll(5)
+        expect(die_result.value).to be 5
+        expect(die_result.rolls).to eql [7, 5]
+        expect(die_result.roll_reasons).to eql %i[basic basic]
+      end
+
+      it 'add to value when exploding up' do
+        die_result.add_roll(6, :reroll_add)
+        expect(die_result.value).to be 13
+        expect(die_result.rolls).to eql [7, 6]
+        expect(die_result.roll_reasons).to eql %i[basic reroll_add]
+      end
+
+      it 'subtract from value when exploding down' do
+        die_result.add_roll(4, :reroll_subtract)
+        expect(die_result.value).to be 3
+        expect(die_result.rolls).to eql [7, 4]
+        expect(die_result.roll_reasons).to eql %i[basic reroll_subtract]
+      end
+
+      it 'optionally replace roll unconditionally' do
+        steps = [[[2, :reroll_replace], 2, [7, 2], %i[basic reroll_replace]],
+                 [[5, :reroll_replace], 5, [7, 2, 5], %i[basic reroll_replace reroll_replace]]]
+        steps.each do |arguments, value, rolls, reasons|
+          die_result.add_roll(*arguments)
+          expect_die_result_state(die_result, value: value, rolls: rolls, reasons: reasons)
+        end
+      end
+
+      it 'optionally use best roll' do
+        steps = [[[2, :reroll_use_best], 7, [7, 2], %i[basic reroll_use_best]],
+                 [[9, :reroll_use_best], 9, [7, 2, 9], %i[basic reroll_use_best reroll_use_best]]]
+        steps.each do |arguments, value, rolls, reasons|
+          die_result.add_roll(*arguments)
+          expect_die_result_state(die_result, value: value, rolls: rolls, reasons: reasons)
+        end
+      end
+
+      it 'optionally use worst roll' do
+        steps = [[[4, :reroll_use_worst], 4, [7, 4], %i[basic reroll_use_worst]],
+                 [[5, :reroll_use_worst], 4, [7, 4, 5], %i[basic reroll_use_worst reroll_use_worst]]]
+        steps.each do |arguments, value, rolls, reasons|
+          die_result.add_roll(*arguments)
+          expect_die_result_state(die_result, value: value, rolls: rolls, reasons: reasons)
+        end
+      end
+
+      it 'correctly handle valid reasons for extra rolls in combination' do
+        steps = [[[[10, :reroll_add], [3, :reroll_subtract]], 14, [7, 10, 3], %i[basic reroll_add reroll_subtract]],
+                 [[[12, :reroll_replace]], 12, [7, 10, 3, 12], %i[basic reroll_add reroll_subtract reroll_replace]],
+                 [[[9, :reroll_use_best]], 12, [7, 10, 3, 12, 9],
+                  %i[basic reroll_add reroll_subtract reroll_replace reroll_use_best]],
+                 [[[15, :reroll_add]], 27, [7, 10, 3, 12, 9, 15],
+                  %i[basic reroll_add reroll_subtract reroll_replace reroll_use_best reroll_add]]]
+        steps.each do |rolls_to_add, value, rolls, reasons|
+          rolls_to_add.each { |arguments| die_result.add_roll(*arguments) }
+          expect_die_result_state(die_result, value: value, rolls: rolls, reasons: reasons)
+        end
+      end
+    end
+  end
+
+  describe '#explain_value' do
+    let(:die_result) { described_class.new }
+
+    it "be empty string for 'no results yet'" do
+      expect(die_result.explain_value).to eql ''
+    end
+
+    it 'be a simple stringified number when there is one die roll' do
+      die_result.add_roll(3)
+      expect(die_result.explain_value).to eql '3'
+    end
+
+    it 'describe all single rolls made and how they combine' do
+      steps = [[[6], '6'], [[5, :reroll_add], '[6+5] 11'], [[2, :reroll_replace], '[6+5|2] 2'],
+               [[7, :reroll_subtract], '[6+5|2-7] -5'], [[4, :reroll_use_worst], '[6+5|2-7\\4] -5'],
+               [[3, :reroll_use_best], '[6+5|2-7\\4/3] 3']]
+      steps.each do |arguments, expected|
+        die_result.add_roll(*arguments)
+        expect(die_result.explain_value).to eq(expected)
+      end
+    end
+  end
+
+  it 'combine via +,- and * intuitively based on #value' do
+    cases = [[seven_result + 3, 10], [4 + seven_result, 11], [seven_result - 2, 5], [9 - seven_result, 2],
+             [seven_result + 7.7, 14.7], [4.1 + seven_result, 11.1], [seven_result * 2, 14], [1 * seven_result, 7],
+             [seven_result + twelve_result, 19], [twelve_result - seven_result, 5]]
+    cases.each { |actual, expected| expect(actual).to eq(expected) }
+  end
+
+  it 'support comparison with >,<,>=,<= as if it were an integer, based on #value' do
+    cases = [[seven_result > 3, true], [seven_result < 14, true], [seven_result >= 7, true],
+             [seven_result <= 9.5, true], [seven_result < 3, false], [seven_result > 14, false],
+             [seven_result <= 8, true], [seven_result >= 14, false], [seven_result > twelve_result, false],
+             [twelve_result > seven_result, true], [seven_result >= twelve_result, false],
+             [twelve_result >= seven_result, true], [seven_result < twelve_result, true],
+             [twelve_result < seven_result, false], [seven_result <= twelve_result, true],
+             [twelve_result <= seven_result, false]]
+    cases.each { |actual, expected| expect(actual).to be(expected) }
+  end
+
+  it 'sort, based on #value' do
+    die_results = [
+      described_class.new(7), described_class.new(5), described_class.new(8), described_class.new(3)
+    ]
+
+    die_results.sort!
+
+    expect(die_results.map(&:value)).to eq([3, 5, 7, 8])
+  end
+
+  [nil, ''].each do |label|
+    it "explains mapped results with a #{label.inspect} label" do
+      result = described_class.new(6)
+      result.apply_map(1, label)
+      expect(result).to have_attributes(value: 1, explain_value: '6', explain_total: '6')
+    end
+  end
+
+  describe 'cloning mapped results' do
+    let(:original) do
+      result = described_class.new(6)
+      result.apply_map(1, 'Success')
+      result
+    end
+    let(:copy) { original.clone }
+
+    it 'preserves the mapped state and label' do
+      expect(copy).to have_attributes(value: 1, total: 6, mapped: true, explain_value: '6 Success')
+    end
+
+    it 'does not share roll history with the original' do
+      copy.add_roll(2, :reroll_replace)
+      expect(copy).to have_attributes(value: 2, mapped: false, rolls: [6, 2])
+      expect(original).to have_attributes(value: 1, mapped: true, rolls: [6])
+    end
+  end
+end

data/spec/{die_spec.rb → games_dice/die_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'helpers'
 
-describe GamesDice::Die do
+describe GamesDice::Die, :aggregate_failures do
   before do
     # Set state of default PRNG
     srand(4567)
@@ -17,8 +17,7 @@ describe GamesDice::Die do
     end
 
     it 'accept any object with a rand(Integer) method as the second param' do
-      prng = TestPRNG.new
-      die = described_class.new(20, prng)
+      die = described_class.new(20, TestPRNG.new)
       [16, 7, 3, 11, 16, 18, 20, 7].each do |expected|
         expect(die.roll).to eql expected
         expect(die.result).to eql expected
@@ -46,19 +45,10 @@ describe GamesDice::Die do
 
   describe '#probabilities' do
     it "return the die's probability distribution as a GamesDice::Probabilities object" do
-      die = described_class.new(6)
-      probs = die.probabilities
+      probs = described_class.new(6).probabilities
       expect(probs).to be_a GamesDice::Probabilities
-
       expect(probs.to_h).to be_valid_distribution
-
-      expect(probs.p_eql(1)).to be_within(1e-10).of 1 / 6.0
-      expect(probs.p_eql(2)).to be_within(1e-10).of 1 / 6.0
-      expect(probs.p_eql(3)).to be_within(1e-10).of 1 / 6.0
-      expect(probs.p_eql(4)).to be_within(1e-10).of 1 / 6.0
-      expect(probs.p_eql(5)).to be_within(1e-10).of 1 / 6.0
-      expect(probs.p_eql(6)).to be_within(1e-10).of 1 / 6.0
-
+      expect_probability_values(probs.to_h, (1..6).to_h { |result| [result, 1 / 6.0] })
       expect(probs.expected).to be_within(1e-10).of 3.5
     end
   end
@@ -78,4 +68,15 @@ describe GamesDice::Die do
       expect(arr).to eql [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     end
   end
+
+  it 'rejects nonpositive sides and an invalid random generator' do
+    [0, -1].each do |sides|
+      expect { described_class.new(sides) }.to raise_error(ArgumentError, /sides value/)
+    end
+    expect { described_class.new(6, Object.new) }.to raise_error(ArgumentError, /prng/)
+  end
+
+  it 'exposes no reroll or map rules for a simple die' do
+    expect(described_class.new(6)).to have_attributes(rerolls: nil, maps: nil)
+  end
 end

data/spec/{map_rule_spec.rb → games_dice/map_rule_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'helpers'
 
-describe GamesDice::MapRule do
+describe GamesDice::MapRule, :aggregate_failures do
   describe '#new' do
     it 'accept self-consistent operator/value pairs as a trigger' do
       expect { described_class.new(5, :>, 1) }.not_to raise_error
@@ -37,4 +37,11 @@ describe GamesDice::MapRule do
       expect(rule.map_from(6)).to be_nil
     end
   end
+
+  it 'uses a nonboolean trigger result as the mapped value' do
+    rule = described_class.new({ 1 => 0, 6 => 3 }, :[], 99)
+    expect(rule.map_from(1)).to eq(0)
+    expect(rule.map_from(6)).to eq(3)
+    expect(rule.map_from(2)).to be_nil
+  end
 end

data/spec/{parser_spec.rb → games_dice/parser_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'helpers'
 
-describe GamesDice::Parser do
+describe GamesDice::Parser, :aggregate_failures do
   describe '#parse' do
     let(:parser) { described_class.new }
 
@@ -30,7 +30,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it "parse 'NdXrY' as 'roll N times X-sided dice, re-roll and replace a Y or less (once)'" do
+    it "parse 'NdXrY' as 'roll N times X-sided dice, re-roll and replace a Y or less (default limit)'" do
       variations = {
         '1d6r1' => { bunches: [{ ndice: 1, sides: 6, multiplier: 1, rerolls: [[1, :>=, :reroll_replace]] }],
                      offset: 0 },
@@ -103,4 +103,14 @@ describe GamesDice::Parser do
       end
     end
   end
+
+  it 'rejects multiple keeper modifiers on the same bunch' do
+    expect { described_class.new.parse('4d6k3k2') }.to raise_error(RuntimeError, /keepers.*twice/)
+  end
+
+  it 'collects bare dice terms without optional signs or modifiers' do
+    tree = { bunches: [{ ndice: '2', sides: '6' }, { constant: '3', op: '+' }] }
+    expect(described_class::ParseTreeProcessor.collect_bunches(tree)).to eq([{ ndice: 2, sides: 6 }])
+    expect(described_class::ParseTreeProcessor.collect_offset(tree)).to eq(3)
+  end
 end