box_packer 0.0.2 → 1.0.0

data/lib/box_packer/container.rb

@@ -0,0 +1,90 @@
+require_relative 'box'
+require_relative 'packing'
+require_relative 'dimensions'
+require_relative 'item'
+require_relative 'packer'
+
+module BoxPacker
+
+	def self.container(*args, &b)
+		Container.new(*args, &b)
+	end
+
+	class Container < Box
+		attr_accessor :label, :weight_limit, :packings_limit
+		attr_reader :items, :packing, :packings, :packed_successfully
+
+		def initialize(dimensions, opts={}, &b)
+			super(Dimensions[*dimensions])
+			@label = opts[:label]
+			@weight_limit = opts[:weight_limit]
+			@packings_limit = opts[:packings_limit]
+			@items = opts[:items] || []
+			orient!
+      		self.instance_exec(&b) if block_given?
+		end
+
+		def add_item(*args)
+			items << Item.new(*args)
+		end
+
+		def <<(item)
+			items << item.dup
+		end
+
+		def items=(new_items)
+			@items = new_items.map(&:dup)
+		end
+
+		def pack!
+			prepare_to_pack!
+			return unless packable?
+			@packed_successfully = Packer.pack(self)
+			packings.count
+		end
+
+		def new_packing!
+			@packing = Packing.new(volume, weight_limit)
+			@packings << @packing
+		end
+
+		def to_s
+			s = "\n|Container|"
+			s << " #{label}" if label
+			s << " #{dimensions}"
+			s << " Weight Limit:#{weight_limit}" if weight_limit
+			s << " Packings Limit:#{packings_limit}" if packings_limit
+			s << "\n"
+			s << (@packings ? @packings : items).map(&:to_s).join 
+		end
+
+	private
+
+		def packable?
+			return false if items.empty?
+			total_weight = 0
+
+			items.each do |item|
+				if weight_limit && item.weight 
+					return false if item.weight > weight_limit 
+					total_weight += item.weight
+				end
+
+				return false unless self >= item
+			end
+
+			if weight_limit && packings_limit
+				return total_weight <= weight_limit * packings_limit 
+			end
+
+			true
+		end
+
+		def prepare_to_pack!
+			items.each(&:orient!)
+			@packings = []
+			@packed_successfully = false
+		end
+
+	end
+end

data/lib/box_packer/dimensions.rb

@@ -0,0 +1,37 @@
+require 'matrix'
+
+module BoxPacker
+	class Dimensions < Vector
+
+		def width
+			Dimensions[self[0], 0, 0]
+		end
+		
+		def height
+			Dimensions[0, self[1], 0]
+		end
+
+		def depth
+			Dimensions[0, 0, self[2]]
+		end
+
+		def volume
+			@volume ||= self[0] * self[1] * self[2]
+		end
+
+		def >=(other_dimensions)
+			map2(other_dimensions){ |v1, v2| v1 >= v2 }.reduce(&:&)
+		end
+
+		def each_rotation
+			to_a.permutation.each do |perm|
+				yield Dimensions[*perm]
+			end
+		end
+
+		def to_s
+			"#{self[0]}x#{self[1]}x#{self[2]}"
+		end
+
+	end
+end

data/lib/box_packer/item.rb

@@ -0,0 +1,33 @@
+require_relative 'box'
+require_relative 'dimensions'
+
+module BoxPacker
+	class Item < Box
+		attr_accessor :label, :weight
+
+		def initialize(dimensions, opts={})
+			super(Dimensions[*dimensions])
+			@label = opts[:label]
+			@weight = opts[:weight]
+		end
+
+		def fit_into?(box)
+			each_rotation do |rotation|
+				if box.dimensions >= rotation
+					@dimensions = rotation
+					return true
+				end
+			end
+			false
+		end
+
+		def to_s
+			s = '|     Item|'
+			s << " #{label}" if label
+			s << " #{dimensions} #{position} Volume:#{volume}"
+			s << " Weight:#{weight}" if weight
+			s << "\n"
+		end
+		
+	end
+end

data/lib/box_packer/packer.rb

@@ -0,0 +1,58 @@
+require 'attr_extras'
+require 'forwardable'
+
+module BoxPacker
+	class Packer
+		extend Forwardable
+		method_object :pack, :container
+		def_delegators :container, :new_packing!, :packings_limit, :packings, :packing
+
+		def pack
+			@items = container.items.sort_by!(&:volume).reverse!
+
+			until too_many_packings? do
+				new_packing!
+				pack_box(@items, container)
+				return true if @items.empty?
+			end
+			false
+		end
+
+	private
+
+		def too_many_packings?
+			packings.count >= packings_limit - 1 if packings_limit
+		end
+
+		def pack_box(possible_items, box)
+			possible_items = possible_items.dup
+			until possible_items.empty?
+				item = possible_items.shift
+
+				if item.fit_into?(box)
+					pack_item!(item, possible_items, box)
+					break if possible_items.empty?
+
+					box.sub_boxes(item).each do |sub_box| 
+						purge!(possible_items)
+						pack_box(possible_items, sub_box)
+					end
+					break
+				end
+			end
+		end
+
+		def pack_item!(item, possible_items, box)
+			item.position = box.position
+			possible_items.delete(item)
+			packing << @items.delete(item)
+		end
+
+		def purge!(possible_items)
+			possible_items.keep_if do |item|
+				packing.fit?(item)			
+			end
+		end
+
+	end
+end

data/lib/box_packer/packing.rb

@@ -0,0 +1,40 @@
+require 'delegate'
+
+module BoxPacker
+	class Packing < SimpleDelegator
+		attr_reader :remaining_weight, :remaining_volume
+
+		def initialize(total_volume, total_weight)
+			super([])
+			@remaining_volume = total_volume
+			@remaining_weight = total_weight
+		end
+
+		def <<(item)
+			@remaining_volume -= item.volume
+			@remaining_weight -= item.weight if weight?(item)
+			super
+		end
+
+		def fit?(item)
+			return false if include?(item)
+			return false if remaining_volume < item.volume
+			return false if weight?(item) && remaining_weight < item.weight
+			true
+		end
+
+		def to_s
+			s = "|  Packing| Remaining Volume:#{remaining_volume}"
+			s << " Remaining Weight:#{remaining_weight}" if remaining_weight
+			s << "\n" 
+			s << map(&:to_s).join 
+		end
+		
+	private
+
+		def weight?(item)
+			remaining_weight && item.weight
+		end
+
+	end
+end

data/lib/box_packer/position.rb

@@ -0,0 +1,11 @@
+require 'matrix'
+
+module BoxPacker
+	class Position < Vector
+
+		def to_s
+			"(#{self[0]},#{self[1]},#{self[2]})"
+		end
+
+	end
+end

data/lib/box_packer/version.rb

@@ -1,3 +1,3 @@
 module BoxPacker
-  VERSION = "0.0.2"
+	VERSION = '1.0.0'
 end

data/spec/lib/box_spec.rb

@@ -0,0 +1,53 @@
+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

data/spec/lib/container_spec.rb

@@ -0,0 +1,88 @@
+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(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 { 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

@@ -0,0 +1,52 @@
+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