box_packer 0.0.2 → 1.0.0

data/spec/lib/item_spec.rb

@@ -0,0 +1,30 @@
+module BoxPacker
+	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
+
+			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

@@ -0,0 +1,81 @@
+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 '#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
+				
+				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
+
+				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
+
+				it do 
+					expect(container.pack!).to eql(0)
+					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) }
+
+				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
+
+				it { expect(container.packed_successfully).to be(true) }
+			end
+
+		end
+
+	end
+end

data/spec/lib/packing_spec.rb

@@ -0,0 +1,73 @@
+module BoxPacker
+	describe Packing do 
+		subject(:packing) { Packing.new(total_volume, total_weight) }
+		let(:total_volume) { 200 }
+		let(:total_weight) { 50 }
+		let(:items) {[
+			Item.new([2, 4, 1], weight: 5),
+			Item.new([5, 2, 7], weight: 6),
+			Item.new([8, 4, 2], weight: 3)
+		]} 
+
+		it 'defaults to empty' do 
+			expect(packing).to eql([])
+		end
+
+		describe '#<<' do 
+			before { items.each{|i| packing << i} }
+
+			it { expect(packing.remaining_volume).to eql(58) }
+			it { expect(packing.remaining_weight).to eql(36) }
+			
+			context 'with items that do not have weight' do
+				let(:items) {[
+					Item.new([2, 4, 1]),
+					Item.new([5, 2, 7]),
+					Item.new([8, 4, 2])
+				]} 
+
+				it { expect(packing.remaining_weight).to be(50) }
+			end
+			
+			context 'with total_weight nil' do
+				let(:total_weight) { nil }
+				it { expect(packing.remaining_weight).to be(nil) }
+			end
+		end
+
+		describe '#fit?' do
+			before { items.each{|i| packing << i} }
+
+			context 'with item that fits' do 
+				let(:item) { Item.new([1, 5, 5], weight: 5)}
+				it { expect(packing.fit?(item)).to be(true) }
+			end
+
+			context 'with item thats already packed' do 
+				it { expect(packing.fit?(items[0])).to be(false) }				
+			end
+
+			context 'with item thats too large' do 
+				let(:item) { Item.new([3, 5, 5], weight: 25)}
+				it { expect(packing.fit?(item)).to be(false) }
+			end
+
+			context 'with item thats too heavy' do 
+				let(:item) { Item.new([1, 5, 5], weight: 45)}
+				it { expect(packing.fit?(item)).to be(false) }
+			end
+
+			context 'with total_weight nil and item that fits' do
+				let(:total_weight) { nil }
+				let(:item) { Item.new([1, 5, 5], weight: 5)}
+				it { expect(packing.fit?(item)).to be(true) }
+			end
+
+			context 'with item that has no weight but fits' do
+				let(:item) { Item.new([1, 5, 5])}
+				it { expect(packing.fit?(item)).to be(true) }
+			end
+		end
+
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+RSpec.configure do |config|
+
+	config.expect_with :rspec do |expectations|
+		expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+	end
+
+	config.mock_with :rspec do |mocks|
+		mocks.verify_partial_doubles = true
+	end
+
+	require_relative '../lib/box_packer'
+	Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+	config.include BoxPacker::Matchers
+end

data/spec/support/matchers/box_packer.rb

@@ -0,0 +1,40 @@
+require 'attr_extras'
+require 'rspec/matchers/built_in/yield'
+
+module BoxPacker
+	module Matchers
+	    class YieldEachOnce
+	    	pattr_initialize :expected
+	 
+			def matches?(block)		
+				@probe = RSpec::Matchers::BuiltIn::YieldProbe.probe(block)
+				@actual = @probe.successive_yield_args
+
+				@actual.each do |value|
+					unless expected.delete(value)
+						@failure_value = value
+						return false 
+					end
+				end
+				true
+			end
+
+			def supports_block_expectations?
+				true
+			end
+
+			def description
+				'be in expected array'
+			end
+
+			def failure_message
+				"value #{@failure_value.to_a} was not in expected array"
+			end
+	 
+	  	end
+
+	  	def yield_each_once(expected)
+	  		YieldEachOnce.new(expected)
+	  	end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: box_packer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,14 +28,42 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: attr_extras
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit
@@ -46,14 +74,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - box_packer.gemspec
 - lib/box_packer.rb
+- lib/box_packer/box.rb
+- lib/box_packer/builder.rb
+- lib/box_packer/container.rb
+- lib/box_packer/dimensions.rb
+- lib/box_packer/item.rb
+- lib/box_packer/packer.rb
+- lib/box_packer/packing.rb
+- lib/box_packer/position.rb
 - lib/box_packer/version.rb
-- lib/tc_box_packer.rb
+- spec/lib/box_spec.rb
+- spec/lib/container_spec.rb
+- spec/lib/dimensions_spec.rb
+- spec/lib/item_spec.rb
+- spec/lib/packer_spec.rb
+- spec/lib/packing_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/box_packer.rb
 homepage: ''
 licenses:
 - MIT
@@ -64,18 +108,26 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit
-test_files: []
+test_files:
+- spec/lib/box_spec.rb
+- spec/lib/container_spec.rb
+- spec/lib/dimensions_spec.rb
+- spec/lib/item_spec.rb
+- spec/lib/packer_spec.rb
+- spec/lib/packing_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/box_packer.rb

data/lib/tc_box_packer.rb

@@ -1,171 +0,0 @@
-require_relative "box_packer"
-require "test/unit"
-require 'benchmark'
- 
-class TestBoxPacker < Test::Unit::TestCase
- 
-	def setup
-		@containers = []
-		@containers[0] = BoxPacker::Container.new("A",[10, 1, 1],15)
-		@containers[1] = BoxPacker::Container.new("B",[1, 10, 5],50)
-		@containers[2] = BoxPacker::Container.new("C",[10, 15, 5],325)
-
-		@items = []
-		@items[0] = BoxPacker::Item.new("a",[1, 1, 1],1)
-		@items[1] = BoxPacker::Item.new("b",[3, 1, 1],6)
-		@items[2] = BoxPacker::Item.new("c",[5, 5, 1],15)
-		@items[3] = BoxPacker::Item.new("d",[5, 5, 5],20)
-
-		@skip_items_count = false
-	end
-
-	def teardown
-    	@containers.delete_if{ |container| container.packings.empty? } 
-    	unless @containers.empty?
-    		assert(@containers[0].packings.map(&:count).reduce(:+) == @containers[0].items.count, "Packed items less than container's list") unless @skip_items_count
-			assert(@containers[0].packings.map(&:remaining_weight).all? { |rw| rw >= 0 }, "Packing too heavy")
-		end
-  	end
-
-	def test_no_items
-		assert_nil(@containers[0].pack)
-	end
-
-	def test_items_too_heavy
-		@items[0].weight = 16
-		@containers[0].items << @items[0] 
-		assert_nil(@containers[0].pack)
-	end
-
-	def test_items_too_big
-		@containers[0].items << @items[2]
-		assert_nil(@containers[0].pack)
-	end
-
-	def test_too_many_packings
-		@containers[0].packings_limit = 1
-		11.times { @containers[0].items << @items[0] }
-		assert_nil(@containers[0].pack)		
-		@skip_items_count = true
-	end
-
-	def test_1d_one_full_packing
-		7.times { @containers[0].items << @items[0] }
-		@containers[0].items << @items[1]
-		assert_equal(1, @containers[0].pack)
-		assert_equal(0, @containers[0].packings[0].remaining_volume)
-	end
- 
-	def test_1d_two_packings_due_to_weight_limit
-		3.times { @containers[0].items << @items[1] }
-		assert_equal(2, @containers[0].pack)
-	end
-
-	def test_1d_three_full_packings
-		@containers[0].packings_limit = 4
-		3.times { @containers[0].items << @items[0] << @items[1] }
-		18.times { @containers[0].items << @items[0] }
-		assert_equal(3, @containers[0].pack)
-	end
-
-	def test_2d_one_full_packing_two_identical_items
-		2.times { @containers[1].items << @items[2] }
-		assert_equal(1, @containers[1].pack)
-		assert_equal(0, @containers[1].packings[0].remaining_volume)
-	end
-
-	def test_2d_one_full_packing_multiple_items
-		4.times { @containers[1].items << @items[0] }
-		7.times { @containers[1].items << @items[1] }
-		@containers[1].items << @items[2]
-		check_pack_in_between(@containers[1], 1, 2)
-	end	
-
-	def test_2d_three_full_packings
-		@containers[1].packings_limit = 5
-		8.times { @containers[1].items << @items[0] }
-		14.times { @containers[1].items << @items[1] }
-		4.times { @containers[1].items << @items[2] }
-		check_pack_in_between(@containers[1], 3, 4)
-	end
-
-	def test_3d_one_full_packing_with_identical_items
-		6.times { @containers[2].items << @items[3] }
-		assert_equal(1, @containers[2].pack)
-		assert_equal(0, @containers[2].packings[0].remaining_volume)
-	end
-
-	def test_3d_one_full_packing_with_multiple_items
-		20.times { @containers[2].items << @items[0] }
-		10.times { @containers[2].items << @items[1] }
-		8.times { @containers[2].items << @items[2] }
-		4.times { @containers[2].items << @items[3] }
-		assert_equal(1, @containers[2].pack)
-		assert_equal(0, @containers[2].packings[0].remaining_volume)
-	end
-
-	def test_3d_three_full_packings
-		@containers[2].packings_limit = 5
-		35.times { @containers[2].items << @items[0] }
-		30.times { @containers[2].items << @items[1] }
-		10.times { @containers[2].items << @items[2] }
-		15.times { @containers[2].items << @items[3] }
-		check_pack_in_between(@containers[2], 3, 4)
-	end		
-
-	def test_benchmark
-		puts "\n\nBenchmarking\n============"
-		iterations = 500
-		containers = []
-
-		(1..iterations).each do |i|
-	    	container_dimensions = [1 + rand(100), 1 + rand(50), 1 + rand(10)]
-	    	container_weight_limit = 1 + rand(1000)
-			container = BoxPacker::Container.new("c#{i}", container_dimensions, container_weight_limit)
-			container.packings_limit = 50
-
-			(1..(1+rand(40))).each do |j|
-				item_dimensions = container_dimensions.map { |c_dimension| 1 + rand(c_dimension) / (1 + rand(5)) }
-				item_weight = 1 + rand(container_weight_limit / (1 + rand(10)))
-	    		container.items << BoxPacker::Item.new("i#{j}", item_dimensions, item_weight)
-			end
-			containers << container
-	    end
-
-		Benchmark.bm(15) do |bm|
-			bm.report('Approx packings') do
-				containers.each{ |container| container.pack }
-			end
-			bm.report('Volume') do
-				containers.each{ |container| container.pack(:sort_by_volume) }
-			end
-			bm.report('Shuffled') do
-				containers.each{ |container| container.pack(:sort_by_shuffle) }
-			end
-		end
-
-		puts "\nBenchmark data\n=============="
-		puts "iterations: #{iterations}"		
-		benchmark_stats = Hash.new{0}
-		containers.each do |container|
-			benchmark_stats[:avg_container_volume] += container.volume
-			benchmark_stats[:avg_packings_count] += container.packings.count
-			benchmark_stats[:avg_items_count] += container.items.count
-			benchmark_stats[:avg_item_volume] += container.items.map(&:volume).reduce(:+) / container.items.count.to_f
-		end
-		benchmark_stats.each do |k, v| 
-			benchmark_stats[k] = v / containers.count.to_f 
-			puts "#{k}: #{benchmark_stats[k]}"
-		end
-		puts "\n"
-	end
-
-private
-
-	def check_pack_in_between(container, lower_bound, upper_bound)
-		assert(container.pack.between?(lower_bound, upper_bound), "Did not pack into #{lower_bound} (or #{upper_bound}) packings")
-		assert(container.packings.map(&:remaining_volume).reduce(:+) % container.volume == 0 , "Total remaining volume doesn't add up")
-	end
-
-end
-