nrb-beerxml 0.0.2

data/lib/beerxml/record.rb

@@ -0,0 +1,49 @@
+require 'active_model'
+module NRB
+  module BeerXML
+    class Record
+      include Inflector
+      include ActiveModel::Model
+      extend ActiveModel::Callbacks
+      extend ActiveModel::Naming
+
+      define_model_callbacks :initialize, only: :after
+
+      attr_accessor :name
+      attr_accessor :version
+
+      validates :name, presence: true
+      validates :version, presence: true, numericality: { only_integer: true }
+
+
+      def initialize(*args)
+        super
+        run_callbacks :initialize
+      end
+
+
+      def record_type
+        underscore(self.class.name.split(/::/).last).to_sym
+      end
+
+
+      def equipment?;    am_a? :equipment; end
+      def fermentable?;  am_a? :fermentable; end
+      def hop?;          am_a? :hop; end
+      def mash_profile?; am_a? :mash_profile; end
+      def mash_step?;    am_a? :mash_step; end
+      def misc?;         am_a? :misc; end
+      def recipe?;       am_a? :recipe; end
+      def style?;        am_a? :style; end
+      def water?;        am_a? :water; end
+      def yeast?;        am_a? :yeast; end
+
+      def persisted?; false; end
+
+    private
+
+      def am_a?(question); record_type == question; end
+
+    end
+  end
+end

data/lib/beerxml/record_set.rb

@@ -0,0 +1,39 @@
+module NRB; module BeerXML
+  class RecordSet
+
+    include Enumerable
+
+    class UnknownRecordTypeError < RuntimeError; end
+
+    attr_reader :record_type, :records
+
+    def self.valid_record_types
+      %i( equipment fermentable hop mash mash_step misc recipe style water yeast )
+    end
+
+
+    def <<(record)
+      raise UnknownRecordTypeError.new("Can't add a #{record.record_type} to this set (only #{record_type}s)") unless valid_record_type?(record.record_type)
+      @records << record
+    end
+
+
+    def each(&block)
+      @records.each &block
+    end
+
+
+    def initialize(record_type: nil)
+      raise UnknownRecordTypeError.new("Don't know what to do with a #{record_type} record") unless valid_record_type?(record_type)
+      @record_type = record_type
+      @records = []
+    end
+
+  private
+
+    def valid_record_type?(type)
+      self.class.valid_record_types.include?(type)
+    end
+
+  end
+end; end

data/lib/beerxml/record_validators.rb

@@ -0,0 +1,8 @@
+module NRB
+  module BeerXML
+    module RecordValidators
+      autoload :BooleanValidator, 'beerxml/record_validators/boolean_validator'
+      autoload :PercentageValidator, 'beerxml/record_validators/percentage_validator'
+    end
+  end
+end

data/lib/beerxml/record_validators/boolean_validator.rb

@@ -0,0 +1,16 @@
+require 'active_model'
+module NRB; module BeerXML;
+  module RecordValidators
+    class BooleanValidator < ActiveModel::Validations::InclusionValidator
+      def validate_each(record, attribute, value)
+        unless include?(record, value)
+          record.errors[attribute] << "must be false or true"
+        end
+      end
+    private
+      def delimiter; [false, true]; end
+    end
+  end
+end; end
+defined?(BooleanValidator) || BooleanValidator = NRB::BeerXML::RecordValidators::BooleanValidator
+

data/lib/beerxml/record_validators/percentage_validator.rb

@@ -0,0 +1,38 @@
+require 'active_model'
+module NRB; module BeerXML;
+  module RecordValidators
+    class PercentageValidator < ActiveModel::EachValidator
+
+      def validate_each(record, attribute, value)
+        return unless value
+        unless value.is_a?(Numeric) && greater_than_min(value) && less_than_max(value)
+          record.errors[attribute] << 'must be a BeerXML percentage (a number between 0 & 100)'
+        end
+      end
+
+    private
+
+      def greater_than_min(value)
+        options[:allow_negative] ? true : value >= min
+      end
+
+
+      def less_than_max(value)
+        options[:give_110] ? true : value <= max
+      end
+
+
+      def max
+        options[:max] || 100
+      end
+
+
+      def min
+        options[:min] || 0
+      end
+
+    end
+  end
+end; end
+defined?(PercentageValidator) || PercentageValidator = NRB::BeerXML::RecordValidators::PercentageValidator
+

data/lib/beerxml/style.rb

@@ -0,0 +1,49 @@
+require 'beerxml/record_validators/percentage_validator'
+module NRB
+  module BeerXML
+    class Style < Record
+
+      attr_accessor :abv_max         # float
+      attr_accessor :abv_min         # float
+      attr_accessor :carb_max        # float
+      attr_accessor :carb_min        # float
+      attr_accessor :category        # string required
+      attr_accessor :category_number # string required
+      attr_accessor :color_max       # float required
+      attr_accessor :color_min       # float required
+      attr_accessor :examples        # text
+      attr_accessor :fg_max          # float required
+      attr_accessor :fg_min          # float required
+      attr_accessor :ibu_max         # float required
+      attr_accessor :ibu_min         # float required
+      attr_accessor :ingredients     # text
+      attr_accessor :notes           # text
+      attr_accessor :og_max          # float required
+      attr_accessor :og_min          # float required
+      attr_accessor :profile         # text
+      attr_accessor :style_guide     # string required
+      attr_accessor :style_letter    # string required
+      attr_accessor :type            # list required
+
+      validates :abv_max, numericality: { greater_than_or_equal_to: 0 }
+      validates :abv_min, numericality: { greater_than_or_equal_to: 0 }
+      validates :carb_max, numericality: { greater_than_or_equal_to: 0 }
+      validates :carb_min, numericality: { greater_than_or_equal_to: 0 }
+      validates :category, presence: true
+      validates :category_number, presence: true
+      validates :color_max, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :color_min, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :fg_max, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :fg_min, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :ibu_max, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :ibu_min, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :og_max, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :og_min, numericality: { greater_than_or_equal_to: 0 }, presence: true
+      validates :style_guide, presence: true
+      validates :style_letter, presence: true
+      validates :type, inclusion: { in: %w(Ale Cider Lager Mead Mixed Wheat ) },
+                       presence: true
+
+    end
+  end
+end

data/lib/beerxml/version.rb

@@ -0,0 +1,6 @@
+module NRB
+  module BeerXML
+    VERSION = "0.0.2"
+    def self.version; VERSION; end
+  end
+end

data/lib/beerxml/water.rb

@@ -0,0 +1,26 @@
+module NRB
+  module BeerXML
+    class Water < Record
+
+      attr_accessor :amount      # volume required
+      attr_accessor :bicarbonate # float required
+      attr_accessor :calcium     # float required
+      attr_accessor :chloride    # float required
+      attr_accessor :magnesium   # float required
+      attr_accessor :notes       # string
+      attr_accessor :ph          # float
+      attr_accessor :sodium      # float required
+      attr_accessor :sulfate     # float required
+
+      validates :amount, numericality: true, presence: true
+      validates :bicarbonate, numericality: true, presence: true
+      validates :calcium, numericality: true, presence: true
+      validates :chloride, numericality: true, presence: true
+      validates :magnesium, numericality: true, presence: true
+      validates :ph, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 14 }
+      validates :sodium, numericality: true, presence: true
+      validates :sulfate, numericality: true, presence: true
+
+    end
+  end
+end

data/lib/beerxml/yeast.rb

@@ -0,0 +1,38 @@
+require 'beerxml/record_validators/boolean_validator'  # hack so "validates boolean:" magic works
+require 'beerxml/record_validators/percentage_validator'  # hack so "validates percentage:" magic works
+module NRB
+  module BeerXML
+    class Yeast < Record
+
+      attr_accessor :add_to_secondary # boolean
+      attr_accessor :amount           # float required
+      attr_accessor :amount_is_weight # boolean
+      attr_accessor :attenuation      # percentage
+      attr_accessor :best_for         # string
+      attr_accessor :flocculation     # list
+      attr_accessor :form             # list required
+      attr_accessor :laboratory       # string
+      attr_accessor :max_reuse        # integer
+      attr_accessor :max_temperature  # temperature
+      attr_accessor :min_temperature  # temperature
+      attr_accessor :notes            # string
+      attr_accessor :product_id       # string
+      attr_accessor :times_cultured   # integer
+      attr_accessor :type             # list required
+
+      validates :add_to_secondary, boolean: true
+      validates :amount, presence: { greater_than_or_equal_to: 0 }
+      validates :amount_is_weight, boolean: true
+      validates :attenuation, percentage: true
+      validates :flocculation, inclusion: { in: ["High", "Low", "Medium", "Very High" ] }
+      validates :form, presence: true, inclusion: { in: %w( Culture Dry Liquid Slant ) }
+      validates :max_reuse, numericality: { greater_than_or_equal_to: 0, only_integer: true }
+      validates :max_temperature, numericality: true
+      validates :min_temperature, numericality: true
+      validates :times_cultured, numericality: { greater_than_or_equal_to: 0, only_integer: true }
+      validates :type, presence: true, inclusion: { in: %w(Ale Champagne Lager Wheat Wine) }
+
+
+    end
+  end
+end

data/spec/cases/beerxml/builder_spec.rb

@@ -0,0 +1,107 @@
+describe NRB::BeerXML::Builder do
+
+  it "returns nil when it can't guess" do
+    expect( subject.build("Blark") ).to be_nil
+  end
+
+
+  it 'returns a Equipment when asked' do
+    expect( subject.build("Equipment") ).to be_a(NRB::BeerXML::Equipment)
+  end
+
+
+  it 'returns a RecordSet when asked for Equipments' do
+    expect( subject.build("Equipments") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Fermentable when asked' do
+    expect( subject.build("Fermentable") ).to be_a(NRB::BeerXML::Fermentable)
+  end
+
+
+  it 'returns a RecordSet when asked for Fermentables' do
+    expect( subject.build("Fermentables") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Hop when asked' do
+    expect( subject.build("Hop") ).to be_a(NRB::BeerXML::Hop)
+  end
+
+
+  it 'returns a RecordSet when asked for Hops' do
+    expect( subject.build("Hops") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Mash when asked' do
+    expect( subject.build("Mash") ).to be_a(NRB::BeerXML::Mash)
+  end
+
+
+  it 'returns a RecordSet when asked for Mashs' do
+    expect( subject.build("Mashs") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a MashStep when asked' do
+    expect( subject.build("MashStep") ).to be_a(NRB::BeerXML::MashStep)
+  end
+
+
+  it 'returns a RecordSet when asked for MashSteps' do
+    expect( subject.build("MashSteps") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Misc when asked' do
+    expect( subject.build("Misc") ).to be_a(NRB::BeerXML::Misc)
+  end
+
+
+  it 'returns a RecordSet when asked for Miscs' do
+    expect( subject.build("Miscs") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Recipe when asked' do
+    expect( subject.build("Recipe") ).to be_a(NRB::BeerXML::Recipe)
+  end
+
+
+  it 'returns a RecordSet when asked for Recipes' do
+    expect( subject.build("Recipes") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Style when asked' do
+    expect( subject.build("Style") ).to be_a(NRB::BeerXML::Style)
+  end
+
+
+  it 'returns a RecordSet when asked for Styles' do
+    expect( subject.build("Styles") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+  it 'returns a Water when asked' do
+    expect( subject.build("Water") ).to be_a(NRB::BeerXML::Water)
+  end
+
+
+  it 'returns a RecordSet when asked for a Waters' do
+    expect( subject.build("Waters") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+
+
+  it 'returns a Yeast when asked' do
+    expect( subject.build("Yeast") ).to be_a(NRB::BeerXML::Yeast)
+  end
+
+  it 'returns a RecordSet when asked for a Yeasts' do
+    expect( subject.build("Yeasts") ).to be_a(NRB::BeerXML::RecordSet)
+  end
+
+end

data/spec/cases/beerxml/equipment_spec.rb

@@ -0,0 +1,38 @@
+require 'shared/active_model_lint'
+describe NRB::BeerXML::Equipment do
+
+  it_behaves_like :ActiveModel
+
+  it { should validate_presence_of :batch_size }
+  it { should validate_presence_of :boil_size }
+
+  it { should validate_numericality_of(:batch_size).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:boil_size).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:boil_time).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:lauter_tun_deadspace).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:top_up_kettle).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:top_up_water).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:trub_chiller_loss).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:tun_specific_heat).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:tun_volume).is_greater_than_or_equal_to(0) }
+  it { should validate_numericality_of(:tun_weight).is_greater_than_or_equal_to(0) }
+
+
+  shared_examples_for :record_typing do
+    let(:all_types) { %i( equipment fermentable hop mash_profile mash_step misc recipe style water yeast ) }
+    it 'correctly answers to its own type' do
+      expect subject.send("#{type}?")
+    end
+    it 'correctly answers to other types' do
+      (all_types - [type]).each do |question|
+        expect ! subject.send("#{question}?")
+      end
+    end
+  end
+
+
+  it_behaves_like :record_typing do
+    let(:type) { :equipment }
+  end
+
+end

data/spec/cases/beerxml/fermentable_spec.rb

@@ -0,0 +1,17 @@
+require 'shared/active_model_lint'
+
+describe NRB::BeerXML::Fermentable do
+
+  it_behaves_like :ActiveModel
+
+  it { should validate_presence_of :amount }
+  it { should validate_presence_of :color }
+  it { should validate_presence_of :type }
+  it { should validate_presence_of :yield }
+
+  it { should validate_inclusion_of(:type).in_array( [ "Adjunct", "Dry Extract", "Extract", "Grain", "Sugar" ] ) }
+
+  it { should validate_numericality_of(:diastatic_power).is_greater_than_or_equal_to(0) }
+
+
+end