nemah 0.1.1

data/lib/nemah/specific_need/phosphor.rb

@@ -0,0 +1,13 @@
+module Nemah
+  module SpecificNeed
+    class Phosphor < AbstractNeed
+      include Nemah::SpecificNeed::MineralBehaviour
+
+      private
+
+      def factor_table
+        FactorTable.new(no_work: 2.8, below_30: 3.6, below_50: 4.2, below_75: 5.8, above_75: 5.8)
+      end
+    end
+  end
+end

data/lib/nemah/specific_need/protein.rb

@@ -0,0 +1,23 @@
+module Nemah
+  module SpecificNeed
+    class Protein < AbstractNeed
+      private
+
+      def _ideal
+        ideal_energy * 6
+      end
+
+      def _min
+        0.90 * _ideal
+      end
+
+      def _max
+        1.10 * _ideal
+      end
+
+      def ideal_energy
+        need.energy.ideal(decimals: 4)
+      end
+    end
+  end
+end

data/lib/nemah/specific_need/salt.rb

@@ -0,0 +1,13 @@
+module Nemah
+  module SpecificNeed
+    class Salt < AbstractNeed
+      include Nemah::SpecificNeed::MineralBehaviour
+
+      private
+
+      def factor_table
+        FactorTable.new(no_work: 5.1, below_30: 7.0, below_50: 9.0, below_75: 9.0, above_75: 13.0)
+      end
+    end
+  end
+end

data/lib/nemah/specific_need/selenium.rb

@@ -0,0 +1,23 @@
+module Nemah
+  module SpecificNeed
+    class Selenium < AbstractNeed
+      def unit
+        :mg
+      end
+
+      private
+
+      def _ideal
+        min
+      end
+
+      def _min
+        horse.weight_in_deciton * 0.20
+      end
+
+      def _max
+        horse.weight_in_deciton * 5.00
+      end
+    end
+  end
+end

data/lib/nemah/specific_need/solids.rb

@@ -0,0 +1,27 @@
+module Nemah
+  module SpecificNeed
+    class Solids < AbstractNeed
+      def max(decimals: 2)
+        _max
+      end
+
+      def unit
+        :kg
+      end
+
+      private
+
+      def _ideal
+        min
+      end
+
+      def _min
+        horse.weight_in_deciton * 1.50
+      end
+
+      def _max
+        Float::INFINITY
+      end
+    end
+  end
+end

data/lib/nemah/version.rb

@@ -0,0 +1,3 @@
+module Nemah
+  VERSION = '0.1.1'
+end

data/lib/nemah/workload.rb

@@ -0,0 +1,30 @@
+module Nemah
+  class Workload
+    ATTRIBUTES = [:walk, :trot_and_canter, :days_per_week].freeze
+
+    attr_reader *ATTRIBUTES
+
+    def initialize(args = {})
+      attributes.each do |attribute|
+        instance_variable_set "@#{attribute}", args.fetch(attribute, 0)
+      end
+      assert_valid_days_per_week
+    end
+
+    def ==(other)
+      attributes.all? do |attribute|
+        send(attribute) == other.send(attribute)
+      end
+    end
+
+    private
+
+    def attributes
+      ATTRIBUTES.dup
+    end
+
+    def assert_valid_days_per_week
+      raise ArgumentError.new('days_per_week must be between 0 and 7') unless (0..7).include? days_per_week
+    end
+  end
+end

data/nemah.gemspec

@@ -0,0 +1,27 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nemah/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'nemah'
+  spec.version       = Nemah::VERSION
+  spec.authors       = ['Kim Persson', 'Lennart Fridén']
+  spec.email         = ['forgetmenotox@notingham.se']
+  spec.description   = 'Nemah is a library for calculating the proper amount of fodder for your horse.'
+  spec.summary       = 'Horse fodder calculations library.'
+  spec.homepage      = 'https://github.com/Lavinia/Nemah'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'byebug', '~> 2.5'
+  spec.add_development_dependency 'guard', '~> 2.2'
+  spec.add_development_dependency 'guard-rspec', '~> 4.2'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rspec', '~> 2.14'
+end

data/spec/nemah/horse_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Nemah do
+  describe Nemah::Horse do
+    it 'must have a weight' do
+      expect { a_horse_without(:weight) }.to raise_error(ArgumentError, 'weight required')
+    end
+
+    it 'must have a gender' do
+      expect { a_horse_without(:gender) }.to raise_error(ArgumentError, 'gender required')
+    end
+
+    it 'cannot have a non-existing gender' do
+      expect {
+        a_horse_with(gender: :non_existing)
+      }.to raise_error(ArgumentError, ':non_existing is not an allowed gender')
+    end
+
+    it 'can be named' do
+      expect(a_horse_named('Nemah').name).to eq('Nemah')
+    end
+
+    it 'is considered to be of normal difficulty to feed' do
+      expect(a_horse.feedability).to eq(:normal)
+    end
+
+    it 'can be hard to feed' do
+      expect(a_horse_with(feedability: :hard).feedability).to eq(:hard)
+    end
+
+    it 'can be easy to feed' do
+      expect(a_horse_with(feedability: :easy).feedability).to eq(:easy)
+    end
+
+    it 'cannot be impossible to feed' do
+      expect {
+        a_horse_with(feedability: :impossible)
+      }.to raise_error(ArgumentError, ':impossible is not an allowed feedability')
+    end
+
+    it 'cannot have a negative weight' do
+      expect {
+        a_horse_with(weight: -50)
+      }.to raise_error(ArgumentError, '-50 is not an allowed weight')
+    end
+
+    it 'defaults to no workload' do
+      no_workload = Nemah::Workload.new(walk: 0, trot_and_canter: 0, days_per_week: 0)
+      expect(a_horse_without(:workload).workload).to eq(no_workload)
+    end
+
+    describe '#stallion?' do
+      it 'returns true if the horse is a stallion' do
+        expect(a_horse_with gender: :stallion).to be_stallion
+      end
+    end
+
+    describe '#weight_in_deciton' do
+      it 'returns the weight divided by a hundred' do
+        expect(a_horse_with(weight: 650).weight_in_deciton).to eq(6.5)
+      end
+    end
+
+    private
+
+    def workload_for_a_horse_told(method)
+      workload = double(walk: 30, trot_and_canter: 20, days_per_week: 3)
+      horse = a_horse_with(workload: workload)
+      horse.send(method)
+      workload
+    end
+
+    def a_horse
+      Nemah::Horse.new(default_attributes)
+    end
+
+    def a_horse_with(attributes)
+      Nemah::Horse.new(default_attributes.merge(attributes))
+    end
+
+    def a_horse_without(attribute)
+      Nemah::Horse.new(default_attributes.delete_if { |key, _| key == attribute })
+    end
+
+    def a_horse_named(name)
+      a_horse_with(name: name)
+    end
+
+    def default_attributes
+      { weight: 450, gender: :mare }
+    end
+  end
+end

data/spec/nemah/need_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Nemah::Need do
+  describe 'calculating solids' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.solids.to_rounded_range).to eq(6.75..Float::INFINITY)
+    end
+
+    it 'for a huge horse' do
+      expect(need_for_samson.solids.to_rounded_range).to eq(13.50..Float::INFINITY)
+    end
+  end
+
+  describe 'calculating energy need with a ±3 variance' do
+    it 'for a non-working, hard to feed mare' do
+      expect(need_for_nemah.energy.to_rounded_range).to eq(50.74..56.74)
+    end
+
+    it 'for a non-working, easy to feed gelding' do
+      expect(need_for_samson.energy.to_rounded_range).to eq(79.16..85.16)
+    end
+
+    it 'for a non-working, normal to feed stallion' do
+      expect(need_for_janus.energy.to_rounded_range).to eq(67.01..73.01)
+    end
+
+    it 'for a moderately-working, hard to feed mare' do
+      expect(need_for_nemah(workload: moderate_workload).energy.to_rounded_range).to eq(71.31..77.31)
+    end
+
+    it 'for a hard-working, easy to feed gelding' do
+      expect(need_for_samson(workload: hard_workload).energy.to_rounded_range).to eq(164.66..170.66)
+    end
+  end
+
+  describe 'calculating protein need with a ±10% variance' do
+    it 'for a non-working easy to feed gelding' do
+      expect(need_for_samson.protein.to_rounded_range).to eq(443.66..542.25)
+    end
+
+    it 'for a moderately-working, hard to feed mare' do
+      expect(need_for_nemah(workload: moderate_workload).protein.to_rounded_range).to eq(401.26..490.43)
+    end
+  end
+
+
+  describe 'calculating calcium' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.calcium.to_rounded_range).to eq(18.00..Float::INFINITY)
+    end
+  end
+
+  describe 'calculating magnesium' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.magnesium.to_rounded_range).to eq(6.75..Float::INFINITY)
+    end
+  end
+
+  describe 'calculating phosphor' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.phosphor.to_rounded_range).to eq(12.60..Float::INFINITY)
+    end
+  end
+
+  describe 'calculating selenium' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.selenium.to_rounded_range).to eq(0.90..22.50)
+    end
+  end
+
+  describe 'calculating salt' do
+    it 'for an arabian princess' do
+      expect(need_for_nemah.salt.to_rounded_range).to eq(22.95..Float::INFINITY)
+    end
+  end
+
+
+  private
+
+  def moderate_workload
+    Nemah::Workload.new(walk: 60, trot_and_canter: 40, days_per_week: 5)
+  end
+
+  def hard_workload
+    Nemah::Workload.new(walk: 85, trot_and_canter: 60, days_per_week: 7)
+  end
+
+  def need_for_horse_with(args)
+    Nemah::Need.new(Nemah::Horse.new(args))
+  end
+
+  def need_for_samson(args = {})
+    need_for_horse_with({weight: 900, gender: :gelding, feedability: :easy}.merge args)
+  end
+
+  def need_for_nemah(args = {})
+    need_for_horse_with({weight: 450, gender: :mare, feedability: :hard}.merge args)
+  end
+
+  def need_for_janus
+    need_for_horse_with(weight: 600, gender: :stallion, feedability: :normal)
+  end
+end

data/spec/nemah/specific_need/calcium_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Calcium do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :g }
+  end
+
+  it_behaves_like 'a mineral' do
+    let(:no_workload_min_need) { 21.20 }
+    let(:light_workload_min_need) { 31.80 }
+    let(:medium_workload_min_need) { 37.10 }
+    let(:hard_workload_min_need) { 42.40 }
+    let(:very_hard_workload_min_need) { 42.40 }
+  end
+end

data/spec/nemah/specific_need/energy_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Energy do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :MJ }
+  end
+
+  describe '#for_workload' do
+    it 'returns the workload portion of the energy need' do
+      expect(energy.for_workload).to eq(10.97)
+    end
+  end
+
+  describe '#for_maintenance' do
+    it 'returns the maintenance energy need' do
+      expect(energy.for_maintenance).to eq(70.01)
+    end
+  end
+
+  describe '#to_rounded_range' do
+    it 'returns a range between minimum and maximum allowed amounts, rounded to two decimals' do
+      expect(energy.to_rounded_range).to eq(77.98..83.98)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(energy.to_rounded_range(decimals: 3)).to eq(77.982..83.982)
+    end
+  end
+
+  describe '#ideal' do
+    it 'returns the ideal energy need' do
+      expect(energy.ideal).to eq(80.98)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(energy.ideal(decimals: 5)).to eq(80.98229)
+    end
+  end
+
+  describe '#min' do
+    it 'returns the minimum energy need' do
+      expect(energy.min).to eq(77.98)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(energy.min(decimals: 4)).to eq(77.9823)
+    end
+
+    it 'cannot be less than 0' do
+      feather_weight_horse_energy = Nemah::SpecificNeed::Energy.new(need(weight: 0.1))
+      expect(feather_weight_horse_energy.min).to eq(0)
+    end
+  end
+
+  describe '#max' do
+    it 'returns the maximum energy need' do
+      expect(energy.max).to eq(83.98)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(energy.max(decimals: 0)).to eq(84)
+    end
+  end
+
+  private
+
+  def energy
+    Nemah::SpecificNeed::Energy.new(need)
+  end
+
+  def need(weight: 600)
+    workload = double('workload', walk: 30, trot_and_canter: 20, days_per_week: 4)
+    horse = double('horse', stallion?: true, weight: weight, weight_in_deciton: weight / 100.0, feedability: :normal, workload: workload)
+    double('need', horse: horse)
+  end
+end