crafting_table 0.3.0

data/spec/crafting_table/item_spec.rb

@@ -0,0 +1,67 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module CraftingTable
+
+  describe Item do
+
+    describe '#initialize' do
+
+      it 'should have the damage value default to 0' do
+        expect(Item.new('Wood', 17).damage_value).to eq 0
+      end
+
+      it 'should set the appropriate instance variables' do
+        comp = Item.new('Wood', 17, 1)
+        expect(comp.name).to eq 'Wood'
+        expect(comp.item_id).to eq 17
+        expect(comp.damage_value).to eq 1
+      end
+
+    end
+
+    describe '#==' do
+
+      it 'should return true if name, item id and damage value are equal' do
+        expect(Item.new('Wood', 17)).to eq Item.new('Wood', 17)
+        expect(Item.new('Wood', 17, 2)).to eq Item.new('Wood', 17, 2)
+      end
+
+      it 'should return false if name or item id are not equal' do
+        expect(Item.new('Wood', 17)).not_to eq Item.new('Wood', 16)
+        expect(Item.new('Wood', 17)).not_to eq Item.new('Log', 17)
+        expect(Item.new('Wood', 17, 1)).not_to eq Item.new('Wood', 17, 2)
+      end
+
+    end
+
+    describe'#eql?' do
+
+      it 'should behave like #==' do
+        expect(Item.new('Wood', 17)).to eql Item.new('Wood', 17)
+        expect(Item.new('Wood', 17, 2)).to eql Item.new('Wood', 17, 2)        
+      end
+
+    end
+
+    describe '#hash' do
+
+      it 'should return a proper value' do
+        expect(Item.new('Wood', 17, 2).hash).to eq ['Wood', 17, 2].hash
+      end
+
+    end
+
+    describe '#identifier' do
+
+      it 'should return an array containing its id and damage value' do
+        expect(Item.new('Wood', 17, 2).identifier).to eq [17, 2]
+        expect(Item.new('Stone', 1, 0).identifier).to eq [1, 0]
+      end
+
+    end
+
+  end
+
+end

data/spec/crafting_table/recipe_manager_spec.rb

@@ -0,0 +1,353 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module CraftingTable
+
+  describe RecipeManager do
+    let(:item_log) { Item.new('Log', 17) }
+
+    let(:item_gold_ore) { Item.new('Gold Ore', 14) }
+    let(:item_iron_ore) { Item.new('Iron Ore', 15) }
+
+    let(:item_wood_oak) { Item.new('Oak Wood', 17, 0) }
+    let(:item_wood_spruce) { Item.new('Spruce Wood', 17, 1) }
+    let(:item_wood_birch) { Item.new('Birch Wood', 17, 2) }
+    let(:item_wood_jungle) { Item.new('Jungle Wood', 17, 3) }
+
+    let(:item_planks) { Item.new('Wood Planks', 5) }
+    let(:item_coal) { Item.new('Coal', 263) }
+    let(:item_stick) { Item.new('Stick', 280) }
+    let(:item_torch) { Item.new('Torch', 50) }
+
+    let(:item_manager) { ItemManager.new([item_log, item_planks, item_stick, item_coal, item_torch]) }
+    
+    let(:recipe_planks) { Recipe.new('Wood Planks', { item_wood_oak => 1 }, { item_planks => 4 }) }
+    let(:recipe_sticks) { Recipe.new('Sticks', { item_planks => 2 }, { item_stick => 4 }) }
+    let(:recipe_torch) { Recipe.new('Torch', { item_stick => 1, item_coal => 1 }, { item_torch => 4 }) }
+    
+    let(:manager) { RecipeManager.new(item_manager) }
+
+
+    describe '#initialize' do
+
+      it 'should set the appropriate instance variables' do
+        expect(manager.recipes).to eq []
+        expect(manager.item_manager).to eq item_manager
+      end
+
+    end
+
+    describe '#add' do
+
+      it 'should add the recipe to the internal collection' do
+        expect { manager.add(recipe_planks) }.to change { manager.recipes.count }.by 1
+        expect(manager.recipes).to include recipe_planks
+      end
+    end
+
+
+    describe '#add_from_file' do
+
+      it 'should add all recipes from the file' do
+        item_manager = ItemManager.new
+        item_manager.add_from_file(ITEM_FILE)
+        
+        manager = RecipeManager.new(item_manager)
+        manager.add_from_file(RECIPE_FILE)
+
+        expect(manager).to have(4).recipes
+        recipe_names = manager.recipes.map(&:name).sort
+        expect(recipe_names).to eq ['Sticks', 'Stone', 'Torch', 'Oak Wood Planks'].sort
+      end
+      
+    end
+
+    describe '#clear' do
+
+      it 'should remove all recipes from the internal collection' do
+        manager.add(recipe_torch)
+        expect { manager.clear }.to change { manager.recipes.count }.to 0
+      end
+
+    end
+
+    describe '#find' do
+      before(:each) do
+        manager.clear
+        manager.add(recipe_torch)
+        manager.add(recipe_planks)
+        manager.add(recipe_sticks)
+      end
+
+      context "when searching for the recipe's name" do
+
+        context 'with case sensitivity' do
+
+          it 'should return recipes with matching case' do
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'Torch'
+            end
+            expect(results).to eq [recipe_torch]
+
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'Sticks'
+            end
+            expect(results).to eq [recipe_sticks]
+          end
+
+          it 'should not return recipes where the case does not match' do
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'torch'
+            end
+            expect(results).to be_empty
+
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'stICkS'
+            end
+            expect(results).to be_empty
+          end
+
+        end
+
+        context 'with case insensitivity' do
+
+          it 'should return recipes no matter their case' do
+            results = manager.find do |search|
+              search.case_sensitive = false
+              search.name = 'Torch'
+            end
+            expect(results).to eq [recipe_torch]
+
+            results = manager.find do |search|
+              search.case_sensitive = false
+              search.name = 'toRcH'
+            end
+            expect(results).to eq [recipe_torch]
+          end
+          
+        end
+
+        context 'with exact matching' do
+
+          it 'should return exact matches' do
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Torch'
+            end
+            expect(results).to eq [recipe_torch]
+
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Sticks'
+            end
+            expect(results).to eq [recipe_sticks]
+          end
+
+          it 'should not return non-exact matches' do
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Tor'
+            end
+            expect(results).to be_empty
+
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'ticks'
+            end
+            expect(results).to be_empty
+          end
+
+        end
+
+        context 'with fuzzy matching' do
+
+          it 'should return non-exact matches too' do
+            results = manager.find do |search|
+              search.exact = false
+              search.name = 'Tor'
+            end
+            expect(results).to eq [recipe_torch]
+
+            results = manager.find do |search|
+              search.exact = false
+              search.name = 'ticks'
+            end
+            expect(results).to eq [recipe_sticks]
+          end
+
+        end
+
+      end
+
+      context 'when searching for inputs' do
+
+        it 'should return all recipes which have the item as input' do
+          results = manager.find do |search|
+            search.input = item_coal
+          end
+          expect(results).to eq [recipe_torch]
+
+          results = manager.find do |search|
+            search.input = item_wood_oak
+          end
+          expect(results).to eq [recipe_planks]
+        end
+        
+      end
+
+      context 'when searching for outputs' do
+
+        it 'should return all recipes which have the item as output' do
+          results = manager.find do |search|
+            search.output = item_torch
+          end
+          expect(results).to eq [recipe_torch]
+
+          results = manager.find do |search|
+            search.output = item_planks
+          end
+          expect(results).to eq [recipe_planks]
+        end
+        
+      end
+      
+    end
+
+    describe '#find_by_name' do
+      before(:each) do
+        manager.clear
+        manager.add(recipe_torch)
+        manager.add(recipe_planks)
+        manager.add(recipe_sticks)
+      end
+
+      context 'with case sensitivity' do
+        let(:args) { { case_sensitive: true } }
+
+        it 'should return recipes with matching case' do
+          expect(manager.find_by_name('Torch', args).first).to eq recipe_torch
+          expect(manager.find_by_name('Sticks', args).first).to eq recipe_sticks
+        end
+
+        it 'should not return recipes where the case does not match' do
+          expect(manager.find_by_name('torch', args)).to be_empty
+          expect(manager.find_by_name('stICkS', args)).to be_empty
+        end
+
+      end
+
+      context 'with case-insensitivity' do
+        let(:args) { { case_sensitive: false } }
+
+        it 'should return recipes no matter their case' do
+          expect(manager.find_by_name('Torch', args).first).to eq recipe_torch
+          expect(manager.find_by_name('toRcH', args).first).to eq recipe_torch
+        end
+
+      end
+
+      context 'with exact matching' do
+        let(:args) { { exact: true } }
+
+        it 'should return exact matches' do
+          expect(manager.find_by_name('Torch', args).first).to eq recipe_torch
+          expect(manager.find_by_name('Sticks', args).first).to eq recipe_sticks
+        end
+
+        it 'should not return non-exact matches' do
+          expect(manager.find_by_name('Tor', args)).to be_empty
+          expect(manager.find_by_name('ticks', args)).to be_empty
+        end
+
+      end
+
+      context 'with fuzzy matching' do
+        let(:args) { { exact: false } }
+
+        it 'should return non-exact matches too' do
+          expect(manager.find_by_name('Tor', args).first).to eq recipe_torch
+          expect(manager.find_by_name('ticks', args).first).to eq recipe_sticks
+        end
+
+      end
+
+    end
+
+    describe '#find_by_input' do
+      before(:each) do
+        manager.clear
+        manager.add(recipe_torch)
+        manager.add(recipe_planks)
+        manager.add(recipe_sticks)
+      end
+
+      it 'should return all recipes which have the item as input' do
+        expect(manager.find_by_input(item_coal).first).to eq recipe_torch
+        expect(manager.find_by_input(item_wood_oak).first).to eq recipe_planks
+      end
+
+    end
+
+    describe '#find_by_output' do
+      before(:each) do
+        manager.clear
+        manager.add(recipe_torch)
+        manager.add(recipe_planks)
+        manager.add(recipe_sticks)
+      end
+
+      it 'should return all recipes which have the item as output' do
+        expect(manager.find_by_output(item_torch).first).to eq recipe_torch
+        expect(manager.find_by_output(item_planks).first).to eq recipe_planks
+      end
+
+    end
+
+    describe '#resolve_recipe' do
+      before(:each) do
+        manager.clear
+        manager.add(recipe_torch)
+        manager.add(recipe_planks)
+        manager.add(recipe_sticks)
+      end
+
+      context 'when resolving one torch' do
+        let(:result) { manager.resolve_recipe(recipe_torch, 1) }
+
+        it 'should return one wood and one coal' do
+          expect(result[item_coal]).to eq 1
+          expect(result[item_wood_oak]).to eq 1
+        end
+
+      end
+
+      context 'when resolving 32 torches' do
+        let(:result) { manager.resolve_recipe(recipe_torch, 32) }
+
+        it 'should return one wood and 8 coal' do
+          expect(result[item_coal]).to eq 8
+          expect(result[item_wood_oak]).to eq 1
+        end
+
+      end
+
+      context 'when resolving 100 torches' do
+        let(:result) { manager.resolve_recipe(recipe_torch, 100) }
+
+        it 'should return 4 wood and 25 coal' do
+          expect(result[item_coal]).to eq 25
+          expect(result[item_wood_oak]).to eq 4
+        end
+
+      end
+
+    end
+    
+  end
+  
+end

data/spec/crafting_table/recipe_spec.rb

@@ -0,0 +1,25 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module CraftingTable
+
+  describe Recipe do
+    let(:comp_wood) { Item.new('Wood', 17, 0) }
+    let(:comp_planks) { Item.new('Wood Planks', 5, 0) }
+
+    let(:recipe_planks) { Recipe.new('Wood Planks', { comp_wood => 1 }, { comp_planks => 2 }) }
+    
+    describe '#initialize' do
+
+      it 'should set the appropriate instance variables' do
+        expect(recipe_planks.name).to eq 'Wood Planks'
+        expect(recipe_planks.input).to eq({ comp_wood => 1 })
+        expect(recipe_planks.output).to eq({ comp_planks => 2})
+      end
+
+    end
+
+  end
+
+end

data/spec/crafting_table/search/search_builder.rb

@@ -0,0 +1,105 @@
+#coding: utf-8
+
+require_relative '../../spec_helper'
+
+module CraftingTable
+
+  module Search
+
+    describe SearchBuilder do
+      let(:search_for_name) do
+        search = SearchBuilder.new
+        search.name = 'Oak Wood'
+        search.case_sensitive = true
+        search.exact = true
+        search
+      end
+
+      let(:search_for_name_fuzzy) do
+        search = SearchBuilder.new
+        search.name = 'Oak Wood'
+        search.case_sensitive = false
+        search.exact = false
+        search
+      end
+
+      let(:search_for_item_id) do
+        search = SearchBuilder.new
+        search.item_id = 1
+        search
+      end
+
+      let(:search_for_item_id_range) do
+        search = SearchBuilder.new
+        search.item_id = 5..10
+        search
+      end
+
+      let(:search_for_damage_value) do
+        search = SearchBuilder.new
+        search.damage_value = [2, 4]
+        search
+      end
+
+      let(:search_for_multiple_conditions) do
+        search = SearchBuilder.new
+        search.item_id = 1
+        search.name = 'Oak Wood'
+        search
+      end
+
+      let(:search_for_input) do
+        search = SearchBuilder.new
+        search.input = Item.new('Stone', 1)
+        search
+      end
+
+      let(:search_for_output) do
+        search = SearchBuilder.new
+        search.output = Item.new('Torch', 50)
+        search
+      end
+
+      describe '#searches' do
+
+        it 'should return a NameSearch if name and exact were set' do
+          expect(search_for_name.searches).to eq [NameSearch.new('Oak Wood',
+                                                                 case_sensitive: true)]
+        end
+        
+        it 'should return a FuzzyNameSearch if name was set, and exact was set to false' do
+          expect(search_for_name_fuzzy.searches).to eq [FuzzyNameSearch.new('Oak Wood',
+                                                                            case_sensitive: false)]
+        end
+
+        it 'should return a ItemIDSearch if item_id was set' do
+          expect(search_for_item_id.searches).to eq [ItemIDSearch.new(1)]
+          expect(search_for_item_id_range.searches).to eq [ItemIDSearch.new(5..10)]
+        end
+
+        it 'should return a DamageSearch if damage_value was set' do
+          expect(search_for_damage_value.searches).to eq [DamageSearch.new([2, 4])]
+        end
+
+        it 'should return an InputSearch if input was set' do
+          expect(search_for_input.searches).to eq [InputSearch.new(Item.new('Stone', 1))]
+        end
+
+        it 'should return an OutputSearch if output was set' do
+          expect(search_for_output.searches).to eq [OutputSearch.new(Item.new('Torch', 50))]
+        end
+
+        it 'should return multiple searches if multiple conditions were set' do
+          expect(search_for_multiple_conditions.searches).to eq [NameSearch.new('Oak Wood',
+                                                                                case_sensitive: true),
+                                                                 ItemIDSearch.new(1)]
+        end
+        
+      end
+      
+        
+    end
+
+  end
+
+end