games_dice 0.3.12 → 0.4.0

data/spec/die_spec.rb

@@ -1,81 +1,81 @@
-require 'helpers'
-
-describe GamesDice::Die do
-
-  before do
-    # Set state of default PRNG
-    srand(4567)
-  end
-
-  describe "#new" do
-    it "should return an object that represents e.g. a six-sided die" do
-      die = GamesDice::Die.new(6)
-      die.min.should == 1
-      die.max.should == 6
-      die.sides.should == 6
-    end
-
-    it "should accept any object with a rand(Integer) method as the second param" do
-      prng = TestPRNG.new()
-      die = GamesDice::Die.new(20,prng)
-      [16,7,3,11,16,18,20,7].each do |expected|
-        die.roll.should == expected
-        die.result.should == expected
-      end
-    end
-  end
-
-  describe "#roll and #result" do
-    it "should return results based on Ruby's internal rand() by default" do
-    die = GamesDice::Die.new(10)
-      [5,4,10,4,7,8,1,9].each do |expected|
-        die.roll.should == expected
-        die.result.should == expected
-      end
-    end
-  end
-
-  describe "#min and #max" do
-    it "should calculate correct min, max" do
-      die = GamesDice::Die.new(20)
-      die.min.should == 1
-      die.max.should == 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)
-      probs = die.probabilities
-      probs.should be_a GamesDice::Probabilities
-
-      probs.to_h.should be_valid_distribution
-
-      probs.p_eql(1).should be_within(1e-10).of 1/6.0
-      probs.p_eql(2).should be_within(1e-10).of 1/6.0
-      probs.p_eql(3).should be_within(1e-10).of 1/6.0
-      probs.p_eql(4).should be_within(1e-10).of 1/6.0
-      probs.p_eql(5).should be_within(1e-10).of 1/6.0
-      probs.p_eql(6).should be_within(1e-10).of 1/6.0
-
-      probs.expected.should be_within(1e-10).of 3.5
-    end
-  end
-
-  describe "#all_values" do
-    it "should return array with one result value per side" do
-      die = GamesDice::Die.new(8)
-      die.all_values.should == [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)
-      arr = []
-      die.each_value { |x| arr << x }
-      arr.should == [1,2,3,4,5,6,7,8,9,10]
-    end
-  end
-
-end
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Die do
+  before do
+    # Set state of default PRNG
+    srand(4567)
+  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
+    end
+
+    it 'should accept any object with a rand(Integer) method as the second param' do
+      prng = TestPRNG.new
+      die = GamesDice::Die.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
+      end
+    end
+  end
+
+  describe '#roll and #result' do
+    it "should return results based on Ruby's internal rand() by default" do
+      die = GamesDice::Die.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
+      end
+    end
+  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
+    end
+  end
+
+  describe '#probabilities' do
+    it "should return the die's probability distribution as a GamesDice::Probabilities object" do
+      die = GamesDice::Die.new(6)
+      probs = die.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(probs.expected).to be_within(1e-10).of 3.5
+    end
+  end
+
+  describe '#all_values' do
+    it 'should return array with one result value per side' do
+      die = GamesDice::Die.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)
+      arr = []
+      die.each_value { |x| arr << x }
+      expect(arr).to eql [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    end
+  end
+end

data/spec/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # games_dice/spec/helpers.rb
 require 'pathname'
 require 'coveralls'
@@ -5,31 +7,31 @@ Coveralls.wear!
 
 require 'games_dice'
 
-
-def fixture name
-  (Pathname.new(__FILE__).dirname + "fixtures" + name).to_s
+def fixture(name)
+  "#{__dir__}/fixtures/#{name}"
 end
 
 # TestPRNG tests short predictable series
 class TestPRNG
   def initialize
-    @numbers = [0.123,0.234,0.345,0.999,0.876,0.765,0.543,0.111,0.333,0.777]
+    @numbers = [0.123, 0.234, 0.345, 0.999, 0.876, 0.765, 0.543, 0.111, 0.333, 0.777]
   end
-  def rand(n)
-    Integer( n * @numbers.pop )
+
+  def rand(num)
+    Integer(num * @numbers.pop)
   end
 end
 
 # TestPRNGMax checks behaviour of re-rolls
 class TestPRNGMax
-  def rand(n)
-    Integer( n ) - 1
+  def rand(num)
+    Integer(num) - 1
   end
 end
 
 # TestPRNGMin checks behaviour of re-rolls
 class TestPRNGMin
-  def rand(n)
+  def rand(_num)
     1
   end
 end
@@ -42,13 +44,13 @@ end
 RSpec::Matchers.define :be_valid_distribution do
   match do |given|
     @error = nil
-    if ! given.is_a?(Hash)
+    if !given.is_a?(Hash)
       @error = "distribution should be a Hash, but it is a #{given.class}"
-    elsif given.keys.any? { |k| ! k.is_a?(Integer) }
-      bad_key = given.keys.first { |k| ! k.is_a?(Integer) }
+    elsif given.keys.any? { |k| !k.is_a?(Integer) }
+      bad_key = given.keys.first { |k| !k.is_a?(Integer) }
       @error = "all keys should be Integers, but found '#{bad_key.inspect}' which is a #{bad_key.class}"
-    elsif given.values.any? { |v| ! v.is_a?(Float) }
-      bad_value = given.values.find { |v| ! v.is_a?(Float) }
+    elsif given.values.any? { |v| !v.is_a?(Float) }
+      bad_value = given.values.find { |v| !v.is_a?(Float) }
       @error = "all values should be Floats, but found '#{bad_value.inspect}' which is a #{bad_value.class}"
     elsif given.values.any? { |v| v < 0.0 || v > 1.0 }
       bad_value = given.values.find { |v| v < 0.0 || v > 1.0 }
@@ -57,18 +59,18 @@ RSpec::Matchers.define :be_valid_distribution do
       total_probs = given.values.inject(:+)
       @error = "sum of values should be 1.0, but got #{total_probs}"
     end
-    ! @error
+    !@error
   end
 
-  failure_message do |given|
-    @error ? @error : 'Distribution is valid and complete'
+  failure_message do |_given|
+    @error || 'Distribution is valid and complete'
   end
 
-  failure_message_when_negated do |given|
-     @error ? @error : 'Distribution is valid and complete'
+  failure_message_when_negated do |_given|
+    @error || 'Distribution is valid and complete'
   end
 
-  description do |given|
-    "a hash describing a complete probability distribution of integer results"
+  description do |_given|
+    'a hash describing a complete probability distribution of integer results'
   end
 end

data/spec/map_rule_spec.rb

@@ -1,44 +1,40 @@
-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 )
-    end
-
-    it "should reject inconsistent operator/value pairs for a trigger" do
-      lambda { GamesDice::MapRule.new( 5, :member?, -1 ) }.should raise_error( ArgumentError )
-      lambda { GamesDice::MapRule.new( (1..5), :>, 12 ) }.should raise_error( ArgumentError )
-    end
-
-    it "should reject non-Integer map results" do
-      lambda { GamesDice::MapRule.new( 5, :>, :reroll_again ) }.should raise_error( TypeError )
-      lambda { GamesDice::MapRule.new( (1..5), :member?, 'foo' ) }.should 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 )
-      rule.map_from(4).should == -1
-
-      rule = GamesDice::MapRule.new( (1..5), :member?, 3 )
-      rule.map_from(4).should == 3
-    end
-
-    it "should return nil for no match" do
-      rule = GamesDice::MapRule.new( 5, :>, -1 )
-      rule.map_from(6).should be_nil
-
-      rule = GamesDice::MapRule.new( (1..5), :member?, 3 )
-      rule.map_from(6).should be_nil
-    end
-
-  end
-
-end
+# frozen_string_literal: true
+
+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)
+    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)
+    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)
+    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)
+
+      rule = GamesDice::MapRule.new((1..5), :member?, 3)
+      expect(rule.map_from(4)).to eql 3
+    end
+
+    it 'should return nil for no match' do
+      rule = GamesDice::MapRule.new(5, :>, -1)
+      expect(rule.map_from(6)).to be_nil
+
+      rule = GamesDice::MapRule.new((1..5), :member?, 3)
+      expect(rule.map_from(6)).to be_nil
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -1,82 +1,106 @@
-require 'helpers'
-
-describe GamesDice::Parser do
-
-  describe "#parse" do
-    let(:parser) { GamesDice::Parser.new }
-
-    it "should 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}], :offset => 0 },
-        '+ 2d10 - 1d4 ' => { :bunches => [{:ndice=>2, :sides=>10, :multiplier=>1},{:ndice=>1, :sides=>4, :multiplier=>-1}], :offset => 0 },
-        ' + 3d6 + 12 ' => { :bunches => [{:ndice=>3, :sides=>6, :multiplier=>1}], :offset => 12 },
-        '-7 + 2d4 + 1 ' => { :bunches => [{:ndice=>2, :sides=>4, :multiplier=>1}], :offset => -6 },
-        '- 3 + 7d20 - 1 ' => { :bunches => [{:ndice=>7, :sides=>20, :multiplier=>1}], :offset => -4 },
-        ' -   2d4' => { :bunches => [{:ndice=>2, :sides=>4, :multiplier=>-1}], :offset => 0 },
-        '3d12+5+2d8+1d6' => { :bunches => [{:ndice=>3, :sides=>12, :multiplier=>1},{:ndice=>2, :sides=>8, :multiplier=>1},{:ndice=>1, :sides=>6, :multiplier=>1}], :offset => 5 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-    it "should 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 },
-        '2d20r7' => { :bunches => [{:ndice=>2, :sides=>20, :multiplier=>1, :rerolls=>[ [7,:>=,:reroll_replace] ]}], :offset => 0 },
-        '1d8r2' => { :bunches => [{:ndice=>1, :sides=>8, :multiplier=>1, :rerolls=>[ [2,:>=,:reroll_replace] ]}], :offset => 0 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-    it "should 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 },
-        '2d10m7' => { :bunches => [{:ndice=>2, :sides=>10, :multiplier=>1, :maps=>[ [7,:<=,1] ]}], :offset => 0 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-    it "should 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 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-    it "should 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 },
-        '3d6x' => { :bunches => [{:ndice=>3, :sides=>6, :multiplier=>1, :rerolls=>[ [6,:==,:reroll_add] ]}], :offset => 0 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-    it "should successfully parse combinations of modifiers in any valid order" do
-      variations = {
-        '5d10r1x' => { :bunches => [{:ndice=>5, :sides=>10, :multiplier=>1, :rerolls=>[ [1,:>=,:reroll_replace], [10,:==,:reroll_add] ]}], :offset => 0 },
-        '3d6xk2' => { :bunches => [{:ndice=>3, :sides=>6, :multiplier=>1, :rerolls=>[ [6,:==,:reroll_add] ], :keep_mode=>:keep_best, :keep_number=>2 }], :offset => 0 },
-        '4d6m8x' => { :bunches => [{:ndice=>4, :sides=>6, :multiplier=>1, :maps=>[ [8,:<=,1] ], :rerolls=>[ [6,:==,:reroll_add] ] }], :offset => 0 },
-      }
-
-      variations.each do |input,expected_output|
-        parser.parse( input ).should ==  expected_output
-      end
-    end
-
-  end # describe "#parse"
-end
+# frozen_string_literal: true
+
+require 'helpers'
+
+describe GamesDice::Parser do
+  describe '#parse' do
+    let(:parser) { GamesDice::Parser.new }
+
+    it 'should 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 }],
+                       offset: 0 },
+        '+ 2d10 - 1d4 ' => {
+          bunches: [{ ndice: 2, sides: 10, multiplier: 1 },
+                    { ndice: 1, sides: 4, multiplier: -1 }], offset: 0
+        },
+        ' + 3d6 + 12 ' => { bunches: [{ ndice: 3, sides: 6, multiplier: 1 }], offset: 12 },
+        '-7 + 2d4 + 1 ' => { bunches: [{ ndice: 2, sides: 4, multiplier: 1 }], offset: -6 },
+        '- 3 + 7d20 - 1 ' => { bunches: [{ ndice: 7, sides: 20, multiplier: 1 }], offset: -4 },
+        ' -   2d4' => { bunches: [{ ndice: 2, sides: 4, multiplier: -1 }], offset: 0 },
+        '3d12+5+2d8+1d6' => {
+          bunches: [{ ndice: 3, sides: 12, multiplier: 1 }, { ndice: 2, sides: 8, multiplier: 1 },
+                    { ndice: 1, sides: 6, multiplier: 1 }], offset: 5
+        }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+
+    it "should 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 },
+        '2d20r7' => { bunches: [{ ndice: 2, sides: 20, multiplier: 1, rerolls: [[7, :>=, :reroll_replace]] }],
+                      offset: 0 },
+        '1d8r2' => { bunches: [{ ndice: 1, sides: 8, multiplier: 1, rerolls: [[2, :>=, :reroll_replace]] }],
+                     offset: 0 }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+
+    it "should 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 },
+        '2d10m7' => { bunches: [{ ndice: 2, sides: 10, multiplier: 1, maps: [[7, :<=, 1]] }],
+                      offset: 0 }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+
+    it "should 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 }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+
+    it "should 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 },
+        '3d6x' => { bunches: [{ ndice: 3, sides: 6, multiplier: 1, rerolls: [[6, :==, :reroll_add]] }],
+                    offset: 0 }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+
+    it 'should successfully parse combinations of modifiers in any valid order' do
+      variations = {
+        '5d10r1x' => {
+          bunches: [{ ndice: 5, sides: 10, multiplier: 1,
+                      rerolls: [[1, :>=, :reroll_replace], [10, :==, :reroll_add]] }], offset: 0
+        },
+        '3d6xk2' => {
+          bunches: [{ ndice: 3, sides: 6, multiplier: 1, rerolls: [[6, :==, :reroll_add]],
+                      keep_mode: :keep_best, keep_number: 2 }], offset: 0
+        },
+        '4d6m8x' => {
+          bunches: [{ ndice: 4, sides: 6, multiplier: 1, maps: [[8, :<=, 1]],
+                      rerolls: [[6, :==, :reroll_add]] }], offset: 0
+        }
+      }
+
+      variations.each do |input, expected_output|
+        expect(parser.parse(input)).to eql expected_output
+      end
+    end
+  end
+end