bag_of_holding 0.0.1

data/spec/dice/die_roller_spec.rb

@@ -0,0 +1,76 @@
+RSpec.describe BagOfHolding::Dice::DieRoller do
+  let(:die) { BagOfHolding::Dice::Die.new sides: 20, explode: 19, reroll: 2 }
+  subject { BagOfHolding::Dice::DieRoller.new die: die }
+
+  # Spec ::build
+  describe '::roll' do
+    it 'passes the argument to new' do
+      klass = BagOfHolding::Dice::DieRoller
+      die = double('Die', roll: true)
+      expect(klass).to receive(:new).with(die: die).and_return(subject)
+      klass.roll die
+    end
+  end
+
+  describe '#roll' do
+    context 'with no options' do
+      it 'returns the roll' do
+        allow(subject).to receive(:rng).and_return(5)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [5],
+                                            value: 5,
+                                            die: subject
+          )
+      end
+    end
+
+    context 'with rerolling die' do
+      it 're-rolls and adds a number larger if we are equal to the reroll' do
+        allow(subject).to receive(:rng).and_return(2, 3)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [2, 3],
+                                            value: 3,
+                                            die: subject
+        )
+      end
+
+      it 're-rolls and adds a number larger if we are less than the reroll' do
+        allow(subject).to receive(:rng).and_return(1, 5)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [1, 5],
+                                            value: 5,
+                                            die: subject
+        )
+      end
+    end
+
+    context 'with an exploding die' do
+      it 'accumulates and re-rolls if we are equal to the explode number' do
+        allow(subject).to receive(:rng).and_return(19, 3)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [19, 3],
+                                            value: 22,
+                                            die: subject
+        )
+      end
+
+      it 'accumulates and re-rolls if we are greater than the explode number' do
+        allow(subject).to receive(:rng).and_return(20, 5)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [20, 5],
+                                            value: 25,
+                                            die: subject
+        )
+      end
+
+      it 'accumulates and re-rolls if we continue to explode' do
+        allow(subject).to receive(:rng).and_return(20, 20, 4)
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::DieResult.new rolls: [20, 20, 4],
+                                            value: 44,
+                                            die: subject
+        )
+      end
+    end
+  end
+end

data/spec/dice/die_spec.rb

@@ -0,0 +1,111 @@
+RSpec.describe BagOfHolding::Dice::Die do
+  subject { BagOfHolding::Dice::Die.new sides: 20, explode: 19, reroll: 2 }
+
+  describe '#initialize' do
+    it 'sets the attributes on the class' do
+      die = BagOfHolding::Dice::Die.new sides: 8, explode: 20, reroll: 1
+      expect(die.sides).to eq(8)
+      expect(die.explode).to eq(20)
+      expect(die.reroll).to eq(1)
+    end
+  end
+
+  describe '#sides=' do
+    it 'sets the number of sides on the die' do
+      subject.sides = 100
+      expect(subject.sides).to eq(100)
+    end
+  end
+
+  describe '#sides' do
+    it 'returns the number of sides on the die' do
+      expect(subject.sides).to eq(20)
+    end
+  end
+
+  describe '#explode=' do
+    it 'sets the number of explode on the die' do
+      subject.explode = 15
+      expect(subject.explode).to eq(15)
+    end
+  end
+
+  describe '#explode' do
+    it 'returns the number of explode on the die' do
+      expect(subject.explode).to eq(19)
+    end
+  end
+
+  describe '#reroll=' do
+    it 'sets the number of reroll on the die' do
+      subject.reroll = 2
+      expect(subject.reroll).to eq(2)
+    end
+  end
+
+  describe '#reroll' do
+    it 'returns the number of reroll on the die' do
+      expect(subject.reroll).to eq(2)
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::Die.new sides: subject.sides,
+                                  explode: subject.explode,
+                                  reroll: subject.reroll
+    end
+
+    it 'returns true for a die with the same attributes' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false for a die with different sides' do
+      other.sides = 10_000
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false for a die with different explode' do
+      other.explode = 1
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false for a die with different reroll' do
+      other.reroll = 4
+      expect(subject == other).to eq(false)
+    end
+  end
+
+  describe '#valid?' do
+    it 'passes itself to DieValidator' do
+      allow(BagOfHolding::Dice::DieValidator).to(
+        receive(:valid?).and_return(true)
+      )
+
+      expect(subject.valid?).to eq(true)
+    end
+
+    it 'returns true with a valid die' do
+      expect(subject.valid?).to eq(true)
+    end
+  end
+
+  describe '#roll' do
+    context 'with an invalid die' do
+      before { subject.sides = nil }
+
+      it 'raises a StandardError' do
+        allow(subject).to receive(:valid?).and_return(false)
+        expect { subject.roll }.to raise_error(StandardError)
+      end
+    end
+
+    it 'passes itself to DieRoller' do
+      result = BagOfHolding::Dice::DieResult.new rolls: [5],
+                                                 value: 5,
+                                                 die: subject
+      allow(BagOfHolding::Dice::DieRoller).to receive(:roll).and_return(result)
+      expect(subject.roll).to eq(result)
+    end
+  end
+end

data/spec/dice/die_validator_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe BagOfHolding::Dice::DieValidator do
+  let(:die) { BagOfHolding::Dice::Die.new sides: 20 }
+  subject { BagOfHolding::Dice::DieValidator.new die: die }
+
+  context 'with a reroll higher than explode' do
+    before do
+      die.explode = 10
+      die.reroll = 11
+    end
+
+    it 'returns false' do
+      expect(subject.valid?).to eq(false)
+    end
+  end
+
+  context 'with an explode equal to reroll' do
+    before do
+      die.explode = 10
+      die.reroll  = 10
+    end
+
+    it 'returns false' do
+      expect(subject.valid?).to eq(false)
+    end
+  end
+
+  context 'with no sides set' do
+    before { die.sides = nil }
+
+    it 'returns false' do
+      expect(subject.valid?).to eq(false)
+    end
+  end
+end

data/spec/dice/division_operation_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe BagOfHolding::Dice::DivisionOperation do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 4 }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 2 }
+
+  subject do
+    BagOfHolding::Dice::DivisionOperation.new left: left,
+                                              right: right
+  end
+
+  describe '::operator' do
+    it 'returns /' do
+      expect(BagOfHolding::Dice::DivisionOperation.operator).to eq('/')
+    end
+  end
+
+  describe '#value' do
+    it 'subtracts the right value from the left' do
+      expect(subject.value).to eq(2)
+    end
+
+    it 'rounds down any values' do
+      BagOfHolding::Dice::Constant.new value: 5
+      BagOfHolding::Dice::Constant.new value: 2
+      op = BagOfHolding::Dice::DivisionOperation.new left: left,
+                                                     right: right
+      expect(op.value).to eq(2)
+    end
+  end
+
+  describe '#operator' do
+    it 'returns /' do
+      expect(subject.operator).to eq('/')
+    end
+  end
+end

data/spec/dice/multiplication_operation_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe BagOfHolding::Dice::MultiplicationOperation do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 4 }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 2 }
+
+  subject do
+    BagOfHolding::Dice::MultiplicationOperation.new left: left,
+                                                    right: right
+  end
+
+  describe '::operator' do
+    it 'returns *' do
+      expect(BagOfHolding::Dice::MultiplicationOperation.operator).to eq('*')
+    end
+  end
+
+  describe '#value' do
+    it 'subtracts the right value from the left' 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/operation_result_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe BagOfHolding::Dice::OperationResult do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 3 }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 5 }
+
+  let(:operation) do
+    BagOfHolding::Dice::AdditionOperation.new left: left,
+                                              right: right
+  end
+
+  subject do
+    BagOfHolding::Dice::OperationResult.new left_result: left.roll,
+                                            operation: operation,
+                                            right_result: right.roll,
+                                            value: 8
+  end
+
+  describe '#initialize' do
+    it 'assigns the attributes that are passed' do
+      result = BagOfHolding::Dice::OperationResult.new left_result: left.roll,
+                                                       operation: operation,
+                                                       right_result: right.roll,
+                                                       value: 8
+      expect(result.left_result).to eq(left.roll)
+      expect(result.operation).to eq(operation)
+      expect(result.right_result).to eq(right.roll)
+      expect(result.value).to eq(8)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns a string with the left result, operator and right result' do
+      expect(subject.to_s).to eq('3 + 5')
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns the inspected left and right results and operator' do
+      expect(subject.to_s).to eq('3 + 5')
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::OperationResult.new left_result: left.roll,
+                                              operation: operation,
+                                              right_result: right.roll,
+                                              value: 8
+    end
+
+    it 'returns true when other has matching attributes' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false with a different left_result' do
+      other.left_result = right.roll
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false with a different right_result' do
+      other.right_result = left.roll
+      expect(subject == other).to eq(false)
+    end
+  end
+end

data/spec/dice/operation_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe BagOfHolding::Dice::Operation do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 3 }
+  let(:operator) { '+' }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 5 }
+
+  subject do
+    BagOfHolding::Dice::Operation.new left: left,
+                                      right: right
+  end
+
+  describe '#initialize' do
+    it 'sets the attributes passed' do
+      op = BagOfHolding::Dice::Operation.new left: left,
+                                             right: right
+      expect(op.left).to eq(left)
+      expect(op.right).to eq(right)
+    end
+  end
+
+  describe '#roll' do
+    it 'returns an OperationResult' do
+      allow(subject).to receive(:value).and_return(8)
+
+      expect(subject.roll).to eq(
+        BagOfHolding::Dice::OperationResult.new(
+          left_result: left.roll,
+          right_result: right.roll,
+          operation: subject,
+          value: 8
+        )
+      )
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::Operation.new left: left,
+                                        right: right
+    end
+
+    it 'returns true when matching attributes' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false with a different left' do
+      other.left = BagOfHolding::Dice::Constant.new value: 30
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false with a different right' do
+      other.left = BagOfHolding::Dice::Constant.new value: 40
+      expect(subject == other).to eq(false)
+    end
+  end
+end

data/spec/dice/parser_spec.rb

@@ -0,0 +1,215 @@
+RSpec.describe BagOfHolding::Dice::Parser do
+  subject { BagOfHolding::Dice::Parser.new }
+
+  describe '#parse' do
+    it 'parses 5' do
+      tree = subject.parse '5'
+      expect(tree).to match(
+        [constant: '5']
+      )
+    end
+
+    it 'parses 1d20' do
+      tree = subject.parse '1d20'
+      expect(tree).to match([
+        { count: '1', die: [{ sides: '20' }] }
+      ])
+    end
+
+    it 'parses 2d20k' do
+      tree = subject.parse '2d20k'
+      expect(tree).to match([
+        { count: '2', die: [{ sides: '20' }, { keep: nil }] }
+      ])
+    end
+
+    it 'parses 3d20k2' do
+      tree = subject.parse '3d20k2'
+      expect(tree).to match([
+        { count: '3', die: [{ sides: '20' }, { keep: '2' }] }
+      ])
+    end
+
+    it 'parses 1d20,1d8' do
+      tree = subject.parse '1d20,1d8'
+      expect(tree).to match(
+        [
+          { count: '1', die: [{ sides: '20' }] },
+          { count: '1', die: [{ sides: '8' }] }
+        ]
+      )
+    end
+
+    it 'parses d20' do
+      tree = subject.parse 'd20'
+      expect(tree).to match([
+        die: [{ sides: '20' }]
+      ])
+    end
+
+    it 'parses 3d8 (Attack)' do
+      tree = subject.parse '3d8 (Attack)'
+      expect(tree).to match([
+        { count: '3', die: [{ sides: '8' }], label: 'Attack' }
+      ])
+    end
+
+    it 'parses 1d20r' do
+      tree = subject.parse '1d20r'
+      expect(tree).to match([
+        { count: '1', die: [{ sides: '20' }, { reroll: nil }] }
+      ])
+    end
+
+    it 'parses 5+6' do
+      tree = subject.parse '5+6'
+      expect(tree).to match([
+        { left: { constant: '5' }, operator: '+', right: { constant: '6' } }
+      ])
+    end
+
+    it 'parses 5-2' do
+      tree = subject.parse '5-2'
+      expect(tree).to match([
+        { left: { constant: '5' }, operator: '-', right: { constant: '2' } }
+      ])
+    end
+
+    it 'parses 4/2' do
+      tree = subject.parse '4/2'
+      expect(tree).to match([
+        { left: { constant: '4' }, operator: '/', right: { constant: '2' } }
+      ])
+    end
+
+    it 'parses 4*2' do
+      tree = subject.parse '4*2'
+      expect(tree).to match([
+        { left: { constant: '4' }, operator: '*', right: { constant: '2' } }
+      ])
+    end
+
+    it 'parses 8, 9' do
+      tree = subject.parse '8, 9'
+      expect(tree).to match([
+        { constant: '8' },
+        { constant: '9' }
+      ])
+    end
+
+    it 'parses 1 + 2, 3' do
+      tree = subject.parse('1 + 2, 3')
+      expect(tree).to match([
+        { left: { constant: '1' }, operator: '+', right: { constant: '2' } },
+        { constant: '3' }
+      ])
+    end
+
+    it 'parses 1d20r (Defense)' do
+      tree = subject.parse('1d20r (Defense)')
+      expect(tree).to match([
+        {
+          count: '1',
+          die: [
+            { sides: '20' },
+            { reroll: nil }
+          ],
+          label: 'Defense' }
+      ])
+    end
+
+    it 'parses 1d20r2' do
+      tree = subject.parse('1d20r2')
+      expect(tree).to match([
+        { count: '1', die: [{ sides: '20' }, { reroll: '2' }] }
+      ])
+    end
+
+    it 'parses 1d20e' do
+      tree = subject.parse('1d20e')
+      expect(tree).to match([
+        { count: '1', die: [{ sides: '20' }, { explode: nil }] }
+      ])
+    end
+
+    it 'parses 1d20e18' do
+      tree = subject.parse('1d20e18')
+      expect(tree).to match([
+        { count: '1', die: [{ sides: '20' }, { explode: '18' }] }
+      ])
+    end
+
+    it 'parses 1d20e18r2' do
+      tree = subject.parse('1d20e18r2')
+      expect(tree).to match([
+        {
+          count: '1',
+          die: [
+            { sides:   '20' },
+            { explode: '18' },
+            { reroll:  '2'  }
+          ]
+        }
+      ])
+    end
+
+    it 'parses 1d20r2e18' do
+      tree = subject.parse('1d20r2e18')
+      expect(tree).to match([
+        {
+          count: '1',
+          die: [
+            { sides:   '20' },
+            { reroll:  '2'  },
+            { explode: '18' }
+          ]
+        }
+      ])
+    end
+
+    it 'parses 1d20 + 5' do
+      tree = subject.parse('1d20 + 5')
+      expect(tree).to match([
+        {
+          left: {
+            count: '1',
+            die: [
+              { sides: '20' }
+            ]
+          },
+          operator: '+',
+          right: {
+            constant: '5'
+          }
+        }
+      ])
+    end
+
+    it 'parses 2d6+ 1d4 + 2' do
+      tree = subject.parse('2d6+ 1d4 + 2')
+      expect(tree).to match([
+        {
+          left: {
+            count: '2',
+            die: [
+              { sides: '6' }
+            ]
+          },
+          operator: '+',
+          right: {
+            left: {
+              count: '1',
+              die: [
+                { sides: '4' }
+              ]
+            },
+            operator: '+',
+            right: {
+              constant: '2'
+            }
+          }
+        }
+      ])
+    end
+  end
+end