nrb-beerxml 0.0.2

data/README.md

@@ -0,0 +1,33 @@
+# NRB::Beerxml
+
+[![Code Climate](https://codeclimate.com/github/NewRepublicBrewing/beerxml/badges/gpa.svg)](https://codeclimate.com/github/NewRepublicBrewing/beerxml)
+
+A BeerXML parser
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nrb-beerxml'
+```
+
+And then execute:
+
+    % bundle
+
+Or install it yourself as:
+
+    % gem install nrb-beerxml
+
+## Usage
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/NewRepublicBrewing/nrb-beerxml/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some beers'`)
+4. Push to the branch (`git push origin my-new-beer`)
+5. Create a Pull Request

data/lib/beerxml.rb

@@ -0,0 +1,24 @@
+module NRB
+  module BeerXML
+
+    autoload :Builder,          'beerxml/builder'
+    autoload :Equipment,        'beerxml/equipment'
+    autoload :Fermentable,      'beerxml/fermentable'
+    autoload :Hop,              'beerxml/hop'
+    autoload :Inflector,        'beerxml/inflector'
+    autoload :Mash,             'beerxml/mash'
+    autoload :MashStep,         'beerxml/mash_step'
+    autoload :Misc,             'beerxml/misc'
+    autoload :Parser,           'beerxml/parser'
+    autoload :Recipe,           'beerxml/recipe'
+    autoload :Record,           'beerxml/record'
+    autoload :RecordSet,        'beerxml/record_set'
+    autoload :RecordValidators, 'beerxml/record_validators'
+    autoload :Style,            'beerxml/style'
+    autoload :Water,            'beerxml/water'
+    autoload :Yeast,            'beerxml/yeast'
+
+  end
+end
+
+defined?(BeerXML) || BeerXML = NRB::BeerXML

data/lib/beerxml/builder.rb

@@ -0,0 +1,30 @@
+module NRB; module BeerXML
+  class Builder
+
+    include Inflector
+
+    RECORDS = %w( Equipment Fermentable Hop Mash MashStep Misc Recipe Style Water Yeast )
+
+    def self.records; RECORDS; end
+    def self.record_sets; records.map() { |type| "#{type}s" }; end
+
+
+    def build(type)
+      if record_set? type
+        RecordSet.new record_type: underscore(type.sub(/s$/,'')).to_sym
+      else
+        ::Module.nesting[1].const_get(type).new
+      end
+    rescue NameError
+      nil
+    end
+
+  private
+
+
+    def record_set?(type)
+      self.class.record_sets.include? type
+    end
+
+  end
+end; end

data/lib/beerxml/equipment.rb

@@ -0,0 +1,38 @@
+require 'beerxml/record_validators/boolean_validator'
+require 'beerxml/record_validators/percentage_validator'
+module NRB
+  module BeerXML
+    class Equipment < Record
+
+      attr_accessor :batch_size           # volume required
+      attr_accessor :boil_size            # volume required
+      attr_accessor :boil_time            # time
+      attr_accessor :calc_boil_volume     # boolean
+      attr_accessor :evap_rate            # percent
+      attr_accessor :hop_utilization      # percent
+      attr_accessor :lauter_tun_deadspace # volume
+      attr_accessor :notes                # string
+      attr_accessor :top_up_kettle        # volume
+      attr_accessor :top_up_water         # volume
+      attr_accessor :trub_chiller_loss    # volume
+      attr_accessor :tun_specific_heat    # float
+      attr_accessor :tun_volume           # volume
+      attr_accessor :tun_weight           # weight
+
+      validates :batch_size, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :boil_size, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :boil_time, numericality: { greater_than_or_equal_to: 0 }
+      validates :calc_boil_volume, boolean: true
+      validates :evap_rate, percentage: true
+      validates :hop_utilization, percentage: { give_110: true }
+      validates :lauter_tun_deadspace, numericality: { greater_than_or_equal_to: 0 }
+      validates :top_up_kettle, numericality: { greater_than_or_equal_to: 0 }
+      validates :top_up_water, numericality: { greater_than_or_equal_to: 0 }
+      validates :trub_chiller_loss, numericality: { greater_than_or_equal_to: 0 }
+      validates :tun_specific_heat, numericality: { greater_than_or_equal_to: 0 }
+      validates :tun_volume, numericality: { greater_than_or_equal_to: 0 }
+      validates :tun_weight, numericality: { greater_than_or_equal_to: 0 }
+
+    end
+  end
+end

data/lib/beerxml/fermentable.rb

@@ -0,0 +1,33 @@
+require 'beerxml/record_validators/boolean_validator'  # hack so "validates percentage:" magic works
+require 'beerxml/record_validators/percentage_validator'  # hack so "validates percentage:" magic works
+
+module NRB
+  module BeerXML
+    class Fermentable < Record
+
+      attr_accessor :add_after_boil   # boolean
+      attr_accessor :amount           # weight required
+      attr_accessor :coarse_fine_diff # percent
+      attr_accessor :color            # float required
+      attr_accessor :diastatic_power  # float
+      attr_accessor :ibu_gal_per_lb   # float
+      attr_accessor :max_in_batch     # percent
+      attr_accessor :moisture         # percent
+      attr_accessor :notes            # text
+      attr_accessor :origin           # text
+      attr_accessor :recommend_mash   # boolean
+      attr_accessor :supplier         # text
+      attr_accessor :type             # list required
+      attr_accessor :yield            # percent required
+
+      validates :add_after_boil, boolean: true
+      validates :amount, presence: true
+      validates :color, presence: true
+      validates :type, inclusion: { in: [ "Adjunct", "Dry Extract", "Extract", "Grain", "Sugar" ] }, presence: true
+      validates :yield, presence: true
+
+      validates :diastatic_power, numericality: { greater_than_or_equal_to: 0 }
+
+    end
+  end
+end

data/lib/beerxml/hop.rb

@@ -0,0 +1,38 @@
+require 'beerxml/record_validators/percentage_validator'  # hack so "validates percentage:" magic works
+module NRB
+  module BeerXML
+    class Hop < Record
+
+      attr_accessor :alpha          # percentage required
+      attr_accessor :amount         # weight     required
+      attr_accessor :beta           # percentage
+      attr_accessor :caryophyllene  # percentage
+      attr_accessor :cohumulone     # percentage
+      attr_accessor :form           # list
+      attr_accessor :hsi            # percentage
+      attr_accessor :myrcene        # percentage
+      attr_accessor :notes          # text
+      attr_accessor :origin         # text
+      attr_accessor :substitutes    # text
+      attr_accessor :time           # time       required
+      attr_accessor :type           # list
+      attr_accessor :use            # list       required
+
+      validates :alpha, presence: true, percentage: true
+      validates :amount, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :beta, percentage: true
+      validates :caryophyllene, percentage: true
+      validates :cohumulone, percentage: true
+      validates :form, inclusion: { in: %w(Leaf Pellet Plug) }
+      validates :hsi, percentage: true
+      validates :myrcene, percentage: true
+      validates :time, presence: true,
+                       numericality: { greater_than_or_equal_to: 0 }
+      validates :type, inclusion: { in: %w(Aroma Bittering Both) }
+
+      validates :use, presence: true,
+                      inclusion: { in: [ "Aroma", "Boil", "Dry Hop", "First Wort", "Mash" ] }
+
+    end
+  end
+end

data/lib/beerxml/inflector.rb

@@ -0,0 +1,27 @@
+module NRB; module BeerXML
+  module Inflector
+
+    def camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      else
+        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      end
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+      string.gsub!('/', '::')
+      string
+    end
+
+
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.gsub('::', '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+  end
+end; end

data/lib/beerxml/mash.rb

@@ -0,0 +1,35 @@
+require 'beerxml/record_validators/boolean_validator'
+module NRB
+  module BeerXML
+    class Mash < Record
+
+      attr_accessor :equip_adjust      # boolean
+      attr_accessor :grain_temp        # temperature required
+      attr_accessor :mash_steps        # record set required
+      attr_accessor :notes             # string
+      attr_accessor :ph                # float
+      attr_accessor :sparge_temp       # temperature
+      attr_accessor :tun_specific_heat # float
+      attr_accessor :tun_temp          # temperature
+      attr_accessor :tun_weight        # weight
+
+      validates :grain_temp, numericality: true, presence: true
+      validates :mash_steps, presence: true
+      validates :ph, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 14 }
+      validates :sparge_temp, numericality: true
+      validates :tun_specific_heat, numericality: { greater_than_or_equal_to: 0 }
+      validates :tun_temp, numericality: true
+      validates :tun_weight, numericality: { greater_than_or_equal_to: 0 }
+
+
+      after_initialize :initialize_mash_steps
+
+    private
+
+      def initialize_mash_steps
+        self.mash_steps ||= RecordSet.new(record_type: :mash_step)
+      end
+
+    end
+  end
+end

data/lib/beerxml/mash_step.rb

@@ -0,0 +1,26 @@
+module NRB
+  module BeerXML
+    class MashStep < Record
+
+      attr_accessor :end_temp      # temperature
+      attr_accessor :infuse_amount # volume conditionally required
+      attr_accessor :ramp_time     # time
+      attr_accessor :step_temp     # temperature required
+      attr_accessor :step_time     # time required
+      attr_accessor :type          # list required
+
+      validates :end_temp, numericality: true
+      validates :infuse_amount, presence: { if: Proc.new { |step| step.infuse_amount_required? } }, numericality: true
+      validates :ramp_time, numericality: { greater_than_or_equal_to: 0 }
+      validates :step_temp, numericality: true, presence: true
+      validates :step_time, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :type, inclusion: { in: %w(Decoction Infusion Temperature) },
+                       presence: true
+
+      def infuse_amount_required?
+        type == "Infusion"
+      end
+
+    end
+  end
+end

data/lib/beerxml/misc.rb

@@ -0,0 +1,24 @@
+require 'beerxml/record_validators/boolean_validator'  # hack so "validates boolean:" magic works
+module NRB
+  module BeerXML
+    class Misc < Record
+
+      attr_accessor :amount           # float required
+      attr_accessor :amount_is_weight # boolean
+      attr_accessor :notes            # string
+      attr_accessor :time             # time required
+      attr_accessor :type             # list required
+      attr_accessor :use              # list required
+      attr_accessor :use_for          # string
+
+      validates :amount, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :amount_is_weight, boolean: true
+      validates :time, numericality: { greater_than_or_equal_to: 0 },
+                       presence: true
+      validates :type, inclusion: { in: ["Fining", "Flavor", "Herb", "Other", "Spice", "Water Agent"] }, presence: true
+      validates :use, inclusion: { in: %w(Boil Bottling Mash Primary Secondary) }, presence: true
+
+
+    end
+  end
+end

data/lib/beerxml/parser.rb

@@ -0,0 +1,114 @@
+require 'nokogiri'
+
+module NRB; module BeerXML
+  class Parser
+
+    include Inflector
+
+    attr_reader :builder, :reader
+
+    def initialize(builder: Builder.new, reader: Nokogiri::XML)
+      @builder = builder
+      @reader = reader
+    end
+
+
+    def parse(entry)
+      doc = case entry
+            when IO
+              parse_xml entry
+            when String
+              parse_path(file: entry)
+            else
+              raise ArgumentError "Don't know how to parse a #{entry.class}"
+            end
+      parse_node doc.root
+    end
+
+  private
+
+    def assign_attribute(object, node)
+      return unless object
+      return unless attribute_node?(node)
+      meth = guess_attribute_assignment_method node
+      if object.respond_to? meth
+        object.send meth, attribute_value(node)
+      end
+    end
+
+
+    def assign_child_to_parent(parent, child)
+      meth = guess_child_assignment_method parent, child
+      parent.respond_to?(meth) && parent.send(meth, child)
+    end
+
+
+    def attribute_node?(node)
+      node.children.size == 1 && node.children.first.text?
+    end
+
+
+    def attribute_value(node)
+      node.children.first.text
+    end
+
+
+    def guess_attribute_assignment_method(node)
+      node.name.downcase + '='
+    end
+
+
+    def guess_child_assignment_method(parent, child)
+      # Smelly, needs refactor
+      return :<< if parent.is_a? RecordSet
+      name = if child.is_a? RecordSet
+               "#{child.record_type.to_s}s"
+             else
+               child.class.name.split(/::/).last
+             end
+      underscore(name) + '='
+    end
+
+
+    def guess_class_name(string)
+      camelize string.downcase
+    end
+
+
+    def parse_node(node,parent=nil)
+      return unless node
+
+      if attribute_node?(node)
+        assign_attribute parent, node
+
+      else
+
+        obj = builder.build guess_class_name(node.name)
+
+        node.children.each do |child|
+          parse_node child, obj
+        end
+
+        assign_child_to_parent parent, obj
+
+        obj
+      end
+    end
+
+
+    def parse_path(file: nil)
+      f = File.open(file)
+      doc = parse_xml(f)
+      f.close
+      doc
+    end
+
+
+    def parse_xml(stream)
+      reader.parse(stream) do |config|
+        config.noblanks
+      end
+    end
+
+  end
+end; end

data/lib/beerxml/recipe.rb

@@ -0,0 +1,109 @@
+require 'beerxml/record_validators/boolean_validator'  # hack so "validates boolean:" magic works
+require 'beerxml/record_validators/percentage_validator'  # hack so "validates percentag:" magic works
+module NRB
+  module BeerXML
+    class Recipe < Record
+
+      after_initialize :set_up_record_sets
+
+      attr_accessor :age                 # time
+      attr_accessor :age_temp            # temperature
+      attr_accessor :asst_brewer         # string
+      attr_accessor :batch_size          # volume required
+      attr_accessor :boil_size           # volume required
+      attr_accessor :boil_time           # time required
+      attr_accessor :brewer              # string required
+      attr_accessor :carbonation         # float
+      attr_accessor :carbonation_temp    # temperature
+      attr_accessor :date                # string
+      attr_accessor :efficiency          # percentage conditionally required
+      attr_reader   :equipment           # equipment record
+      attr_accessor :fermentables        # fermentables record set required
+      attr_accessor :fermentation_stages # integer
+      attr_accessor :fg                  # specific gravity
+      attr_accessor :forced_carbonation  # boolean
+      attr_accessor :hops                # hops record set required
+      attr_accessor :keg_priming_factor  # float
+      attr_accessor :mash                # mash profile record required
+      attr_accessor :miscs               # miscs record set required
+      attr_accessor :notes               # string
+      attr_accessor :og                  # specific gravity
+      attr_accessor :primary_age         # time
+      attr_accessor :primary_temp        # temperature
+      attr_accessor :priming_sugar_equiv # float
+      attr_accessor :priming_sugar_name  # string
+      attr_accessor :secondary_age       # time
+      attr_accessor :secondary_temp      # temperature
+      attr_reader   :style               # style record required
+      attr_accessor :taste_notes         # string
+      attr_accessor :taste_rating        # float
+      attr_accessor :tertiary_age        # time
+      attr_accessor :tertiary_temp       # temperature
+      attr_accessor :type                # list required
+      attr_accessor :waters              # waters record set required
+      attr_accessor :yeasts              # yeasts record set required
+
+      validates :age, numericality: { greater_than_or_equal_to: 0 }
+      validates :age_temp, numericality: true
+      validates :batch_size, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :boil_size, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :boil_time, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :brewer, presence: true
+      validates :carbonation, numericality: { greater_than_or_equal_to: 0 }
+      validates :carbonation_temp, numericality: true
+      validates :equipment, presence: true
+      validates :efficiency, percentage: true, presence: { if: Proc.new { |recipe| recipe.efficiency_required? } }
+      validates :fermentables, presence: true
+      validates :fermentation_stages, numericality: { only_integer: true }
+      validates :fg, numericality: true
+      validates :forced_carbonation, boolean: true
+      validates :hops, presence: true
+      validates :keg_priming_factor, numericality: true
+      validates :mash, presence: true
+      validates :miscs, presence: true
+      validates :og, numericality: true
+      validates :primary_age, numericality: { greater_than_or_equal_to: 0 }
+      validates :primary_temp, numericality: true
+      validates :priming_sugar_equiv, numericality: true
+      validates :secondary_age, numericality: { greater_than_or_equal_to: 0 }
+      validates :secondary_temp, numericality: true
+      validates :style, presence: true
+      validates :taste_rating, numericality: true
+      validates :tertiary_age, numericality: { greater_than_or_equal_to: 0 }
+      validates :tertiary_temp, numericality: true
+      validates :type, inclusion: { in: [ "All Grain", "Extract", "Partial Mash" ] }, presence: true
+      validates :waters, presence: true
+      validates :yeasts, presence: true
+
+
+      def equipment=(equipment)
+        restricted_assign :equipment, equipment
+      end
+
+
+      def efficiency_required?
+        ["ALl Grain", "Partial Mash"].include?(type)
+      end
+
+
+      def set_up_record_sets
+        %i(fermentable hop misc water yeast).each do |record_type|
+          send "#{record_type}s=", RecordSet.new(record_type: record_type)
+        end
+      end
+
+
+      def style=(style)
+        restricted_assign :style, style
+      end
+
+    private
+
+      def restricted_assign(type, value)
+        raise "Can't assign a non-#{type} to #{type} (got a #{value.record_type}" unless value.nil? || value.send("#{type}?")
+        instance_variable_set "@#{type}", value
+      end
+
+    end
+  end
+end