dicebag 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc6f9c347f892aeb166fcae63db74f852f4f78d5
-  data.tar.gz: 4b719b9fa625bef4c4cc5a9bf531249d1cd366b6
+  metadata.gz: a04e07e333e0dbee195dc20264c31791b3df0e30
+  data.tar.gz: e142197e3d345460e984497d85daf271468bc8c3
 SHA512:
-  metadata.gz: 78bf99b571914d1a28c26f964cdaf23ffbdb1bbb923527bacf1f613785f46b82cbfba283471cc080bdcc53a5c95263550472294ee4e3c22f6e5eaa77d3907769
-  data.tar.gz: da473d03f4524f4e0824d02b2875b705a2ef41c5254f6ad002ec1816696f2d78e348a5fe1ed3b636199b91587e6d8da4614b5d70f2ec6f2e67eedf03b84d8b03
+  metadata.gz: f48eea7ecae33fd45c4f8849b74a627b8cbaf13ef01084320d8cc66397c581501a7852be399a7734f2118562c66e383c5c7d149099722b44387e1744b5b4981a
+  data.tar.gz: 98c8bb9b2e6199487db54d8b11a95f11cac4225a2687a54e356b58c31184e497e633226cf921445f13e5f883fedf92c116d72381dd1af4260a3d3a73bade4959

data/lib/dicebag.rb

@@ -18,7 +18,7 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 # USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-# dicelib.rb -- version: 3.2.0
+# dicelib.rb -- version: 3.2.2
 
 require 'parslet'
 
@@ -73,8 +73,10 @@ module DiceBag
       LabelPart.new val
     when Hash
       RollPart.new normalize_xdx(val)
-    else
+    when Integer
       StaticPart.new val
+    else
+      val
     end
   end
 
@@ -112,57 +114,57 @@ module DiceBag
   end
 
   # Prevent Explosion abuse.
-  def self.normalize_explode(xdx)
-    return unless xdx[:options].key? :explode
-
-    explode = xdx[:options][:explode]
+  def self.normalize_explode(hash)
+    return unless hash[:options].key? :explode
 
-    if explode.nil? || explode.zero? || explode == 1
-      xdx[:options][:explode] = xdx[:sides]
+    if hash[:options][:explode] == 1
+      hash[:options][:explode] = hash[:sides]
 
-      xdx[:notes].push("Explode set to #{xdx[:sides]}")
+      hash[:notes].push("Explode set to #{hash[:sides]}")
     end
   end
 
   # Prevent Reroll abuse.
-  def self.normalize_reroll(xdx)
-    return unless xdx[:options].key? :reroll
+  def self.normalize_reroll(hash)
+    return unless hash[:options].key? :reroll
 
-    if xdx[:options][:reroll] >= xdx[:sides]
-      xdx[:options][:reroll] = 0
+    if hash[:options][:reroll] >= hash[:sides]
+      hash[:options][:reroll] = 0
 
-      xdx[:notes].push 'Reroll reset to 0.'
+      hash[:notes].push 'Reroll reset to 0.'
     end
   end
 
   # 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)
+  def self.normalize_drop_keep(hash)
+    drop = hash[:options].fetch(:drop, 0)
+    keep = hash[:options].fetch(:keep, 0)
 
-    if (drop + keep) >= xdx[:count]
-      xdx[:options][:drop] = 0
-      xdx[:options][:keep] = 0
+    if (drop + keep) >= hash[:count]
+      hash[:options][:drop] = 0
+      hash[:options][:keep] = 0
 
-      xdx[:notes].push 'Drop and Keep Conflict. Both reset to 0.'
+      hash[: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
+  # 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(hash)
+    return unless hash[:options].key? :target
 
-    target = xdx[:options][:target]
+    target = hash[:options][:target]
 
-    return if target >= 0 && target <= xdx[:sides]
+    return if target >= 0 && target <= hash[:sides]
 
-    xdx[:options][:target] = 0
+    hash[:options][:target] = 0
 
-    xdx[:notes].push 'Target number too large or is negative; reset to 0.'
+    hash[:notes].push 'Target number too large or is negative; reset to 0.'
   end
 
   # This is the wrapper for the parse, transform,
@@ -175,6 +177,10 @@ module DiceBag
 
     normalize_tree ast
   end
+
+  def self.roll(dstr = '')
+    Roll.new(dstr).roll
+  end
 end
 
 # Our sub-modules.

data/lib/dicebag/parser.rb

@@ -24,10 +24,7 @@ module DiceBag
     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.
@@ -39,12 +36,16 @@ module DiceBag
     # xDx Parts.
     # All xDx parts may be followed by none, one, or more
     # options.
+    #
+    # TODO: Remove the .as(:xdx) and rework the Transform
+    # sub-class to account for it. It'll make the
+    # resulting data much cleaner.
     rule(:xdx) { (count >> sides).as(:xdx) >> options? }
 
     # xdx Options.
     # Note that :explode is allowed to NOT have a number
-    # assigned, which will leave it with a nil value.
-    # This is handled in RollPart#initialize.
+    # assigned, which will leave it with a nil value. This
+    # is handled in the Transform class.
     rule(:explode) { str('e') >> number?.as(:explode) >> space? }
     rule(:drop)    { str('d') >> number.as(:drop) >> space? }
     rule(:keep)    { str('k') >> number.as(:keep) >> space? }

data/lib/dicebag/transform.rb

@@ -14,10 +14,9 @@ module DiceBag
       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
-    # options when these rules are matched.)
+    # Options.
+    # The full options hash is updated later with these
+    # sub-hashes.
     rule(drop:    simple(:x)) { { drop:   Integer(x) } }
     rule(keep:    simple(:x)) { { keep:   Integer(x) } }
     rule(reroll:  simple(:x)) { { reroll: Integer(x) } }
@@ -25,58 +24,47 @@ module DiceBag
 
     # Explode is special, in that if it is nil, then it
     # must remain that way.
-    rule(explode: simple(:x)) { { explode: (x ? Integer(x) : nil) } }
-
-    # Parts {:ops => (:xdx | :number)}
-    # These are first-match, so the simple number will
-    # be matched before the xdx subtree.
-
-    # Match an operator followed by a static number.
-    # 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
-      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
+    rule(explode: simple(:x)) { { explode: (x ? Integer(x) : 1) } }
 
     # Match a label by itself.
-    rule(label: simple(:s)) { [:label, String(s)] }
+    rule(label: simple(:s)) { [:label, LabelPart.new(String(s))] }
 
     # Match a label followed by a :start subtree.
     rule(label: simple(:s), start: subtree(:part)) do
-      label = String(s)
-
-      [[:label, label], [:start, part]]
+      [
+        [:label, LabelPart.new(String(s))],
+        [: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, part]
     end
 
+    # Match the xdx and options hash.
+    #
+    # TODO: Remove the .as(:xdx) in the Parser sub-class
+    # and then update this class to account for it. It'll
+    # make the resulting data much cleaner.
     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.
     rule(count: simple(:c), sides: simple(:s)) do
-      { count: Integer(c), sides: Integer(s) }
+      { count: (c ? Integer(c) : 1), sides: Integer(s) }
+    end
+
+    # Match an operator followed by an :xdx subtree.
+    rule(op: simple(:o), value: subtree(:part)) do
+      part[:options] = Transform.hashify_options(part[:options])
+
+      [String(o), part]
+    end
+
+    rule(op: simple(:o), value: simple(:v)) do
+      [String(o), Integer(v)]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dicebag
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
 platform: ruby
 authors:
 - SynTruth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-18 00:00:00.000000000 Z
+date: 2016-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet