bag_of_holding 0.0.1

data/spec/dice/pool_factory_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe BagOfHolding::Dice::PoolFactory do
+  subject { BagOfHolding::Dice::PoolFactory }
+
+  describe '::build' do
+    it 'builds a pool simple labeled 20 sided die' do
+      pool = subject.build count: 10, die: [{ sides: 20 }], label: 'Spec'
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 10,
+          die: BagOfHolding::Dice::Die.new(sides: 20),
+          label: 'Spec'
+        )
+      )
+    end
+
+    it 'defaults a pool count to 1' do
+      pool = subject.build count: nil, die: [{ sides: 20 }], label: 'Spec'
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20),
+          label: 'Spec'
+        )
+      )
+    end
+
+    it 'defaults explosions to the number of sides' do
+      pool = subject.build count: nil,
+                           die: [{ sides: 20 }, { explode: nil }]
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 20)
+        )
+      )
+    end
+
+    it 'sets the explode value' do
+      pool = subject.build count: nil,
+                           die: [{ sides: 20 }, { explode: 15 }]
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 15)
+        )
+      )
+    end
+
+    it 'defaults rerolls to 1' do
+      pool = subject.build count: nil,
+                           die: [{ sides: 20 }, { reroll: nil }]
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, reroll: 1)
+        )
+      )
+    end
+
+    it 'sets the reroll value' do
+      pool = subject.build count: nil,
+                           die: [{ sides: 20 }, { reroll: 5 }]
+      expect(pool).to eq(
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, reroll: 5)
+        )
+      )
+    end
+  end
+end

data/spec/dice/pool_result_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe BagOfHolding::Dice::PoolResult do
+  let(:die_results) do
+    [
+      BagOfHolding::Dice::DieResult.new(rolls: [3], value: 3),
+      BagOfHolding::Dice::DieResult.new(rolls: [4], value: 4),
+      BagOfHolding::Dice::DieResult.new(rolls: [5], value: 5)
+    ]
+  end
+
+  subject do
+    BagOfHolding::Dice::PoolResult.new(
+      die_results: die_results,
+      value: 12
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets the die_results and value attributes' do
+      result = BagOfHolding::Dice::PoolResult.new die_results: die_results,
+                                                  value: 12
+
+      expect(result.die_results).to eq(die_results)
+      expect(result.value).to eq(12)
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::PoolResult.new(
+        die_results: subject.die_results,
+        value: subject.value
+      )
+    end
+
+    it 'returns true when compared to an identical pool result' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false when compared to a pool with a different value' do
+      other.value = 42
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false when compared to a pool with different die results' do
+      other.die_results = []
+      expect(subject == other).to eq(false)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the value and the pool string' do
+      subject.pool = double(to_s: '2d20')
+      expect(subject.to_s).to eq('12 (2d20)')
+    end
+  end
+
+  describe '#inspect' do
+    it 'returns a string with the specific rolls' do
+      subject.pool = double(to_s: '2d20')
+      expect(subject.inspect).to eq('12 (2d20) [3] [4] [5]')
+    end
+  end
+end

data/spec/dice/pool_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe BagOfHolding::Dice::Pool do
+  let(:die) { BagOfHolding::Dice::Die.new sides: 10 }
+  subject { BagOfHolding::Dice::Pool.new count: 2, die: die }
+
+  describe '#initialize' do
+    it 'sets the attributes on the class' do
+      pool = BagOfHolding::Dice::Pool.new(
+        count: 2,
+        die: BagOfHolding::Dice::Die.new(sides: 10),
+        label: 'Specs'
+      )
+
+      expect(pool.count).to eq(2)
+      expect(pool.die).to eq(BagOfHolding::Dice::Die.new(sides: 10))
+      expect(pool.label).to eq('Specs')
+    end
+  end
+
+  describe '#count=' do
+    it 'sets the number of dice in the pool' do
+      subject.count = 100
+      expect(subject.count).to eq(100)
+    end
+  end
+
+  describe '#count' do
+    it 'returns the number of dice in the pool' do
+      expect(subject.count).to eq(2)
+    end
+  end
+
+  describe '#die=' do
+    it 'sets the die the pool is made of' do
+      die = BagOfHolding::Dice::Die.new sides: 76
+      subject.die = die
+      expect(subject.die).to eq(die)
+    end
+  end
+
+  describe '#die' do
+    it 'returns the die the pool is made of' do
+      expect(subject.die).to eq(die)
+    end
+  end
+
+  describe '#==' do
+    let(:other) do
+      BagOfHolding::Dice::Pool.new count: subject.count,
+                                   die: subject.die,
+                                   label: subject.label
+    end
+
+    it 'returns true for a pool with the same attributes' do
+      expect(subject == other).to eq(true)
+    end
+
+    it 'returns false for a pool with a different count' do
+      other.count = 10_00
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false for a pool with a different die' do
+      other.die = BagOfHolding::Dice::Die.new sides: 4
+      expect(subject == other).to eq(false)
+    end
+
+    it 'returns false for a pool with a different label' do
+      other.label = 'Others'
+      expect(subject == other).to eq(false)
+    end
+  end
+
+  describe '#roll' do
+    let(:die_results) do
+      [
+        BagOfHolding::Dice::DieResult.new(rolls: [3], value: 3),
+        BagOfHolding::Dice::DieResult.new(rolls: [5], value: 5),
+        BagOfHolding::Dice::DieResult.new(rolls: [1], value: 1)
+      ]
+    end
+    subject { BagOfHolding::Dice::Pool.new count: 3, die: die }
+
+    before :each do
+      allow(die).to receive(:roll).and_return(*die_results)
+    end
+
+    context 'without a keep value' do
+      it 'sums the rolls of the dice in the pool' do
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::PoolResult.new die_results: die_results,
+                                             value: 9,
+                                             pool: subject
+        )
+      end
+    end
+
+    context 'with a keep value of 1' do
+      it 'returns the value of the highest die' do
+        subject.keep = 1
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::PoolResult.new die_results: die_results,
+                                             value: 5,
+                                             pool: subject
+        )
+      end
+    end
+
+    context 'with a keep value of 2' do
+      it 'returns the value of the highest die' do
+        subject.keep = 2
+        expect(subject.roll).to eq(
+          BagOfHolding::Dice::PoolResult.new die_results: die_results,
+                                             value: 8,
+                                             pool: subject
+        )
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the die str' do
+      subject.die = double(to_s: 'd172')
+      expect(subject.to_s).to eq('2d172')
+    end
+  end
+end

data/spec/dice/subtraction_operation_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe BagOfHolding::Dice::SubtractionOperation do
+  let(:left) { BagOfHolding::Dice::Constant.new value: 11 }
+  let(:right) { BagOfHolding::Dice::Constant.new value: 7 }
+
+  subject do
+    BagOfHolding::Dice::SubtractionOperation.new left: left,
+                                                 right: right
+  end
+
+  describe '::operator' do
+    it 'returns -' do
+      expect(BagOfHolding::Dice::SubtractionOperation.operator).to eq('-')
+    end
+  end
+
+  describe '#value' do
+    it 'subtracts the right value from the left' do
+      expect(subject.value).to eq(4)
+    end
+  end
+
+  describe '#operator' do
+    it 'returns -' do
+      expect(subject.operator).to eq('-')
+    end
+  end
+end

data/spec/dice/transform_spec.rb

@@ -0,0 +1,237 @@
+RSpec.describe BagOfHolding::Dice::Transform do
+  subject       { BagOfHolding::Dice::Transform.new }
+  let(:parser)  { BagOfHolding::Dice::Parser.new    }
+
+  describe '#apply' do
+    it 'transforms 5' do
+      tree = parser.parse '5'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Constant.new(value: 5)
+      ])
+    end
+
+    it 'transforms 1d20' do
+      tree = parser.parse '1d20'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20)
+        )
+      ])
+    end
+
+    it 'transforms 2d20k' do
+      tree = parser.parse '2d20k'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 2,
+          die: BagOfHolding::Dice::Die.new(sides: 20),
+          keep: 1
+        )
+      ])
+    end
+
+    it 'transforms 1d20,1d8' do
+      tree = parser.parse '1d20,1d8'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20)
+        ),
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 8)
+        )
+      ])
+    end
+
+    it 'transforms d20' do
+      tree = parser.parse 'd20'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20)
+        )
+      ])
+    end
+
+    it 'transforms 3d8 (Attack)' do
+      tree = parser.parse '3d8 (Attack)'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 3,
+          label: 'Attack',
+          die: BagOfHolding::Dice::Die.new(sides: 8)
+        )
+      ])
+    end
+
+    it 'transforms 1d20r' do
+      tree = parser.parse '1d20r'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, reroll: 1)
+        )
+      ])
+    end
+
+    it 'transforms 5+6' do
+      tree = parser.parse '5+6'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::AdditionOperation.new(
+          left: BagOfHolding::Dice::Constant.new(value: 5),
+          right: BagOfHolding::Dice::Constant.new(value: 6)
+        )
+      ])
+    end
+
+    it 'transforms 5-6' do
+      tree = parser.parse '5-6'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::SubtractionOperation.new(
+          left: BagOfHolding::Dice::Constant.new(value: 5),
+          right: BagOfHolding::Dice::Constant.new(value: 6)
+        )
+      ])
+    end
+
+    it 'transforms 4/2' do
+      tree = parser.parse '4/2'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::DivisionOperation.new(
+          left: BagOfHolding::Dice::Constant.new(value: 4),
+          right: BagOfHolding::Dice::Constant.new(value: 2)
+        )
+      ])
+    end
+
+    it 'transforms 4*2' do
+      tree = parser.parse '4*2'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::MultiplicationOperation.new(
+          left: BagOfHolding::Dice::Constant.new(value: 4),
+          right: BagOfHolding::Dice::Constant.new(value: 2)
+        )
+      ])
+    end
+
+    it 'transforms 8, 9' do
+      tree = parser.parse '8, 9'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Constant.new(value: 8),
+        BagOfHolding::Dice::Constant.new(value: 9)
+      ])
+    end
+
+    it 'transforms 1 + 2, 3' do
+      tree = parser.parse '1 + 2, 3'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::AdditionOperation.new(
+          left: BagOfHolding::Dice::Constant.new(value: 1),
+          right: BagOfHolding::Dice::Constant.new(value: 2)
+        ),
+        BagOfHolding::Dice::Constant.new(value: 3)
+      ])
+    end
+
+    it 'transforms 1d20r (Defense)' do
+      tree = parser.parse '1d20r (Defense)'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, reroll: 1),
+          label: 'Defense'
+        )
+      ])
+    end
+
+    it 'transforms 1d20r2' do
+      tree = parser.parse '1d20r2'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, reroll: 2)
+        )
+      ])
+    end
+
+    it 'transforms 1d20e' do
+      tree = parser.parse '1d20e'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 20)
+        )
+      ])
+    end
+
+    it 'transforms 1d20e18' do
+      tree = parser.parse '1d20e18'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 18)
+        )
+      ])
+    end
+
+    it 'transforms 1d20e18r2' do
+      tree = parser.parse '1d20e18r2'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 18, reroll: 2)
+        )
+      ])
+    end
+
+    it 'transforms 1d20r2e18' do
+      tree = parser.parse '1d20r2e18'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::Pool.new(
+          count: 1,
+          die: BagOfHolding::Dice::Die.new(sides: 20, explode: 18, reroll: 2)
+        )
+      ])
+    end
+
+    it 'transforms 1d20 + 5' do
+      tree = parser.parse '1d20 + 5'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::AdditionOperation.new(
+          left: BagOfHolding::Dice::Pool.new(
+            count: 1,
+            die: BagOfHolding::Dice::Die.new(sides: 20)
+          ),
+          right: BagOfHolding::Dice::Constant.new(value: 5)
+        )
+      ])
+    end
+
+    it 'transforms 2d6r+ 1d4 + 2+1d8' do
+      tree = parser.parse '2d6r+ 1d4 + 2+1d8'
+      expect(subject.apply(tree)).to match([
+        BagOfHolding::Dice::AdditionOperation.new(
+          left: BagOfHolding::Dice::Pool.new(
+            count: 2,
+            die: BagOfHolding::Dice::Die.new(sides: 6, reroll: 1)
+          ),
+          right: BagOfHolding::Dice::AdditionOperation.new(
+            left: BagOfHolding::Dice::Pool.new(
+              count: 1,
+              die: BagOfHolding::Dice::Die.new(sides: 4)
+            ),
+            right: BagOfHolding::Dice::AdditionOperation.new(
+              left: BagOfHolding::Dice::Constant.new(value: 2),
+              right: BagOfHolding::Dice::Pool.new(
+                count: 1,
+                die: BagOfHolding::Dice::Die.new(sides: 8)
+              )
+            )
+          )
+        )
+      ])
+    end
+  end
+end