dicebag 3.2.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 755294b13e5e461c7cefc63493214beb228d539a
-  data.tar.gz: 340241ef792274c0da3a67b97f64ba81f18e6163
+  metadata.gz: dc6f9c347f892aeb166fcae63db74f852f4f78d5
+  data.tar.gz: 4b719b9fa625bef4c4cc5a9bf531249d1cd366b6
 SHA512:
-  metadata.gz: 5efb90bebf321dd2a721f367ec7b1a3c4e57963858210393a0f246646d4cb3865c6f36260c390639007d824100fac44cd16707c9c539db41cf92c833d2073827
-  data.tar.gz: d2b2871d3940d219091daedc85c63771b69a1a789d087e972cb50ae41a0279880733abfabb61199b4d3bb9a35f8f52d00f202d97a4bad8ca47c3e6d5ac7c7a6a
+  metadata.gz: 78bf99b571914d1a28c26f964cdaf23ffbdb1bbb923527bacf1f613785f46b82cbfba283471cc080bdcc53a5c95263550472294ee4e3c22f6e5eaa77d3907769
+  data.tar.gz: da473d03f4524f4e0824d02b2875b705a2ef41c5254f6ad002ec1816696f2d78e348a5fe1ed3b636199b91587e6d8da4614b5d70f2ec6f2e67eedf03b84d8b03

data/lib/dicebag.rb

@@ -40,32 +40,16 @@ module DiceBag
   # happens in the Roll class. It will convert all
   # values into the correct *Part class.
   def self.normalize_tree(tree)
-    tree.collect do |part|
-      case part
-      when Hash
-        normalize_hash part
-      when Array
-        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])
+    tree = [tree] unless tree.first.is_a? Array
 
-      return [:start, RollPart.new(xdx)]
-    end
-
-    part
+    tree.map { |part| normalize part }
   end
 
-  def self.normalize_array(part)
-    [normalize_op(part.first), normalize_value(part.last)]
+  def self.normalize(part)
+    [
+      normalize_op(part.first),
+      normalize_value(part.last)
+    ]
   end
 
   def self.normalize_op(op)
@@ -84,40 +68,47 @@ module DiceBag
   end
 
   def self.normalize_value(val)
-    val.is_a?(Hash) ? RollPart.new(normalize_xdx(val)) : StaticPart.new(val)
+    case val
+    when String
+      LabelPart.new val
+    when Hash
+      RollPart.new normalize_xdx(val)
+    else
+      StaticPart.new val
+    end
   end
 
   # This further massages the xDx hashes.
-  def self.normalize_xdx(xdx)
-    count = xdx[:xdx][:count]
-    sides = xdx[:xdx][:sides]
+  def self.normalize_xdx(hash)
+    count = hash[:xdx][:count]
+    sides = hash[:xdx][:sides]
 
     # Delete the no longer needed :xdx key.
-    xdx.delete(:xdx)
+    hash.delete(:xdx)
 
     # Default to at least 1 die.
     count = 1 if count.zero? || count.nil?
 
     # Set the :count and :sides keys directly
     # and set the notes array.
-    xdx[:count] = count
-    xdx[:sides] = sides
-    xdx[:notes] = []
+    hash[:count] = count
+    hash[:sides] = sides
+    hash[:notes] = []
 
-    normalize_options xdx
+    normalize_options hash
   end
 
-  def self.normalize_options(xdx)
-    if xdx[:options].empty?
-      xdx.delete(:options)
+  def self.normalize_options(hash)
+    if hash[:options].empty?
+      hash.delete(:options)
     else
-      normalize_explode xdx
-      normalize_reroll xdx
-      normalize_drop_keep xdx
-      normalize_target xdx
+      normalize_explode hash
+      normalize_reroll hash
+      normalize_drop_keep hash
+      normalize_target hash
     end
 
-    xdx
+    hash
   end
 
   # Prevent Explosion abuse.

data/lib/dicebag/parser.rb

@@ -5,16 +5,6 @@ module DiceBag
   # 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 }
 
@@ -64,10 +54,11 @@ 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) do
-      space? >> (drop | explode | keep | reroll | target).repeat >> space?
+    rule(:option) do
+      (drop | explode | keep | reroll | target)
     end
 
+    rule(:options) { space? >> option.repeat >> space? }
     rule(:options?) { options.maybe.as(:options) }
 
     # Part Operators.
@@ -81,11 +72,7 @@ module DiceBag
     # 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?
+      space? >> op >> space? >> (xdx | number).as(:value) >> space?
     end
 
     # All parts of a dice roll MUST start with an xDx

data/lib/dicebag/roll_part_string.rb

@@ -7,8 +7,7 @@ module RollPartString
   # string. Optionally, passing true to the method will
   # remove spaces form the finished string.
   def to_s(no_spaces = false)
-    @string = ''
-    @space  = (no_spaces ? '' : ' ')
+    @parts = []
 
     to_s_xdx
     to_s_explode
@@ -17,7 +16,9 @@ module RollPartString
     to_s_reroll
     to_s_target
 
-    @string
+    join_str = no_spaces ? '' : ' '
+
+    @parts.join join_str
   end
 
   private
@@ -26,38 +27,38 @@ module RollPartString
     c = count.zero? ? '' : count.to_s
     s = sides.to_s
 
-    @string += format('%sd%s', c, s)
+    @parts.push format('%sd%s', c, s)
   end
 
   def to_s_explode
-    return unless @options[:explode].zero?
+    return if @options[:explode].zero?
 
     e = (@options[:explode] == sides) ? @options[:explode] : ''
 
-    @string += format('%se%s', @space, e)
+    @parts.push format('e%s', e)
   end
 
   def to_s_drop
-    return unless @options[:drop].zero?
+    return if @options[:drop].zero?
 
-    @string += format('%sd%d', @space, @options[:drop])
+    @parts.push format('d%d', @options[:drop])
   end
 
   def to_s_keep
-    return unless @options[:keep].zero?
+    return if @options[:keep].zero?
 
-    @string += format('%sk%s', @space, @options[:keep])
+    @parts.push format('k%s', @options[:keep])
   end
 
   def to_s_reroll
-    return unless @options[:reroll].zero?
+    return if @options[:reroll].zero?
 
-    @string += format('%sr%s', @space, @options[:reroll])
+    @parts.push format('r%s', @options[:reroll])
   end
 
   def to_s_target
-    return unless @options[:target].zero?
+    return if @options[:target].zero?
 
-    @string += format('%st%s', @space, @options[:target])
+    @parts.push format('t%s', @options[:target])
   end
 end

data/lib/dicebag/roll_string.rb

@@ -4,41 +4,48 @@
 # generation methods.
 module RollString
   def to_s(no_spaces = false)
-    @string = ''
-    @space  = no_spaces ? '' : ' '
+    @parts = []
 
     to_s_tree
 
-    @string.strip
+    str = @parts.join ' '
+
+    no_spaces ? str.tr(' ', '') : str
   end
 
   private
 
   def to_s_tree
-    tree.each { |op, value| @string += send("to_s_#{op}", value) }
+    tree.each do |op, value|
+      @parts.push send("to_s_#{op}", value)
+    end
   end
 
   def to_s_label(value)
-    "#{value}#{@space}"
+    value.to_s
   end
 
   def to_s_start(value)
-    "#{value}#{@space}"
+    value.to_s
   end
 
   def to_s_add(value)
-    "+#{@space}#{value}#{@space}"
+    _op_value '+', value
   end
 
   def to_s_sub(value)
-    "-#{@space}#{value}#{@space}"
+    _op_value '-', value
   end
 
   def to_s_mul(value)
-    "*#{@space}#{value}#{@space}"
+    _op_value '*', value
   end
 
   def to_s_div(value)
-    "/#{@space}#{value}#{@space}"
+    _op_value '/', value
+  end
+
+  def _op_value(op, value)
+    "#{op}#{value}"
   end
 end

data/lib/dicebag/transform.rb

@@ -9,7 +9,7 @@ module DiceBag
     def self.hashify_options(options)
       opts = {}
 
-      options.each { |opt, val| opts[opt] = val } if options.is_a?(Array)
+      options.each { |val| opts.update val } if options.respond_to? :each
 
       opts
     end
@@ -18,16 +18,14 @@ module DiceBag
     # 2-element arrays ('tagged arrays'), which is then
     # 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
-      [:explode, (x ? Integer(x) : nil)]
-    end
+    rule(explode: simple(:x)) { { explode: (x ? Integer(x) : nil) } }
 
     # Parts {:ops => (:xdx | :number)}
     # These are first-match, so the simple number will
@@ -56,27 +54,24 @@ module DiceBag
     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)
-      xdx     = part[:xdx]
-      options = Transform.hashify_options(part[:options])
+      label = String(s)
 
-      [{ label: label }, { start: { xdx: xdx, options: options } }]
+      [[:label, label], [:start, part]]
     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])
-        }
-      }
+      [:start, part]
+    end
+
+    rule(xdx: subtree(:xdx), options: subtree(:opts)) do
+      { xdx: xdx, options: Transform.hashify_options(opts) }
     end
 
     # Convert the count and sides of an :xdx part.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dicebag
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.2.1
 platform: ruby
 authors:
 - SynTruth
@@ -14,6 +14,9 @@ dependencies:
   name: parslet
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
@@ -21,6 +24,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.4.0
@@ -42,7 +48,8 @@ files:
 - lib/dicebag/static_part.rb
 - lib/dicebag/transform.rb
 homepage: https://github.com/syntruth/Dice-Bag
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []