games_dice 0.5.0 → 0.6.0

data/spec/games_dice_spec.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+require 'helpers'
+# This spec demonstrates that documentation from the README.md works as intended
+
+describe GamesDice, :aggregate_failures do
+  describe '#create' do
+    it "converts a string such as '3d6+6' into a GamesDice::Dice object" do
+      d = described_class.create '3d6+6'
+      expect(d).to be_a GamesDice::Dice
+    end
+
+    it "takes a parameter 'dice_description', which is a string such as '3d6' or '2d4-1'" do
+      d = described_class.create '3d6'
+      expect(d).to be_a GamesDice::Dice
+      d = described_class.create '2d4-1'
+      expect(d).to be_a GamesDice::Dice
+    end
+
+    it "takes an optional parameter 'prng', which should be an object that has a method 'rand( integer )'" do
+      prng = TestPRNG.new
+      d = described_class.create '3d6', prng
+      expect(d).to be_a GamesDice::Dice
+      expect_injected_prng(d, prng)
+    end
+  end
+
+  describe GamesDice::Dice do
+    before do
+      srand(67_809)
+    end
+
+    let(:dice) { GamesDice.create '3d6' }
+
+    describe '#roll' do
+      it 'simulates rolling the dice as they were described in the constructor' do
+        expected_results = [11, 15, 11, 12, 12, 9]
+        expected_results.each do |expected|
+          expect(dice.roll).to eql expected
+        end
+      end
+    end
+
+    describe '#result' do
+      it 'returns the value from the last call to roll' do
+        expected_results = [11, 15, 11, 12, 12, 9]
+        expected_results.each do |expected|
+          dice.roll
+          expect(dice.result).to eql expected
+        end
+      end
+
+      it 'is nil if no roll has been made yet' do
+        expect(dice.result).to be_nil
+      end
+    end
+
+    describe '#explain_result' do
+      it 'attempts to show how the result from the last call to roll was composed' do
+        expected_results = [
+          '3d6: 3 + 6 + 2 = 11',
+          '3d6: 4 + 5 + 6 = 15',
+          '3d6: 3 + 6 + 2 = 11',
+          '3d6: 5 + 6 + 1 = 12'
+        ]
+        expected_results.each do |expected|
+          dice.roll
+          expect(dice.explain_result).to eql expected
+        end
+      end
+
+      it 'is nil if no roll has been made yet' do
+        expect(dice.explain_result).to be_nil
+      end
+    end
+
+    describe '#max' do
+      it 'returns the maximum possible value from a roll of the dice' do
+        expect(dice.max).to be 18
+      end
+    end
+
+    describe '#min' do
+      it 'returns the minimum possible value from a roll of the dice' do
+        expect(dice.min).to be 3
+      end
+    end
+
+    describe '#minmax' do
+      it 'returns an array [ dice.min, dice.max ]' do
+        expect(dice.minmax).to eql [3, 18]
+      end
+    end
+
+    describe '#probabilities' do
+      it 'calculates probability distribution for the dice' do
+        pd = dice.probabilities
+        expect(pd).to be_a GamesDice::Probabilities
+        expect(pd.p_eql(3)).to be_within(1e-10).of 1.0 / 216
+        expect(pd.p_eql(11)).to be_within(1e-10).of 27.0 / 216
+      end
+    end
+  end
+
+  describe GamesDice::Probabilities do
+    let(:probs) { GamesDice.create('3d6').probabilities }
+
+    describe '#to_h' do
+      it 'returns a hash representation of the probability distribution' do
+        h = probs.to_h
+        expect(h).to be_valid_distribution
+        expect(h[3]).to be_within(1e-10).of 1.0 / 216
+        expect(h[11]).to be_within(1e-10).of 27.0 / 216
+      end
+    end
+
+    describe '#max' do
+      it 'returns maximum result in the probability distribution' do
+        expect(probs.max).to be 18
+      end
+    end
+
+    describe '#min' do
+      it 'returns minimum result in the probability distribution' do
+        expect(probs.min).to be 3
+      end
+    end
+
+    describe '#p_eql( n )' do
+      it 'returns the probability of a result equal to the integer n' do
+        expect(probs.p_eql(3)).to be_within(1e-10).of 1.0 / 216
+        expect(probs.p_eql(2)).to be 0.0
+      end
+    end
+
+    describe '#p_gt( n )' do
+      it 'returns the probability of a result greater than the integer n' do
+        expect(probs.p_gt(17)).to be_within(1e-10).of 1.0 / 216
+        expect(probs.p_gt(2)).to be 1.0
+      end
+    end
+
+    describe '#p_ge( n )' do
+      it 'returns the probability of a result greater than the integer n' do
+        expect(probs.p_ge(17)).to be_within(1e-10).of 4.0 / 216
+        expect(probs.p_ge(3)).to be 1.0
+      end
+    end
+
+    describe '#p_le( n )' do
+      it 'returns the probability of a result less than or equal to the integer n' do
+        expect(probs.p_le(17)).to be_within(1e-10).of 215.0 / 216
+        expect(probs.p_le(3)).to be_within(1e-10).of 1.0 / 216
+      end
+    end
+
+    describe '#p_lt( n )' do
+      it 'returns the probability of a result less than the integer n' do
+        expect(probs.p_lt(17)).to be_within(1e-10).of 212.0 / 216
+        expect(probs.p_lt(3)).to be 0.0
+      end
+    end
+  end
+
+  describe 'String Dice Description' do
+    before do
+      srand(35_241)
+    end
+
+    describe "'1d6'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '1d6'
+        expect((1..20).map { |_n| d.roll }).to eql [6, 3, 2, 3, 4, 6, 4, 2, 6, 3, 3, 5, 6, 6, 3, 6, 5, 2, 1, 4]
+      end
+    end
+
+    describe "'2d6 + 1d4'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '2d6 + 1d4'
+        expect((1..5).map { |_n| d.roll }).to eql [11, 10, 12, 12, 14]
+      end
+    end
+
+    describe "'1d100 + 1d20 - 5'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '1d100 + 1d20 - 5'
+        expect((1..5).map { |_n| d.roll }).to eql [75, 78, 24, 102, 32]
+      end
+    end
+
+    describe "'1d10x'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '1d10x'
+        expect((1..20).map { |_n| d.roll }).to eql [2, 3, 4, 7, 6, 7, 4, 2, 6, 3, 7, 5, 6, 7, 6, 6, 5, 19, 4, 19]
+      end
+    end
+
+    describe "'1d6r1'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '1d6r1'
+        expect((1..20).map { |_n| d.roll }).to eql [6, 3, 2, 3, 4, 6, 4, 2, 6, 3, 3, 5, 6, 6, 3, 6, 5, 2, 4, 2]
+      end
+    end
+
+    describe "'5d10r:10,add.k2'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '5d10r:10,add.k2'
+        expect((1..5).map { |_n| d.roll }).to eql [13, 13, 14, 38, 15]
+      end
+    end
+
+    describe "'3d10m6'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '3d10m6'
+        expect((1..6).map { |_n| d.roll }).to eql [0, 3, 1, 1, 3, 2]
+      end
+    end
+
+    describe "'5d10k2'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '5d10k2'
+        expect((1..5).map { |_n| d.roll }).to eql [13, 13, 14, 19, 19]
+      end
+    end
+
+    describe "'5d10x'" do
+      it "is the same as '5d10r:10,add.'" do
+        results1 = seeded_rolls(described_class, '5d10x', seed: 235_241, count: 50)
+        results2 = seeded_rolls(described_class, '5d10r:10,add.', seed: 235_241, count: 50)
+        expect(results1).to eql results2
+      end
+    end
+
+    describe "'1d6r:1.'" do
+      it "return same as '1d6r1'" do
+        results1 = seeded_rolls(described_class, '1d6r:1.', seed: 235_241, count: 50)
+        results2 = seeded_rolls(described_class, '1d6r1', seed: 235_241, count: 50)
+        expect(results1).to eql results2
+      end
+    end
+
+    describe "'1d10r:10,replace,1.'" do
+      it 'roll a 10-sided die, re-roll a result of 10 and take the value of the second roll' do
+        d = described_class.create '1d10r:10,replace,1.'
+        expect((1..27).map do
+                 d.roll
+               end).to eql [2, 3, 4, 7, 6, 7, 4, 2, 6, 3, 7, 5, 6, 7, 6, 6, 5, 9, 4, 9, 8, 3, 1, 6, 7, 1, 1]
+      end
+    end
+
+    describe "'1d20r:<=10,use_best,1.'" do
+      it 'roll a 20-sided die, re-roll a result if 10 or lower, and use best result' do
+        d = described_class.create '1d20r:<=10,use_best,1.'
+        expect((1..20).map do
+                 d.roll
+               end).to eql [18, 19, 20, 20, 3, 11, 7, 20, 15, 19, 6, 16, 17, 16, 15, 11, 9, 15, 20, 16]
+      end
+    end
+
+    describe "'5d10r:10,add.k2', '5d10xk2' and '5d10x.k2'" do
+      it 'all be equivalent' do
+        results1 = seeded_rolls(described_class, '5d10r:10,add.k2', seed: 135_241, count: 50)
+        results2 = seeded_rolls(described_class, '5d10xk2', seed: 135_241, count: 50)
+        results3 = seeded_rolls(described_class, '5d10x.k2', seed: 135_241, count: 50)
+        expect(results1).to eql results2
+        expect(results1).to eql results3
+      end
+    end
+
+    describe "'5d10r:>8,add.'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '5d10r:>8,add.'
+        expect((1..5).map { |_n| d.roll }).to eql [22, 22, 31, 64, 26]
+      end
+    end
+
+    describe "'9d6x.m:10.'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '9d6x.m:10.'
+        expect((1..5).map { |_n| d.roll }).to eql [1, 2, 1, 1, 1]
+      end
+
+      it 'can be explained as number of exploding dice scoring 10+' do
+        d = described_class.create '9d6x.m:10.'
+        expect((1..5).map do |_n|
+                 d.roll
+                 d.explain_result
+               end).to eql [
+                 '9d6: [6+3] 9, 2, 3, 4, [6+4] 10, 2, [6+3] 9, 3, 5. Successes: 1',
+                 '9d6: [6+6+3] 15, [6+5] 11, 2, 1, 4, 2, 1, 3, 5. Successes: 2',
+                 '9d6: 1, [6+6+1] 13, 2, 1, 1, 3, [6+1] 7, 5, 4. Successes: 1',
+                 '9d6: [6+4] 10, 3, 4, 5, 5, 1, [6+3] 9, 3, 5. Successes: 1',
+                 '9d6: [6+3] 9, 3, [6+5] 11, 4, 2, 2, 1, 4, 5. Successes: 1'
+               ]
+      end
+    end
+
+    describe "'9d6x.m:10,1,S.'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '9d6x.m:10,1,S.'
+        expect((1..5).map { |_n| d.roll }).to eql [1, 2, 1, 1, 1]
+      end
+
+      it "includes the string 'S' next to each success" do
+        d = described_class.create '9d6x.m:10,1,S.'
+        expect((1..5).map do |_n|
+                 d.roll
+                 d.explain_result
+               end).to eql [
+                 '9d6: [6+3] 9, 2, 3, 4, [6+4] 10 S, 2, [6+3] 9, 3, 5. Successes: 1',
+                 '9d6: [6+6+3] 15 S, [6+5] 11 S, 2, 1, 4, 2, 1, 3, 5. Successes: 2',
+                 '9d6: 1, [6+6+1] 13 S, 2, 1, 1, 3, [6+1] 7, 5, 4. Successes: 1',
+                 '9d6: [6+4] 10 S, 3, 4, 5, 5, 1, [6+3] 9, 3, 5. Successes: 1',
+                 '9d6: [6+3] 9, 3, [6+5] 11 S, 4, 2, 2, 1, 4, 5. Successes: 1'
+               ]
+      end
+    end
+
+    describe "'5d10m:>=6,1,S.m:==1,-1,F.'" do
+      it 'returns expected results from rolling' do
+        d = described_class.create '5d10m:>=6,1,S.m:==1,-1,F.'
+        expect((1..10).map { |_n| d.roll }).to eql [2, 2, 4, 3, 2, 1, 1, 3, 3, 0]
+      end
+
+      it "includes the string 'S' next to each success, and 'F' next to each 'fumble'" do
+        d = described_class.create '5d10m:>=6,1,S.m:==1,-1,F.'
+        expect((1..5).map do |_n|
+                 d.roll
+                 d.explain_result
+               end).to eql [
+                 '5d10: 2, 3, 4, 7 S, 6 S. Successes: 2',
+                 '5d10: 7 S, 4, 2, 6 S, 3. Successes: 2',
+                 '5d10: 7 S, 5, 6 S, 7 S, 6 S. Successes: 4',
+                 '5d10: 6 S, 5, 10 S, 9 S, 4. Successes: 3',
+                 '5d10: 10 S, 9 S, 8 S, 3, 1 F. Successes: 2'
+               ]
+      end
+    end
+
+    describe "'4d6k:3.r:1,replace,1.'" do
+      it 'represents roll 4 six-sided dice, re-roll any 1s, and keep best 3.' do
+        d = described_class.create '4d6k:3.r:1,replace,1.'
+        expect((1..10).map { |_n| d.roll }).to eql [12, 14, 14, 18, 11, 17, 11, 15, 14, 14]
+      end
+
+      it 'includes re-rolls and keeper choice in explanations' do
+        d = described_class.create '4d6k:3.r:1,replace,1.'
+        expect((1..5).map do |_n|
+                 d.roll
+                 d.explain_result
+               end).to eql [
+                 '4d6: 6, 3, 2, 3. Keep: 3 + 3 + 6 = 12',
+                 '4d6: 4, 6, 4, 2. Keep: 4 + 4 + 6 = 14',
+                 '4d6: 6, 3, 3, 5. Keep: 3 + 5 + 6 = 14',
+                 '4d6: 6, 6, 3, 6. Keep: 6 + 6 + 6 = 18',
+                 '4d6: 5, 2, [1|4] 4, 2. Keep: 2 + 4 + 5 = 11'
+               ]
+      end
+    end
+
+    describe "'2d20k:1,worst.'" do
+      it 'represents roll 2 twenty-sided dice, return lowest of the two results' do
+        d = described_class.create '2d20k:1,worst.'
+        expect((1..10).map { |_n| d.roll }).to eql [18, 6, 2, 3, 5, 10, 15, 1, 7, 10]
+      end
+
+      it 'includes keeper choice in explanations' do
+        d = described_class.create '2d20k:1,worst.'
+        expect((1..5).map do |_n|
+                 d.roll
+                 d.explain_result
+               end).to eql [
+                 '2d20: 18, 19. Keep: 18',
+                 '2d20: 20, 6. Keep: 6',
+                 '2d20: 20, 2. Keep: 2',
+                 '2d20: 3, 11. Keep: 3',
+                 '2d20: 5, 7. Keep: 5'
+               ]
+      end
+    end
+  end
+end

data/spec/helpers.rb

@@ -1,12 +1,74 @@
 # frozen_string_literal: true
 
 # games_dice/spec/helpers.rb
+require_relative 'support/coverage'
+
 require 'pathname'
 
 require 'games_dice'
 
-def fixture(name)
-  "#{__dir__}/fixtures/#{name}"
+def marshal_round_trip(value)
+  payload = Marshal.dump(value)
+  # RuboCop rationale: round-trip compatibility requires loading data generated by this test helper.
+  # rubocop:disable Security/MarshalLoad
+  Marshal.load(payload)
+  # rubocop:enable Security/MarshalLoad
+end
+
+def expect_probability_values(actual, expected, tolerance: 1e-10, tolerances: {}, total_tolerance: 1e-9)
+  expected.each do |result, probability|
+    matcher = probability.nil? ? be_nil : be_within(tolerances.fetch(result, tolerance)).of(probability)
+    expect(actual[result]).to matcher
+  end
+  expect(actual.values.sum).to be_within(total_tolerance).of(1.0) if total_tolerance
+end
+
+def expect_aggregate_probabilities(actual, expected, tolerance: 1e-10)
+  expected.each do |query, cases|
+    cases.each do |target, probability|
+      boundary_probability = probability.zero? || (1.0 - probability).zero?
+      matcher = boundary_probability ? eq(probability) : be_within(tolerance).of(probability)
+      expect(actual.public_send(query, target)).to matcher
+    end
+  end
+end
+
+def expect_rule_arguments(die_class, keyword, valid:, invalid:)
+  valid.each { |value| expect { die_class.new(10, **{ keyword => value }) }.not_to raise_error }
+  invalid.each { |value, error| expect { die_class.new(10, **{ keyword => value }) }.to raise_error(error) }
+end
+
+def expect_die_result_state(actual, value:, rolls:, reasons:)
+  expect(actual.value).to eq(value)
+  expect(actual.rolls).to eq(rolls)
+  expect(actual.roll_reasons).to eq(reasons)
+end
+
+def expect_fair_die(probability_class, sides)
+  probability = probability_class.for_fair_die(sides)
+  expect(probability).to be_a(probability_class)
+  expect_fair_distribution(probability.to_h, sides)
+end
+
+def expect_fair_distribution(distribution, sides)
+  expected = (1..sides).to_h { |result| [result, 1.0 / sides] }
+  expect(distribution).to be_valid_distribution
+  expect(distribution.keys).to match_array(expected.keys)
+  expect_probability_values(distribution, expected, total_tolerance: nil)
+end
+
+def expect_injected_prng(die, prng)
+  (0..5).each do |die_result|
+    allow(prng).to receive(:rand).and_return(die_result)
+    expect(die.roll).to eq((die_result + 1) * 3)
+    expect(prng).to have_received(:rand).with(6).at_least(:once)
+  end
+end
+
+def seeded_rolls(factory, notation, seed:, count:)
+  srand(seed)
+  die = factory.create(notation)
+  Array.new(count) { die.roll }
 end
 
 # TestPRNG tests short predictable series

data/spec/simple_cov_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'helpers'
+require 'open3'
+require 'rbconfig'
+require_relative 'support/validation'
+
+describe SimpleCov, :aggregate_failures do
+  include_context 'with temporary Ruby source'
+
+  let(:coverage_setup) { File.expand_path('support/coverage.rb', __dir__) }
+
+  def coverage_result(source, load_source: true)
+    with_source(source) do |directory|
+      code = load_source ? 'require "./lib/probe"' : ''
+      Open3.capture2e(RbConfig.ruby, '-r', coverage_setup, '-e', code, chdir: directory)
+    end
+  end
+
+  it 'accepts fully covered Ruby code' do
+    output, status = coverage_result('[true, false].each { |flag| flag ? 1 : 2 }')
+    expect(status).to be_success, output
+  end
+
+  it 'rejects a line coverage shortfall' do
+    output, status = coverage_result("def uncalled\n  1\n  2\nend\n")
+    expect(status.exitstatus).to eq(2)
+    expect(output).to include('Line coverage', 'below the expected minimum coverage (95.00%)')
+  end
+
+  it 'rejects a branch shortfall even when every line runs' do
+    output, status = coverage_result('[true].each { |flag| flag ? 1 : 2 }')
+    expect(status.exitstatus).to eq(2)
+    expect(output).to include('Line Coverage: 100.0%', 'Branch coverage', 'expected minimum coverage (95.00%)')
+  end
+
+  it 'counts maintained Ruby files that were never loaded' do
+    output, status = coverage_result("class Unloaded\n  def value\n    1\n  end\nend\n", load_source: false)
+    expect(status.exitstatus).to eq(2)
+    expect(output).to include('Line Coverage: 0.0%')
+  end
+end

data/spec/support/coverage.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+
+SimpleCov.start do
+  enable_coverage :branch
+  track_files 'lib/**/*.rb'
+  add_filter { |source| !source.filename.start_with?(File.join(SimpleCov.root, 'lib/')) }
+  coverage_dir 'coverage/ruby'
+  use_merging false
+  minimum_coverage line: 95, branch: 95
+end

data/spec/support/validation.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+
+shared_context 'with temporary Ruby source' do
+  def with_source(source)
+    Dir.mktmpdir('games-dice-validation') do |directory|
+      FileUtils.mkdir_p(File.join(directory, 'lib'))
+      File.write(File.join(directory, 'lib/probe.rb'), source)
+      yield directory
+    end
+  end
+end

data/spec/yard/cli/stats_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'helpers'
+require 'open3'
+require 'rbconfig'
+require 'yard'
+require_relative '../../support/validation'
+
+describe YARD::CLI::Stats, :aggregate_failures do
+  include_context 'with temporary Ruby source'
+
+  let(:documentation_check) { File.expand_path('../../../script/check_documentation.rb', __dir__) }
+
+  def documentation_result(source)
+    with_source(source) do |directory|
+      Open3.capture2e(RbConfig.ruby, documentation_check, chdir: directory)
+    end
+  end
+
+  it 'accepts documented source' do
+    output, status = documentation_result("# A documented class.\nclass Probe\nend\n")
+    expect(status).to be_success, output
+    expect(output).to include('100.00% documented')
+  end
+
+  it 'rejects undocumented objects' do
+    output, status = documentation_result("class Probe\nend\n")
+    expect(status).not_to be_success
+    expect(output).to include('Documentation check found undocumented objects', 'Probe')
+  end
+
+  it 'rejects YARD warnings even when the object is documented' do
+    output, status = documentation_result("# A documented class.\n# @unknown_tag invalid\nclass Probe\nend\n")
+    expect(status).not_to be_success
+    expect(output).to include('Unknown tag @unknown_tag', '100.00% documented')
+  end
+
+  it 'rejects an empty documentation source boundary' do
+    output, status = documentation_result('# No API objects here.')
+    expect(status).not_to be_success
+    expect(output).to include('Documentation check found no objects')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: games_dice
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Neil Slater
@@ -55,25 +55,42 @@ files:
 - lib/games_dice/complex_die_helpers.rb
 - lib/games_dice/constants.rb
 - lib/games_dice/dice.rb
+- lib/games_dice/dice_helpers.rb
 - lib/games_dice/die.rb
 - lib/games_dice/die_result.rb
 - lib/games_dice/map_rule.rb
 - lib/games_dice/marshal.rb
 - lib/games_dice/parser.rb
+- lib/games_dice/probability_budget.rb
+- lib/games_dice/probability_calculation.rb
+- lib/games_dice/probability_shortcuts.rb
+- lib/games_dice/recipe_cache.rb
 - lib/games_dice/reroll_rule.rb
 - lib/games_dice/version.rb
-- spec/bunch_spec.rb
-- spec/complex_die_spec.rb
-- spec/dice_spec.rb
-- spec/die_result_spec.rb
-- spec/die_spec.rb
-- spec/fixtures/probs_fair_die_6.dat
+- script/check_documentation.rb
+- spec/games_dice/bunch_regressions_spec.rb
+- spec/games_dice/bunch_spec.rb
+- spec/games_dice/complex_die_budget_spec.rb
+- spec/games_dice/complex_die_limits_spec.rb
+- spec/games_dice/complex_die_spec.rb
+- spec/games_dice/dice_mutation_spec.rb
+- spec/games_dice/dice_regressions_spec.rb
+- spec/games_dice/dice_spec.rb
+- spec/games_dice/die_result_spec.rb
+- spec/games_dice/die_spec.rb
+- spec/games_dice/map_rule_spec.rb
+- spec/games_dice/parser_spec.rb
+- spec/games_dice/probabilities_boundaries_spec.rb
+- spec/games_dice/probabilities_marshal_spec.rb
+- spec/games_dice/probabilities_spec.rb
+- spec/games_dice/probability_budget_spec.rb
+- spec/games_dice/reroll_rule_spec.rb
+- spec/games_dice_spec.rb
 - spec/helpers.rb
-- spec/map_rule_spec.rb
-- spec/parser_spec.rb
-- spec/probability_spec.rb
-- spec/readme_spec.rb
-- spec/reroll_rule_spec.rb
+- spec/simple_cov_spec.rb
+- spec/support/coverage.rb
+- spec/support/validation.rb
+- spec/yard/cli/stats_spec.rb
 homepage: https://github.com/neilslater/games_dice
 licenses:
 - MIT