games_dice 0.4.0 → 0.4.2

data/spec/die_result_spec.rb

@@ -4,157 +4,157 @@ require 'helpers'
 
 describe GamesDice::DieResult do
   describe '.new' do
-    it "should work without parameters to represent 'no results yet'" do
-      die_result = GamesDice::DieResult.new
-      expect(die_result.value).to eql nil
+    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 'should work with a single Integer param to represent an initial result' do
-      die_result = GamesDice::DieResult.new(8)
-      expect(die_result.value).to eql 8
+    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 'should not accept a param that cannot be coerced to Integer' do
-      expect(-> { GamesDice::DieResult.new([]) }).to raise_error(TypeError)
-      expect(-> { GamesDice::DieResult.new('N') }).to raise_error(ArgumentError)
+    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 'should not accept unknown reasons for making a roll' do
-      expect(-> { GamesDice::DieResult.new(8, 'wooo') }).to raise_error(ArgumentError)
-      expect(-> { GamesDice::DieResult.new(8, :frabulous) }).to raise_error(ArgumentError)
+    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 "starting from 'no results yet'" do
-      let(:die_result) { GamesDice::DieResult.new }
+    context "when starting from 'no results yet'" do
+      let(:die_result) { described_class.new }
 
-      it 'should create an initial result' do
+      it 'create an initial result' do
         die_result.add_roll(5)
-        expect(die_result.value).to eql 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 'should accept non-basic reasons for the first roll' do
+      it 'accept non-basic reasons for the first roll' do
         die_result.add_roll(4, :reroll_subtract)
-        expect(die_result.value).to eql(-4)
+        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 'should 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)
+      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 'should 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)
+      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 'starting with an initial result' do
-      let(:die_result) { GamesDice::DieResult.new(7) }
+    context 'when starting with an initial result' do
+      let(:die_result) { described_class.new(7) }
 
-      it 'should 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)
+      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 'should 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)
+      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
 
-      context 'add another basic roll' do
-        it 'should replace an initial result, as if the die were re-rolled' do
+      context 'when adding another basic roll' do
+        it 'replace an initial result, as if the die were re-rolled' do
           die_result.add_roll(5)
-          expect(die_result.value).to eql 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
       end
 
-      context 'exploding dice' do
-        it 'should add to value when exploding up' do
+      context 'with exploding dice' do
+        it 'add to value when exploding up' do
           die_result.add_roll(6, :reroll_add)
-          expect(die_result.value).to eql 13
+          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 'should subtract from value when exploding down' do
+        it 'subtract from value when exploding down' do
           die_result.add_roll(4, :reroll_subtract)
-          expect(die_result.value).to eql 3
+          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
       end
 
-      context 're-roll dice' do
-        it 'should optionally replace roll unconditionally' do
+      context 'with re-roll dice' do
+        it 'optionally replace roll unconditionally' do
           die_result.add_roll(2, :reroll_replace)
-          expect(die_result.value).to eql 2
+          expect(die_result.value).to be 2
           expect(die_result.rolls).to eql [7, 2]
           expect(die_result.roll_reasons).to eql %i[basic reroll_replace]
 
           die_result.add_roll(5, :reroll_replace)
-          expect(die_result.value).to eql 5
+          expect(die_result.value).to be 5
           expect(die_result.rolls).to eql [7, 2, 5]
           expect(die_result.roll_reasons).to eql %i[basic reroll_replace reroll_replace]
         end
 
-        it 'should optionally use best roll' do
+        it 'optionally use best roll' do
           die_result.add_roll(2, :reroll_use_best)
-          expect(die_result.value).to eql 7
+          expect(die_result.value).to be 7
           expect(die_result.rolls).to eql [7, 2]
           expect(die_result.roll_reasons).to eql %i[basic reroll_use_best]
 
           die_result.add_roll(9, :reroll_use_best)
-          expect(die_result.value).to eql 9
+          expect(die_result.value).to be 9
           expect(die_result.rolls).to eql [7, 2, 9]
           expect(die_result.roll_reasons).to eql %i[basic reroll_use_best reroll_use_best]
         end
 
-        it 'should optionally use worst roll' do
+        it 'optionally use worst roll' do
           die_result.add_roll(4, :reroll_use_worst)
-          expect(die_result.value).to eql 4
+          expect(die_result.value).to be 4
           expect(die_result.rolls).to eql [7, 4]
           expect(die_result.roll_reasons).to eql %i[basic reroll_use_worst]
 
           die_result.add_roll(5, :reroll_use_worst)
-          expect(die_result.value).to eql 4
+          expect(die_result.value).to be 4
           expect(die_result.rolls).to eql [7, 4, 5]
           expect(die_result.roll_reasons).to eql %i[basic reroll_use_worst reroll_use_worst]
         end
       end
 
-      context 'combinations of reroll reasons' do
-        it 'should correctly handle valid reasons for extra rolls in combination' do
+      context 'with combinations of reroll reasons' do
+        it 'correctly handle valid reasons for extra rolls in combination' do
           die_result.add_roll(10, :reroll_add)
           die_result.add_roll(3, :reroll_subtract)
-          expect(die_result.value).to eql 14
+          expect(die_result.value).to be 14
           expect(die_result.rolls).to eql [7, 10, 3]
           expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract]
 
           die_result.add_roll(12, :reroll_replace)
-          expect(die_result.value).to eql 12
+          expect(die_result.value).to be 12
           expect(die_result.rolls).to eql [7, 10, 3, 12]
           expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace]
 
           die_result.add_roll(9, :reroll_use_best)
-          expect(die_result.value).to eql 12
+          expect(die_result.value).to be 12
           expect(die_result.rolls).to eql [7, 10, 3, 12, 9]
           expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace
                                                     reroll_use_best]
 
           die_result.add_roll(15, :reroll_add)
-          expect(die_result.value).to eql 27
+          expect(die_result.value).to be 27
           expect(die_result.rolls).to eql [7, 10, 3, 12, 9, 15]
           expect(die_result.roll_reasons).to eql %i[basic reroll_add reroll_subtract reroll_replace
                                                     reroll_use_best reroll_add]
@@ -164,18 +164,18 @@ describe GamesDice::DieResult do
   end
 
   describe '#explain_value' do
-    let(:die_result) { GamesDice::DieResult.new }
+    let(:die_result) { described_class.new }
 
-    it "should be empty string for 'no results yet'" do
+    it "be empty string for 'no results yet'" do
       expect(die_result.explain_value).to eql ''
     end
 
-    it 'should be a simple stringified number when there is one die roll' do
+    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 'should describe all single rolls made and how they combine' do
+    it 'describe all single rolls made and how they combine' do
       die_result.add_roll(6)
       expect(die_result.explain_value).to eql '6'
 
@@ -196,59 +196,59 @@ describe GamesDice::DieResult do
     end
   end
 
-  it 'should combine via +,- and * intuitively based on #value' do
-    die_result = GamesDice::DieResult.new(7)
-    expect((die_result + 3)).to eql 10
-    expect((4 + die_result)).to eql 11
-    expect((die_result - 2)).to eql 5
-    expect((9 - die_result)).to eql 2
+  it 'combine via +,- and * intuitively based on #value' do
+    die_result = described_class.new(7)
+    expect(die_result + 3).to be 10
+    expect(4 + die_result).to be 11
+    expect(die_result - 2).to be 5
+    expect(9 - die_result).to be 2
 
-    expect((die_result + 7.7)).to eql 14.7
-    expect((4.1 + die_result)).to eql 11.1
+    expect(die_result + 7.7).to be 14.7
+    expect(4.1 + die_result).to be 11.1
 
-    expect((die_result * 2)).to eql 14
-    expect((1 * die_result)).to eql 7
+    expect(die_result * 2).to be 14
+    expect(1 * die_result).to be 7
 
-    other_die_result = GamesDice::DieResult.new(6)
+    other_die_result = described_class.new(6)
     other_die_result.add_roll(6, :reroll_add)
-    expect((die_result + other_die_result)).to eql 19
-    expect((other_die_result - die_result)).to eql 5
+    expect(die_result + other_die_result).to be 19
+    expect(other_die_result - die_result).to be 5
   end
 
-  it 'should support comparison with >,<,>=,<= as if it were an integer, based on #value' do
-    die_result = GamesDice::DieResult.new(7)
+  it 'support comparison with >,<,>=,<= as if it were an integer, based on #value' do
+    die_result = described_class.new(7)
 
-    expect((die_result > 3)).to eql true
-    expect((die_result < 14)).to eql true
-    expect((die_result >= 7)).to eql true
-    expect((die_result <= 9.5)).to eql true
-    expect((die_result < 3)).to eql false
-    expect((die_result > 14)).to eql false
-    expect((die_result <= 8)).to eql true
-    expect((die_result >= 14)).to eql false
+    expect(die_result > 3).to be true
+    expect(die_result < 14).to be true
+    expect(die_result >= 7).to be true
+    expect(die_result <= 9.5).to be true
+    expect(die_result < 3).to be false
+    expect(die_result > 14).to be false
+    expect(die_result <= 8).to be true
+    expect(die_result >= 14).to be false
 
-    other_die_result = GamesDice::DieResult.new(6)
+    other_die_result = described_class.new(6)
     other_die_result.add_roll(6, :reroll_add)
-    expect((die_result > other_die_result)).to eql false
-    expect((other_die_result > die_result)).to eql true
-    expect((die_result >= other_die_result)).to eql false
-    expect((other_die_result >= die_result)).to eql true
-    expect((die_result < other_die_result)).to eql true
-    expect((other_die_result < die_result)).to eql false
-    expect((die_result <= other_die_result)).to eql true
-    expect((other_die_result <= die_result)).to eql false
+    expect(die_result > other_die_result).to be false
+    expect(other_die_result > die_result).to be true
+    expect(die_result >= other_die_result).to be false
+    expect(other_die_result >= die_result).to be true
+    expect(die_result < other_die_result).to be true
+    expect(other_die_result < die_result).to be false
+    expect(die_result <= other_die_result).to be true
+    expect(other_die_result <= die_result).to be false
   end
 
-  it 'should sort, based on #value' do
+  it 'sort, based on #value' do
     die_results = [
-      GamesDice::DieResult.new(7), GamesDice::DieResult.new(5), GamesDice::DieResult.new(8), GamesDice::DieResult.new(3)
+      described_class.new(7), described_class.new(5), described_class.new(8), described_class.new(3)
     ]
 
     die_results.sort!
 
-    expect(die_results[0].value).to eql 3
-    expect(die_results[1].value).to eql 5
-    expect(die_results[2].value).to eql 7
-    expect(die_results[3].value).to eql 8
+    expect(die_results[0].value).to be 3
+    expect(die_results[1].value).to be 5
+    expect(die_results[2].value).to be 7
+    expect(die_results[3].value).to be 8
   end
 end

data/spec/die_spec.rb

@@ -9,16 +9,16 @@ describe GamesDice::Die do
   end
 
   describe '#new' do
-    it 'should return an object that represents e.g. a six-sided die' do
-      die = GamesDice::Die.new(6)
-      expect(die.min).to eql 1
-      expect(die.max).to eql 6
-      expect(die.sides).to eql 6
+    it 'return an object that represents e.g. a six-sided die' do
+      die = described_class.new(6)
+      expect(die.min).to be 1
+      expect(die.max).to be 6
+      expect(die.sides).to be 6
     end
 
-    it 'should accept any object with a rand(Integer) method as the second param' do
+    it 'accept any object with a rand(Integer) method as the second param' do
       prng = TestPRNG.new
-      die = GamesDice::Die.new(20, prng)
+      die = described_class.new(20, prng)
       [16, 7, 3, 11, 16, 18, 20, 7].each do |expected|
         expect(die.roll).to eql expected
         expect(die.result).to eql expected
@@ -27,8 +27,8 @@ describe GamesDice::Die do
   end
 
   describe '#roll and #result' do
-    it "should return results based on Ruby's internal rand() by default" do
-      die = GamesDice::Die.new(10)
+    it "return results based on Ruby's internal rand() by default" do
+      die = described_class.new(10)
       [5, 4, 10, 4, 7, 8, 1, 9].each do |expected|
         expect(die.roll).to eql expected
         expect(die.result).to eql expected
@@ -37,16 +37,16 @@ describe GamesDice::Die do
   end
 
   describe '#min and #max' do
-    it 'should calculate correct min, max' do
-      die = GamesDice::Die.new(20)
-      expect(die.min).to eql 1
-      expect(die.max).to eql 20
+    it 'calculate correct min, max' do
+      die = described_class.new(20)
+      expect(die.min).to be 1
+      expect(die.max).to be 20
     end
   end
 
   describe '#probabilities' do
-    it "should return the die's probability distribution as a GamesDice::Probabilities object" do
-      die = GamesDice::Die.new(6)
+    it "return the die's probability distribution as a GamesDice::Probabilities object" do
+      die = described_class.new(6)
       probs = die.probabilities
       expect(probs).to be_a GamesDice::Probabilities
 
@@ -64,15 +64,15 @@ describe GamesDice::Die do
   end
 
   describe '#all_values' do
-    it 'should return array with one result value per side' do
-      die = GamesDice::Die.new(8)
+    it 'return array with one result value per side' do
+      die = described_class.new(8)
       expect(die.all_values).to eql [1, 2, 3, 4, 5, 6, 7, 8]
     end
   end
 
   describe '#each_value' do
-    it 'should iterate through all sides of the die' do
-      die = GamesDice::Die.new(10)
+    it 'iterate through all sides of the die' do
+      die = described_class.new(10)
       arr = []
       die.each_value { |x| arr << x }
       expect(arr).to eql [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

data/spec/helpers.rb

@@ -2,8 +2,6 @@
 
 # games_dice/spec/helpers.rb
 require 'pathname'
-require 'coveralls'
-Coveralls.wear!
 
 require 'games_dice'
 
@@ -55,8 +53,8 @@ RSpec::Matchers.define :be_valid_distribution do
     elsif given.values.any? { |v| v < 0.0 || v > 1.0 }
       bad_value = given.values.find { |v| v < 0.0 || v > 1.0 }
       @error = "all values should be in range (0.0..1.0), but found #{bad_value}"
-    elsif (1.0 - given.values.inject(:+)).abs > 1e-6
-      total_probs = given.values.inject(:+)
+    elsif (1.0 - given.values.sum).abs > 1e-6
+      total_probs = given.values.sum
       @error = "sum of values should be 1.0, but got #{total_probs}"
     end
     !@error

data/spec/map_rule_spec.rb

@@ -4,36 +4,36 @@ require 'helpers'
 
 describe GamesDice::MapRule do
   describe '#new' do
-    it 'should accept self-consistent operator/value pairs as a trigger' do
-      GamesDice::MapRule.new(5, :>, 1)
-      GamesDice::MapRule.new((1..5), :member?, 17)
+    it 'accept self-consistent operator/value pairs as a trigger' do
+      expect { described_class.new(5, :>, 1) }.not_to raise_error
+      expect { described_class.new(1..5, :member?, 17) }.not_to raise_error
     end
 
-    it 'should reject inconsistent operator/value pairs for a trigger' do
-      expect(-> { GamesDice::MapRule.new(5, :member?, -1) }).to raise_error(ArgumentError)
-      expect(-> { GamesDice::MapRule.new((1..5), :>, 12) }).to raise_error(ArgumentError)
+    it 'reject inconsistent operator/value pairs for a trigger' do
+      expect { described_class.new(5, :member?, -1) }.to raise_error(ArgumentError)
+      expect { described_class.new(1..5, :>, 12) }.to raise_error(ArgumentError)
     end
 
-    it 'should reject non-Integer map results' do
-      expect(-> { GamesDice::MapRule.new(5, :>, :reroll_again) }).to raise_error(TypeError)
-      expect(-> { GamesDice::MapRule.new((1..5), :member?, 'foo') }).to raise_error(TypeError)
+    it 'reject non-Integer map results' do
+      expect { described_class.new(5, :>, :reroll_again) }.to raise_error(TypeError)
+      expect { described_class.new(1..5, :member?, 'foo') }.to raise_error(TypeError)
     end
   end
 
   describe '#map_from' do
-    it 'should return the mapped value for a match' do
-      rule = GamesDice::MapRule.new(5, :>, -1)
-      expect(rule.map_from(4)).to eql(-1)
+    it 'return the mapped value for a match' do
+      rule = described_class.new(5, :>, -1)
+      expect(rule.map_from(4)).to be(-1)
 
-      rule = GamesDice::MapRule.new((1..5), :member?, 3)
-      expect(rule.map_from(4)).to eql 3
+      rule = described_class.new(1..5, :member?, 3)
+      expect(rule.map_from(4)).to be 3
     end
 
-    it 'should return nil for no match' do
-      rule = GamesDice::MapRule.new(5, :>, -1)
+    it 'return nil for no match' do
+      rule = described_class.new(5, :>, -1)
       expect(rule.map_from(6)).to be_nil
 
-      rule = GamesDice::MapRule.new((1..5), :member?, 3)
+      rule = described_class.new(1..5, :member?, 3)
       expect(rule.map_from(6)).to be_nil
     end
   end

data/spec/parser_spec.rb

@@ -4,9 +4,9 @@ require 'helpers'
 
 describe GamesDice::Parser do
   describe '#parse' do
-    let(:parser) { GamesDice::Parser.new }
+    let(:parser) { described_class.new }
 
-    it 'should parse simple dice sums' do
+    it 'parse simple dice sums' do
       variations = {
         '1d6' => { bunches: [{ ndice: 1, sides: 6, multiplier: 1 }], offset: 0 },
         '2d8-1d4' => { bunches: [{ ndice: 2, sides: 8, multiplier: 1 }, { ndice: 1, sides: 4, multiplier: -1 }],
@@ -30,7 +30,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it "should 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 (once)'" do
       variations = {
         '1d6r1' => { bunches: [{ ndice: 1, sides: 6, multiplier: 1, rerolls: [[1, :>=, :reroll_replace]] }],
                      offset: 0 },
@@ -45,7 +45,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it "should parse 'NdXmZ' as 'roll N times X-sided dice, a value of Z or more equals 1 (success)'" do
+    it "parse 'NdXmZ' as 'roll N times X-sided dice, a value of Z or more equals 1 (success)'" do
       variations = {
         '5d6m6' => { bunches: [{ ndice: 5, sides: 6, multiplier: 1, maps: [[6, :<=, 1]] }],
                      offset: 0 },
@@ -58,7 +58,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it "should parse 'NdXkC' as 'roll N times X-sided dice, add together the best C'" do
+    it "parse 'NdXkC' as 'roll N times X-sided dice, add together the best C'" do
       variations = {
         '5d10k3' => { bunches: [{ ndice: 5, sides: 10, multiplier: 1, keep_mode: :keep_best, keep_number: 3 }],
                       offset: 0 }
@@ -69,7 +69,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it "should parse 'NdXx' as 'roll N times X-sided *exploding* dice'" do
+    it "parse 'NdXx' as 'roll N times X-sided *exploding* dice'" do
       variations = {
         '5d10x' => { bunches: [{ ndice: 5, sides: 10, multiplier: 1, rerolls: [[10, :==, :reroll_add]] }],
                      offset: 0 },
@@ -82,7 +82,7 @@ describe GamesDice::Parser do
       end
     end
 
-    it 'should successfully parse combinations of modifiers in any valid order' do
+    it 'successfully parse combinations of modifiers in any valid order' do
       variations = {
         '5d10r1x' => {
           bunches: [{ ndice: 5, sides: 10, multiplier: 1,