games_dice 0.3.9 → 0.4.0

data/spec/dice_spec.rb

@@ -1,34 +1,33 @@
-require 'games_dice'
-
-describe GamesDice::Dice do
-
-  describe "dice scheme" do
-
-    before :each do
-      srand(67809)
-    end
-
-    describe '1d10+2' do
-      let(:dice) { GamesDice::Dice.new( [ { :sides => 10, :ndice => 1 } ], 2 ) }
-
-      it "should simulate rolling a ten-sided die, and adding two to each result" do
-        [5,4,10,10,7,5,9].each do |expected_total|
-          dice.roll.should == expected_total
-          dice.result.should == expected_total
-        end
-      end
-    end
-
-    describe '2d6+6' do
-      let(:dice) { GamesDice::Dice.new( [ { :sides => 6, :ndice => 2 } ], 6) }
-
-      it "should simulate rolling two six-sided dice and adding six to the result" do
-        [15,12,17,15,13,13,16].each do |expected_total|
-          dice.roll.should == expected_total
-          dice.result.should == expected_total
-        end
-      end
-    end
-
-  end
-end
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Dice do
+  describe 'dice scheme' do
+    before :each do
+      srand(67_809)
+    end
+
+    describe '1d10+2' do
+      let(:dice) { GamesDice::Dice.new([{ sides: 10, ndice: 1 }], 2) }
+
+      it 'should 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) { GamesDice::Dice.new([{ sides: 6, ndice: 2 }], 6) }
+
+      it 'should 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
+end

data/spec/die_result_spec.rb

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