beerxml 0.0.1 → 0.0.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Brian Palmer
+
+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/Rakefile

@@ -10,10 +10,11 @@ end
 RSpec::Core::RakeTask.new(:rcov) do |t|
   t.rspec_opts = "-c -f d"
   t.rcov = true
+  t.rcov_opts = ["--exclude", "spec,gems/,rubygems/"]
 end
 
 require 'yard'
 YARD::Rake::YardocTask.new(:doc) do |t|
   version = Beerxml::VERSION
-  t.options = ["--title", "beerxml #{version}"]
+  t.options = ["--title", "beerxml #{version}", "--files", "LICENSE"]
 end

data/beerxml.gemspec

@@ -22,8 +22,9 @@ Gem::Specification.new do |s|
   s.add_dependency "dm-validations", "~> 1.0"
   s.add_dependency "dm-types", "~> 1.0"
 
-  s.add_development_dependency "rspec", "~> 2.0"
-  s.add_development_dependency "ruby-debug"
+  s.add_development_dependency "rspec", "~> 2.5"
+  s.add_development_dependency "autotest-standalone"
+  s.add_development_dependency "autotest-growl"
   s.add_development_dependency "rcov"
   s.add_development_dependency "yard"
 end

data/lib/beerxml.rb

@@ -6,6 +6,15 @@ require 'nokogiri'
 module Beerxml
   # This'll have to go eventually, but for now it's nice
   DataMapper.setup(:default, "abstract::")
+
+  def self.parse(string_or_io)
+    Beerxml::Model.from_xml(Nokogiri::XML(string_or_io).root)
+  end
+
+  def self.round(float, to = 0)
+    exp = 10 ** to
+    (float * exp).round.to_f / exp
+  end
 end
 
 require 'beerxml/model'

data/lib/beerxml/fermentable.rb

@@ -0,0 +1,34 @@
+class Beerxml::Fermentable < Beerxml::Model
+  property :name, String, :required => true
+  property :type, Enum['Grain', 'Sugar', 'Extract', 'Dry Extract', 'Adjunct'], :required => true
+  property :amount, Weight, :required => true
+  property :yield, Float, :required => true
+  property :color, Float, :required => true
+
+  property :add_after_boil, Boolean, :default => false
+  property :origin, String, :length => 512
+  property :supplier, String, :length => 512
+  property :notes, String, :length => 65535
+  property :coarse_fine_diff, Float
+  property :moisture, Float
+  property :diastatic_power, Float
+  property :protein, Float
+  property :max_in_batch, Float
+  property :recommend_mash, Boolean
+  property :ibu_gal_per_lb, Float
+
+  # these are not used in the xml
+  property :id, Serial
+  belongs_to :recipe, :required => false
+
+  def ppg
+    # potential is (yield * 0.001 + 1)
+    (self.yield * 0.01) * 46.214
+  end
+
+  def total_ppg(efficiency = nil)
+    total = ppg * amount.in_pounds.to_f
+    total *= (efficiency * 0.01) unless efficiency.nil? || type != 'Grain'
+    total
+  end
+end

data/lib/beerxml/hop.rb

@@ -1,9 +1,10 @@
 class Beerxml::Hop < Beerxml::Model
   property :name, String, :required => true
   property :alpha, Float, :required => true
-  property :amount, Float, :required => true
+  property :amount, Weight, :required => true
   property :use, Enum['Boil', 'Dry Hop', 'Mash', 'First Wort', 'Aroma'], :required => true
-  property :time, Integer, :required => true
+  property :time, Time, :required => true
+
   property :notes, String, :length => 65535
   property :type, Enum[nil, 'Bittering', 'Aroma', 'Both']
   property :form, Enum[nil, 'Pellet', 'Plug', 'Leaf']
@@ -19,4 +20,17 @@ class Beerxml::Hop < Beerxml::Model
   # these are not used in the xml
   property :id, Serial
   belongs_to :recipe, :required => false
+
+  def tinseth(post_boil_og, batch_size) # batch size is gallons or Unit
+    bigness = 1.65 * 0.000125**(post_boil_og - 1)
+    boil_factor = (1 - 2.72 ** (-0.04 * time.in_minutes.to_f)) / 4.15
+    utilization = bigness * boil_factor
+    ibus = utilization * (aau * 0.01 * 7490) / U(batch_size, 'gallons').to_f
+    Beerxml.round(ibus, 1)
+  end
+  alias_method :ibus, :tinseth
+
+  def aau
+    alpha * amount.in('ounces').to_f
+  end
 end

data/lib/beerxml/model.rb

@@ -1,10 +1,43 @@
 class Beerxml::Model
   include DataMapper::Resource
+  require 'beerxml/properties'
+  include Beerxml::Properties
+
+  ##########################
+
+  @models = {}
+  @plurals = {}
 
   def self.beerxml_name
     name.split('::').last.upcase
   end
 
+  def self.beerxml_plural_name
+    "#{beerxml_name}S"
+  end
+
+  def self.inherited(klass)
+    super
+    @models[klass.beerxml_name] = klass
+    @plurals["#{klass.beerxml_name}S"] = klass
+  end
+
+  ##########################
+
+  # Takes a Nokogiri node, figures out what sort of class it is, and parses it.
+  # Raises if it's not a Beerxml::Model class (or collection).
+  def self.from_xml(node)
+    if model = @models[node.name]
+      model.new.from_xml(node)
+    elsif model = @plurals[node.name]
+      collection_from_xml(node)
+    else
+      raise "Unknown BeerXML node type: #{node.name}"
+    end
+  end
+
+  # Parse a Nokogiri node, reading in the properties defined on this model.
+  # Assumes the node is of the correct type.
   def from_xml(node)
     properties.each do |property|
       read_xml_field(node, property.name.to_s)
@@ -14,17 +47,26 @@ class Beerxml::Model
       child_model = rel.child_model
       next unless child_model.ancestors.include?(Beerxml::Model)
 
-      model_name = child_model.beerxml_name
-      child_wrapper_node = (node>model_name.pluralize.upcase).first
-      next unless child_wrapper_node
-
-      (child_wrapper_node>model_name).each do |child_node|
-        self.send(rel.name) << child_model.new.from_xml(child_node)
+      # look for the plural element in the children of this node
+      # e.g., for Hop, see if there's any HOPS element.
+      (node>child_model.beerxml_plural_name).each do |child_wrapper_node|
+        collection = Beerxml::Model.collection_from_xml(child_wrapper_node)
+        self.send(rel.name).concat(collection)
       end
     end
     self
   end
 
+  # takes a collection root xml node, like <HOPS>, and returns an array of the
+  # child model objects inside the node.
+  def self.collection_from_xml(collection_node)
+    model = @plurals[collection_node.name]
+    raise("Unknown model: #{collection_node.name}") unless model
+    (collection_node>model.beerxml_name).map do |child_node|
+      model.new.from_xml(child_node)
+    end
+  end
+
   def read_xml_field(node, attr_name, node_name = attr_name.upcase)
     child = (node>node_name).first
     return unless child
@@ -33,6 +75,8 @@ class Beerxml::Model
     self.send("#{attr_name}=", child)
   end
 
+  ##########################
+
   def to_beerxml(parent = Nokogiri::XML::Document.new)
     # TODO: do we raise an error if not valid?
     node = Nokogiri::XML::Node.new(self.class.beerxml_name, parent)
@@ -55,5 +99,5 @@ class Beerxml::Model
   end
 end
 
-require 'beerxml/hop'
-require 'beerxml/recipe'
+%w(hop recipe fermentable).
+  each { |f| require "beerxml/#{f}" }

data/lib/beerxml/properties.rb

@@ -0,0 +1,93 @@
+require 'beerxml/unit'
+
+# Custom DM property types for the various BeerXML data types.
+module Beerxml::Properties
+
+  class Property < DataMapper::Property::Float
+    def custom?
+      true
+    end
+
+    def load(value)
+      return if value.nil?
+      if value.is_a?(Beerxml::Unit)
+        raise(ArgumentError, 'Weight required') unless value.type == unit_type
+        value
+      else
+        U(value, base_unit)
+      end
+    end
+
+    def dump(value)
+      return if value.nil?
+      value.in(base_unit).to_f
+    end
+
+    def typecast_to_primitive(value)
+      load(value)
+    end
+  end
+
+  # Represents a weight. Default scale is kilograms, since that's what
+  # BeerXML uses. But can handle conversion/display of other units.
+  class Weight < Property
+    def unit_type
+      'weight'
+    end
+    def base_unit
+      'kilograms'
+    end
+  end
+
+  # A volume, in liters.
+  class Volume < Property
+    def unit_type
+      'volume'
+    end
+    def base_unit
+      'liters'
+    end
+  end
+
+  # A temperature, in deg C.
+  class Temperature < Property
+    def unit_type
+      'temperature'
+    end
+    def base_unit
+      'C'
+    end
+  end
+
+  # A time, in minutes.
+  class Time < Property
+    def unit_type
+      'time'
+    end
+    def base_unit
+      'minutes'
+    end
+  end
+
+  # Time, but in days.
+  class TimeInDays < Time
+    def base_unit
+      'days'
+    end
+  end
+
+  # Appendix A: http://www.beerxml.com/beerxml.htm
+  # "all fields that are defined for display only may also use a unit
+  # tag after them". For example “3.45 gal” is an acceptable value.
+  class DisplayWeight < Weight
+  end
+
+  class DisplayVolume < Volume
+  end
+
+  class DisplayTemperature < Temperature
+  end
+
+  class DisplayTime < Time
+  end
+end

data/lib/beerxml/recipe.rb

@@ -2,9 +2,58 @@ class Beerxml::Recipe < Beerxml::Model
   include DataMapper::Resource
 
   property :name, String, :required => true
+  property :type, Enum['Extract', 'Partial Mash', 'All Grain'], :required => true
+  # has 1, :style, :required => true
+  property :brewer, String, :required => true
+  property :batch_size, Volume, :required => true
+  property :boil_size, Volume, :required => true
+  property :boil_time, Time, :required => true
+  property :efficiency, Float
+  validates_presence_of :efficiency, :if => proc { |t| t.type != 'Extract' }
 
   has n, :hops
+  has n, :fermentables
+  # has n, :miscs
+  # has n, :yeasts
+  # has n, :waters
+
+  property :asst_brewer, String
+  property :notes, String, :length => 65535
+  property :taste_notes, String, :length => 65535
+  property :taste_rating, Float
+  property :og, Float
+  property :fg, Float
+  property :fermentation_stages, Integer
+  property :primary_age, TimeInDays
+  property :primary_temp, Temperature
+  property :secondary_age, TimeInDays
+  property :secondary_temp, Temperature
+  property :tertiary_age, TimeInDays
+  property :tertiary_temp, Temperature
+  property :age, TimeInDays
+  property :age_temp, Temperature
+  property :date, String
+  property :carbonation, Float
+  property :forced_carbonation, Boolean
+  property :priming_sugar_name, String
+  property :carbonation_temp, Temperature
+  property :priming_sugar_equiv, Float
+  property :keg_priming_factor, Float
+  # has 1, :equipment
+  # has 1, :mash
+  # validates_presence_of :mash, :if => proc { |t| t.type != 'Extract' }
 
   # these are not used in the xml
   property :id, Serial
+
+  def tinseth
+    Beerxml.round(hops.select { |h| h.use == 'Boil' }.inject(0) { |v, h| v + h.tinseth(og, batch_size) }, 1)
+  end
+  alias_method :ibus, :tinseth
+
+  def calculate_og
+    total_ppg = fermentables.inject(0) { |v, f| v + f.total_ppg(efficiency) }
+    og = 1 + ((total_ppg / batch_size.in_gallons.to_f) * 0.001)
+    Beerxml.round(og, 3)
+  end
 end

data/lib/beerxml/unit.rb

@@ -0,0 +1,168 @@
+module Beerxml
+# Unit system with conversions between units of the same type. Very much
+# a work in progress.
+class Unit
+  attr_reader :type, :unit
+
+  Units = {}
+  BaseUnits = {}
+  UnitToType = {}
+
+  def in(unit, *args)
+    self.clone.in!(unit, *args)
+  end
+  alias_method :to, :in
+
+  def in!(new_unit, *args)
+    new_unit = new_unit.to_s
+    new_unit_type = UnitToType[new_unit]
+    raise(ArgumentError, "Unknown unit: #{new_unit}") if new_unit_type.nil?
+    if new_unit_type != type
+      raise(ArgumentError, "New unit: #{new_unit} not compatible with current unit: #{unit}")
+    end
+    @unit = new_unit
+    self
+  end
+  alias_method :to!, :in!
+  alias_method :unit=, :in!
+
+  def base_unit
+    BaseUnits[type]
+  end
+
+  def to_f
+    @value * Units[type][unit]
+  end
+
+  def initialize(amount, unit = nil)
+    if amount.is_a?(Unit)
+      if unit
+        amount = amount.to(unit).to_f
+      else
+        amount, unit = amount.to_f, amount.unit
+      end
+    elsif !unit
+      amount, unit = amount.to_s.split(/\s+/, 2)
+    end
+    unit = unit.to_s
+
+    @type = UnitToType[unit]
+    self.unit = unit
+    @value = Float(amount) / Units[type][unit]
+  end
+
+  def is?(unit)
+    self.unit == unit ||
+      (UnitToType[self.unit] == UnitToType[unit] &&
+       Units[type][self.unit] == Units[type][unit])
+  end
+
+  def self.add_type(type, base_unit_name, *aliases)
+    Units[type] = {}
+    Units[type][base_unit_name] = 1.0
+    UnitToType[base_unit_name] = type
+    BaseUnits[type] = base_unit_name
+    aliases.each { |a| add_alias(type, base_unit_name, a) }
+  end
+  def self.add(type, factor, name, *aliases)
+    Units[type][name] = factor.to_f
+    aliases.each { |a| add_alias(type, name, a) }
+    UnitToType[name] = type
+  end
+  def self.add_alias(type, name, new_alias)
+    base = Units[type][name]
+    raise(ArgumentError, "Unknown base: #{name}") unless base
+    Units[type][new_alias] = base
+    UnitToType[new_alias] = type
+  end
+
+  def ==(rhs)
+    # TODO: hard-coding this precision stinks...
+    if rhs.is_a?(self.class)
+      rhs = rhs.in(base_unit)
+      @value.between?(rhs.to_f - 0.01, rhs.to_f + 0.01)
+    elsif rhs.is_a?(Numeric)
+      to_f.between?(rhs.to_f - 0.01, rhs.to_f + 0.01)
+    else
+      raise ArgumentError, "#{rhs.inspect} is not a #{self.class.name}"
+    end
+  end
+
+  def method_missing(meth, *a, &b)
+    if meth.to_s =~ %r{\A(to|in)_([^!]+)(!)?\z}
+      send($3 ? :in! : :in, $2)
+    else
+      super
+    end
+  end
+
+  # todo: remove this, to_beerxml is using it (and incorrectly at that)
+  def to_s
+    to_f.to_s
+  end
+
+  def inspect
+    "[#{to_f} #{unit}]"
+  end
+
+  def *(rhs)
+    if rhs.is_a?(Numeric)
+      ret = Unit.new(self.to_f * rhs, self.unit)
+    elsif rhs.is_a?(Unit) && rhs.type == type
+      ret = Unit.new(self.to_f * rhs.to(self.unit).to_f, self.unit)
+    else
+      super
+    end
+  end
+
+  # Assumes earth gravity ;)
+  module Weight
+    def self.included(k)
+      k.add_type('weight', 'kg', 'kilogram', 'kilograms')
+      k.add('weight', 1000, 'g', 'gram', 'grams')
+      k.add('weight', 2.204622, 'lb', 'pound', 'pounds', 'lbs')
+      k.add('weight', 35.273961, 'oz', 'ounce', 'ounces')
+    end
+  end
+  include Weight
+
+  module Volume
+    def self.included(k)
+      k.add_type('volume', 'liters', 'l', 'liter')
+      k.add('volume', 0.26417, 'gallons', 'gallon')
+    end
+  end
+  include Volume
+
+  module Time
+    def self.included(k)
+      k.add_type('time', 'day', 'days')
+      k.add('time', 24, 'hour', 'hours')
+      k.add('time', 1440, 'minute', 'minutes')
+    end
+  end
+  include Time
+
+  module Temperature
+    def self.included(k)
+      k.add_type('temperature', 'c', 'C', 'celsius')
+      # k.add('temperature', proc {}, 'f', 'F', 'fahrenheit')
+    end
+  end
+  include Temperature
+
+  def self.apply_to_numeric!
+    Beerxml::Unit::UnitToType.each do |unit, v|
+      Numeric.class_eval(<<-METHOD, __FILE__, __LINE__+1)
+      def #{unit}
+        Beerxml::Unit.new(self, #{unit.inspect})
+      end
+      METHOD
+    end
+  end
+end
+end
+
+def U(*a)
+  Beerxml::Unit.new(*a)
+end

data/lib/beerxml/version.rb

@@ -1,3 +1,3 @@
 module Beerxml
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/hops_spec.rb

@@ -0,0 +1,27 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+require 'beerxml/unit'
+
+describe Beerxml::Hop do
+  describe "IBUs" do
+    it "should calculate IBUs using the Tinseth formula" do
+      hop = Beerxml::Hop.new(:name => "Cascade",
+                             :alpha => 6,
+                             :amount => U('0.5 oz'),
+                             :use => 'Boil',
+                             :time => 20)
+      hop.should be_valid
+      hop.tinseth(1.065, 5.5).should == 5
+      # tinseth by default
+      hop.ibus(1.065, 5.5).should == 5
+
+      hop2 = Beerxml::Hop.new(:name => 'Goldings',
+                              :alpha => 5,
+                              :amount => U(4.5, 'oz'),
+                              :use => 'Boil',
+                              :time => 60)
+      hop2.should be_valid
+      hop2.ibus(1.081, 11).should == 26.7
+    end
+  end
+end

data/spec/parsing_spec.rb

@@ -1,10 +1,6 @@
-require 'spec/spec_helper'
+require "#{File.dirname(__FILE__)}/spec_helper"
 
 describe "beerxml.com examples" do
-  def read_xml(example)
-    Nokogiri::XML(File.read("examples/beerxml.com/#{example}.xml"))
-  end
-
   it "should parse the first recipe and its hops" do
     recipe = Beerxml::Recipe.new.from_xml(read_xml("recipes").root.children[1])
 
@@ -29,4 +25,127 @@ describe "beerxml.com examples" do
     hop2.should be_valid
     hop2.attributes.should == hop.attributes
   end
+
+  def assert_hops(hops)
+    hops.size.should == 5
+    hops.each { |h| h.should(be_a(Beerxml::Hop)) && h.should(be_valid) }
+    hops.map(&:name).should == ["Cascade", "Galena", "Goldings, B.C.", "Northern Brewer", "Tettnang"]
+  end
+
+  describe "auto-discovery of root node types" do
+    it "should discover singular nodes" do
+      hop = Beerxml::Model.from_xml(read_xml("hops").root.children[1])
+      hop.should be_a(Beerxml::Hop)
+      hop.should be_valid
+      hop.name.should == "Cascade"
+    end
+
+    it "should discover plural nodes" do
+      hops = Beerxml::Model.from_xml(read_xml("hops").root)
+      assert_hops(hops)
+    end
+  end
+
+  it "should parse given a string or IO" do
+    hops = Beerxml.parse(File.read(filename("hops")))
+    assert_hops(hops)
+    hops = Beerxml.parse(File.open(filename("hops"), "rb"))
+    assert_hops(hops)
+  end
+
+  describe "sanity checks" do
+    def check_parse(klass, file, node, attrs)
+      model = klass.new.from_xml(read_xml(file).root.children[node])
+      model.should be_valid
+      model.attributes.reject { |k,v| v.nil? }.should == attrs
+      model
+    end
+    it "should parse fermentables" do
+      check_parse(Beerxml::Fermentable, "grain", 5, {
+        :name => 'Munich Malt',
+        :type => 'Grain',
+        :amount => 0.0,
+        :yield => 80.0,
+        :color => 9.0,
+        :add_after_boil => false,
+        :origin => 'Germany',
+        :notes => "Malty-sweet flavor characteristic and adds a reddish amber color to the beer.
+Does not contribute signficantly to body or head retention.
+Use for: Bock, Porter, Marzen, Oktoberfest beers",
+        :coarse_fine_diff => 1.3,
+        :moisture => 5.0,
+        :diastatic_power => 72.0,
+        :protein => 11.5,
+        :max_in_batch => 80.0,
+        :recommend_mash => true,
+        :ibu_gal_per_lb => 0.0,
+        :supplier => '',
+      })
+    end
+    it "should parse hops" do
+      check_parse(Beerxml::Hop, "hops", 7, {
+        :name => 'Northern Brewer',
+        :origin => 'Germany',
+        :alpha => 8.5,
+        :amount => 0.0,
+        :use => 'Boil',
+        :time => 0.0,
+        :notes => %{Also called Hallertauer Northern Brewers
+Use for: Bittering and finishing both ales and lagers of all kinds
+Aroma: Fine, dry, clean bittering hop.  Unique flavor.
+Substitute: Hallertauer Mittelfrueh, Hallertauer
+Examples: Anchor Steam, Old Peculiar, },
+        :type => 'Both',
+        :form => 'Pellet',
+        :beta => 4.0,
+        :hsi => 35.0,
+      })
+    end
+    it "should parse recipes" do
+      recipe = check_parse(Beerxml::Recipe, "recipes", 3, {
+        :name => 'Dry Stout',
+        :type => 'All Grain',
+        :brewer => 'Brad Smith',
+        :asst_brewer => '',
+        :batch_size => 18.92716800,
+        :boil_size => 20.81988500,
+        :boil_time => 60,
+        :efficiency => 72.0,
+        :notes => %{A very simple all grain beer that produces a great Guiness-style taste every time.  So light in body that I have even made black and tans with it using a full body pale ale in the bottom of the glass.},
+        :taste_notes => %{One of my favorite stock beers - I always keep a keg on hand.  Rich flavored dry Irish Stout that is very simple to make.  Perfect every time!},
+        :taste_rating => 44.0,
+        :og => 1.038,
+        :fg => 1.012,
+        :carbonation => 2.3,
+        :fermentation_stages => 2,
+        :primary_age => 4,
+        :primary_temp => 20.000,
+        :secondary_age => 7,
+        :secondary_temp => 20.000,
+        :tertiary_age => 0,
+        :age => 7,
+        :age_temp => 5.000,
+        :date => '4/1/2003',
+      })
+      recipe.hops.map(&:attributes).should == [
+        :name => 'Goldings, East Kent',
+        :origin => 'United Kingdom',
+        :alpha => 5.0,
+        :amount => 0.0637860,
+        :use => 'Boil',
+        :time => 60,
+        :notes => %{Used For: General purpose hops for bittering/finishing all British Ales
+Aroma: Floral, aromatic, earthy, slightly sweet spicy flavor
+Substitutes: Fuggles, BC Goldings
+Examples: Bass Pale Ale, Fullers ESB, Samual Smith's Pale Ale
+},
+        :type => 'Aroma',
+        :form => 'Pellet',
+        :beta => 3.5,
+        :hsi => 35.0,
+        :recipe_id => nil,
+      ]
+      recipe.fermentables.map(&:name).should == ['Pale Malt (2 Row) UK', 'Barley, Flaked', 'Black Barley (Stout)']
+    end
+  end
 end

data/spec/recipes_spec.rb

@@ -0,0 +1,15 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+describe Beerxml::Recipe do
+  it "should calculate IBUs using the tinseth method" do
+    recipe = Beerxml::Recipe.new.from_xml(read_xml("recipes").root.children[1])
+    recipe.should be_valid
+    recipe.ibus.round.should == 32
+  end
+
+  it "should calculate the OG for an all grain batch" do
+    recipe = Beerxml::Recipe.new.from_xml(read_xml("recipes").root.children[1])
+    recipe.should be_valid
+    recipe.calculate_og.should == 1.056
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,15 @@
-require 'bundler'
-Bundler.require(:default, :development)
-
 require 'beerxml'
 
-require 'ruby-debug'
+require 'rspec'
 
 RSpec.configure do |c|
+  def filename(example)
+    "examples/beerxml.com/#{example}.xml"
+  end
+  def read_file(example)
+    File.read(filename(example))
+  end
+  def read_xml(example)
+    Nokogiri::XML(read_file(example))
+  end
 end

data/spec/units_spec.rb

@@ -0,0 +1,123 @@
+require "#{File.dirname(__FILE__)}/spec_helper"
+
+class Float
+  def near?(rhs, prec = 0.01)
+    self.between?(rhs - prec, rhs + prec)
+  end
+end
+
+describe Beerxml::Unit do
+  it "should allow constructing with base units" do
+    w = U('153.27 kg')
+    w.unit.should == 'kg'
+    w.is?('kg').should be_true
+    w.is?('kilograms').should be_true
+    w.is?('g').should be_false
+    w.to_f.should == 153.27
+    w.should == 153.27
+    w.should == U(153.27, 'kg')
+    w.should == U('153.27', 'kg')
+  end
+
+  it "should reject unknown units" do
+    proc { U('153') }.should raise_error(ArgumentError)
+    proc { U('153 glorbs') }.should raise_error(ArgumentError)
+    proc { U(153, 'glorbs') }.should raise_error(ArgumentError)
+  end
+
+  it "should require an amount" do
+    proc { U('kg') }.should raise_error(ArgumentError)
+    proc { U('hai kg') }.should raise_error(ArgumentError)
+    proc { U('hai', 'kg') }.should raise_error(ArgumentError)
+  end
+
+  it "should allow symbols for units" do
+    U(2, :kg).should == U(2, 'kilograms')
+  end
+
+  it "should allow constructing with different units" do
+    w = U(53.97, 'oz')
+    w.in('kg').should == U(1.53, 'kg')
+    w.should == U('53.97 oz')
+  end
+
+  it "should allow constructing from another compatible Unit object" do
+    w = U(53.97, 'oz')
+    w2 = U(w) # defaults to oz, same units as copying object
+    w3 = U(w, 'kg')
+    w.should == w2
+    w.should == w3
+    w2.should == w3
+    w2.should == 53.97
+    w3.should == 1.53
+  end
+
+  describe "equality" do
+    it "should compare between units" do
+      w = U(3.5, 'kg')
+      lbs = w.in('pounds')
+      lbs.to_f.should be_near(7.7162)
+      w.should == lbs
+      w.should == 3.5
+      w.in('lbs').should == 7.716
+    end
+
+    it "should not compare with strings" do
+      w = U(1, 'kg')
+      proc { w == "5" }.should raise_error(ArgumentError)
+    end
+
+    it "should not allow equality between incompatible units" do
+      w = U(53.97, 'oz')
+      v = U(2, 'gallons')
+      proc { w == v }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "should infer in_* methods for defined units" do
+    w = U(1, 'kg')
+    w.in_grams.should == 1000
+    w.in_kilograms.should == 1
+  end
+
+  describe "changing units in place" do
+    it "should allow changing units with attr writer" do
+      w = U(1, 'kg')
+      w.to_f.should == 1
+      w.unit = 'g'
+      w.to_f.should == 1000
+    end
+
+    it "should not allow changing to an unknown unit" do
+      w = U(1, 'kg')
+      proc { w.in!('blorg') }.should raise_error(ArgumentError)
+    end
+
+    it "should not allow changing to an incompatible unit" do
+      w = U(1, 'kg')
+      proc { w.in!('minutes') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "changing units with in()" do
+    it "should handle basic conversions" do
+      w = U(1.53, 'kg')
+      w.in('grams').should == 1530
+      w.in('lbs').to_f.should be_near(3.37)
+      w.in('lbs').in('ounces').to_f.should be_near(53.97)
+      w.in('pounds').in('grams').in('kg').to_f.should be_near(1.53)
+    end
+
+    it "should not allow changing to an unknown unit" do
+      w = U(1, 'kg')
+      proc { w.in('blorg') }.should raise_error(ArgumentError)
+      proc { w.in_blorg }.should raise_error(ArgumentError)
+    end
+
+    it "should not allow changing to an incompatible unit" do
+      w = U(1, 'kg')
+      proc { w.in('minutes') }.should raise_error(ArgumentError)
+      proc { w.in_hours }.should raise_error(ArgumentError)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: beerxml
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Brian Palmer
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-06 00:00:00 -07:00
+date: 2011-03-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -86,15 +86,15 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 9
         segments: 
         - 2
-        - 0
-        version: "2.0"
+        - 5
+        version: "2.5"
   type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: ruby-debug
+  name: autotest-standalone
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
@@ -108,7 +108,7 @@ dependencies:
   type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: rcov
+  name: autotest-growl
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
@@ -122,7 +122,7 @@ dependencies:
   type: :development
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: rcov
   prerelease: false
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
@@ -135,6 +135,20 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
 description: |-
   Library for parsing and generating beerxml (http://www.beerxml.com/).
   More than that, this library also contains various methods for doing calculations on beer ingredients and recipes, among other helpers.
@@ -149,6 +163,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - beerxml.gemspec
@@ -163,12 +178,18 @@ files:
 - examples/beerxml.com/water.xml
 - examples/beerxml.com/yeast.xml
 - lib/beerxml.rb
+- lib/beerxml/fermentable.rb
 - lib/beerxml/hop.rb
 - lib/beerxml/model.rb
+- lib/beerxml/properties.rb
 - lib/beerxml/recipe.rb
+- lib/beerxml/unit.rb
 - lib/beerxml/version.rb
+- spec/hops_spec.rb
 - spec/parsing_spec.rb
+- spec/recipes_spec.rb
 - spec/spec_helper.rb
+- spec/units_spec.rb
 has_rdoc: true
 homepage: https://github.com/codekitchen/beerxml
 licenses: []
@@ -204,5 +225,8 @@ signing_key:
 specification_version: 3
 summary: Library for parsing and generating beerxml (http://www.beerxml.com/)
 test_files: 
+- spec/hops_spec.rb
 - spec/parsing_spec.rb
+- spec/recipes_spec.rb
 - spec/spec_helper.rb
+- spec/units_spec.rb