bag_of_holding 0.0.1

data/lib/bag_of_holding/dice/pool.rb

@@ -0,0 +1,58 @@
+module BagOfHolding
+  module Dice
+    # Internal: Contains information about the number of dice in a pool, the
+    # description of those dice and a label if it has one.
+    class Pool
+      attr_accessor :count, :die, :label, :keep
+
+      def initialize(count: nil, die: nil, label: nil, keep: nil)
+        self.count  = count
+        self.die    = die
+        self.label  = label
+        self.keep   = keep
+      end
+
+      def ==(other)
+        begin
+          return false unless count == other.count
+          return false unless die == other.die
+          return false unless label == other.label
+        rescue NoMethodError
+          return false
+        end
+
+        true
+      end
+
+      def roll
+        BagOfHolding::Dice::PoolResult.new die_results: die_results,
+                                           value: value,
+                                           pool: self
+      end
+
+      def to_s
+        "#{count}#{die}"
+      end
+
+      private
+
+      def value
+        if keep.nil?
+          @value = die_values.reduce(&:+)
+        else
+          @value = die_values.sort.reverse.slice(0, keep).reduce(&:+)
+        end
+
+        @value
+      end
+
+      def die_values
+        @die_values ||= die_results.map(&:value)
+      end
+
+      def die_results
+        @die_results ||= count.times.map { die.roll }
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/pool_factory.rb

@@ -0,0 +1,70 @@
+module BagOfHolding
+  module Dice
+    # Internal: This class takes the parser output describing a dice pool
+    # and builds the correct pool object.
+    class PoolFactory
+      def self.build(count: nil, die:, label: nil)
+        new(count: count, die: die, label: label).build
+      end
+
+      DIE_OPTIONS = [:sides, :reroll, :explode]
+
+      DIE_DEFAULTS = {
+        explode: ->(attrs)  { attrs[:sides] },
+        reroll:  ->(_attrs) { 1 }
+      }
+
+      def initialize(count: nil, die:, label: nil)
+        self.raw_count = count
+        self.raw_die = die
+        self.raw_label = label
+      end
+
+      def build
+        BagOfHolding::Dice::Pool.new count: pool_count,
+                                     die: die,
+                                     label: raw_label,
+                                     keep: keep
+      end
+
+      private
+
+      attr_accessor :raw_count, :raw_die, :raw_label
+
+      def keep
+        keep_option = raw_die.find { |o| o.keys.first == :keep }
+        return nil if keep_option.nil?
+
+        value = keep_option.values.first
+        value.nil? ? 1 : value.to_i
+      end
+
+      def pool_count
+        raw_count.nil? ? 1 : raw_count.to_i
+      end
+
+      def die
+        BagOfHolding::Dice::Die.new die_attrs
+      end
+
+      def die_attrs
+        die_options.reduce({}) do |attrs, attr|
+          attrs.merge die_attr(attr, attrs)
+        end
+      end
+
+      def die_attr(attr, attrs)
+        name = attr.keys.first
+
+        value = attr.values.first
+        value = value.nil? ? DIE_DEFAULTS[name].call(attrs) : value.to_i
+
+        { name => value }
+      end
+
+      def die_options
+        raw_die.select { |attr| DIE_OPTIONS.include? attr.keys.first }
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/pool_result.rb

@@ -0,0 +1,37 @@
+module BagOfHolding
+  module Dice
+    # Internal: contains the results of a rolled pool and the die rolls that
+    # got us there.
+    class PoolResult
+      attr_accessor :die_results, :value, :pool
+
+      def initialize(die_results: nil, value: nil, pool: nil)
+        self.die_results = die_results
+        self.value = value
+        self.pool = pool
+      end
+
+      def ==(other)
+        return false if value != other.value
+        return false if die_results != other.die_results
+        return false if pool != other.pool
+
+        true
+      end
+
+      def to_s
+        "#{value} (#{pool})"
+      end
+
+      def inspect
+        "#{value} (#{pool})".tap do |str|
+          die_results.each do |die_result|
+            die_result.rolls.each do |roll|
+              str << " [#{roll}]"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice/subtraction_operation.rb

@@ -0,0 +1,18 @@
+module BagOfHolding
+  module Dice
+    # Internal: Encapsulates subtracting two expressions
+    class SubtractionOperation < 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/transform.rb

@@ -0,0 +1,59 @@
+require 'parslet'
+
+module BagOfHolding
+  module Dice
+    # Internal: Transform a parsed dice string into a callable structure
+    class Transform < Parslet::Transform
+      rule(constant: simple(:value)) do |dict|
+        build_const value: dict[:value]
+      end
+
+      # Dice pool with count, without label
+      rule(count: simple(:count), die: subtree(:die)) do |dict|
+        build_pool count: dict[:count], die: dict[:die]
+      end
+
+      # Dice pool without a count, without label
+      rule(die: subtree(:die)) do |dict|
+        build_pool die: dict[:die]
+      end
+
+      # Dice pool with count, label
+      rule(
+        count: simple(:count), die: subtree(:die), label: simple(:label)
+      ) do |dict|
+        build_pool count: dict[:count],
+                   die: dict[:die],
+                   label: dict[:label]
+      end
+
+      rule(
+        left: simple(:left), operator: simple(:operator), right: simple(:right)
+      ) do |dict|
+        build_operation left: dict[:left],
+                        operator: dict[:operator],
+                        right: dict[:right]
+      end
+
+      def self.build_operation(left:, operator:, right:)
+        operations = [
+          AdditionOperation, SubtractionOperation,
+          DivisionOperation, MultiplicationOperation
+        ]
+
+        operations.find { |o| o.operator == operator }.new left: left,
+                                                           right: right
+      end
+
+      def self.build_const(value:)
+        BagOfHolding::Dice::Constant.new value: Integer(value)
+      end
+
+      def self.build_pool(count: nil, die:, label: nil)
+        BagOfHolding::Dice::PoolFactory.build count: count,
+                                              die: die,
+                                              label: label
+      end
+    end
+  end
+end

data/lib/bag_of_holding/dice.rb

@@ -0,0 +1,41 @@
+require 'bag_of_holding/dice/constant'
+require 'bag_of_holding/dice/constant_result'
+
+require 'bag_of_holding/dice/die'
+require 'bag_of_holding/dice/die_validator'
+require 'bag_of_holding/dice/die_roller'
+require 'bag_of_holding/dice/die_result'
+
+require 'bag_of_holding/dice/operation'
+require 'bag_of_holding/dice/addition_operation'
+require 'bag_of_holding/dice/subtraction_operation'
+require 'bag_of_holding/dice/division_operation'
+require 'bag_of_holding/dice/multiplication_operation'
+require 'bag_of_holding/dice/operation_result'
+
+require 'bag_of_holding/dice/parser'
+
+require 'bag_of_holding/dice/pool'
+require 'bag_of_holding/dice/pool_factory'
+require 'bag_of_holding/dice/pool_result'
+
+require 'bag_of_holding/dice/transform'
+
+module BagOfHolding
+  # Public: Bag of Holding dice bag. All you need for your myriad of dice
+  # rolling needs.
+  #
+  # Examples
+  #
+  #   BagOfHolding::Dice.roll '1d20+5'
+  #   # => [BagOfHolding::Dice::OperationResult]
+  module Dice
+    class << self
+      def roll(str)
+        tree = Parser.new.parse str
+        rollables = Transform.new.apply(tree)
+        rollables.map(&:roll)
+      end
+    end
+  end
+end

data/lib/bag_of_holding.rb

@@ -0,0 +1 @@
+require 'bag_of_holding/dice'

data/spec/dice/addition_operation_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe BagOfHolding::Dice::AdditionOperation do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 3 }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 5 }
+  subject { BagOfHolding::Dice::AdditionOperation.new left: left, right: right }
+
+  describe '::operator' do
+    it 'returns +' do
+      expect(BagOfHolding::Dice::AdditionOperation.operator).to eq('+')
+    end
+  end
+
+  describe '#value' do
+    it 'adds the left and right values' do
+      expect(subject.value).to eq(8)
+    end
+  end
+
+  describe '#operator' do
+    it 'returns +' do
+      expect(subject.operator).to eq('+')
+    end
+  end
+end

data/spec/dice/constant_result_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe BagOfHolding::Dice::ConstantResult do
+  subject { BagOfHolding::Dice::ConstantResult.new value: 5 }
+
+  describe '::new' do
+    it 'sets the attributes on the class' do
+      const = BagOfHolding::Dice::ConstantResult.new value: 9
+      expect(const.value).to eq(9)
+    end
+  end
+
+  describe '#value' do
+    it 'returns the value' do
+      expect(subject.value).to eq(5)
+    end
+  end
+
+  describe '#value=' do
+    it 'sets the value' do
+      subject.value = 7
+      expect(subject.value).to eq(7)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the value as a string' do
+      expect(subject.to_s).to eq('5')
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns the value as a string' do
+      expect(subject.inspect).to eq('5')
+    end
+  end
+
+  describe '#==' do
+    let(:other) { BagOfHolding::Dice::ConstantResult.new value: 5 }
+
+    it 'returns true when the other constant has a matching value' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false when the other constant has a different value' do
+      other.value = 99
+      expect(subject == other).to eq(false)
+    end
+  end
+end

data/spec/dice/constant_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe BagOfHolding::Dice::Constant do
+  subject { BagOfHolding::Dice::Constant.new value: 5 }
+
+  describe '::new' do
+    it 'sets the attributes on the class' do
+      const = BagOfHolding::Dice::Constant.new value: 9
+      expect(const.value).to eq(9)
+    end
+  end
+
+  describe '#roll' do
+    it 'always rolls to the value' do
+      expect(subject.roll).to eq(
+        BagOfHolding::Dice::ConstantResult.new value: subject.value
+      )
+    end
+  end
+
+  describe '#==' do
+    let(:other) { BagOfHolding::Dice::Constant.new value: 5 }
+
+    it 'returns true when the other constant has a matching value' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false when the other constant has a different value' do
+      other.value = 9
+      expect(subject == other).to eq(false)
+    end
+  end
+end

data/spec/dice/die_result_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe BagOfHolding::Dice::DieResult do
+  let(:die) { BagOfHolding::Dice::Die.new sides: 4 }
+  subject do
+    BagOfHolding::Dice::DieResult.new rolls: [1, 4],
+                                      value: 4,
+                                      die: die
+  end
+
+  describe '#initialize' do
+    it 'sets the rolls and value attributes' do
+      result = BagOfHolding::Dice::DieResult.new rolls: [1, 20],
+                                                 value: 20,
+                                                 die: die
+
+      expect(result.rolls).to eq([1, 20])
+      expect(result.value).to eq(20)
+      expect(result.die).to eq(die)
+    end
+  end
+
+  describe '#add_roll' do
+    it 'adds the roll to the end of the rolls' do
+      subject.add_roll 8
+      expect(subject.rolls).to eq([1, 4, 8])
+    end
+  end
+
+  describe '#rolls' do
+    it 'returns the array of roll results' do
+      expect(subject.rolls).to eq([1, 4])
+    end
+  end
+
+  describe '#value' do
+    it 'returns the result value' do
+      expect(subject.value).to eq(4)
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::DieResult.new rolls: [1, 4],
+                                        value: 4,
+                                        die: die
+    end
+
+    it 'returns true when passed another result with equal rolls and value' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns true when passed another result with equal rolls and value' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false when the other result has a different value' do
+      other.value = 1
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false when the other result has different rolls' do
+      other.rolls = [4]
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false when the other result has a different die' do
+      other.die = BagOfHolding::Dice::Die.new sides: 8
+      expect(subject == other).to eq(false)
+    end
+  end
+end