crafting_table 0.3.0

data/data/test/recipes/vanilla.yml

@@ -0,0 +1,25 @@
+---
+- name: Stone
+  input:
+    "4:0": 1
+  output:
+    "1:0": 1
+
+- name: Oak Wood Planks
+  input:
+    "17:0": 1
+  output:
+    "5:0": 4
+
+- name: Sticks
+  input:
+    "5:0": 2
+  output:
+    "280:0": 4
+
+- name: Torch
+  input:
+    "280:0": 1
+    "263:0": 1
+  output:
+    "50:0": 4

data/examples/interactive_table.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+#coding: utf-8
+
+require 'crafting_table'
+
+class InteractiveTable
+  attr_reader :item_manager, :recipe_manager
+  
+  def initialize(opts)
+    @item_manager = CraftingTable::ItemManager.new
+    @recipe_manager = CraftingTable::RecipeManager.new(item_manager)
+
+    opts.fetch(:items, []).each do |file|
+      @item_manager.add_from_file(file)
+    end
+
+    opts.fetch(:recipes, []).each do |file|
+      @recipe_manager.add_from_file(file)
+    end
+  end
+
+  def run
+    loop do
+      input = gets.chomp
+
+      exit(0) if ['exit', 'close'].include? input
+      
+      handle(input)
+    end
+  end
+
+  def item_search(cmd)
+    cmd.match(/item (.*)/) do |match|
+      name = match[1].strip
+      results = item_manager.find_by_name(name, exact: false, case_sensitive: false)
+
+      if results.empty?
+        puts 'No results found'
+      else
+        puts results.map { |item| "- #{ item.name } (#{ item.item_id }:#{ item.damage_value })" }.join("\n")
+      end
+    end
+  end
+  
+  def recipe_search(cmd)
+    cmd.match(/recipe (.*)/) do |match|
+      name = match[1].strip
+      results = recipe_manager.find_by_name(name, exact: false, case_sensitive: false).each_with_index.to_a
+      if results.empty?
+        puts 'No results found'
+        return
+      else
+        puts results.map { |recipe, index| "[#{ index }] #{ recipe.name }" }.join("\n")
+        print 'Select recipe: '
+        index = gets.chomp
+        return if index == 'exit'
+        recipe = results[index.to_i].first
+        print 'Amount: '
+        amount = gets.chomp.to_i
+        components = recipe_manager.resolve_recipe(recipe, amount)
+        puts "To craft #{ amount } of #{ recipe.name } you need:"
+        puts components.map { |item, amount| "- #{ amount } of #{ item.name }" }.join("\n")
+      end
+    end
+    
+  end
+  
+  def usage
+    puts 'Commands:'
+    puts '`item <item_name>` - Search for items.'
+    puts '`recipe <recipe_name>` - Search for, and resolve. recipes.'
+  end
+  
+  def handle(cmd)
+    if cmd.start_with?('item')
+      item_search(cmd)
+    elsif cmd.start_with?('recipe')
+      recipe_search(cmd)
+    else
+      usage
+    end
+  end
+
+end
+
+def main
+  
+  table = InteractiveTable.new(:items => ['../data/items/vanilla.yml',
+                                          '../data/items/thermal_expansion.yml'],
+                               :recipes => ['../data/recipes/vanilla.yml',
+                                            '../data/recipes/thermal_expansion.yml'])
+
+  table.run
+  
+end
+
+main
+

data/features/item_differentiation.feature

@@ -0,0 +1,18 @@
+Feature: Differentiating between several versions of an item
+  In order to distinguish between several versions of an item, like several types of wood, or damaged and undamaged tools
+  As a developer
+  I want to be able to specify a meta value of an item.
+
+  Scenario: Damage value defaults to 0
+    Given I created a new item without damage value
+    When I query its damage value
+    Then it should be 0
+
+  Scenario: Same base items with different damage values are not equal
+    Given I have these items:
+      | name | item_id | damage_value |
+      | Axe  | 123     | 0            |
+      | Axe  | 123     | 1            |
+
+    When I query them for equality
+    Then none of them should be equal

data/features/loading_items.feature

@@ -0,0 +1,10 @@
+Feature: Loading items from a data source (file, database, web API, ...)
+  In order to be able to store items permanently
+  As a developer
+  I want to load them from a data source
+
+  Scenario: Loading an item from a YAML file
+    Given I have a YAML file containing multiple items
+    When I tell the item manager to load the file
+    Then it should contain "371" items
+    And it should contain the following items: "Stone, Grass Block, Sand, Gold Ore, Note Block, Piston"

data/features/resolving_recipes.feature

@@ -0,0 +1,26 @@
+Feature: Resolving recipes into their base components
+  In order to help me with crafting
+  As a user
+  I want to be able to resolve recipes into their base components.
+
+  Background:
+    Given I have the vanilla items loaded
+    And I have the vanilla recipes loaded
+
+  Scenario Outline: Resolving the torch recipe
+    Given I want <amount_torch> of torches
+    When I resolve the recipe
+    Then it should require <amount_wood> of wood
+    And it should require <amount_coal> of coal
+
+  # 1 Wood => 4 Planks => 8 Sticks => 32 Torches
+  # 1 Coal => 4 Torches
+  Examples: Resolving the torch recipe
+    | amount_torch | amount_wood | amount_coal |
+    |            1 |           1 |           1 |
+    |            4 |           1 |           1 |
+    |           16 |           1 |           4 |
+    |           17 |           1 |           5 |
+    |           32 |           1 |           8 |
+    |           33 |           2 |           9 |
+    |          100 |           4 |          25 |

data/features/searching_items.feature

@@ -0,0 +1,83 @@
+Feature: Searching items by various criteria
+  In order to easily retrieve items
+  As a developer
+  I want to be able to search for items based on various criteria.
+
+  Background:
+    Given I have the following items loaded:
+      | Name        | Item ID | Damage       |
+      | Stone       | 1       |              |
+      | Dirt        | 3       |              |
+      | Sand        | 12      |              |
+      | Gold Ore    | 14      |              |
+      | Iron Ore    | 15      |              |
+      | Coal Ore    | 16      |              |
+      | Oak Wood    | 17      | 0            |
+      | Spruce Wood | 17      | 1            |
+      | Birch Wood  | 17      | 2            |
+      | Jungle Wood | 17      | 3            |
+      | Sandstone   | 24      |              |
+
+  Scenario Outline: Searching for item's name
+    Given I use exact matching: <exact_match>
+    And use case sensitivity: <case_sensitive>
+    When I search for its name: <name>
+    Then it should return the following items: <item_names>
+
+    Examples: Case-sensitive, exact matching
+      | name     | exact_match | case_sensitive | item_names                                  |
+      | Stone    | yes         | yes            | Stone                                       |
+      | Gold Ore | yes         | yes            | Gold Ore                                    |
+      | Ore      | yes         | yes            |                                             |
+      | stone    | yes         | yes            |                                             |
+
+    Examples: Case-insensitive, exact matching
+      | name     | exact_match | case_sensitive | item_names                                  |
+      | Stone    | yes         | no             | Stone                                       |
+      | Gold Ore | yes         | no             | Gold Ore                                    |
+      | Ore      | yes         | no             |                                             |
+      | stone    | yes         | no             | Stone                                       |
+
+    Examples: Case-sensitive, non-exact matching
+      | name     | exact_match | case_sensitive | item_names                                  |
+      | Stone    | no          | yes            | Stone                                       |
+      | Gold Ore | no          | yes            | Gold Ore                                    |
+      | Ore      | no          | yes            | Gold Ore, Iron Ore, Coal Ore                |
+      | iron ore | no          | yes            |                                             |
+
+    Examples: Case-insensitive, non-exact matching
+      | name     | exact_match | case_sensitive | item_names                                  |
+      | Stone    | no          | no             | Stone, Sandstone                            |
+      | Gold Ore | no          | no             | Gold Ore                                    |
+      | Ore      | no          | no             | Gold Ore, Iron Ore, Coal Ore                |
+      | stone    | no          | no             | Stone, Sandstone                            |
+
+
+  Scenario Outline: Searching for item's ID
+    When I search for item ID <id>
+    Then it should return the following items: <item_names>
+
+    Examples: Using an integer
+      | id | item_names                                     |
+      | 1  | Stone                                          |
+      | 17 | Oak Wood, Spruce Wood, Birch Wood, Jungle Wood |
+
+    Examples: Using a range
+      | id    | item_names           |
+      | 3..14 | Dirt, Sand, Gold Ore |
+
+  Scenario Outline: Searching for item's damage value
+    When I search for damage value <damage_value>
+    Then it should return the following items: <item_names>
+
+    Examples: Using an integer
+      | damage_value | item_names              |
+      |            2 | Birch Wood              |
+      |            3 | Jungle Wood             |
+      |         2..3 | Birch Wood, Jungle Wood |
+
+  Scenario: Searching for multiple conditions
+    When I search for the name 'Wood', using fuzzy matching, and for damage value 3
+    Then it should return the following items: Jungle Wood
+
+

data/features/searching_recipes.feature

@@ -0,0 +1,42 @@
+Feature: Searching recipes by various criteria
+  In order to easily look up recipes
+  As a developer
+  I want to be able to search for recipes based on various criteria.
+
+  Background:
+    Given I have the vanilla items loaded
+    And I have the vanilla recipes loaded
+
+  Scenario Outline: Searching for recipe's name
+    Given I use exact matching: <exact_match>
+    And use case sensitivity: <case_sensitive>
+    When I search for the recipe's name: <name>
+    Then the result should contain the following recipe: <recipe_name>
+
+  Examples: Case-sensitive, exact matching
+    | name  | exact_match | case_sensitive | recipe_name |
+    | Stone | yes         | yes            | Stone       |
+    | Torch | yes         | yes            | Torch       |
+    | torch | yes         | yes            |             |
+    | Tor   | yes         | yes            |             |
+
+  Examples: Case-insensitive, exact matching
+    | name  | exact_match | case_sensitive | recipe_name |
+    | Stone | yes         | no             | Stone       |
+    | Torch | yes         | no             | Torch       |
+    | torch | yes         | no             | Torch       |
+    | Tor   | yes         | no             |             |
+
+  Examples: Case-sensitive, non-exact matching
+    | name  | exact_match | case_sensitive | recipe_name |
+    | Stone | no          | yes            | Stone       |
+    | Torch | no          | yes            | Torch       |
+    | torch | no          | yes            |             |
+    | Tor   | no          | yes            | Torch       |
+
+  Examples: Case-insensitive, non-exact matching
+    | name  | exact_match | case_sensitive | recipe_name |
+    | Stone | no          | no             | Stone       |
+    | Torch | no          | no             | Torch       |
+    | torch | no          | no             | Torch       |
+    | Tor   | no          | no             | Torch       |

data/features/step_definitions/item_manager_steps.rb

@@ -0,0 +1,88 @@
+require 'pry'
+
+Given(/^I have the following items loaded:$/) do |table|
+  @manager = CraftingTable::ItemManager.new
+
+  table.raw[1..-1].each do |name, id, damage_value|
+    if damage_value.empty?
+      damage_value = :any
+    else
+      damage_value = damage_value.to_i
+    end
+
+    @manager.add(CraftingTable::Item.new(name, id.to_i, damage_value))
+  end
+end
+
+
+Given(/^I have the vanilla items loaded$/) do
+  @item_manager = CraftingTable::ItemManager.new
+  @item_manager.add_from_file ITEM_FILE
+end
+
+
+Given(/^(?:I )?use exact matching: (.*)$/) do |exact_match|
+  @exact_match = string_to_boolean(exact_match)
+end
+
+Given(/^(?:I )?use case sensitivity: (.*)$/) do |case_sensitive|
+  @case_sensitive = string_to_boolean(case_sensitive)
+end
+
+When(/^I search for its name: (.*)$/) do |name|
+  @results = @manager.find do |search|
+    search.name = name
+    search.case_sensitive = @case_sensitive
+    search.exact = @exact_match
+  end
+end
+
+When(/^I search for item ID (.*)$/) do |item_id|
+  @results = @manager.find do |search|
+    search.item_id = string_to_range_or_integer(item_id)
+  end
+end
+
+When(/^I search for damage value (.*)$/) do |damage_value|
+  @results = @manager.find do |search|
+    search.damage_value = string_to_range_or_integer(damage_value)
+  end
+end
+
+When(/^I search for the name '([^']*)', using fuzzy matching, and for damage value (\d+)$/) do |name, damage|
+  @results = @manager.find do |search|
+    search.name = name
+    search.damage_value = string_to_range_or_integer(damage)
+    search.exact = false
+  end
+end
+
+Then(/^it should return the following items: (.*)$/) do |item_names|
+  expect(@results.map(&:name).sort).to eq (item_names.split(', ').sort)
+end
+
+
+Then(/^it should return "([^"]*)"$/) do |item_names|
+  expect(@results.map(&:name).sort).to eq (item_names.split(', ').sort)
+end
+
+Given(/^I have a YAML file containing multiple items$/) do
+  expect(File.exist? ITEM_FILE).to be_true
+end
+
+When(/^I tell the item manager to load the file$/) do
+  @manager = CraftingTable::ItemManager.new
+  @manager.add_from_file(ITEM_FILE)
+end
+
+Then(/^it should contain "([^"]*)" items$/) do |arg|
+  expect(@manager).to have(arg.to_i).items
+end
+
+When(/^it should contain the following items: "([^"]*)"$/) do |arg|
+  item_names = @manager.items.map(&:name)
+
+  arg.split(', ').each do |item_name|
+    expect(item_names).to include item_name
+  end
+end

data/features/step_definitions/item_steps.rb

@@ -0,0 +1,23 @@
+Given(/^I created a new item without damage value$/) do
+  @item = CraftingTable::Item.new('Stone', 1)
+end
+
+When(/^I query its damage value$/) do
+  @result = @item.damage_value
+end
+
+Then(/^it should be 0$/) do
+  expect(@result).to eq 0
+end
+
+Given(/^I have these items:$/) do |table|
+  @items = table.raw[1..-1].map { |name, id, damage| CraftingTable::Item.new(name, id, damage) }
+end
+
+When(/^I query them for equality$/) do
+  @results = @items.combination(2).map { |item_1, item_2| item_1 == item_2 }
+end
+
+Then(/^none of them should be equal$/) do
+  expect(@results.any?).to be_false
+end

data/features/step_definitions/recipe_manager_steps.rb

@@ -0,0 +1,42 @@
+When(/^I have the vanilla recipes loaded$/) do
+  @recipe_manager = CraftingTable::RecipeManager.new(@item_manager)
+  @recipe_manager.add_from_file RECIPE_FILE
+end
+
+When(/^I search for the recipe's name: (.*)$/) do |name|
+  @results = @recipe_manager.find do |search|
+    search.name = name
+    search.case_sensitive = @case_sensitive
+    search.exact = @exact_match
+  end
+end
+
+Then(/^the result should contain the following recipe: (.*)$/) do |recipe_name|
+  if recipe_name.empty?
+    expect(@results).to be_empty
+  else
+    expect(@results.map(&:name)).to include recipe_name
+  end
+end
+
+
+Given(/^I want (\d+) of torches$/) do |amount_torch|
+  @amount = amount_torch.to_i
+end
+
+When(/^I resolve the recipe$/) do
+  recipe_torch =  @recipe_manager.find_by_name('Torch').first
+  @result = @recipe_manager.resolve_recipe(recipe_torch, @amount)
+end
+
+Then(/^it should require (\d+) of wood$/) do |amount_wood|
+  item_wood = @item_manager.find_by_name('Wood').select { |item| item.damage_value == 0 }.first
+
+  expect(@result[item_wood]).to eq amount_wood.to_i
+end
+
+Then(/^it should require (\d+) of coal$/) do |amount_coal|
+  item_coal = @item_manager.find_by_name('Coal').first
+  
+  expect(@result[item_coal]).to eq amount_coal.to_i
+end