box_packer 1.1.2 → 1.2.0

data/lib/box_packer/version.rb

@@ -1,3 +1,3 @@
 module BoxPacker
-	VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end

data/spec/lib/box_spec.rb

@@ -1,53 +1,52 @@
 module BoxPacker
-	describe Box do 
-		subject(:box) { Box.new(dimensions, position: position) }
-		let(:dimensions) { Dimensions[25, 30, 10] }
-		let(:position) { Position[10, 25, 5] }
-		let(:item) { Item.new(Dimensions[5, 2, 1]) }
-
-		context 'if no position is given' do 
-			let(:position) { nil }
-
-			it "defaults to origin position" do 
-				expect(box.position).to eql(Position[0, 0, 0])
-			end
-		end
-
-		describe '#orient!' do 
-			before { box.orient! }
-			it { expect(box.dimensions).to eql(Dimensions[30, 25, 10]) }
-		end
-
-		describe '#sub_boxes_args' do 
-			let(:expected_args) {[
-				[ Dimensions[20, 30, 10], position: Position[15, 25, 5] ],
-				[ Dimensions[5, 28, 10],  position: Position[10, 27, 5] ],
-				[ Dimensions[5, 2, 9],    position: Position[10, 25, 6] ]
-			]}
-
-			it 'calculates the correct dimensions and positions' do 
-				expect(box.send(:sub_boxes_args, item)).to eql(expected_args)
-			end
-		end
-
-		describe '#sub_boxes' do
-
-			it 'orders sub-boxes by volumes' do
-				sub_boxes = box.sub_boxes(item)
-				expect(sub_boxes[0].volume).to be >=(sub_boxes[1].volume)
-				expect(sub_boxes[1].volume).to be >=(sub_boxes[2].volume)
-			end
-
-			context 'with an item that reaches a side' do 
-				let(:item) { Box.new(Dimensions[15, 2, 10]) }
-
-				it 'only returns 2 sub-boxes' do 
-					sub_boxes = box.sub_boxes(item)
-					expect(sub_boxes.length).to eql(2)
-				end
-			end
-				
-		end
-
-	end
-end
+  describe Box do
+    subject(:box) { Box.new(dimensions, position: position) }
+    let(:dimensions) { Dimensions[25, 30, 10] }
+    let(:position) { Position[10, 25, 5] }
+    let(:item) { Item.new(Dimensions[5, 2, 1]) }
+
+    context 'if no position is given' do
+      let(:position) { nil }
+
+      it 'defaults to origin position' do
+        expect(box.position).to eql(Position[0, 0, 0])
+      end
+    end
+
+    describe '#orient!' do
+      before { box.orient! }
+      it { expect(box.dimensions).to eql(Dimensions[30, 25, 10]) }
+    end
+
+    describe '#sub_boxes_args' do
+      let(:expected_args) do
+        [
+          [Dimensions[20, 30, 10], position: Position[15, 25, 5]],
+          [Dimensions[5, 28, 10],  position: Position[10, 27, 5]],
+          [Dimensions[5, 2, 9],    position: Position[10, 25, 6]]
+        ]
+      end
+
+      it 'calculates the correct dimensions and positions' do
+        expect(box.send(:sub_boxes_args, item)).to eql(expected_args)
+      end
+    end
+
+    describe '#sub_boxes' do
+      it 'orders sub-boxes by volumes' do
+        sub_boxes = box.sub_boxes(item)
+        expect(sub_boxes[0].volume).to be >= (sub_boxes[1].volume)
+        expect(sub_boxes[1].volume).to be >= (sub_boxes[2].volume)
+      end
+
+      context 'with an item that reaches a side' do
+        let(:item) { Box.new(Dimensions[15, 2, 10]) }
+
+        it 'only returns 2 sub-boxes' do
+          sub_boxes = box.sub_boxes(item)
+          expect(sub_boxes.length).to eql(2)
+        end
+      end
+    end
+  end
+end

data/spec/lib/container_spec.rb

@@ -1,88 +1,89 @@
 module BoxPacker
-	describe Container do 
-		subject(:container) { Container.new([25, 30, 15]) }
-
-		it { expect(container.packings).to eql(nil) }
-		
-		context 'with items' do
-			let(:items) { [
-				Item.new([15, 24, 8], weight: 25),
-				Item.new([ 2,  1, 2], weight:  6),
-				Item.new([ 9,  9, 10], weight: 30)
-			] }
-			before { container.items = items }
-
-			context 'with container prepared' do 
-				before do
-					container.send(:prepare_to_pack!)
-				end
-
-				describe '#prepare_to_pack!' do 	
-					let(:expected_dimensions){[
-						Dimensions[24, 15, 8], 
-						Dimensions[2, 2, 1], 
-						Dimensions[10, 9, 9]
-					]}
-
-					it { expect(container.items.map(&:dimensions)).to eql(expected_dimensions) }
-					it { expect(container.packings).to eql([]) }
-				end
-
-				context 'with some items packed' do 
-					before do
-						container.new_packing!
-						container.packing << items[1]
-						container.packing << items[2]
-					end
-
-					it { expect(container.packings.length).to eql(1) }
-					it { expect(container.packing).to match_array([items[1], items[2]]) }
-
-					describe '#new_packing!!' do 	
-						before { container.new_packing! }
-						it { expect(container.packings.length).to eql(2) }
-						it { expect(container.packing).to eql([]) }
-					end
-				end	
-			end
-
-			describe '#packable?' do 
-
-				context 'with no items' do 
-					before { container.items = [] }
-					it { expect(container.send(:packable?)).to be(false) }
-				end
-
-				context 'with items that fit' do 
-					it { expect(container.send(:packable?)).to be(true) }
-				end
-
-				context 'with an item to large' do 
-					before { container.items[0].dimensions = Dimensions[26, 34, 8] }
-					it { expect(container.send(:packable?)).to be(false) }					
-				end
-
-				context 'with a weight limit thats lighter than one of the items' do 
-					before { container.weight_limit = 24 }
-					it { expect(container.send(:packable?)).to be(false) }
-				end
-
-				context 'with a packings limit of one packing' do 
-					before { container.packings_limit = 1 }
-
-					context 'with a weight limit thats lighter than items' do 
-						before { container.weight_limit = 50 }
-						it { expect(container.send(:packable?)).to be(false) }
-					end
-
-					context 'with a weight limit thats heavier than items' do 
-						before { container.weight_limit = 70 }
-						it { expect(container.send(:packable?)).to be(true) }
-					end
-
-				end
-
-			end
-		end
-	end
-end
+  describe Container do
+    subject(:container) { Container.new([25, 30, 15]) }
+
+    it { expect(container.packings).to eql(nil) }
+
+    context 'with items' do
+      let(:items) do
+        [
+          Item.new([15, 24, 8], weight: 25),
+          Item.new([2,  1, 2], weight:  6),
+          Item.new([9,  9, 10], weight: 30)
+        ]
+      end
+      before { container.items = items }
+
+      context 'with container prepared' do
+        before do
+          container.send(:prepare_to_pack!)
+        end
+
+        describe '#prepare_to_pack!' do
+          let(:expected_dimensions)do
+            [
+              Dimensions[24, 15, 8],
+              Dimensions[2, 2, 1],
+              Dimensions[10, 9, 9]
+            ]
+          end
+
+          it { expect(container.items.map(&:dimensions)).to eql(expected_dimensions) }
+          it { expect(container.packings).to eql([]) }
+        end
+
+        context 'with some items packed' do
+          before do
+            container.new_packing!
+            container.packing << items[1]
+            container.packing << items[2]
+          end
+
+          it { expect(container.packings.length).to eql(1) }
+          it { expect(container.packing).to match_array([items[1], items[2]]) }
+
+          describe '#new_packing!!' do
+            before { container.new_packing! }
+            it { expect(container.packings.length).to eql(2) }
+            it { expect(container.packing).to eql([]) }
+          end
+        end
+      end
+
+      describe '#packable?' do
+        context 'with no items' do
+          before { container.items = [] }
+          it { expect(container.send(:packable?)).to be(false) }
+        end
+
+        context 'with items that fit' do
+          it { expect(container.send(:packable?)).to be(true) }
+        end
+
+        context 'with an item to large' do
+          before { container.items[0].dimensions = Dimensions[26, 34, 8] }
+          it { expect(container.send(:packable?)).to be(false) }
+        end
+
+        context 'with a weight limit thats lighter than one of the items' do
+          before { container.weight_limit = 24 }
+          it { expect(container.send(:packable?)).to be(false) }
+        end
+
+        context 'with a packings limit of one packing' do
+          before { container.packings_limit = 1 }
+
+          context 'with a weight limit thats lighter than items' do
+            before { container.weight_limit = 50 }
+            it { expect(container.send(:packable?)).to be(false) }
+          end
+
+          context 'with a weight limit thats heavier than items' do
+            before { container.weight_limit = 70 }
+            it { expect(container.send(:packable?)).to be(true) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/dimensions_spec.rb

@@ -1,52 +1,54 @@
+require_relative '../support/matchers/yield_each_once'
+
 module BoxPacker
-	describe Dimensions do 
-		subject(:dimensions){ Dimensions[2, 10, 3] }
-
-		describe '#volume' do 
-			it { expect(dimensions.volume).to eql(60) }
-		end
-
-		describe '#>=' do 
-
-			context 'when compared with Dimensions that are all bigger' do 
-				let(:other_dimensions) { Dimensions[1, 5, 2] }
-				it { expect(dimensions >= other_dimensions).to be(true) }
-			end
-
-			context 'when compared with Dimensions where some are bigger and some are equal' do 
-				let(:other_dimensions) { Dimensions[2, 5, 3] }
-				it { expect(dimensions >= other_dimensions).to be(true) }
-			end
-
-			context 'when compared with Dimensions that are all equal' do 
-				let(:other_dimensions) { Dimensions[2, 10, 3] }
-				it { expect(dimensions >= other_dimensions).to be(true) }
-			end
-
-			context 'when compared with Dimensions where some are bigger and some are smaller' do 
-				let(:other_dimensions) { Dimensions[5, 5, 1] }
-				it { expect(dimensions >= other_dimensions).to be(false) }
-			end
-
-			context 'when compared with Dimensions where none are bigger' do 
-				let(:other_dimensions) { Dimensions[5, 15, 11] }
-				it { expect(dimensions >= other_dimensions).to be(false) }
-			end
-
-		end
-
-		describe '#each_rotation' do 
-			let(:rotations){[
-				Dimensions[2, 10, 3], 
-				Dimensions[2, 3, 10], 
-				Dimensions[10, 2, 3], 
-				Dimensions[10, 3, 2], 
-				Dimensions[3, 10, 2], 
-				Dimensions[3, 2, 10]
-			]}
-
-			it { expect{|b| dimensions.each_rotation(&b)}.to yield_each_once(rotations) }
-		end
-
-	end
-end
+  describe Dimensions do
+    include BoxPacker::Matchers
+    subject(:dimensions) { Dimensions[2, 10, 3] }
+
+    describe '#volume' do
+      it { expect(dimensions.volume).to eql(60) }
+    end
+
+    describe '#>=' do
+      context 'when compared with Dimensions that are all bigger' do
+        let(:other_dimensions) { Dimensions[1, 5, 2] }
+        it { expect(dimensions >= other_dimensions).to be(true) }
+      end
+
+      context 'when compared with Dimensions where some are bigger and some are equal' do
+        let(:other_dimensions) { Dimensions[2, 5, 3] }
+        it { expect(dimensions >= other_dimensions).to be(true) }
+      end
+
+      context 'when compared with Dimensions that are all equal' do
+        let(:other_dimensions) { Dimensions[2, 10, 3] }
+        it { expect(dimensions >= other_dimensions).to be(true) }
+      end
+
+      context 'when compared with Dimensions where some are bigger and some are smaller' do
+        let(:other_dimensions) { Dimensions[5, 5, 1] }
+        it { expect(dimensions >= other_dimensions).to be(false) }
+      end
+
+      context 'when compared with Dimensions where none are bigger' do
+        let(:other_dimensions) { Dimensions[5, 15, 11] }
+        it { expect(dimensions >= other_dimensions).to be(false) }
+      end
+    end
+
+    describe '#each_rotation' do
+      let(:rotations)do
+        [
+          Dimensions[2, 10, 3],
+          Dimensions[2, 3, 10],
+          Dimensions[10, 2, 3],
+          Dimensions[10, 3, 2],
+          Dimensions[3, 10, 2],
+          Dimensions[3, 2, 10]
+        ]
+      end
+
+      it { expect { |b| dimensions.each_rotation(&b) }.to yield_each_once(rotations) }
+    end
+  end
+end

data/spec/lib/item_spec.rb

@@ -1,30 +1,27 @@
 module BoxPacker
-	describe Item do 
-		subject(:item){ Item.new(dimensions) }
-		let(:dimensions){ [12, 5, 7] }
+  describe Item do
+    subject(:item) { Item.new(dimensions) }
+    let(:dimensions) { [12, 5, 7] }
 
-		describe '#fit_into' do 
-			
-			context 'when box is larger than box' do
-				let(:box) { Box.new(Dimensions[6, 15, 9]) }
-				let(:rotated_dimensions) { Dimensions[5, 12, 7] }
-				
-				it 'fits and orientation is rotated to fit' do 
-					expect(item.fit_into?(box)).to be(true)
-					expect(item.dimensions).to eql(rotated_dimensions)
-				end
-			end
+    describe '#fit_into' do
+      context 'when box is larger than box' do
+        let(:box) { Box.new(Dimensions[6, 15, 9]) }
+        let(:rotated_dimensions) { Dimensions[5, 12, 7] }
 
-			context 'when other box has a smaller side than box' do
-				let(:box) { Box.new(Dimensions[11, 6, 7]) }
-				
-				it 'does not fit and orientation is unchanged' do 
-					expect(item.fit_into?(box)).to be(false)
-					expect(item.dimensions).to eql(Dimensions[*dimensions])
-				end
-			end
+        it 'fits and orientation is rotated to fit' do
+          expect(item.fit_into?(box)).to be(true)
+          expect(item.dimensions).to eql(rotated_dimensions)
+        end
+      end
 
-		end
-		
-	end
-end
+      context 'when other box has a smaller side than box' do
+        let(:box) { Box.new(Dimensions[11, 6, 7]) }
+
+        it 'does not fit and orientation is unchanged' do
+          expect(item.fit_into?(box)).to be(false)
+          expect(item.dimensions).to eql(Dimensions[*dimensions])
+        end
+      end
+    end
+  end
+end

data/spec/lib/packer_spec.rb

@@ -1,81 +1,80 @@
 module BoxPacker
-	describe Packer do 
-		subject(:container) { Container.new(dimensions) }
-		let(:dimensions) { [10, 15, 5] }
-		let(:opts) { nil }
-		let(:items){[
-			Item.new([1,1,1], weight: 1),
-			Item.new([3,1,1], weight: 6),
-			Item.new([5,5,1], weight: 15),
-			Item.new([5,5,5], weight: 20)
-		]}
+  describe Packer do
+    subject(:container) { Container.new(dimensions) }
+    let(:dimensions) { [10, 15, 5] }
+    let(:opts) { nil }
+    let(:items)do
+      [
+        Item.new([1, 1, 1], weight: 1),
+        Item.new([3, 1, 1], weight: 6),
+        Item.new([5, 5, 1], weight: 15),
+        Item.new([5, 5, 5], weight: 20)
+      ]
+    end
 
-		describe '#pack' do 
+    describe '#pack' do
+      context 'with items that fit exactly in one packing' do
+        before do
+          20.times { container.items << items[0].dup }
+          10.times { container.items << items[1].dup }
+          8.times { container.items << items[2].dup }
+          4.times { container.items << items[3].dup }
+        end
 
-			context 'with items that fit exactly in one packing' do
-				before do
-					20.times { container.items << items[0].dup }
-					10.times { container.items << items[1].dup }
-					8.times { container.items << items[2].dup }
-					4.times { container.items << items[3].dup }
-				end
-				
-				it do 
-					expect(container.pack!).to eql(1)
-					expect(container.packed_successfully).to be(true)
-				end
-			end
+        it do
+          expect(container.pack!).to eql(1)
+          expect(container.packed_successfully).to be(true)
+        end
+      end
 
-			context 'with items that fit exactly in three packings' do
-				before do
-					35.times { container.items << items[0].dup }
-					30.times { container.items << items[1].dup }
-					10.times { container.items << items[2].dup }
-					15.times { container.items << items[3].dup }
-				end
+      context 'with items that fit exactly in three packings' do
+        before do
+          35.times { container.items << items[0].dup }
+          30.times { container.items << items[1].dup }
+          10.times { container.items << items[2].dup }
+          15.times { container.items << items[3].dup }
+        end
 
-				it do 
-					expect(container.pack!).to eql(3)
-					expect(container.packed_successfully).to be(true)
-				end
-			end
+        it do
+          expect(container.pack!).to eql(3)
+          expect(container.packed_successfully).to be(true)
+        end
+      end
 
-			context 'with a packing limit of one and too many items' do 
-				before do
-					container.packings_limit = 1
-					35.times { container.items << items[0].dup }
-					30.times { container.items << items[1].dup }
-					10.times { container.items << items[2].dup }
-					15.times { container.items << items[3].dup }
-				end
+      context 'with a packing limit of one and too many items' do
+        before do
+          container.packings_limit = 1
+          35.times { container.items << items[0].dup }
+          30.times { container.items << items[1].dup }
+          10.times { container.items << items[2].dup }
+          15.times { container.items << items[3].dup }
+        end
 
-				it do 
-					expect(container.pack!).to be(false)
-					expect(container.packed_successfully).to be(false)
-				end
-			end
+        it do
+          expect(container.pack!).to be(false)
+          expect(container.packed_successfully).to be(false)
+        end
+      end
 
-			context 'with random container and random items' do
-				let(:dimensions) { [x, y, z] }
-				let(:x) { rand(1..75) }
-				let(:y) { rand(1..75) }
-				let(:z) { rand(1..75) }
+      context 'with random container and random items' do
+        let(:dimensions) { [x, y, z] }
+        let(:x) { rand(1..75) }
+        let(:y) { rand(1..75) }
+        let(:z) { rand(1..75) }
 
-				let(:items) do
-					(1..rand(1..100)).map do
-						Item.new([x / rand(1..5), y / rand(1..5), z / rand(1..5)])
-					end
-				end
+        let(:items) do
+          (1..rand(1..100)).map do
+            Item.new([x / rand(1..5), y / rand(1..5), z / rand(1..5)])
+          end
+        end
 
-				before do
-					container.items = items
-					container.pack!
-				end
+        before do
+          container.items = items
+          container.pack!
+        end
 
-				it { expect(container.packed_successfully).to be(true) }
-			end
-
-		end
-
-	end
-end
+        it { expect(container.packed_successfully).to be(true) }
+      end
+    end
+  end
+end