dicebag 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dc6f9c347f892aeb166fcae63db74f852f4f78d5
-  data.tar.gz: 4b719b9fa625bef4c4cc5a9bf531249d1cd366b6
+SHA256:
+  metadata.gz: b36691cc7b34c8637154bac79f610b1867d55902b904e83b390b12ae1e6ebf37
+  data.tar.gz: d3fb57f5f563a1e599beb75831953ff3e8bc6dd2e60fcc82aee66a609ac96b1a
 SHA512:
-  metadata.gz: 78bf99b571914d1a28c26f964cdaf23ffbdb1bbb923527bacf1f613785f46b82cbfba283471cc080bdcc53a5c95263550472294ee4e3c22f6e5eaa77d3907769
-  data.tar.gz: da473d03f4524f4e0824d02b2875b705a2ef41c5254f6ad002ec1816696f2d78e348a5fe1ed3b636199b91587e6d8da4614b5d70f2ec6f2e67eedf03b84d8b03
+  metadata.gz: d0367e80fdfc838a465a5b431c766a3418dcb35ae99f8cce9a6ee9f040e6dd4b859b1c561a36f6bfbed16e88a4e9e817e9f9c077263de8721e72498ab9e6e63d
+  data.tar.gz: d1cf650ccb9d0a75fcfb9d278198b949c17291ebf488878f3c7df3a3accb63ac8c9e9ed8c00b1ffb6222369fd6ed9c0ad1bad8a5c5c8b471cefd59e7cffa63d7

data/bin/dicebag

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+# require 'dicebag'
+require_relative '../lib/dicebag'
+
+# Define the Dicebag CLI app
+class DiceBagCLI
+  attr_reader :params
+
+  def self.call
+    new.perform
+  end
+
+  def initialize
+    @params = { notes: false }
+  end
+
+  def opts
+    @opts ||= OptionParser.new do |args|
+      args.on '-n', '--notes', 'Display any notes for the roll.'
+    end
+  end
+
+  def perform
+    nonopts = opts.parse! into: params
+
+    roll   = DiceBag::Roll.new nonopts.first
+    result = roll.roll
+
+    puts result
+
+    puts_notes(roll) if params[:notes]
+  rescue StandardError => err
+    abort err.to_s
+  end
+
+  def puts_notes(roll)
+    nstr = roll.notes_to_s
+
+    return if nstr.empty?
+
+    puts nstr
+  end
+end
+
+DiceBagCLI.call

data/lib/dicebag/label_part.rb

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

data/lib/dicebag/normalize.rb

@@ -0,0 +1,165 @@
+# DiceBag Module
+module DiceBag
+  # Encapsulate the Normalization Process
+  #
+  # 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 classes.
+  class Normalize
+    # The Abstract Source Tree
+    attr_reader :ast
+
+    def self.call(ast)
+      new(ast).perform
+    end
+
+    def initialize(ast)
+      # ASTs that only have a :start section will be a single array by
+      # itself, with the first element being `:start`, so we need to
+      # wrap it once more.
+      ast = [ast] unless ast.first.is_a? Array
+
+      @ast = ast
+    end
+
+    def perform
+      ast.map { |part| normalize part }
+    end
+
+    private
+
+    def normalize(part)
+      [op(part.first), value(part.last)]
+    end
+
+    def op(oper)
+      # We swap out the strings for symbols. If the oper is not one of
+      # the arithimetic operators, then the oper itself is returned.
+      # (This should only happen on :start and :label parts.)
+      case oper
+      when '+' then :add
+      when '-' then :sub
+      when '*' then :mul
+      when '/' then :div
+      else
+        oper
+      end
+    end
+
+    def 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 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.nil? || count.zero?
+
+      # Set the :count and :sides keys directly and setup the notes array.
+      hash[:count] = count
+      hash[:sides] = sides
+      hash[:notes] = []
+
+      normalize_options hash
+    end
+
+    def normalize_options(hash)
+      if hash[:options].empty?
+        hash.delete(:options)
+
+        return hash
+      end
+
+      normalize_explode hash
+      normalize_reroll hash
+      normalize_drop_keep hash
+      normalize_target hash
+      normalize_failure hash
+
+      hash
+    end
+
+    # Prevent Explosion abuse.
+    def normalize_explode(hash)
+      return unless hash[:options].key?(:explode)
+
+      explode = hash[:options][:explode]
+
+      return if explode.nil? || explode >= 2
+
+      hash[:options][:explode] = nil
+
+      hash[:notes].push("Explode set to #{hash[:sides]}")
+    end
+
+    # Prevent Reroll abuse.
+    def normalize_reroll(hash)
+      return unless hash[:options].key?(:reroll) &&
+                    hash[:options][:reroll] >= hash[:sides]
+
+      hash[:options][:reroll] = 0
+
+      hash[:notes].push 'Reroll reset to 0.'
+    end
+
+    # Make sure there are enough dice to handle both Drop and Keep values.
+    # If not, both are reset to 0. Harsh.
+    def normalize_drop_keep(hash)
+      drop = hash[:options].fetch(:drop, 0)
+      keep = hash[:options].fetch(:keep, 0)
+
+      return unless (drop + keep) >= hash[:count]
+
+      hash[:options][:drop] = 0
+      hash[:options][:keep] = 0
+
+      hash[:notes].push 'Drop and Keep Conflict. Both reset to 0.'
+    end
+
+    # If we have a failure number, make sure it is equal to or less than
+    # the dice sides and greater than 0, otherwise, set it to 0 (i.e. no
+    # failure number) and add a note.
+    def normalize_failure(hash)
+      return unless hash[:options].key?(:failure)
+
+      failure = hash[:options][:failure]
+
+      return if failure >= 0 && failure <= hash[:sides]
+
+      hash[:options][:failure] = 0
+
+      hash[:notes].push 'Failure number too large or is negative; reset to 0.'
+    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
+    # (i.e. no target number) and add a note.
+    def 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
+  end
+end

data/lib/dicebag/parser.rb

@@ -1,61 +1,87 @@
-# 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.
+  # 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
     # Base rules.
     rule(:space?)  { str(' ').repeat }
 
-    # Numbers are limited to 3 digit places. Why?
-    # To prevent abuse from people rolling:
-    # 999999999D999999999 and 'DOS'-ing the app.
+    # Numbers are limited to 3 digit places.
+    #
+    # Why? To prevent abuse from people rolling: 999999999D999999999 and
+    # 'DOS'-ing the app.
     rule(:number)  { match('[0-9]').repeat(1, 3) }
     rule(:number?) { number.maybe }
 
     # Label rule
-    # Labels must match '(<some text here>)' and
-    # 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
-    # parenethesis or a comma.
+    #
+    # Labels must match '(<some text here>)' and 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 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.
-    # :count is allowed to be nil, which will default
-    # to 1.
+    #
+    # :count is allowed to be nil, which will default to 1.
     rule(:count) { number?.as(:count) }
     rule(:sides) { match('[dD]') >> number.as(:sides) }
 
     # xDx Parts.
-    # All xDx parts may be followed by none, one, or more
-    # options.
+    #
+    # 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.
+    #
+    # Note that :explode is allowed to NOT have a number assigned, which
+    # will leave it with a nil value. This is handled in the Transform
+    # class.
+    #
+    # For whatever reason ri doesn't work here, so I'm ordering the
+    # indefinite options as ir
+
+    # Explode!
     rule(:explode) { str('e') >> number?.as(:explode) >> space? }
-    rule(:drop)    { str('d') >> number.as(:drop) >> space? }
-    rule(:keep)    { str('k') >> number.as(:keep) >> space? }
-    rule(:reroll)  { str('r') >> number.as(:reroll) >> space? }
-    rule(:target)  { str('t') >> number.as(:target) >> space? }
-
-    # 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.
+
+    # Drop number of lowest rolled dice equal to drop value.
+    rule(:drop) { str('d') >> number.as(:drop) >> space? }
+
+    # Keep dice which are greater than the keep value.
+    rule(:keep) { str('k') >> number.as(:keep) >> space? }
+
+    # Only keep dice that are lower than the keeplowest value.
+    rule(:keeplowest) { str('kl') >> number.as(:keeplowest) >> space? }
+
+    # Reroll if die is less than reroll value.
+    rule(:reroll) { str('r') >> number.as(:reroll) >> space? }
+
+    # Don't tally the dice, but count how many rolled >= the target
+    # value.
+    rule(:target) { str('t') >> number.as(:target) >> space? }
+
+    # Opposite of :target, dice that roll below the failure value are
+    # not considered successes and are subtraced from successes.
+    rule(:failure) { str('f') >> number.as(:failure) >> space? }
+
+    # 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(:option) do
-      (drop | explode | keep | reroll | target)
+      drop |
+        explode |
+        keep |
+        keeplowest |
+        reroll |
+        target |
+        failure
     end
 
     rule(:options) { space? >> option.repeat >> space? }
@@ -69,19 +95,19 @@ module DiceBag
     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.
+    #
+    # 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?
     end
 
-    # All parts of a dice roll MUST start with an xDx
-    # string and then followed by any optional parts.
-    # The first xDx string is labeled as :start.
+    # All parts of a dice roll MUST start with an xDx string and then
+    # followed by any optional parts. The first xDx string is labeled as
+    # :start.
     rule(:parts) { xdx.as(:start) >> part.repeat }
 
-    # A dice string is an optional label, followed by
-    # the defined parts.
+    # A dice string is an optional label, followed by the defined parts.
     rule(:dice) { label.maybe >> parts }
 
     root(:dice)

data/lib/dicebag/result.rb

@@ -1,10 +1,9 @@
-# Encoding: UTF-8
-
 module DiceBag
-  # This class merely encapsulates the result,
-  # providing convience methods to access the
-  # results of each section if desired.
+  # This class merely encapsulates the result, providing convience
+  # methods to access the results of each section if desired.
   class Result
+    include Comparable
+
     attr_reader :label
     attr_reader :total
     attr_reader :sections
@@ -15,8 +14,8 @@ module DiceBag
       @sections = sections
     end
 
-    def each
-      sections.each { |section| yield section }
+    def each(&block)
+      sections.each { |section| block.call section }
     end
 
     def to_s
@@ -24,5 +23,13 @@ module DiceBag
 
       total.to_s
     end
+
+    def inspect
+      "<#{self.class.name} #{self}>"
+    end
+
+    def <=>(other)
+      @total <=> other.total
+    end
   end
 end

data/lib/dicebag/roll.rb

@@ -1,10 +1,7 @@
-# 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.
+  # 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 DiceBag.default_roll
   class Roll
     include RollString
 
@@ -14,21 +11,28 @@ module DiceBag
     alias parsed tree
 
     def initialize(dstr = nil)
-      @dstr   = dstr ||= DEFAULT_ROLL
+      @dstr   = dstr ||= DiceBag.default_roll
       @tree   = DiceBag.parse dstr
       @result = nil
     end
 
     def notes
-      str = ''
+      arr = []
+      fmt = "For %s: %s\n"
 
       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)
+        if part.is_a?(RollPart) && !part.notes.empty?
+          arr.push format(fmt, part, part.notes)
+        end
       end
 
-      str
+      arr
+    end
+
+    def notes_to_s
+      n = notes
+
+      n.empty? ? '' : n.join("\n")
     end
 
     def result
@@ -62,8 +66,8 @@ module DiceBag
       end
     end
 
-    def handle_op(op, part)
-      case op
+    def handle_op(oper, part)
+      case oper
       when :start then @total  = part.total
       when :add   then @total += part.total
       when :sub   then @total -= part.total