crafting_table 0.3.0

data/lib/crafting_table/search/damage_search.rb

@@ -0,0 +1,51 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which allows to filter recipes and items by their damage value.
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class DamageSearch
+      attr_reader :damage_value
+
+      # Create a new DamageSearch
+      #
+      # @param [Fixnum, Range] damage_value Damage value for which to filter.
+      def initialize(damage_value)
+        @damage_value = damage_value
+      end
+
+      # Apply this filter to a collection of items.
+      #
+      # @param [Array<Item>] items
+      #   Collection of items which to filter.
+      # @return [Array<Item>]
+      #   Items which matched the search criteria
+      def apply_to(items)
+        if damage_value.respond_to?(:include?)
+          items.select { |item| damage_value.include? item.damage_value }
+        else
+          items.select { |item| damage_value == item.damage_value }
+        end
+      end
+
+      # Compare two searches for equality.
+      #
+      # They are considered equal if the damage value for which they filter is equal.
+      #
+      # @param [DamageSearch] other DamageSearch which to compare for equality.
+      # @return [Boolean] Whether two searches are equal.
+      def ==(other)
+        other.damage_value == damage_value
+      end
+
+      alias_method :eq?, :==
+        
+    end
+
+  end
+
+end

data/lib/crafting_table/search/fuzzy_name_search.rb

@@ -0,0 +1,39 @@
+#coding: utf-8
+
+module CraftingTable
+  
+  module Search
+    
+    # A class which allows to filter recipes and items by their name.
+    #
+    # Unlike NameSearch, this class does not filter for exact matches,
+    # but for inclusions. E.g. searching for "Ore" will return "Iron
+    # Ore" as well as "Gold Ore".
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class FuzzyNameSearch < NameSearch
+
+      def exact?
+        false
+      end
+
+      # Apply this filter to a collection of items or recipes.
+      # 
+      # @param [Array<Item, Recipe>] collection
+      #   Collection of items and recipes which to filter.
+      # @return [Array<Item, Recipe>]
+      #   Items and recipes which matched the search criteria.
+      def apply_to(collection)
+        if case_sensitive?
+          collection.select { |item| item.name.include? name }
+        else
+          collection.select { |item| item.name.downcase.include? name.downcase }
+        end
+      end
+      
+    end
+
+  end
+
+end

data/lib/crafting_table/search/input_search.rb

@@ -0,0 +1,47 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which allows to filter recipes by their input.
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class InputSearch
+      attr_reader :item
+
+      # Create a new InputSearch
+      #
+      # @param [Item] item Item for which to filter.
+      def initialize(item)
+        @item = item
+      end
+
+      # Apply this filter to a collection of recipes.
+      #
+      # @param [Array<Recipe>] recipes
+      #   Collection of recipes which to filter.
+      # @return [Array<Recipe>]
+      #   Recipes which matched the search criteria
+      def apply_to(recipes)
+        recipes.select { |recipe| recipe.input.include? item }
+      end
+
+      # Compare two searches for equality.
+      #
+      # They are considered equal if the item for which they filter is equal.
+      #
+      # @param [InputSearch] other InputSearch which to compare for equality.
+      # @return [Boolean] Whether two searches are equal.
+      def ==(other)
+        other.item == item
+      end
+
+      alias_method :eq?, :==
+      
+    end
+
+  end
+
+end

data/lib/crafting_table/search/item_id_search.rb

@@ -0,0 +1,51 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which allows to filter recipes and items by their item ID.
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class ItemIDSearch
+      attr_reader :item_id
+
+      # Create a new ItemIDSearch
+      #
+      # @param [Fixnum, Range] item_id Item ID for which to search.
+      def initialize(item_id)
+        @item_id = item_id
+      end
+
+      # Apply this filter to a collection of items.
+      #
+      # @param [Array<Item>] items
+      #   Collection of items which to filter.
+      # @return [Array<Item>]
+      #   Items which matched the search criteria
+      def apply_to(items)
+        if item_id.respond_to?(:include?)
+          items.select { |item| item_id.include? item.item_id }
+        else
+          items.select { |item| item_id == item.item_id }
+        end
+      end
+
+      # Compare two searches for equality.
+      #
+      # They are considered equal if the item ID for which they filter is equal.
+      #
+      # @param [ItemIDSearch] other ItemIDSearch which to compare for equality.
+      # @return [Boolean] Whether two searches are equal.
+      def ==(other)
+        other.item_id == item_id
+      end
+
+      alias_method :eq?, :==
+
+    end
+
+  end
+
+end

data/lib/crafting_table/search/name_search.rb

@@ -0,0 +1,71 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which allows to filter recipes and items by their name.
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class NameSearch
+      attr_reader :name, :case_sensitive
+
+      # Create a new NameSearch
+      #
+      # @param [String] name Name for which to filter.
+      # @param [Hash] options Options hash which influences the filtering.
+      # @option options [Boolean] :case_sensitive (true)
+      #   Whether to filter case-sensitively.
+      def initialize(name, options = {})
+        @name = name
+        @case_sensitive = options.fetch(:case_sensitive, true)
+      end
+
+      def exact?
+        true
+      end
+
+      def case_sensitive?
+        @case_sensitive
+      end
+
+      # Apply this filter to a collection of items or recipes.
+      # 
+      # @param [Array<Item, Recipe>] collection
+      #   Collection of items and recipes which to filter.
+      # @return [Array<Item, Recipe>]
+      #   Items and recipes which matched the search criteria.
+      def apply_to(collection)
+        if case_sensitive?
+          if exact?
+            collection.select { |item| item.name == name }
+          else
+            collection.select { |item| item.name.include? name }
+          end
+        else
+          if exact?
+            collection.select { |item| item.name.downcase == name.downcase }
+          else
+            collection.select { |item| item.name.downcase.include? name.downcase }
+          end
+        end
+      end
+
+      # Compare two searches for equality.
+      #
+      # They are considered equal if the name for which they filter is equal.
+      #
+      # @param [NameSearch] other NameSearch which to compare for equality.
+      # @return [Boolean] Whether two searches are equal.
+      def ==(other)
+        other.name == name && other.case_sensitive == case_sensitive
+      end
+
+      alias_method :eq?, :==
+
+    end
+    
+  end
+
+end

data/lib/crafting_table/search/output_search.rb

@@ -0,0 +1,47 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which allows to filter recipes by their output.
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class OutputSearch
+      attr_reader :item
+
+      # Create a new OutputSearch.
+      #
+      # @param [Item] item Item for which to filter.
+      def initialize(item)
+        @item = item
+      end
+
+      # Apply this filter to a collection of recipes.
+      #
+      # @param [Array<Recipe>] recipes
+      #   Collection of recipes which to filter.
+      # @return [Array<Recipe>]
+      #   Recipes which matched the search criteria
+      def apply_to(recipes)
+        recipes.select { |recipe| recipe.output.include? item }
+      end
+
+      # Compare two searches for equality.
+      #
+      # They are considered equal if the item for which they filter is equal.
+      #
+      # @param [InputSearch] other InputSearch which to compare for equality.
+      # @return [Boolean] Whether two searches are equal.
+      def ==(other)
+        other.item == item
+      end
+
+      alias_method :eq?, :==
+
+    end
+
+  end
+
+end

data/lib/crafting_table/search/search_builder.rb

@@ -0,0 +1,85 @@
+#coding: utf-8
+
+module CraftingTable
+
+  module Search
+
+    # A class which provides a basic API to construct searches.
+    #
+    # This allows to easily create multiple searches without having to
+    # know about the underlying classes.
+    #
+    # @example Searching for name and damage value
+    #   builder = SearchBuilder.new
+    #   builder.name           = 'Wood'
+    #   builder.exact          = false
+    #   builder.case_sensitive = false
+    #   builder.damage_value   = 3
+    #
+    #   builder.searches #=> [FuzzyNameSearch(...), DamageSearch(...)]
+    #
+    # @author Michael Senn <morrolan@morrolan.ch>
+    # @since 0.3
+    class SearchBuilder
+      # @!attribute [rw] name
+      #   @return [String] The name for which to search.
+      #
+      # @!attribute [rw] exact
+      #   @return [Boolean] Whether to search for an exact match.
+      #
+      # @!attribute [rw] case_sensitive
+      #   @return [Boolean] Whether to search case-sensitively.
+      #
+      # @!attribute [rw] damage_value
+      #   @return [#include?, Fixnum]
+      #     The damage value(s) for which to search.
+      #
+      # @!attribute [rw] item_id
+      #   @return [#include?, Fixnum]
+      #     The item ID(s) for which to search.
+      #
+      # @!attribute [rw] input
+      #   @return [Item] The input for which to search.
+      #
+      # @!attribute [rw] output
+      #   @return [Item] The output for which to search.      
+      
+      attr_accessor :name, :exact, :case_sensitive
+      attr_accessor :damage_value
+      attr_accessor :item_id
+      attr_accessor :input, :output
+
+      
+      # Create a collection of searches based on the instance
+      # variables which were set.
+      #
+      # @return [Array<*Search>]
+      def searches
+        searches = []
+
+        if name
+          c_sens = case_sensitive.nil? ? true : case_sensitive
+          if exact
+            searches << NameSearch.new(name, case_sensitive: c_sens)
+          else
+            searches << FuzzyNameSearch.new(name, case_sensitive: c_sens)
+          end
+        end
+
+        searches << DamageSearch.new(damage_value) if damage_value
+
+        searches << ItemIDSearch.new(item_id) if item_id
+
+        searches << InputSearch.new(input) if input
+
+        searches << OutputSearch.new(output) if output
+
+        searches
+        
+      end
+
+    end
+
+  end
+
+end

data/spec/crafting_table/item_manager_spec.rb

@@ -0,0 +1,421 @@
+#coding: utf-8
+
+require_relative '../spec_helper'
+
+module CraftingTable
+
+  describe ItemManager do
+    let(:manager) { ItemManager.new }
+    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_stone) { Item.new('Stone', 1) }
+
+    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) }
+
+
+    describe '#initialize' do
+
+      it 'should set the appropriate instance variables' do
+        expect(manager.items).to eq []
+
+        expect(ItemManager.new([item_log, item_gold_ore]).items).to eq [item_log, item_gold_ore]
+      end
+
+    end
+
+    describe '#add' do
+
+      it 'should add the item to the internal collection' do
+        expect { manager.add(item_log) }.to change { manager.items.count }.by 1
+        expect(manager.items).to include item_log
+      end
+
+    end
+
+    describe '#add_from_file' do
+
+      it 'should add all items from file' do
+        # Todo: This test is very brittle. A separate data file for
+        # testing purposes which does not get modified might be a good idea.
+
+        manager.add_from_file(ITEM_FILE)
+        expect(manager.items).to have(371).items
+
+        item_names = manager.items.map(&:name)
+        ['Stone', 'Gold Ore', 'Piston', 'Lapis Lazuli Ore'].each do |name|
+          expect(item_names).to include name
+        end
+
+        expect(manager.find_by_identifier([1, 0]).first.name).to eq 'Stone'
+      end
+
+    end
+
+    describe '#clear' do
+
+      it 'should remove all items from the internal collection' do
+        manager.add(item_gold_ore)
+        expect { manager.clear }.to change { manager.items.count }.to 0
+      end
+
+    end
+
+    describe '#find' do
+      before(:each) do
+        manager.clear
+        manager.add(item_log)
+        manager.add(item_gold_ore)
+        manager.add(item_iron_ore)
+        manager.add(item_stone)
+
+        manager.add(item_wood_oak)
+        manager.add(item_wood_spruce)
+        manager.add(item_wood_birch)
+        manager.add(item_wood_jungle)        
+      end
+
+      context "when searching for the item's name" do
+
+        context 'with case sensitivity' do
+
+          it 'should return items with matching case' do
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'Gold Ore'
+            end
+            expect(results).to eq [item_gold_ore]
+
+            results = manager.find do |search|
+              search.case_sensitive = true              
+              search.name = 'Log'
+            end
+            expect(results).to eq [item_log]
+          end
+
+          it 'should not return items where the case does not match' do
+            results = manager.find do |search|
+              search.case_sensitive = true
+              search.name = 'gold ore'
+            end
+            expect(results).to be_empty
+
+            results = manager.find do |search|
+              search.case_sensitive = true              
+              search.name = 'LoG'
+            end
+            expect(results).to be_empty
+          end
+
+        end
+
+        context 'with case-insensitivity' do
+
+          it 'should return items no matter their case' do
+            results = manager.find do |search|
+              search.case_sensitive = false
+              search.name = 'Gold Ore'
+            end
+            expect(results).to eq [item_gold_ore]
+
+            results = manager.find do |search|
+              search.case_sensitive = false
+              search.name = 'LOG'
+            end
+            expect(results).to eq [item_log]
+
+            results = manager.find do |search|
+              search.case_sensitive = false
+              search.name = 'iron ore'
+            end
+            expect(results).to eq [item_iron_ore]
+          end
+
+        end
+
+        context 'with exact matching' do
+
+          it 'should return exact matches' do
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Gold Ore'
+            end
+            expect(results).to eq [item_gold_ore]
+          end
+
+          it 'should not return non-exact matches' do
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Gold'
+            end
+            expect(results).to be_empty
+
+            results = manager.find do |search|
+              search.exact = true
+              search.name = 'Ore'
+            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 = 'Gold Ore'
+            end
+            expect(results).to eq [item_gold_ore]
+
+            results = manager.find do |search|
+              search.exact = false
+              search.name = 'Ore'
+            end
+            expect(results).to eq [item_gold_ore, item_iron_ore]
+          end
+
+        end
+
+      end
+
+      context "when searching for the item's damage value" do
+
+        context 'with an integer' do
+
+          it 'should return items with matching damage value' do
+            results = manager.find do |search|
+              search.damage_value = 3
+            end
+            expect(results).to eq [item_wood_jungle]
+
+            results = manager.find do |search|
+              search.damage_value = 1
+            end
+            expect(results).to eq [item_wood_spruce]
+          end
+
+        end
+
+        context 'with a range or array' do
+
+          it 'should return items the damage value of which is included in the range or array' do
+            results = manager.find do |search|
+              search.damage_value = 1..3
+            end
+            expect(results).to eq [item_wood_spruce,
+                                   item_wood_birch,
+                                   item_wood_jungle]
+
+            results = manager.find do |search|
+              search.damage_value = [1, 3]
+            end
+            expect(results).to eq [item_wood_spruce,
+                                   item_wood_jungle]
+          end
+
+        end
+
+      end
+
+      context "when searching for the item's ID" do
+        # let(:item_stone { Item.new('Stone', 1) }
+        # 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) }
+
+
+        context 'with an integer' do
+
+          it 'should return items with matching ID' do
+            results = manager.find do |search|
+              search.item_id = 15
+            end
+            expect(results).to eq [item_iron_ore]
+
+            results = manager.find do |search|
+              search.item_id = 1
+            end
+            expect(results).to eq [item_stone]
+          end
+
+        end
+
+        context 'with a range or array' do
+
+          it 'should return items the item ID of which is included in the range or array' do
+            results = manager.find do |search|
+              search.item_id = 14..15
+            end
+            expect(results.sort_by { |item| item.name }).to eq [item_gold_ore,
+                                                                item_iron_ore]
+
+            results = manager.find do |search|
+              search.item_id = [1, 15]
+            end
+            expect(results.sort_by { |item| item.name }).to eq [item_iron_ore,
+                                                               item_stone]
+          end
+
+        end
+
+      end
+
+      context 'with multiple searches' do
+
+        it 'should return items which matched all criteria' do
+          results = manager.find do |search|
+            search.name = 'Wood'
+            search.exact = false
+
+            search.damage_value = 3
+          end
+          expect(results).to eq [item_wood_jungle]
+        end
+
+      end
+
+    end
+
+    
+
+
+    describe '#find_by_name' do
+      before(:each) do
+        manager.clear
+        manager.add(item_log)
+        manager.add(item_gold_ore)
+        manager.add(item_iron_ore)
+      end
+
+      context 'with case sensitivity' do
+        let(:args) { { case_sensitive: true } }
+
+        it 'should return items with matching case' do
+          expect(manager.find_by_name('Gold Ore', args).first).to eq item_gold_ore
+          expect(manager.find_by_name('Log', args).first).to eq item_log
+        end
+
+        it 'should not return items where the case does not match' do
+          expect(manager.find_by_name('gold ore', args)).to be_empty
+          expect(manager.find_by_name('LoG', args)).to be_empty
+        end
+
+      end
+
+      context 'with case-insensitivity' do
+        let(:args) { { case_sensitive: false } }
+
+        it 'should return items no matter their case' do
+          expect(manager.find_by_name('Gold Ore', args).first).to eq item_gold_ore
+          expect(manager.find_by_name('LOG', args).first).to eq item_log
+          expect(manager.find_by_name('iron ore', args).first).to eq item_iron_ore
+        end
+
+      end
+
+      context 'with exact matching' do
+        let(:args) { { exact: true } }
+
+        it 'should return exact matches' do
+          expect(manager.find_by_name('Gold Ore', args).first).to eq item_gold_ore
+        end
+
+        it 'should not return non-exact matches' do
+          expect(manager.find_by_name('Gold', args)).to be_empty
+          expect(manager.find_by_name('Ore', 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('Gold Ore', args).first).to eq item_gold_ore
+
+          expect(manager.find_by_name('Gold', args).first).to eq item_gold_ore
+          expect(manager.find_by_name('Ore', args).sort { |i1, i2| i1.name <=> i2.name } ) .to eq [item_gold_ore, item_iron_ore]
+        end
+
+      end
+
+    end
+
+    describe '#find_by_item_id' do
+      before(:each) do
+        manager.clear
+        manager.add(item_log)
+        manager.add(item_gold_ore)
+        manager.add(item_iron_ore)
+      end
+
+      context 'when supplied an integer' do
+
+        it 'should return all items with the same item id' do
+          expect(manager.find_by_item_id(17).first).to eq item_log
+          expect(manager.find_by_item_id(0)).to be_empty
+        end
+
+      end
+
+      context 'when supplied something which provides #include?' do
+
+        it 'should return all items the id of which was included in the collection' do
+          expect(manager.find_by_item_id(14..15).sort { |i1, i2| i1.name <=> i2.name }).to eq [item_gold_ore, item_iron_ore]
+          expect(manager.find_by_item_id([15, 17]).sort { |i1, i2| i1.name <=> i2.name }).to eq [item_iron_ore, item_log]
+        end
+
+      end
+
+    end
+
+    describe '#find_by_damage_value' do
+      before(:each) do
+        manager.clear
+        manager.add(item_wood_oak)
+        manager.add(item_wood_spruce)
+        manager.add(item_wood_birch)
+        manager.add(item_wood_jungle)
+      end
+
+      context 'when supplied an integer' do
+
+        it 'should return all items with the same damage value' do
+          expect(manager.find_by_damage_value(2).first).to eq item_wood_birch
+        end
+
+      end
+
+      context 'when supplied something which provides #include?' do
+
+        it 'should return all items the damage value of which was included in the collection' do
+          expect(manager.find_by_damage_value(0..2).sort { |i1, i2| i1.damage_value <=> i2.damage_value }).to eq [item_wood_oak, item_wood_spruce, item_wood_birch]
+          expect(manager.find_by_damage_value([1, 3]).sort { |i1, i2| i1.damage_value <=> i2.damage_value }).to eq [item_wood_spruce, item_wood_jungle]
+        end
+
+      end
+
+    end
+
+    describe '#find_by_identifier' do
+      before(:each) do
+        manager.clear
+        manager.add(item_wood_oak)
+        manager.add(item_wood_spruce)
+        manager.add(item_wood_birch)
+        manager.add(item_wood_jungle)
+      end
+
+      it 'should return all items with the specified identifier' do
+        expect(manager.find_by_identifier([17, 1]).first).to eq item_wood_spruce
+      end
+
+    end
+
+  end
+
+end