games_dice 0.4.0 → 0.4.2

data/lib/games_dice/parser.rb

@@ -46,9 +46,11 @@ module GamesDice
     rule(:condition_type_and_num) do
       opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) >> comma >> integer.as(:num)
     end
+
     rule(:condition_num_and_output) do
       opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) >> comma >> output_string.as(:output)
     end
+
     rule(:num_and_type) { integer.as(:num) >> comma >> ctl_string.as(:type) }
 
     rule(:reroll_params) { condition_type_and_num | condition_and_type | condition_only }
@@ -78,25 +80,41 @@ module GamesDice
     def parse(dice_description)
       dice_description = dice_description.to_s.strip
       # Force first item to start '+' for simpler parse rules
-      dice_description = "+#{dice_description}" unless dice_description =~ /\A[+-]/
-      dice_expressions = super(dice_description)
-      { bunches: collect_bunches(dice_expressions), offset: collect_offset(dice_expressions) }
+      dice_description = "+#{dice_description}" unless /\A[+-]/.match?(dice_description)
+      dice_expressions = super
+      {
+        bunches: ParseTreeProcessor.collect_bunches(dice_expressions),
+        offset: ParseTreeProcessor.collect_offset(dice_expressions)
+      }
     end
 
-    private
+    # Class converts parse tree to GamesDice hash model
+    # @!visibility private
+    class ParseTreeProcessor
+      class << self
+        def collect_bunches(dice_expressions)
+          dice_expressions[:bunches].select { |h| h[:ndice] }.map do |in_hash|
+            out_hash = {}
+            collect_bunch_basics(in_hash, out_hash)
+            collect_bunch_multiplier(in_hash, out_hash) if in_hash[:op]
+
+            in_hash[:mods]&.each do |mod|
+              collect_bunch_modifier(mod, out_hash)
+            end
+
+            out_hash
+          end
+        end
 
-    def collect_bunches(dice_expressions)
-      dice_expressions[:bunches].select { |h| h[:ndice] }.map do |in_hash|
-        out_hash = {}
-        # Convert integers
-        %i[ndice sides].each do |s|
-          next unless in_hash[s]
+        def collect_bunch_basics(in_hash, out_hash)
+          %i[ndice sides].each do |s|
+            next unless in_hash[s]
 
-          out_hash[s] = in_hash[s].to_i
+            out_hash[s] = in_hash[s].to_i
+          end
         end
 
-        # Multiplier
-        if in_hash[:op]
+        def collect_bunch_multiplier(in_hash, out_hash)
           optype = in_hash[:op].to_s
           out_hash[:multiplier] = case optype
                                   when '+' then 1
@@ -104,116 +122,124 @@ module GamesDice
                                   end
         end
 
-        # Modifiers
-        in_hash[:mods]&.each do |mod|
+        def collect_bunch_modifier(mod, out_hash)
           if mod[:alias]
-            collect_alias_modifier mod, out_hash
+            ParseTreeBunchModifier.collect_alias_modifier mod, out_hash
           elsif mod[:keep]
-            collect_keeper_rule mod, out_hash
+            ParseTreeBunchModifier.collect_keeper_rule mod, out_hash
           elsif mod[:map]
-            out_hash[:maps] ||= []
-            collect_map_rule mod, out_hash
+            ParseTreeBunchModifier.collect_map_rule mod, out_hash
           elsif mod[:reroll]
-            out_hash[:rerolls] ||= []
-            collect_reroll_rule mod, out_hash
+            ParseTreeBunchModifier.collect_reroll_rule mod, out_hash
           end
         end
 
-        out_hash
+        def collect_offset(dice_expressions)
+          dice_expressions[:bunches].select { |h| h[:constant] }.inject(0) do |total, in_hash|
+            c = in_hash[:constant].to_i
+            optype = in_hash[:op].to_s
+            if optype == '+'
+              total + c
+            else
+              total - c
+            end
+          end
+        end
       end
     end
 
-    def collect_offset(dice_expressions)
-      dice_expressions[:bunches].select { |h| h[:constant] }.inject(0) do |total, in_hash|
-        c = in_hash[:constant].to_i
-        optype = in_hash[:op].to_s
-        if optype == '+'
-          total += c
-        else
-          total -= c
+    # Class for collating bunch data into bunch construction hash
+    # @!visibility private
+    class ParseTreeBunchModifier
+      class << self
+        # Called when we have a single letter convenient alias for common dice adjustments
+        def collect_alias_modifier(alias_mod, out_hash)
+          alias_name = alias_mod[:alias].to_s
+          case alias_name
+          when 'x' # Exploding re-roll
+            out_hash[:rerolls] ||= []
+            out_hash[:rerolls] << [out_hash[:sides], :==, :reroll_add]
+          end
         end
-        total
-      end
-    end
 
-    # Called when we have a single letter convenient alias for common dice adjustments
-    def collect_alias_modifier(alias_mod, out_hash)
-      alias_name = alias_mod[:alias].to_s
-      case alias_name
-      when 'x' # Exploding re-roll
-        out_hash[:rerolls] ||= []
-        out_hash[:rerolls] << [out_hash[:sides], :==, :reroll_add]
-      end
-    end
+        # Called for any parsed reroll rule
+        def collect_reroll_rule(reroll_mod, out_hash)
+          out_hash[:rerolls] ||= []
+          if reroll_mod[:simple_value]
+            out_hash[:rerolls] << [reroll_mod[:simple_value].to_i, :>=, :reroll_replace]
+            return
+          end
 
-    # Called for any parsed reroll rule
-    def collect_reroll_rule(reroll_mod, out_hash)
-      out_hash[:rerolls] ||= []
-      if reroll_mod[:simple_value]
-        out_hash[:rerolls] << [reroll_mod[:simple_value].to_i, :>=, :reroll_replace]
-        return
-      end
+          collect_complex_reroll_rule(reroll_mod, out_hash)
+        end
 
-      # Typical reroll_mod: {:reroll=>"r"@5, :condition=>{:compare_num=>"10"@7}, :type=>"add"@10}
-      op = get_op_symbol(reroll_mod[:condition][:comparison] || '==')
-      v = reroll_mod[:condition][:compare_num].to_i
-      type = "reroll_#{reroll_mod[:type] || 'replace'}".to_sym
+        def collect_complex_reroll_rule(reroll_mod, out_hash)
+          # Typical reroll_mod: {:reroll=>"r"@5, :condition=>{:compare_num=>"10"@7}, :type=>"add"@10}
+          op = get_op_symbol(reroll_mod[:condition][:comparison] || '==')
+          v = reroll_mod[:condition][:compare_num].to_i
+          type = :"reroll_#{reroll_mod[:type] || 'replace'}"
+
+          out_hash[:rerolls] << if reroll_mod[:num]
+                                  [v, op, type, reroll_mod[:num].to_i]
+                                else
+                                  [v, op, type]
+                                end
+        end
 
-      out_hash[:rerolls] << if reroll_mod[:num]
-                              [v, op, type, reroll_mod[:num].to_i]
-                            else
-                              [v, op, type]
-                            end
-    end
+        # Called for any parsed keeper mode
+        def collect_keeper_rule(keeper_mod, out_hash)
+          raise 'Cannot set keepers for a bunch twice' if out_hash[:keep_mode]
 
-    # Called for any parsed keeper mode
-    def collect_keeper_rule(keeper_mod, out_hash)
-      raise 'Cannot set keepers for a bunch twice' if out_hash[:keep_mode]
+          if keeper_mod[:simple_value]
+            out_hash[:keep_mode] = :keep_best
+            out_hash[:keep_number] = keeper_mod[:simple_value].to_i
+            return
+          end
 
-      if keeper_mod[:simple_value]
-        out_hash[:keep_mode] = :keep_best
-        out_hash[:keep_number] = keeper_mod[:simple_value].to_i
-        return
-      end
+          # Typical keeper_mod: {:keep=>"k"@5, :num=>"1"@7, :type=>"worst"@9}
+          out_hash[:keep_number] = keeper_mod[:num].to_i
+          out_hash[:keep_mode] = :"keep_#{keeper_mod[:type] || 'best'}"
+        end
 
-      # Typical keeper_mod: {:keep=>"k"@5, :num=>"1"@7, :type=>"worst"@9}
-      out_hash[:keep_number] = keeper_mod[:num].to_i
-      out_hash[:keep_mode] = "keep_#{keeper_mod[:type] || 'best'}".to_sym
-    end
+        # Called for any parsed map mode
+        def collect_map_rule(map_mod, out_hash)
+          out_hash[:maps] ||= []
+          if map_mod[:simple_value]
+            out_hash[:maps] << [map_mod[:simple_value].to_i, :<=, 1]
+            return
+          end
 
-    # Called for any parsed map mode
-    def collect_map_rule(map_mod, out_hash)
-      out_hash[:maps] ||= []
-      if map_mod[:simple_value]
-        out_hash[:maps] << [map_mod[:simple_value].to_i, :<=, 1]
-        return
-      end
+          collect_complex_map_rule(map_mod, out_hash)
+        end
 
-      # Typical map_mod: {:map=>"m"@4, :condition=>{:compare_num=>"5"@6}, :num=>"2"@8, :output=>"Qwerty"@10}
-      op = get_op_symbol(map_mod[:condition][:comparison] || '>=')
-      v = map_mod[:condition][:compare_num].to_i
-      out_val = 1
-      out_val = map_mod[:num].to_i if map_mod[:num]
-
-      out_hash[:maps] << if map_mod[:output]
-                           [v, op, out_val, map_mod[:output].to_s]
-                         else
-                           [v, op, out_val]
-                         end
-    end
+        def collect_complex_map_rule(map_mod, out_hash)
+          # Typical map_mod: {:map=>"m"@4, :condition=>{:compare_num=>"5"@6}, :num=>"2"@8, :output=>"Qwerty"@10}
+          op = get_op_symbol(map_mod[:condition][:comparison] || '>=')
+          v = map_mod[:condition][:compare_num].to_i
+          out_val = 1
+          out_val = map_mod[:num].to_i if map_mod[:num]
+
+          out_hash[:maps] << if map_mod[:output]
+                               [v, op, out_val, map_mod[:output].to_s]
+                             else
+                               [v, op, out_val]
+                             end
+        end
 
-    # The dice description language uses (r).op.x, whilst GamesDice::RerollRule uses x.op.(r), so
-    # as well as converting to a symbol, we must reverse sense of input to constructor
-    OP_CONVERSION = {
-      '==' => :==,
-      '>=' => :<=,
-      '>' => :<,
-      '<' => :>,
-      '<=' => :>=
-    }.freeze
-
-    def get_op_symbol(parsed_op_string)
-      OP_CONVERSION[parsed_op_string.to_s]
+        # The dice description language uses (r).op.x, whilst GamesDice::RerollRule uses x.op.(r), so
+        # as well as converting to a symbol, we must reverse sense of input to constructor
+        OP_CONVERSION = {
+          '==' => :==,
+          '>=' => :<=,
+          '>' => :<,
+          '<' => :>,
+          '<=' => :>=
+        }.freeze
+
+        def get_op_symbol(parsed_op_string)
+          OP_CONVERSION[parsed_op_string.to_s]
+        end
+      end
     end
   end
 end

data/lib/games_dice/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module GamesDice
-  VERSION = '0.4.0'
+  # Current version of the gem.
+  VERSION = '0.4.2'
 end

data/lib/games_dice.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 require 'games_dice/version'
-begin
-  require 'games_dice/games_dice'
-rescue LoadError
-  require 'games_dice/probabilities'
-end
 require 'games_dice/constants'
 require 'games_dice/die'
 require 'games_dice/die_result'
@@ -15,20 +10,23 @@ require 'games_dice/complex_die'
 require 'games_dice/bunch'
 require 'games_dice/dice'
 require 'games_dice/parser'
+require 'games_dice/games_dice'
 require 'games_dice/marshal'
 
+# GamesDice is a library for simulating dice combinations used in dice and board games.
 module GamesDice
-  # @!visibility private
-  @@parser = GamesDice::Parser.new
-
   # Creates an instance of GamesDice::Dice from a string description.
   # @param [String] dice_description Uses a variation of common game notation, examples: '1d6', '3d8+1d4+7', '5d10k2'
   # @param [#rand] prng Optional random number generator, default is to use Ruby's built-in #rand()
   # @return [GamesDice::Dice] A new dice object.
   #
   def self.create(dice_description, prng = nil)
-    parsed = @@parser.parse(dice_description)
+    parsed = parser.parse(dice_description)
     parsed[:bunches].each { |bunch| bunch.merge!(prng: prng) } if prng
     GamesDice::Dice.new(parsed[:bunches], parsed[:offset])
   end
+
+  def self.parser
+    @parser ||= GamesDice::Parser.new
+  end
 end