dicebag 3.2.1 → 3.3.0

data/lib/dicebag/transform.rb

@@ -1,82 +1,93 @@
-# Encoding: UTF-8
-
-# This continues definining the DiceBag module.
+# 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.)
+  # 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 self.hashify_options(options)
       opts = {}
 
-      options.each { |val| opts.update val } if options.respond_to? :each
+      options.each { |val| opts.update val } if options.respond_to?(:each)
 
       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.)
-    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)) { { 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)]
+    # Options.
+    #
+    # The full options hash is updated later with these sub-hashes.
+    rule(drop: simple(:x)) do
+      { drop: Integer(x) }
     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])
+    rule(keep: simple(:x)) do
+      { keep: Integer(x) }
+    end
 
-                { xdx: { count: count, sides: sides }, options: options }
-              else
-                Integer(part)
-              end
+    rule(keeplowest: simple(:x)) do
+      { keeplowest: Integer(x) }
+    end
+
+    rule(reroll: simple(:x)) do
+      { reroll: Integer(x) }
+    end
 
-      [String(o), value]
+    rule(target: simple(:x)) do
+      { target: Integer(x) }
+    end
+
+    rule(failure: simple(:x)) do
+      { failure: Integer(x) }
+    end
+
+    # Explode is special, in that if it is nil, then we set it to -1 to
+    # reflect that.
+    rule(explode: simple(:x)) do
+      { explode: (x ? Integer(x) : nil) }
     end
 
     # 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
+
+    # Match an operator followed by a immediate value.
+    rule(op: simple(:o), value: simple(:v)) do
+      [String(o), Integer(v)]
     end
   end
 end

data/lib/dicebag.rb

@@ -1,183 +1,33 @@
-# Copyright (c) 2012 Randy Carnahan <syn at dragonsbait dot com>
-#
-# 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
-# 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
-# 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
-# USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# dicelib.rb -- version: 3.2.0
-
 require 'parslet'
 
 # This defined the main DiceBag module.
 module DiceBag
-  DEFAULT_ROLL = '1d6'.freeze
-
-  # This is our generic DiceBagError
-  # exception subclass.
-  class DiceBagError < Exception; end
-
-  ###
-  # Module Methods
-  ###
-
-  # This takes the parsed tree, AFTER it has
-  # been through the Transform class, and massages
-  # the data a bit more, to ease the iteration that
-  # happens in the Roll class. It will convert all
-  # values into the correct *Part class.
-  def self.normalize_tree(tree)
-    tree = [tree] unless tree.first.is_a? Array
-
-    tree.map { |part| normalize part }
-  end
-
-  def self.normalize(part)
-    [
-      normalize_op(part.first),
-      normalize_value(part.last)
-    ]
-  end
-
-  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)
-    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(hash)
-    count = hash[:xdx][:count]
-    sides = hash[:xdx][:sides]
-
-    # Delete the no longer needed :xdx key.
-    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.
-    hash[:count] = count
-    hash[:sides] = sides
-    hash[:notes] = []
-
-    normalize_options hash
-  end
-
-  def self.normalize_options(hash)
-    if hash[:options].empty?
-      hash.delete(:options)
-    else
-      normalize_explode hash
-      normalize_reroll hash
-      normalize_drop_keep hash
-      normalize_target hash
-    end
-
-    hash
-  end
+  # This is our generic DiceBagError exception subclass.
+  class DiceBagError < StandardError; end
 
-  # Prevent Explosion abuse.
-  def self.normalize_explode(xdx)
-    return unless xdx[:options].key? :explode
-
-    explode = xdx[:options][:explode]
-
-    if explode.nil? || explode.zero? || explode == 1
-      xdx[:options][:explode] = xdx[:sides]
-
-      xdx[:notes].push("Explode set to #{xdx[:sides]}")
-    end
-  end
-
-  # Prevent Reroll abuse.
-  def self.normalize_reroll(xdx)
-    return unless xdx[:options].key? :reroll
-
-    if xdx[:options][:reroll] >= xdx[:sides]
-      xdx[:options][:reroll] = 0
-
-      xdx[: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)
-
-    if (drop + keep) >= xdx[:count]
-      xdx[:options][:drop] = 0
-      xdx[:options][:keep] = 0
+  # 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 parts for other purposes.
+  def self.parse(dstr = '')
+    tree = Parser.new.parse(dstr)
+    ast  = Transform.new.apply(tree)
 
-      xdx[:notes].push 'Drop and Keep Conflict. Both reset to 0.'
-    end
+    Normalize.call ast
   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.'
+  ### Main Syntatic Sugar Interface
+  def self.roll(dstr)
+    DiceBag::Roll.new(dstr).roll
   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 = '')
-    tree = Parser.new.parse(dstr)
-    ast  = Transform.new.apply(tree)
-
-    normalize_tree ast
+  # The default roll if one is not given.
+  def self.default_roll
+    '1d6'
   end
 end
 
 # Our sub-modules.
+require_relative './dicebag/normalize'
 require_relative './dicebag/roll_string'
 require_relative './dicebag/roll_part_string'
 require_relative './dicebag/parser'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dicebag
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.3.0
 platform: ruby
 authors:
 - SynTruth
-autorequire: 
+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
@@ -32,12 +32,15 @@ dependencies:
         version: 1.4.0
 description: A very flexible dice rolling library for Ruby.
 email: syntruth@gmail.com
-executables: []
+executables:
+- dicebag
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/dicebag
 - lib/dicebag.rb
 - lib/dicebag/label_part.rb
+- lib/dicebag/normalize.rb
 - lib/dicebag/parser.rb
 - lib/dicebag/result.rb
 - lib/dicebag/roll.rb
@@ -46,29 +49,35 @@ files:
 - lib/dicebag/roll_string.rb
 - lib/dicebag/simple_part.rb
 - lib/dicebag/static_part.rb
+- lib/dicebag/systems/dnd.rb
+- lib/dicebag/systems/fudge.rb
+- lib/dicebag/systems/gurps.rb
+- lib/dicebag/systems/savage_worlds.rb
+- lib/dicebag/systems/standard.rb
+- lib/dicebag/systems/storyteller.rb
 - lib/dicebag/transform.rb
 homepage: https://github.com/syntruth/Dice-Bag
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- lib/systems
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: 'Dice Bag: Ruby Dice Rolling Library'
 test_files: []