dicebag 3.1.0 → 3.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 755294b13e5e461c7cefc63493214beb228d539a
+  data.tar.gz: 340241ef792274c0da3a67b97f64ba81f18e6163
+SHA512:
+  metadata.gz: 5efb90bebf321dd2a721f367ec7b1a3c4e57963858210393a0f246646d4cb3865c6f36260c390639007d824100fac44cd16707c9c539db41cf92c833d2073827
+  data.tar.gz: d2b2871d3940d219091daedc85c63771b69a1a789d087e972cb50ae41a0279880733abfabb61199b4d3bb9a35f8f52d00f202d97a4bad8ca47c3e6d5ac7c7a6a

data/lib/dicebag/label_part.rb

@@ -1,9 +1,10 @@
+# Encoding: UTF-8
+
 module DiceBag
   # The subclass for a label.
   class LabelPart < SimplePart
     def to_s
-      return "(%s)" % self.value
+      format('(%s)', value)
     end
   end
-
 end

data/lib/dicebag/parser.rb

@@ -1,12 +1,27 @@
+# Encoding: UTF-8
+
 module DiceBag
+  # This class parses the dice string into the individual
+  # components. To understand this code, please refer to
+  # the Parslet library's documentation.
   class Parser < Parslet::Parser
+    # We override the #parse method, so that we can
+    # assure that we always return an Array.
+    def parse(dstr)
+      result = super dstr
+
+      result = [result] unless result.is_a? Array
+
+      result
+    end
+
     # Base rules.
     rule(:space?)  { str(' ').repeat }
 
     # Numbers are limited to 3 digit places. Why?
-    # To prevent abuse from people rolling: 
+    # To prevent abuse from people rolling:
     # 999999999D999999999 and 'DOS'-ing the app.
-    rule(:number)  { match('[0-9]').repeat(1,3) }
+    rule(:number)  { match('[0-9]').repeat(1, 3) }
     rule(:number?) { number.maybe }
 
     # Label rule
@@ -14,15 +29,15 @@ module DiceBag
     # are not allowed to have commas in the label.
     # This for future use of parsing multiple dice
     # definitions in comma-separated strings.
-    # The :label matches anything that ISN'T a 
+    # The :label matches anything that ISN'T a
     # parenethesis or a comma.
     rule(:lparen) { str('(') }
     rule(:rparen) { str(')') }
     rule(:label) do
-      lparen >> 
-      match('[^(),]').repeat(1).as(:label) >> 
-      rparen >> 
-      space?
+      lparen >>
+        match('[^(),]').repeat(1).as(:label) >>
+        rparen >>
+        space?
     end
 
     # count and sides rules.
@@ -49,9 +64,9 @@ module DiceBag
     # This allows options to be defined in any order and
     # even have more than one of the same option, however
     # only the last option of a given key will be kept.
-    rule(:options) { 
+    rule(:options) do
       space? >> (drop | explode | keep | reroll | target).repeat >> space?
-    }
+    end
 
     rule(:options?) { options.maybe.as(:options) }
 
@@ -61,16 +76,16 @@ module DiceBag
     rule(:mul) { str('*') }
     rule(:div) { str('/') }
     rule(:op)  { (add | sub | mul | div).as(:op) }
-    
+
     # Part Rule
     # A part is an operator, followed by either an xDx
     # string or a static number value.
-    rule(:part)  do
-      space?                    >> 
-      op                        >> 
-      space?                    >> 
-      (xdx | number).as(:value) >> 
-      space?
+    rule(:part) do
+      space? >>
+        op >>
+        space? >>
+        (xdx | number).as(:value) >>
+        space?
     end
 
     # All parts of a dice roll MUST start with an xDx
@@ -80,7 +95,7 @@ module DiceBag
 
     # A dice string is an optional label, followed by
     # the defined parts.
-    rule(:dice) { label.maybe >> parts  }
+    rule(:dice) { label.maybe >> parts }
 
     root(:dice)
   end

data/lib/dicebag/result.rb

@@ -1,8 +1,10 @@
+# Encoding: UTF-8
+
 module DiceBag
   # This class merely encapsulates the result,
   # providing convience methods to access the
   # results of each section if desired.
-  class Result 
+  class Result
     attr_reader :label
     attr_reader :total
     attr_reader :sections
@@ -13,17 +15,14 @@ module DiceBag
       @sections = sections
     end
 
-    def each(&block)
-      self.sections.each do |section|
-        yield section
-      end
-      return nil
+    def each
+      sections.each { |section| yield section }
     end
 
     def to_s
-      return "#{self.label}: #{self.total}" unless self.label.empty?
-      return self.total.to_s
+      return "#{label}: #{total}" unless label.empty?
+
+      total.to_s
     end
   end
-
 end

data/lib/dicebag/roll.rb

@@ -1,98 +1,77 @@
+# Encoding: UTF-8
+
 module DiceBag
   # This is the 'main' class of Dice Bag. This class
   # takes the dice string, parses it, and encapsulates
   # the actual rolling of the dice. If no dice string
   # is given, it defaults to DefaultRoll.
   class Roll
-    attr :dstr
-    attr :tree
+    include RollString
+
+    attr_reader :dstr
+    attr_reader :tree
 
-    alias :parsed :tree
+    alias parsed tree
 
-    def initialize(dstr=nil)
-      @dstr   = dstr ||= DefaultRoll
-      @tree   = DiceBag.parse(dstr)
+    def initialize(dstr = nil)
+      @dstr   = dstr ||= DEFAULT_ROLL
+      @tree   = DiceBag.parse dstr
       @result = nil
     end
 
     def notes
-      s = ""
+      str = ''
 
-      self.tree.each do |op, part|
-        if part.is_a?(RollPart)
-          n  = part.notes
-          s += "For: #{part}:\n#{n}\n\n" unless n.empty?
-        end
+      tree.each do |_op, part|
+        next unless part.is_a?(RollPart) || !part.notes.empty?
+
+        str += format('For: %s\n%s\n\n', part, part.notes)
       end
 
-      return s
+      str
     end
 
     def result
-      self.roll() unless @result
-      return @result
+      roll unless @result
+
+      @result
     end
 
     def roll
-      total    = 0
-      label    = ""
-      sections = []
-    
-      self.tree.each do |op, part|
-        do_push = true
- 
-        # If this is a RollPart instance,
-        # ensure fresh results.
-        part.roll() if part.is_a?(RollPart)
-
-        case op
-        when :label
-          label   = part.value()
-          do_push = false
-        when :start
-          total = part.total()
-        when :add
-          total += part.total()
-        when :sub
-          total -= part.total()
-        when :mul
-          total *= part.total()
-        when :div
-          total /= part.total()
-        end
-
-        sections.push(part) if do_push
-      end
+      @label    = ''
+      @total    = 0
+      @sections = []
 
-      @result = Result.new(label, total, sections)
+      handle_tree
 
-      return @result
+      @result = Result.new(@label, @total, @sections)
     end
 
-    def to_s(with_space=true)
-      s = ""
-
-      sp = with_space ? ' ' : ''
-
-      self.tree.each do |op, value|
-        case op
-        when :label
-          s += "#{value}#{sp}"
-        when :start
-          s += "#{value}#{sp}"
-        when :add
-          s += "+#{sp}#{value}#{sp}"
-        when :sub
-          s += "-#{sp}#{value}#{sp}"
-        when :mul
-          s += "*#{sp}#{value}#{sp}"
-        when :div
-          s += "/#{sp}#{value}#{sp}"
+    private
+
+    def handle_tree
+      tree.each do |op, part|
+        if op == :label
+          @label = part.value
+          next
         end
+
+        part.roll if part.is_a?(RollPart) # ensure fresh results.
+
+        handle_op op, part
       end
+    end
 
-      return s.strip
+    def handle_op(op, part)
+      case op
+      when :start then @total  = part.total
+      when :add   then @total += part.total
+      when :sub   then @total -= part.total
+      when :mul   then @total *= part.total
+      when :div   then @total /= part.total
+      end
+
+      @sections.push part
     end
   end
-
 end

data/lib/dicebag/roll_part.rb

@@ -1,11 +1,15 @@
+# Encoding: UTF-8
+
 module DiceBag
   # This represents the xDx part of the dice string.
   class RollPart < SimplePart
+    include RollPartString
 
-    attr :count
-    attr :sides
-    attr :parts
-    attr :options
+    attr_reader :count
+    attr_reader :sides
+    attr_reader :parts
+    attr_reader :options
+    attr_reader :tally
 
     def initialize(part)
       @total  = nil
@@ -16,127 +20,111 @@ module DiceBag
       @notes  = part[:notes] || []
 
       # Our Default Options
-      @options = {
-        :explode => 0,
-        :drop    => 0,
-        :keep    => 0,
-        :reroll  => 0,
-        :target  => 0
-      }
-
-      @options.update(part[:options]) if part.has_key?(:options)
+      @options = { explode: 0, drop: 0, keep: 0, reroll: 0, target: 0 }
+
+      @options.update(part[:options]) if part.key?(:options)
     end
 
     def notes
-      return @notes.join("\n") unless @notes.empty?
-      return ""
+      @notes.empty? ? '' : @notes.join("\n")
     end
 
     # Checks to see if this instance has rolled yet
     # or not.
-    def has_rolled?
-      return @total.nil? ? false : true
+    def rolled?
+      @total.nil? ? false : true
     end
 
     # Rolls a single die from the xDx string.
-    def roll_die()
-      num    = 0
-      reroll = @options[:reroll]
+    def roll_die
+      num = 0
+      num = rand(sides) + 1 while num <= @options[:reroll]
 
-      while num <= reroll
-        num = rand(self.sides) + 1
-      end
-
-      return num
+      num
     end
 
     def roll
-      results = []
-      explode = @options[:explode]
-
-      self.count.times do
-        roll = self.roll_die()
+      generate_results
 
-        results.push(roll)
-
-        unless explode.zero?
-          while roll >= explode
-            roll = self.roll_die()
-            results.push(roll)
-          end
-        end
-      end
-
-      results.sort!
-      results.reverse!
+      @results.sort!
+      @results.reverse!
 
       # Save the tally in case it's requested later.
-      @tally = results.dup()
+      @tally = @results.dup
 
-      # Drop the low end numbers if :drop is less than zero.
-      if @options[:drop] < 0
-        results = results[0 ... @options[:drop]]
-      end
+      # Drop the low end numbers if :drop is not zero.
+      handle_drop
 
       # Keep the high end numbers if :keep is greater than zero.
-      if @options[:keep] > 0
-        results = results[0 ... @options[:keep]]
-      end
+      handle_keep
 
-      # If we have a target number, count how many rolls
-      # in the tally are >= than this number, otherwise
-      # we just add up all the numbers.
-      if @options[:target] and @options[:target] > 0
-        @total = results.count {|r| r >= @options[:target]}
-      else
-        # I think reduce(:+) is ugly, but it's very fast.
-        @total = results.reduce(:+)
-      end
-
-      return self
-    end
+      # Set the total.
+      handle_total
 
-    # Returns the tally from the roll. This is the entire
-    # tally, even if a :keep or :drop options were given.
-    def tally()
-      return @tally
+      self
     end
 
-    # Gets the total of the last roll; if there is no 
+    # Gets the total of the last roll; if there is no
     # last roll, it calls roll() first.
     def total
-      self.roll() if @total.nil?
-      return @total
+      roll if @total.nil?
+
+      @total
+    end
+
+    def <=>(other)
+      total <=> other.total
     end
 
-    # This takes the @parts hash and recreates the xDx
-    # string. Optionally, passing true to the method will
-    # remove spaces form the finished string.
-    def to_s(no_spaces=false)
-      s = ""
-
-      sp = no_spaces ? "" : " "
-      
-      s += self.count.to_s unless self.count.zero?
-      s += "d"
-      s += self.sides.to_s
-
-      unless @options[:explode].zero?
-        s += "#{sp}e"
-        s += @options[:explode].to_s unless @options[:explode] == self.sides
+    private
+
+    def generate_results
+      @results = []
+
+      count.times do
+        r = roll_die
+
+        @results.push(r)
+
+        handle_explode(r) unless @options[:explode].zero?
       end
+    end
 
-      s += "#{sp}t" + @options[:target].to_s   unless @options[:target].zero?
-      s += "#{sp}~" + @options[:drop].abs.to_s unless @options[:drop].zero?
-      s += "#{sp}!" + @options[:keep].to_s     unless @options[:keep].zero?
-      s += "#{sp}r" + @options[:reroll].to_s   unless @options[:reroll].zero?
+    def handle_explode(r)
+      while r >= @options[:explode]
+        r = roll_die
 
-      return s
+        @results.push(r)
+      end
     end
 
-    def <=>(other)
-      return self.total <=> other.total
+    def handle_drop
+      return unless @options[:drop] > 0
+
+      # Note that we invert the drop value here.
+      range = 0...-(@options[:drop])
+
+      @results = @results.slice range
+    end
+
+    def handle_keep
+      return unless @options[:keep] > 0
+
+      range = 0...@options[:keep]
+
+      @results = @results.slice range
     end
-  end
 
+    def handle_total
+      # If we have a target number, count how many rolls
+      # in the results are >= than this number, otherwise
+      # we just add up all the numbers.
+      @total = if @options[:target] && @options[:target] > 0
+                 @results.count { |r| r >= @options[:target] }
+               else
+                 # I think reduce(:+) is ugly, but it's very fast.
+                 @results.reduce(:+)
+               end
+    end
+  end
 end

data/lib/dicebag/roll_part_string.rb

@@ -0,0 +1,63 @@
+# Encoding: UTF-8
+
+# This encapsulates the RollPart string
+# generation methods.
+module RollPartString
+  # This takes the @parts hash and recreates the xDx
+  # string. Optionally, passing true to the method will
+  # remove spaces form the finished string.
+  def to_s(no_spaces = false)
+    @string = ''
+    @space  = (no_spaces ? '' : ' ')
+
+    to_s_xdx
+    to_s_explode
+    to_s_drop
+    to_s_keep
+    to_s_reroll
+    to_s_target
+
+    @string
+  end
+
+  private
+
+  def to_s_xdx
+    c = count.zero? ? '' : count.to_s
+    s = sides.to_s
+
+    @string += format('%sd%s', c, s)
+  end
+
+  def to_s_explode
+    return unless @options[:explode].zero?
+
+    e = (@options[:explode] == sides) ? @options[:explode] : ''
+
+    @string += format('%se%s', @space, e)
+  end
+
+  def to_s_drop
+    return unless @options[:drop].zero?
+
+    @string += format('%sd%d', @space, @options[:drop])
+  end
+
+  def to_s_keep
+    return unless @options[:keep].zero?
+
+    @string += format('%sk%s', @space, @options[:keep])
+  end
+
+  def to_s_reroll
+    return unless @options[:reroll].zero?
+
+    @string += format('%sr%s', @space, @options[:reroll])
+  end
+
+  def to_s_target
+    return unless @options[:target].zero?
+
+    @string += format('%st%s', @space, @options[:target])
+  end
+end

data/lib/dicebag/roll_string.rb

@@ -0,0 +1,44 @@
+# Encoding: UTF-8
+
+# This encapsulates the Roll class' string
+# generation methods.
+module RollString
+  def to_s(no_spaces = false)
+    @string = ''
+    @space  = no_spaces ? '' : ' '
+
+    to_s_tree
+
+    @string.strip
+  end
+
+  private
+
+  def to_s_tree
+    tree.each { |op, value| @string += send("to_s_#{op}", value) }
+  end
+
+  def to_s_label(value)
+    "#{value}#{@space}"
+  end
+
+  def to_s_start(value)
+    "#{value}#{@space}"
+  end
+
+  def to_s_add(value)
+    "+#{@space}#{value}#{@space}"
+  end
+
+  def to_s_sub(value)
+    "-#{@space}#{value}#{@space}"
+  end
+
+  def to_s_mul(value)
+    "*#{@space}#{value}#{@space}"
+  end
+
+  def to_s_div(value)
+    "/#{@space}#{value}#{@space}"
+  end
+end

data/lib/dicebag/simple_part.rb

@@ -4,18 +4,18 @@ module DiceBag
   # it will be an instance of this class, which simply
   # returns the value given to it.
   class SimplePart
-    attr :value
+    attr_reader :value
 
     def initialize(part)
       @value = part
     end
 
     def result
-      return @value
+      value
     end
 
     def to_s
-      return @value
+      value
     end
   end
 end

data/lib/dicebag/static_part.rb

@@ -3,17 +3,16 @@ module DiceBag
   # of the dice string.
   class StaticPart < SimplePart
     def initialize(num)
-      num    = num.to_i() if num.is_a?(String)
+      num    = num.to_i if num.is_a?(String)
       @value = num
     end
 
     def total
-      return self.value
+      value
     end
 
     def to_s
-      return self.value.to_s()
+      value.to_s
     end
   end
-
 end

data/lib/dicebag/transform.rb

@@ -1,25 +1,32 @@
+# Encoding: UTF-8
+
+# This continues definining the DiceBag module.
 module DiceBag
+  # This is the Transform subclass that takes the
+  # parsed tree and transforms it into its (almost)
+  # final form. (It gets a normalization pass later.)
   class Transform < Parslet::Transform
-
-    def Transform.hashify_options(options)
+    def self.hashify_options(options)
       opts = {}
-      options.each {|opt, val| opts[opt] = val} if options.is_a?(Array)
-      return opts
+
+      options.each { |opt, val| opts[opt] = val } if options.is_a?(Array)
+
+      opts
     end
 
     # Option transforms. These are turned into an array of
     # 2-element arrays ('tagged arrays'), which is then
-    # hashified later. (There is no way to update the 
+    # hashified later. (There is no way to update the
     # options when these rules are matched.)
-    rule(:drop    => simple(:x)) { [:drop,   Integer(x)] }
-    rule(:keep    => simple(:x)) { [:keep,   Integer(x)] }
-    rule(:reroll  => simple(:x)) { [:reroll, Integer(x)] }
-    rule(:target  => simple(:x)) { [:target, Integer(x)] }
-    
+    rule(drop:    simple(:x)) { [:drop,   Integer(x)] }
+    rule(keep:    simple(:x)) { [:keep,   Integer(x)] }
+    rule(reroll:  simple(:x)) { [:reroll, Integer(x)] }
+    rule(target:  simple(:x)) { [:target, Integer(x)] }
+
     # Explode is special, in that if it is nil, then it
     # must remain that way.
-    rule(:explode => simple(:x)) do
-      x.nil? ? [:explode, nil] : [:explode, Integer(x)]
+    rule(explode: simple(:x)) do
+      [:explode, (x ? Integer(x) : nil)]
     end
 
     # Parts {:ops => (:xdx | :number)}
@@ -27,52 +34,54 @@ module DiceBag
     # be matched before the xdx subtree.
 
     # Match an operator followed by a static number.
-    rule(:op => simple(:o), :value => simple(:v)) do
+    # TODO: find out why this is not matching simple
+    # op => integers! -- 2016-04-18
+    rule(op: simple(:o), value: simple(:v)) do
       [String(o), Integer(v)]
     end
 
     # Match an operator followed by an :xdx subtree.
-    rule(:op => simple(:o), :value => subtree(:part)) do
-      [String(o), 
-        {
-          :xdx => {
-            :count => Integer(part[:xdx][:count]),
-            :sides => Integer(part[:xdx][:sides])
-          },
-          :options => Transform.hashify_options(part[:options])
-        }
-      ] 
+    rule(op: simple(:o), value: subtree(:part)) do
+      value = if part.is_a? Hash
+                count   = Integer(part[:xdx][:count])
+                sides   = Integer(part[:xdx][:sides])
+                options = Transform.hashify_options(part[:options])
+
+                { xdx: { count: count, sides: sides }, options: options }
+              else
+                Integer(part)
+              end
+
+      [String(o), value]
     end
 
     # Match a label by itself.
-    rule(:label => simple(:s)) { {:label => String(s)} }
+    rule(label: simple(:s)) { { label: String(s) } }
 
     # Match a label followed by a :start subtree.
-    rule(:label => simple(:s), :start => subtree(:part)) do
-      [
-        {:label => String(s)},
-        {:start => {
-          :xdx     => part[:xdx],
-          :options => Transform.hashify_options(part[:options])
-          }
-        }
-      ]
+    rule(label: simple(:s), start: subtree(:part)) do
+      label   = String(s)
+      xdx     = part[:xdx]
+      options = Transform.hashify_options(part[:options])
+
+      [{ label: label }, { start: { xdx: xdx, options: options } }]
     end
 
     # Match a :start subtree, with the label not present.
     # Note that this returns a hash, but the final output
     # will still be in an array.
-    rule(:start => subtree(:part)) do
-      {:start => {
-        :xdx     => part[:xdx],
-        :options => Transform.hashify_options(part[:options])
+    rule(start: subtree(:part)) do
+      {
+        start: {
+          xdx:     part[:xdx],
+          options: Transform.hashify_options(part[:options])
         }
       }
     end
 
     # Convert the count and sides of an :xdx part.
-    rule(:count => simple(:c), :sides => simple(:s)) do
-      { :count => Integer(c), :sides => Integer(s) }
+    rule(count: simple(:c), sides: simple(:s)) do
+      { count: Integer(c), sides: Integer(s) }
     end
   end
 end

data/lib/dicebag.rb

@@ -1,31 +1,33 @@
 # Copyright (c) 2012 Randy Carnahan <syn at dragonsbait dot com>
 #
-# Permission is hereby granted, free of charge, to any person obtaining 
+# Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the "Software"),
-# to deal in the Software without restriction, including without limitation 
+# to deal in the Software without restriction, including without limitation
 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
 # and/or sell copies of the Software, and to permit persons to whom the
 # Software is furnished to do so, subject to the following conditions:
 #
-# The above copyright notice and this permission notice shall be included 
+# The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN 
-# NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 
-# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+# NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 # USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-# dicelib.rb -- version: 3.1.0
+# dicelib.rb -- version: 3.2.0
 
 require 'parslet'
 
+# This defined the main DiceBag module.
 module DiceBag
+  DEFAULT_ROLL = '1d6'.freeze
 
-  DefaultRoll = "1d6"
-
+  # This is our generic DiceBagError
+  # exception subclass.
   class DiceBagError < Exception; end
 
   ###
@@ -38,148 +40,160 @@ module DiceBag
   # happens in the Roll class. It will convert all
   # values into the correct *Part class.
   def self.normalize_tree(tree)
-    return tree.collect do |part|
-
+    tree.collect do |part|
       case part
       when Hash
-        if part.has_key?(:label)
-          part = [:label, LabelPart.new(part[:label])]
-        elsif part.has_key?(:start)
-          xdx  = normalize_xdx(part[:start])
-          part = [:start, RollPart.new(xdx)]
-        end
-
+        normalize_hash part
       when Array
-        # We swap out the strings for symbols.
-        # If the op is not one of the arithimetic 
-        # operators, then the op itself is returned.
-        # (This should only happen on :start arrays.)
-
-        op  = part.first
-        val = part.last
-
-        op = case op
-        when "+" then :add
-        when "-" then :sub
-        when "*" then :mul
-        when "/" then :div
-        end
-        
-        # If the value is a hash, it's an :xdx hash.
-        # Normalize it.
-        if val.is_a?(Hash)
-          xdx = normalize_xdx(val)
-          val = RollPart.new(xdx)
-        else
-          val = StaticPart.new(val)
-        end
-
-        part = [op, val]
+        normalize_array part
+      else
+        part
       end
+    end
+  end
+
+  def self.normalize_hash(part)
+    return [:label, LabelPart.new(part[:label])] if part.key? :label
+
+    if part.key? :start
+      xdx = normalize_xdx(part[:start])
+
+      return [:start, RollPart.new(xdx)]
+    end
+
+    part
+  end
+
+  def self.normalize_array(part)
+    [normalize_op(part.first), normalize_value(part.last)]
+  end
 
-      part
+  def self.normalize_op(op)
+    # We swap out the strings for symbols.
+    # If the op is not one of the arithimetic
+    # operators, then the op itself is returned.
+    # (This should only happen on :start arrays.)
+    case op
+    when '+' then :add
+    when '-' then :sub
+    when '*' then :mul
+    when '/' then :div
+    else
+      op
     end
   end
 
+  def self.normalize_value(val)
+    val.is_a?(Hash) ? RollPart.new(normalize_xdx(val)) : StaticPart.new(val)
+  end
+
   # This further massages the xDx hashes.
   def self.normalize_xdx(xdx)
     count = xdx[:xdx][:count]
     sides = xdx[:xdx][:sides]
-    notes = []
+
+    # Delete the no longer needed :xdx key.
+    xdx.delete(:xdx)
 
     # Default to at least 1 die.
-    count = 1 if count.zero? or count.nil?
+    count = 1 if count.zero? || count.nil?
 
     # Set the :count and :sides keys directly
-    # and get rid of the :xdx sub-hash.
+    # and set the notes array.
     xdx[:count] = count
     xdx[:sides] = sides
-    xdx.delete(:xdx)
+    xdx[:notes] = []
+
+    normalize_options xdx
+  end
 
+  def self.normalize_options(xdx)
     if xdx[:options].empty?
       xdx.delete(:options)
     else
-      # VALIDATE ALL THE OPTIONS!!!
+      normalize_explode xdx
+      normalize_reroll xdx
+      normalize_drop_keep xdx
+      normalize_target xdx
+    end
 
-      # Prevent Explosion abuse.
-      if xdx[:options].has_key?(:explode)
-        explode = xdx[:options][:explode]
+    xdx
+  end
 
-        if explode.nil? or explode.zero? or explode == 1
-          xdx[:options][:explode] = sides
-          notes.push("Explode set to #{sides}")
-        end
-      end
+  # Prevent Explosion abuse.
+  def self.normalize_explode(xdx)
+    return unless xdx[:options].key? :explode
 
-      # Prevent Reroll abuse.
-      if xdx[:options].has_key?(:reroll) and xdx[:options][:reroll] >= sides
-        xdx[:options][:reroll] = 0 
-        notes.push("Reroll reset to 0.")
-      end
+    explode = xdx[:options][:explode]
 
-      # Make sure there are enough dice to
-      # handle both Drop and Keep values.
-      # If not, both are reset to 0. Harsh.
-      drop = xdx[:options][:drop] || 0
-      keep = xdx[:options][:keep] || 0
+    if explode.nil? || explode.zero? || explode == 1
+      xdx[:options][:explode] = xdx[:sides]
 
-      if (drop + keep) >= count
-        xdx[:options][:drop] = 0
-        xdx[:options][:keep] = 0
-        notes.push("Drop and Keep Conflict. Both reset to 0.")
-      end
+      xdx[:notes].push("Explode set to #{xdx[:sides]}")
+    end
+  end
 
-      # Negate :drop. See why in RollPart#roll.
-      xdx[:options][:drop] = -(drop)
+  # Prevent Reroll abuse.
+  def self.normalize_reroll(xdx)
+    return unless xdx[:options].key? :reroll
 
-      # Finally, if we have a target number, make sure it is equal
-      # to or less than the dice sides and greater than 0, otherwise, 
-      # set it to 0 (aka no target number) and add a note.
-      if xdx[:options].has_key?(:target)
-        target = xdx[:options][:target]
+    if xdx[:options][:reroll] >= xdx[:sides]
+      xdx[:options][:reroll] = 0
 
-        if target > sides or target < 0
-          xdx[:options][:target] = 0
-          notes.push("Target number too large or is negative; reset to 0.")
-        end
-      end
+      xdx[:notes].push 'Reroll reset to 0.'
     end
+  end
 
-    xdx[:notes] = notes unless notes.empty?
+  # Make sure there are enough dice to
+  # handle both Drop and Keep values.
+  # If not, both are reset to 0. Harsh.
+  def self.normalize_drop_keep(xdx)
+    drop = xdx[:options].fetch(:drop, 0)
+    keep = xdx[:options].fetch(:keep, 0)
 
-    return xdx
+    if (drop + keep) >= xdx[:count]
+      xdx[:options][:drop] = 0
+      xdx[:options][:keep] = 0
+
+      xdx[:notes].push 'Drop and Keep Conflict. Both reset to 0.'
+    end
+  end
+
+  # Finally, if we have a target number, make sure it is equal
+  # to or less than the dice sides and greater than 0, otherwise,
+  # set it to 0 (aka no target number) and add a note.
+  def self.normalize_target(xdx)
+    return unless xdx[:options].key? :target
+
+    target = xdx[:options][:target]
+
+    return if target >= 0 && target <= xdx[:sides]
+
+    xdx[:options][:target] = 0
+
+    xdx[:notes].push 'Target number too large or is negative; reset to 0.'
   end
 
   # This is the wrapper for the parse, transform,
   # and normalize calls. This is called by the Roll
   # class, but may be called to get the raw returned
   # array of parsed bits for other purposes.
-  def self.parse(dstr="")
-    begin
-      tree = Parser.new.parse(dstr)
-      ast  = Transform.new.apply(tree)
-
-      # Sometimes, we get a hash back, so wrap it as 
-      # a single element array.
-      ast = [ast] unless ast.is_a?(Array)
-      
-      return normalize_tree(ast)
-
-    rescue Parslet::ParseFailed => reason
-      # We're merely re-wrapping the error here to 
-      # hide implementation from user who doesn't care
-      # to read the source.
-      raise DiceBagError, "Dice Parse Error for string: #{dstr}"
-    end
-  end
-end 
-
-require 'dicebag/parser'
-require 'dicebag/transform'
-require 'dicebag/simple_part'
-require 'dicebag/label_part'
-require 'dicebag/static_part'
-require 'dicebag/roll_part'
-require 'dicebag/roll'
-require 'dicebag/result'
+  def self.parse(dstr = '')
+    tree = Parser.new.parse(dstr)
+    ast  = Transform.new.apply(tree)
 
+    normalize_tree ast
+  end
+end
+
+# Our sub-modules.
+require_relative './dicebag/roll_string'
+require_relative './dicebag/roll_part_string'
+require_relative './dicebag/parser'
+require_relative './dicebag/transform'
+require_relative './dicebag/simple_part'
+require_relative './dicebag/label_part'
+require_relative './dicebag/static_part'
+require_relative './dicebag/roll_part'
+require_relative './dicebag/roll'
+require_relative './dicebag/result'

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: dicebag
 version: !ruby/object:Gem::Version
-  version: 3.1.0
-  prerelease: 
+  version: 3.2.0
 platform: ruby
 authors:
 - SynTruth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-21 00:00:00.000000000 Z
+date: 2016-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
 description: A very flexible dice rolling library for Ruby.
@@ -33,37 +30,38 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/dicebag.rb
 - lib/dicebag/label_part.rb
 - lib/dicebag/parser.rb
 - lib/dicebag/result.rb
 - lib/dicebag/roll.rb
 - lib/dicebag/roll_part.rb
+- lib/dicebag/roll_part_string.rb
+- lib/dicebag/roll_string.rb
 - lib/dicebag/simple_part.rb
 - lib/dicebag/static_part.rb
 - lib/dicebag/transform.rb
-- lib/dicebag.rb
 homepage: https://github.com/syntruth/Dice-Bag
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
-summary: ! 'Dice Bag: Ruby Dice Rolling Library'
+specification_version: 4
+summary: 'Dice Bag: Ruby Dice Rolling Library'
 test_files: []