games_dice 0.3.12 → 0.4.2

data/lib/games_dice/parser.rb

@@ -1,218 +1,245 @@
-require 'parslet'
-
-# Based on the parslet gem, this class defines the dice mini-language used by GamesDice.create
-#
-# An instance of this class is a parser for the language. There are no user-definable instance
-# variables.
-#
-
-class GamesDice::Parser < Parslet::Parser
-
-  # Parslet rules that define the dice string grammar.
-  rule(:integer) { match('[0-9]').repeat(1) }
-  rule(:plus_minus_integer) { ( match('[+-]') >> integer ) | integer }
-  rule(:range) { integer.as(:range_start) >> str('..') >> integer.as(:range_end) }
-  rule(:dlabel) { match('[d]') }
-  rule(:space) { match('\s').repeat(1) }
-  rule(:space?) { space.maybe }
-  rule(:underscore) { str('_').repeat(1) }
-  rule(:underscore?) { space.maybe }
-
-  rule(:bunch_start) { integer.as(:ndice) >> dlabel >> integer.as(:sides) }
-
-  rule(:reroll_label) { match(['r']).as(:reroll) }
-  rule(:keep_label) { match(['k']).as(:keep) }
-  rule(:map_label) { match(['m']).as(:map) }
-  rule(:alias_label) { match(['x']).as(:alias) }
-
-  rule(:single_modifier) { alias_label }
-  rule(:modifier_label) {  reroll_label | keep_label | map_label }
-  rule(:simple_modifier) { modifier_label >> integer.as(:simple_value) }
-  rule(:comparison_op) { str('>=') | str('<=') | str('==') | str('>') | str('<') }
-  rule(:ctl_string) { match('[a-z_]').repeat(1) }
-  rule(:output_string) { match('[A-Za-z0-9_]').repeat(1) }
-
-  rule(:opint_or_int) { (comparison_op.as(:comparison) >> integer.as(:compare_num)) | integer.as(:compare_num) }
-  rule(:comma) { str(',') }
-  rule(:stop) { str('.') }
-
-  rule(:condition_only) { opint_or_int.as(:condition) }
-  rule(:num_only) { integer.as(:num) }
-
-
-  rule(:condition_and_type) { opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) }
-  rule(:condition_and_num) { opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) }
-
-  rule(:condition_type_and_num) { opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) >> comma >> integer.as(:num) }
-  rule(:condition_num_and_output) { opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) >> comma >> output_string.as(:output) }
-  rule(:num_and_type) { integer.as(:num)  >> comma >> ctl_string.as(:type) }
-
-  rule(:reroll_params) { condition_type_and_num | condition_and_type | condition_only }
-  rule(:map_params) { condition_num_and_output | condition_and_num | condition_only }
-  rule(:keeper_params) { num_and_type | num_only }
-
-  rule(:full_reroll) { reroll_label >> str(':') >> reroll_params >> stop }
-  rule(:full_map) { map_label >> str(':') >> map_params >> stop }
-  rule(:full_keepers) { keep_label >> str(':') >> keeper_params >> stop }
-
-  rule(:complex_modifier) { full_reroll | full_map | full_keepers }
-
-  rule(:bunch_modifier) { complex_modifier | ( single_modifier >> stop.maybe ) | ( simple_modifier >> stop.maybe ) }
-  rule(:bunch) { bunch_start >> bunch_modifier.repeat.as(:mods) }
-
-  rule(:operator) { match('[+-]').as(:op) >> space? }
-  rule(:add_bunch) { operator >> bunch >> space? }
-  rule(:add_constant) { operator >> integer.as(:constant) >> space? }
-  rule(:dice_expression) { add_bunch | add_constant }
-  rule(:expressions) { dice_expression.repeat.as(:bunches) }
-  root :expressions
-
-  # Parses a string description in the dice mini-language, and returns data for feeding into
-  # GamesDice::Dice constructor.
-  # @param [String] dice_description Text to parse e.g. '1d6'
-  # @return [Hash] Analysis of dice_description
-  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 ) }
-  end
-
-  private
-
-  def collect_bunches dice_expressions
-    dice_expressions[:bunches].select {|h| h[:ndice] }.map do |in_hash|
-      out_hash = {}
-      # Convert integers
-      [:ndice, :sides].each do |s|
-        next unless in_hash[s]
-        out_hash[s] = in_hash[s].to_i
-      end
-
-      # Multiplier
-      if in_hash[:op]
-        optype = in_hash[:op].to_s
-        out_hash[:multiplier] = case optype
-          when '+' then 1
-          when '-' then -1
-        end
-      end
-
-      # Modifiers
-      if in_hash[:mods]
-        in_hash[:mods].each do |mod|
-          case
-          when mod[:alias]
-            collect_alias_modifier mod, out_hash
-          when mod[:keep]
-            collect_keeper_rule mod, out_hash
-          when mod[:map]
-            out_hash[:maps] ||= []
-            collect_map_rule mod, out_hash
-          when mod[:reroll]
-            out_hash[:rerolls] ||= []
-            collect_reroll_rule mod, out_hash
-          end
-        end
-      end
-
-      out_hash
-    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
-      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
-
-    # 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
-
-    if reroll_mod[:num]
-      out_hash[:rerolls] << [ v, op, type, reroll_mod[:num].to_i ]
-    else
-      out_hash[:rerolls] << [ 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]
-    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' ) ).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
-
-    # 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
-    if map_mod[:num]
-      out_val = map_mod[:num].to_i
-    end
-
-    if map_mod[:output]
-      out_hash[:maps] << [ v, op, out_val, map_mod[:output].to_s ]
-    else
-      out_hash[:maps] << [ 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 = {
-    '==' => :==,
-    '>=' => :<=,
-    '>' => :<,
-    '<' => :>,
-    '<=' => :>=,
-  }
-
-  def get_op_symbol parsed_op_string
-    OP_CONVERSION[ parsed_op_string.to_s ]
-  end
-
-end # class Parser
+# frozen_string_literal: true
+
+require 'parslet'
+
+module GamesDice
+  # Based on the parslet gem, this class defines the dice mini-language used by GamesDice.create
+  #
+  # An instance of this class is a parser for the language. There are no user-definable instance
+  # variables.
+  #
+  class Parser < Parslet::Parser
+    # Parslet rules that define the dice string grammar.
+    rule(:integer) { match('[0-9]').repeat(1) }
+    rule(:plus_minus_integer) { (match('[+-]') >> integer) | integer }
+    rule(:range) { integer.as(:range_start) >> str('..') >> integer.as(:range_end) }
+    rule(:dlabel) { match('[d]') }
+    rule(:space) { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:underscore) { str('_').repeat(1) }
+    rule(:underscore?) { space.maybe }
+
+    rule(:bunch_start) { integer.as(:ndice) >> dlabel >> integer.as(:sides) }
+
+    rule(:reroll_label) { match(['r']).as(:reroll) }
+    rule(:keep_label) { match(['k']).as(:keep) }
+    rule(:map_label) { match(['m']).as(:map) }
+    rule(:alias_label) { match(['x']).as(:alias) }
+
+    rule(:single_modifier) { alias_label }
+    rule(:modifier_label) {  reroll_label | keep_label | map_label }
+    rule(:simple_modifier) { modifier_label >> integer.as(:simple_value) }
+    rule(:comparison_op) { str('>=') | str('<=') | str('==') | str('>') | str('<') }
+    rule(:ctl_string) { match('[a-z_]').repeat(1) }
+    rule(:output_string) { match('[A-Za-z0-9_]').repeat(1) }
+
+    rule(:opint_or_int) { (comparison_op.as(:comparison) >> integer.as(:compare_num)) | integer.as(:compare_num) }
+    rule(:comma) { str(',') }
+    rule(:stop) { str('.') }
+
+    rule(:condition_only) { opint_or_int.as(:condition) }
+    rule(:num_only) { integer.as(:num) }
+
+    rule(:condition_and_type) { opint_or_int.as(:condition) >> comma >> ctl_string.as(:type) }
+    rule(:condition_and_num) { opint_or_int.as(:condition) >> comma >> plus_minus_integer.as(:num) }
+
+    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 }
+    rule(:map_params) { condition_num_and_output | condition_and_num | condition_only }
+    rule(:keeper_params) { num_and_type | num_only }
+
+    rule(:full_reroll) { reroll_label >> str(':') >> reroll_params >> stop }
+    rule(:full_map) { map_label >> str(':') >> map_params >> stop }
+    rule(:full_keepers) { keep_label >> str(':') >> keeper_params >> stop }
+
+    rule(:complex_modifier) { full_reroll | full_map | full_keepers }
+
+    rule(:bunch_modifier) { complex_modifier | (single_modifier >> stop.maybe) | (simple_modifier >> stop.maybe) }
+    rule(:bunch) { bunch_start >> bunch_modifier.repeat.as(:mods) }
+
+    rule(:operator) { match('[+-]').as(:op) >> space? }
+    rule(:add_bunch) { operator >> bunch >> space? }
+    rule(:add_constant) { operator >> integer.as(:constant) >> space? }
+    rule(:dice_expression) { add_bunch | add_constant }
+    rule(:expressions) { dice_expression.repeat.as(:bunches) }
+    root :expressions
+
+    # Parses a string description in the dice mini-language, and returns data for feeding into
+    # GamesDice::Dice constructor.
+    # @param [String] dice_description Text to parse e.g. '1d6'
+    # @return [Hash] Analysis of dice_description
+    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 /\A[+-]/.match?(dice_description)
+      dice_expressions = super
+      {
+        bunches: ParseTreeProcessor.collect_bunches(dice_expressions),
+        offset: ParseTreeProcessor.collect_offset(dice_expressions)
+      }
+    end
+
+    # 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_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
+          end
+        end
+
+        def collect_bunch_multiplier(in_hash, out_hash)
+          optype = in_hash[:op].to_s
+          out_hash[:multiplier] = case optype
+                                  when '+' then 1
+                                  when '-' then -1
+                                  end
+        end
+
+        def collect_bunch_modifier(mod, out_hash)
+          if mod[:alias]
+            ParseTreeBunchModifier.collect_alias_modifier mod, out_hash
+          elsif mod[:keep]
+            ParseTreeBunchModifier.collect_keeper_rule mod, out_hash
+          elsif mod[:map]
+            ParseTreeBunchModifier.collect_map_rule mod, out_hash
+          elsif mod[:reroll]
+            ParseTreeBunchModifier.collect_reroll_rule mod, out_hash
+          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
+            end
+          end
+        end
+      end
+    end
+
+    # 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
+
+        # 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
+
+        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
+
+        # 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
+
+          # 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
+
+        # 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
+
+        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]
+        end
+      end
+    end
+  end
+end

data/lib/games_dice/reroll_rule.rb

@@ -1,77 +1,76 @@
-# This class models a variety of game rules that cause dice to be re-rolled.
-#
-# An object of the class represents a single rule, such as "re-roll a result of 1
-# and use the new value".
-#
-# @example A rule for "exploding" dice
-#  rule = GamesDice::RerollRule.new( 6, :<=, :reroll_add )
-#  # Test whether the rule applies . . .
-#  rule.applies? 4   # => false
-#  rule.applies? 6   # => true
-#  rule.type         # => :reroll_add
-#
-# @example A rule for re-rolling and taking best value if first attempt is lower than a threshold
-#  rule = GamesDice::RerollRule.new( 11, :>, :reroll_use_best, 1 )
-#  # Test whether the rule applies . . .
-#  rule.applies? 4   # => true
-#  rule.applies? 14  # => false
-#  rule.type         # => :reroll_use_best
-#
-
-class GamesDice::RerollRule
-
-  # Creates new instance of GamesDice::RerollRule. The rule will be assessed as
-  #   trigger_value.send( trigger_op, x )
-  # where x is the Integer value shown on a die.
-  # @param [Integer,Range<Integer>,Object] trigger_value Any object is allowed, but typically an Integer
-  # @param [Symbol] trigger_op A method of trigger_value that takes an Integer param and returns Boolean
-  # @param [Symbol] type The type of reroll
-  # @param [Integer] limit Maximum number of times this rule can be applied to a single die
-  # @return [GamesDice::RerollRule]
-  def initialize trigger_value, trigger_op, type, limit = 1000
-
-    if ! trigger_value.respond_to?( trigger_op )
-      raise ArgumentError, "trigger_value #{trigger_value.inspect} cannot respond to trigger_op #{trigger_value.inspect}"
-    end
-
-    unless GamesDice::REROLL_TYPES.has_key?(type)
-      raise ArgumentError, "Unrecognised reason for a re-roll #{type}"
-    end
-
-    @trigger_value = trigger_value
-    @trigger_op = trigger_op
-    @type = type
-    @limit = limit ? Integer( limit ) : 1000
-    @limit = 1 if @type == :reroll_subtract
-  end
-
-  # Trigger operation. How the rule is assessed against #trigger_value.
-  # @return [Symbol] Method name to be sent to #trigger_value
-  attr_reader :trigger_op
-
-  # Trigger value. An object that will use #trigger_op to assess a die result for a reroll.
-  # @return [Integer,Range,Object] Object that receives (#trigger_op, die_result)
-  attr_reader :trigger_value
-
-  # The reroll behaviour that this rule triggers.
-  # @return [Symbol] A category for the re-roll, declares how it should be processed
-  # The following values are supported:
-  # +:reroll_add+:: add result of reroll to running total, and ignore :reroll_subtract for this die
-  # +reroll_subtract+:: subtract result of reroll from running total, and reverse sense of any further :reroll_add results
-  # +:reroll_replace+:: use the new value in place of existing value for the die
-  # +:reroll_use_best+:: use the new value if it is higher than the existing value
-  # +:reroll_use_worst+:: use the new value if it is higher than the existing value
-  attr_reader :type
-
-  # Maximum to number of times that this rule can be applied to a single die.
-  # @return [Integer] A number of rolls.
-  attr_reader :limit
-
-  # Assesses the rule against a die result value.
-  # @param [Integer] test_value Value that is result of rolling a single die.
-  # @return [Boolean] Whether the rule applies.
-  def applies? test_value
-    @trigger_value.send( @trigger_op, test_value ) ? true : false
-  end
-
-end # class RerollRule
+# frozen_string_literal: true
+
+module GamesDice
+  # This class models a variety of game rules that cause dice to be re-rolled.
+  #
+  # An object of the class represents a single rule, such as "re-roll a result of 1
+  # and use the new value".
+  #
+  # @example A rule for "exploding" dice
+  #  rule = GamesDice::RerollRule.new( 6, :<=, :reroll_add )
+  #  # Test whether the rule applies . . .
+  #  rule.applies? 4   # => false
+  #  rule.applies? 6   # => true
+  #  rule.type         # => :reroll_add
+  #
+  # @example A rule for re-rolling and taking best value if first attempt is lower than a threshold
+  #  rule = GamesDice::RerollRule.new( 11, :>, :reroll_use_best, 1 )
+  #  # Test whether the rule applies . . .
+  #  rule.applies? 4   # => true
+  #  rule.applies? 14  # => false
+  #  rule.type         # => :reroll_use_best
+  #
+  class RerollRule
+    # Creates new instance of GamesDice::RerollRule. The rule will be assessed as
+    #   trigger_value.send( trigger_op, x )
+    # where x is the Integer value shown on a die.
+    # @param [Integer,Range<Integer>,Object] trigger_value Any object is allowed, but typically an Integer
+    # @param [Symbol] trigger_op A method of trigger_value that takes an Integer param and returns Boolean
+    # @param [Symbol] type The type of reroll
+    # @param [Integer] limit Maximum number of times this rule can be applied to a single die
+    # @return [GamesDice::RerollRule]
+    def initialize(trigger_value, trigger_op, type, limit = 1000)
+      unless trigger_value.respond_to?(trigger_op)
+        raise ArgumentError,
+              "trigger_value #{trigger_value.inspect} cannot respond to trigger_op #{trigger_value.inspect}"
+      end
+
+      raise ArgumentError, "Unrecognised reason for a re-roll #{type}" unless GamesDice::REROLL_TYPES.key?(type)
+
+      @trigger_value = trigger_value
+      @trigger_op = trigger_op
+      @type = type
+      @limit = limit ? Integer(limit) : 1000
+      @limit = 1 if @type == :reroll_subtract
+    end
+
+    # Trigger operation. How the rule is assessed against #trigger_value.
+    # @return [Symbol] Method name to be sent to #trigger_value
+    attr_reader :trigger_op
+
+    # Trigger value. An object that will use #trigger_op to assess a die result for a reroll.
+    # @return [Integer,Range,Object] Object that receives (#trigger_op, die_result)
+    attr_reader :trigger_value
+
+    # The reroll behaviour that this rule triggers.
+    # @return [Symbol] A category for the re-roll, declares how it should be processed
+    # The following values are supported:
+    # +:reroll_add+:: add result of reroll to running total, and ignore :reroll_subtract for this die
+    # +reroll_subtract+:: subtract result of reroll from running total, reverse sense of any further :reroll_add results
+    # +:reroll_replace+:: use the new value in place of existing value for the die
+    # +:reroll_use_best+:: use the new value if it is higher than the existing value
+    # +:reroll_use_worst+:: use the new value if it is higher than the existing value
+    attr_reader :type
+
+    # Maximum to number of times that this rule can be applied to a single die.
+    # @return [Integer] A number of rolls.
+    attr_reader :limit
+
+    # Assesses the rule against a die result value.
+    # @param [Integer] test_value Value that is result of rolling a single die.
+    # @return [Boolean] Whether the rule applies.
+    def applies?(test_value)
+      @trigger_value.send(@trigger_op, test_value) ? true : false
+    end
+  end
+end