bag_of_holding 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39a78a5204d2098a8fecd8cccd492ba45139f81b
+  data.tar.gz: 6d51bf38c65f02d9ce32491429ee79a113063e38
+SHA512:
+  metadata.gz: b2ca5daf352b62082f721add1a6bc2a8b4688503ab86c3f80abe9ffaaa8c641959c3740af2bec702d024e0ba8ef8fba04149b9c04c54dcb56a0535b3b813ef43
+  data.tar.gz: b41b2a0dafea439a03a1ed06d1c284d51b95651d383df9f175697e41208a2a0a6c0d4dbea7fce9ad8c6daa818bf1ae465f7c152ffa79f3e4e79304dd10da77bb

data/README.md

@@ -0,0 +1,37 @@
+# Bag of Holding [![Code Climate](https://codeclimate.com/github/packetmonkey/bag_of_holding/badges/gpa.svg)](https://codeclimate.com/github/packetmonkey/bag_of_holding)
+
+Bag of Holding is a command line utility and library to help out with various
+table top gaming needs. It currently contains a dice roller but will grow to
+include a dungeon generator, various card deck functions and anything else I
+think to include.
+
+## Install
+Currently you can clone the repository directly to use it. I will eventually
+distribute it as a ruby gem.
+```sh
+git clone https://github.com/packetmonkey/bag_of_holding.git
+cd bag_of_holding
+bundle
+```
+
+## Usage
+```sh
+./bin/boh roll 1d20+5
+8 = 3 (1d20) + 5
+```
+
+## Found a bug?
+Open a [github issue](https://github.com/packetmonkey/bag_of_holding/issues)
+
+## Contributing & Development
+1. Fork the project.
+2. Make your feature addition or bug fix. All specs should pass.
+3. Add specs for your changes.
+4. Commit
+5. Send a pull request. Bonus points for topic branches.
+
+## Licence
+Bag of Holding is released under the [MIT Licence](http://choosealicense.com/licenses/mit/)
+
+## Authors
+Bag of Holding is written and maintained by Evan Sharp.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+require 'bag_of_holding'
+
+desc 'Run a console with BagOfHolding loaded'
+task :console do
+  require 'pry'
+  ARGV.clear
+  Pry.start
+end
+
+task default: [:spec, :rubocop]

data/bin/boh

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'thor'
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+require 'bag_of_holding'
+
+module BagOfHolding
+  # Internal: Externally executable entry points to the library
+  class CLI < Thor
+    option :verbose, type: :boolean
+    desc 'roll <dice string>', 'Roll dice pools specified in <dice string>'
+    def roll(str)
+      ::BagOfHolding::Dice.roll(str).each do |result|
+        if options[:verbose]
+          puts "#{result.value} = #{result.inspect}"
+        else
+          puts "#{result.value} = #{result}"
+        end
+      end
+    end
+  end
+end
+
+BagOfHolding::CLI.start(ARGV)

data/lib/bag_of_holding/dice/addition_operation.rb

@@ -0,0 +1,18 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulates an operation such as adding two dice pools
+    class AdditionOperation < Operation
+      def self.operator
+        '+'
+      end
+
+      def value
+        left_result.value + right_result.value
+      end
+
+      def operator
+        '+'
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/constant.rb

@@ -0,0 +1,23 @@
+module BagOfHolding
+  module Dice
+    # Internal: Stores a constant value with a rollable API so that this
+    # object can be called like a pool or operation.
+    class Constant
+      attr_accessor :value
+
+      def initialize(value:)
+        self.value = value
+      end
+
+      def roll
+        BagOfHolding::Dice::ConstantResult.new value: value
+      end
+
+      def ==(other)
+        return false unless other.respond_to? :value
+        return false unless value == other.value
+        true
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/constant_result.rb

@@ -0,0 +1,27 @@
+module BagOfHolding
+  module Dice
+    # Internal: Present the 'result' of a constant with a result API so it
+    # can be used interchangeably with an OperationResult or a PoolResult
+    class ConstantResult
+      attr_accessor :value
+
+      def initialize(value: nil)
+        self.value = value
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def inspect
+        value.to_s
+      end
+
+      def ==(other)
+        return false unless other.respond_to? :value
+        return false unless value == other.value
+        true
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/die.rb

@@ -0,0 +1,39 @@
+module BagOfHolding
+  module Dice
+    # Internal: Represent a physical die and it's attributes
+    class Die
+      attr_accessor :sides, :reroll, :explode
+
+      def initialize(opts = {})
+        self.sides    = opts[:sides]
+        self.explode  = opts[:explode]
+        self.reroll   = opts[:reroll]
+      end
+
+      def ==(other)
+        return false if sides != other.sides
+        return false if explode != other.explode
+        return false if reroll != other.reroll
+
+        true
+      end
+
+      def roll
+        fail StandardError unless valid?
+        BagOfHolding::Dice::DieRoller.roll self
+      end
+
+      def valid?
+        DieValidator.valid? self
+      end
+
+      def to_s
+        'd'.tap do |str|
+          str << sides.to_s
+          str << "r#{reroll}" if reroll
+          str << "e#{explode}" if explode
+        end
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/die_result.rb

@@ -0,0 +1,26 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulate the value of a die roll along with the rolls that
+    # where performed to achieve that value.
+    class DieResult
+      attr_accessor :rolls, :value, :die
+
+      def initialize(rolls: nil, value: nil, die: nil)
+        self.rolls = rolls || []
+        self.value = value
+        self.die = die
+      end
+
+      def ==(other)
+        return false if value != other.value
+        return false if rolls != other.rolls
+        return false if die != other.die
+        true
+      end
+
+      def add_roll(roll)
+        rolls.push roll
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/die_roller.rb

@@ -0,0 +1,51 @@
+module BagOfHolding
+  module Dice
+    # Contain all the logic around rolling a die given it's options
+    class DieRoller
+      def self.roll(die)
+        new(die: die).roll
+      end
+
+      attr_accessor :die, :current_roll
+
+      def initialize(die:)
+        self.die = die
+      end
+
+      def roll
+        loop do
+          self.current_roll = rng
+          result.add_roll current_roll
+
+          next if reroll?
+
+          result.value += current_roll
+
+          next if explode?
+
+          break
+        end
+
+        result
+      end
+
+      def result
+        @result ||= BagOfHolding::Dice::DieResult.new(
+          value: 0, rolls: [], die: self
+        )
+      end
+
+      def reroll?
+        die.reroll && current_roll <= die.reroll
+      end
+
+      def explode?
+        die.explode && current_roll >= die.explode
+      end
+
+      def rng
+        1 + rand(die.sides)
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/die_validator.rb

@@ -0,0 +1,23 @@
+module BagOfHolding
+  module Dice
+    # Internal: Wraps the logic that determines if a die can be rolled
+    # successfully
+    class DieValidator
+      def self.valid?(die)
+        new(die: die).valid?
+      end
+
+      attr_accessor :die
+
+      def initialize(die:)
+        self.die = die
+      end
+
+      def valid?
+        return false unless die.sides
+        return false if die.reroll && die.explode && die.reroll >= die.explode
+        true
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/division_operation.rb

@@ -0,0 +1,18 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulates subtracting two expressions
+    class DivisionOperation < Operation
+      def self.operator
+        '/'
+      end
+
+      def value
+        left_result.value / right_result.value
+      end
+
+      def operator
+        '/'
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/multiplication_operation.rb

@@ -0,0 +1,18 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulates subtracting two expressions
+    class MultiplicationOperation < Operation
+      def self.operator
+        '*'
+      end
+
+      def value
+        left_result.value * right_result.value
+      end
+
+      def operator
+        '*'
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/operation.rb

@@ -0,0 +1,45 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulates an operation such as adding two dice pools
+    class Operation
+      attr_accessor :left, :right
+
+      def initialize(left: nil, right: nil)
+        self.left = left
+        self.right = right
+      end
+
+      def roll
+        BagOfHolding::Dice::OperationResult.new left_result: left_result,
+                                                right_result: right_result,
+                                                operation: self,
+                                                value: value
+      end
+
+      def ==(other)
+        begin
+          return false unless left == other.left
+          return false unless right == other.right
+        rescue NoMethodError
+          return false
+        end
+
+        true
+      end
+
+      private
+
+      def value
+        fail NotImplementedError
+      end
+
+      def left_result
+        @left_result ||= left.roll
+      end
+
+      def right_result
+        @right_result ||= right.roll
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/operation_result.rb

@@ -0,0 +1,38 @@
+module BagOfHolding
+  module Dice
+    # Internal: Represent the results of an operation such as adding two
+    # dice pools.
+    class OperationResult
+      attr_accessor :left_result, :right_result, :operation, :value
+
+      def initialize(left_result: nil, right_result: nil,
+                     operation: nil, value: nil)
+        self.left_result = left_result
+        self.right_result = right_result
+        self.operation = operation
+        self.value = value
+      end
+
+      def to_s
+        "#{left_result} #{operation.operator} #{right_result}"
+      end
+
+      def inspect
+        "#{left_result.inspect} #{operation.operator} #{right_result.inspect}"
+      end
+
+      def ==(other)
+        begin
+          return false unless left_result == other.left_result
+          return false unless right_result == other.right_result
+          return false unless operation == other.operation
+          return false unless value == other.value
+        rescue NoMethodError
+          return false
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/parser.rb

@@ -0,0 +1,50 @@
+require 'parslet'
+
+module BagOfHolding
+  module Dice
+    # Internal: Parse a string defining a given roll into an ast
+    class Parser < Parslet::Parser
+      rule(:space)      { match('\s') }
+      rule(:space?)     { space.maybe }
+      rule(:integer)    { match('[0-9]').repeat(1) }
+
+      rule(:label_text) { match('[^()]').repeat(1).as(:label) }
+      rule(:label)      { space? >> str('(') >> label_text >> str(')') }
+      rule(:label?)     { label.maybe }
+
+      rule(:exploding)  { str('e') >> integer.maybe.as(:explode) }
+      rule(:reroll)     { str('r') >> integer.maybe.as(:reroll) }
+      rule(:keep)       { str('k') >> integer.maybe.as(:keep) }
+      rule(:option)     { exploding | reroll | keep }
+      rule(:options)    { option.repeat }
+      rule(:options?)   { options.maybe }
+
+      rule(:sides)      { integer.as(:sides).repeat(1) }
+
+      rule(:die)        { str('d') >> sides >> options? }
+
+      rule(:count)      { integer.as(:count) }
+      rule(:count?)     { count.maybe }
+
+      rule(:pool)       { count? >> die.as(:die) >> label? }
+      rule(:constant)   { integer.as(:constant) }
+
+      rule(:addition)       { str('+') }
+      rule(:subtraction)    { str('-') }
+      rule(:division)       { str('/') }
+      rule(:multiplication) { str('*') }
+      rule(:operators) do
+        addition | subtraction | division | multiplication
+      end
+      rule(:operator)       { operators.as(:operator) >> space? }
+
+      rule(:sum) { value.as(:left) >> operator >> expression.as(:right) }
+
+      rule(:value)        { (pool | constant) >> space? }
+      rule(:expression)   { (sum | value) >> str(',').maybe >> space? }
+      rule(:expressions)  { expression.repeat(1) }
+
+      root :expressions
+    end
+  end
+end