brewscribe 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in brewscribe.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/brewscribe/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^spec/support/(.+)\.rb$})                 { "spec/" }
+  watch('spec/spec_helper.rb')                       { "spec/" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Andrew Nordman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Brewscribe
+
+Brewscribe is a Beersmith2 (.bsmx) file parser.
+
+## Installation
+
+`gem install brewscribe` or `gem brewscribe` in your Gemfile.
+
+## Usage
+
+To start, you can import your .bsmx file with `Brewscribe.import(file)` where file
+is any object that responds to `#read`.  This will return an array of Brewscribe::Recipe
+objects.  You now have a parsed version of the recipe files.
+
+By default, Brewscribe will set a text property for each attribute of the recipe, and
+if it has a parser object it will attempt to further parse the data.
+
+An example of this is found in `Brewscribe::IngredientList`:
+
+```
+recipe = Brewscribe.import File.read './spec/support/recipe.bsmx'
+recipe.ingredients.class # => Brewscribe::IngredientList
+recipe.ingredients.grains.class # => Array
+recipe.ingredients.grains.first.class # => Brewscribe::Grain
+recipe.ingredients.grains.first.name # => "Pale Malt (2 Row) US"
+```
+
+## Contributing
+
+I <3 Contributions.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Author
+
+Created by [Andrew Nordman](https://github.com/cadwallion/).

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+  # spec.ruby_opts = ['-w']
+end
+
+task :default => :spec

data/brewscribe.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/brewscribe/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Andrew Nordman"]
+  gem.email         = ["cadwallion@gmail.com"]
+  gem.summary       = %q{A Beersmith (.bsmx) file parser}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "brewscribe"
+  gem.require_paths = ["lib"]
+  gem.version       = Brewscribe::VERSION
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_dependency 'nokogiri'
+end

data/lib/brewscribe.rb

@@ -0,0 +1,11 @@
+require "brewscribe/version"
+require 'brewscribe/recipe'
+require 'brewscribe/ingredient_list'
+require 'brewscribe/conversion'
+
+module Brewscribe
+  def self.import file
+    data = file.read 
+    Recipe.new(data)  
+  end
+end

data/lib/brewscribe/conversion.rb

@@ -0,0 +1,22 @@
+module Brewscribe
+  module Conversion
+    BOOLEAN_CONV = ->(k) { k == '1' }
+    FLOAT_CONV = ->(k) { k.to_f }
+    PERCENT_CONV = ->(k) { k.to_f * 0.001 }
+    INT_CONV = ->(k) { k.to_i }
+    DATE_CONV = ->(k) { Date.parse k }
+
+
+    def data_to_properties data
+      data.each_key do |key|
+        if self.class.const_get(:KEY_CONVERSION).has_key? key
+          value = self.class.const_get(:KEY_CONVERSION)[key].call(data[key])
+        else
+          value = data[key]
+        end
+
+        self.instance_variable_set "@#{key}".to_sym, value
+      end
+    end
+  end
+end

data/lib/brewscribe/grain.rb

@@ -0,0 +1,40 @@
+require 'brewscribe/conversion'
+
+module Brewscribe
+  class Grain
+    attr_reader :name, :origin, :amount, :color, :yield, :percent, :price,
+      :recommend_mash, :in_recipe, :type, :add_after_boil, :notes, :boil_time,
+      :max_in_batch, :ibu_gal_per_lb, :protein, :diastatic_power, :late_extract,
+      :convert_grain, :moisture, :coarse_fine_diff, :convert_grain, :supplier
+
+    include Brewscribe::Conversion
+
+    TYPES = ['Grain', 'Extract Sugar', 'Adjunct', 'Dry Extract']
+
+    KEY_CONVERSION = {
+      amount: FLOAT_CONV,
+      color: FLOAT_CONV,
+      yield: PERCENT_CONV,
+      price: FLOAT_CONV,
+      boil_time: ->(k) { k.to_i },
+      percent: PERCENT_CONV,
+      max_in_batch: PERCENT_CONV,
+      add_after_boil: BOOLEAN_CONV,
+      recommend_mash: BOOLEAN_CONV,
+      in_recipe: BOOLEAN_CONV,
+      type: ->(k) { TYPES[k.to_i] },
+      ibu_gal_per_lb: FLOAT_CONV,
+      protein: PERCENT_CONV,
+      diastatic_power: PERCENT_CONV,
+      late_extract: FLOAT_CONV,
+      moisture: PERCENT_CONV,
+      coarse_fine_diff: PERCENT_CONV
+    }
+
+    def initialize grain_data
+      @original_data = grain_data 
+
+      data_to_properties grain_data
+    end
+  end
+end

data/lib/brewscribe/hops.rb

@@ -0,0 +1,34 @@
+module Brewscribe
+  class Hops
+    attr_reader :name, :origin, :alpha, :beta, :notes, :boil_time, :percent,
+      :amount, :hsi, :dry_hop_time, :ibu_contrib, :use, :in_recipe, :price,
+      :type, :form
+
+    include Brewscribe::Conversion
+
+    KEY_CONVERSION = {
+      alpha: FLOAT_CONV,
+      beta: FLOAT_CONV,
+      boil_time: ->(k) { k.to_i },
+      percent: PERCENT_CONV,
+      amount: FLOAT_CONV,
+      hsi: FLOAT_CONV,
+      dry_hop_time: ->(k) { k.to_i },
+      ibu_contrib: PERCENT_CONV,
+      use: ->(k) { USES[k.to_i] },
+      type: ->(k) { TYPES[k.to_i] },
+      form: ->(k) { FORMS[k.to_i] },
+      in_recipe: BOOLEAN_CONV,
+      price: FLOAT_CONV
+    }
+
+    TYPES = ['Bittering', 'Aroma', 'Both']
+    FORMS = ['Pellet', 'Plug', 'Leaf']
+    USES = ['Boil', 'Dry Hop', 'Mash', 'First Wort', 'Aroma']
+
+    def initialize data
+      @original_data = data   
+      data_to_properties data
+    end
+  end
+end

data/lib/brewscribe/ingredient_list.rb

@@ -0,0 +1,58 @@
+require 'brewscribe/grain'
+require 'brewscribe/hops'
+require 'brewscribe/yeast'
+
+module Brewscribe
+  class IngredientList
+    attr_reader :grains, :hops, :yeasts
+    def self.from_data data
+      list = new
+
+      case data[:grain]
+      when Array
+        data[:grain].each do |grain|
+          list.add_grain grain
+        end
+      when Hash
+        list.add_graind data[:grain]
+      end
+
+      case data[:hops]
+      when Array
+        data[:hops].each do |hops|
+          list.add_hops hops
+        end
+      when Hash
+        list.add_hops data[:hops]
+      end
+
+      case data[:yeast]
+      when Array
+        data[:yeast].each do |yeast|
+          list.add_yeast yeast
+        end
+      when Hash
+        list.add_yeast data[:yeast]
+      end
+      list
+    end
+
+    def initialize
+      @grains = []
+      @hops   = []
+      @yeasts  = []
+    end
+
+    def add_grain grain_data
+      @grains << Grain.new(grain_data)
+    end
+
+    def add_hops hop_data
+      @hops << Hops.new(hop_data)
+    end
+
+    def add_yeast yeast_data
+      @yeasts << Yeast.new(yeast_data) 
+    end
+  end
+end

data/lib/brewscribe/recipe.rb

@@ -0,0 +1,76 @@
+require 'nokogiri'
+
+module Brewscribe
+  class Recipe
+    attr_reader :raw_data, :hash
+
+    def initialize raw_data
+      @raw_data = raw_data
+
+      parse_raw_data
+    end
+
+    def parse_raw_data
+      @xml = Nokogiri::XML(@raw_data).xpath('/Selections/Data/Recipe') 
+      @hash = xml_node_to_hash(@xml.first)
+
+      create_recipe_accessors
+      parse_ingredients
+    end
+
+    def create_recipe_accessors
+       @hash.keys.each do |key|
+        self.class.module_eval do
+          attr_accessor key
+        end
+
+        self.send "#{key}=", @hash[key]
+      end     
+    end
+
+    def clean_key key
+      extracted = key.to_s.match(/(F_(\w{1,2}_)?)?(_MOD_|.+)/)[3]
+      if extracted == '_MOD_' 
+        return 'last_modified'
+      else
+        extracted.downcase
+      end
+    end
+
+    def parse_ingredients
+      self.ingredients = IngredientList.from_data(self.ingredients[:data])
+    end
+
+    def xml_node_to_hash node
+      if node.element?
+        if node.children.size > 0
+          result_hash = {} 
+
+          node.children.each do |child|
+            result = xml_node_to_hash child
+            property = clean_key child.name
+            key = property.to_sym
+
+            if child.name == 'text'
+              return result if !child.next && !child.previous
+            elsif result_hash[key]
+              if result_hash[key].is_a? Array
+                result_hash[key] << result
+              else
+                result_hash[key] = [result_hash[key]] << result
+              end
+            else
+              result_hash[key] = result
+            end
+          end
+
+          return result_hash
+        else
+          return nil
+        end
+      else
+        return node.content.to_s
+      end
+    end
+  end
+end

data/lib/brewscribe/version.rb

@@ -0,0 +1,3 @@
+module Brewscribe
+  VERSION = "0.0.1"
+end

data/lib/brewscribe/yeast.rb

@@ -0,0 +1,44 @@
+module Brewscribe
+  class Yeast
+    attr_reader :name, :lab, :product_id, :flocculation, :type, :form, 
+      :starter_size, :amount, :price, :in_recipe, :brew_date, :pkg_date,
+      :cells, :min_attenuation, :max_attenuation, :min_temp, :max_temp,
+      :use_starter, :add_to_secondary, :times_cultured, :max_reuse,
+      :culture_date, :best_for, :notes, :last_modified
+
+    include Brewscribe::Conversion
+
+    FLOCCULATION_TYPES = ['Low', 'Medium', 'High', 'Very High']
+    TYPES = ['Ale', 'Lager', 'Wine', 'Champagne', 'Wheat']
+    FORMS = ['Liquid', 'Dry', 'Slant', 'Culture']
+    KEY_CONVERSION = {
+      product_id: INT_CONV,
+      flocculation: ->(k) { FLOCCULATION_TYPES[k.to_i] },
+      type: ->(k) { TYPES[k.to_i] },
+      last_modified: DATE_CONV,
+      form: ->(k) { FORMS[k.to_i] },
+      starter_size: FLOAT_CONV,
+      amount: FLOAT_CONV,
+      price: FLOAT_CONV,
+      in_recipe: BOOLEAN_CONV,
+      brew_date: DATE_CONV,
+      pkg_date: DATE_CONV,
+      cells: FLOAT_CONV,
+      min_attenuation: PERCENT_CONV,
+      max_attenuation: PERCENT_CONV,
+      min_temp: FLOAT_CONV,
+      max_temp: FLOAT_CONV,
+      use_starter: BOOLEAN_CONV,
+      add_to_secondary: BOOLEAN_CONV,
+      times_cultured: INT_CONV,
+      max_reuse: INT_CONV,
+      culture_date: DATE_CONV
+    }
+
+    def initialize data
+      @original_data = data
+
+      data_to_properties data
+    end
+  end
+end

data/spec/brewscribe_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Brewscribe do
+  let(:recipe_file) { File.open(File.dirname(__FILE__) + '/support/recipe.bsmx', 'r') }
+
+  describe '#import' do
+    before do
+      Brewscribe::Recipe.any_instance.stub(:parse_raw_data)
+    end
+
+    it 'should call #read on the passed IO object' do
+      file = double()
+      file.should_receive(:read)
+      Brewscribe.import(file)
+    end
+
+    it 'should return a Recipe object' do
+      file = double()
+      file.stub(:read)
+      recipe = Brewscribe.import(file)
+      recipe.should be_a(Brewscribe::Recipe)
+    end
+  end
+end