dicebag 3.2.2 → 3.3.1

data/lib/dicebag/transform.rb

@@ -1,30 +1,51 @@
-# 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)
+      return options if options.is_a? Hash
+
       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
 
     # 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) } }
-    rule(target:  simple(:x)) { { target: Integer(x) } }
+    #
+    # The full options hash is updated later with these sub-hashes.
+    rule(drop: simple(:x)) do
+      { drop: Integer(x) }
+    end
+
+    rule(keep: simple(:x)) do
+      { keep: Integer(x) }
+    end
+
+    rule(keeplowest: simple(:x)) do
+      { keeplowest: Integer(x) }
+    end
 
-    # Explode is special, in that if it is nil, then it
-    # must remain that way.
-    rule(explode: simple(:x)) { { explode: (x ? Integer(x) : 1) } }
+    rule(reroll: simple(:x)) do
+      { reroll: Integer(x) }
+    end
+
+    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, and it'll be updated in the normalization phase.
+    rule(explode: simple(:x)) do
+      { explode: (x ? Integer(x) : -1) }
+    end
 
     # Match a label by itself.
     rule(label: simple(:s)) { [:label, LabelPart.new(String(s))] }
@@ -44,16 +65,19 @@ module DiceBag
 
     # 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.
+    # 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: (c ? Integer(c) : 1), sides: Integer(s) }
+      {
+        count: (c ? Integer(c) : 1),
+        sides: Integer(s)
+      }
     end
 
     # Match an operator followed by an :xdx subtree.
@@ -63,6 +87,7 @@ module DiceBag
       [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

data/lib/dicebag.rb

@@ -1,189 +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.2
-
 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)
-    when Integer
-      StaticPart.new val
-    else
-      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(hash)
-    return unless hash[:options].key? :explode
-
-    if hash[:options][:explode] == 1
-      hash[:options][:explode] = hash[:sides]
-
-      hash[:notes].push("Explode set to #{hash[:sides]}")
-    end
-  end
-
-  # Prevent Reroll abuse.
-  def self.normalize_reroll(hash)
-    return unless hash[:options].key? :reroll
-
-    if hash[:options][:reroll] >= hash[:sides]
-      hash[:options][:reroll] = 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(hash)
-    drop = hash[:options].fetch(:drop, 0)
-    keep = hash[:options].fetch(:keep, 0)
-
-    if (drop + keep) >= hash[:count]
-      hash[:options][:drop] = 0
-      hash[:options][:keep] = 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(hash)
-    return unless hash[:options].key? :target
-
-    target = hash[:options][:target]
-
-    return if target >= 0 && target <= hash[:sides]
-
-    hash[:options][:target] = 0
-
-    hash[: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.
+  # 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)
 
-    normalize_tree ast
+    Normalize.call ast
+  end
+
+  ### Main Syntatic Sugar Interface
+  def self.roll(dstr)
+    DiceBag::Roll.new(dstr).roll
   end
 
-  def self.roll(dstr = '')
-    Roll.new(dstr).roll
+  # 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,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: dicebag
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.3.1
 platform: ruby
 authors:
 - SynTruth
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2016-04-25 00:00:00.000000000 Z
@@ -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: []