nemah 0.1.1

data/spec/nemah/specific_need/magnesium_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Magnesium do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :g }
+  end
+
+  it_behaves_like 'a mineral' do
+    let(:no_workload_min_need) { 7.95 }
+    let(:light_workload_min_need) { 10.07 }
+    let(:medium_workload_min_need) { 12.19 }
+    let(:hard_workload_min_need) { 15.9 }
+    let(:very_hard_workload_min_need) { 15.9 }
+  end
+end

data/spec/nemah/specific_need/phosphor_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Phosphor do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :g }
+  end
+
+  it_behaves_like 'a mineral' do
+    let(:no_workload_min_need) { 14.84 }
+    let(:light_workload_min_need) { 19.08 }
+    let(:medium_workload_min_need) { 22.26 }
+    let(:hard_workload_min_need) { 30.74 }
+    let(:very_hard_workload_min_need) { 30.74 }
+  end
+end

data/spec/nemah/specific_need/protein_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Protein do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :g }
+  end
+
+  describe '#to_rounded_range' do
+    it 'returns a range between minimum and maximum allowed amounts, rounded to two decimals' do
+      expect(protein.to_rounded_range).to eq(288.63..352.77)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(protein.to_rounded_range(decimals: 0)).to eq(289..353)
+    end
+  end
+
+  describe '#ideal' do
+    it 'returns the ideal amount of protein needed' do
+      expect(protein.ideal).to eq(320.70)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(protein.ideal(decimals: 0)).to eq(321)
+    end
+  end
+
+  describe '#min' do
+    it 'returns the minimum protein need' do
+      expect(protein.min).to eq(288.63)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(protein.min(decimals: 1)).to eq(288.6)
+    end
+  end
+
+  describe '#max' do
+    it 'returns the maximum protein need' do
+      expect(protein.max).to eq(352.77)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(protein.max(decimals: 1)).to eq(352.8)
+    end
+  end
+
+  def protein
+    Nemah::SpecificNeed::Protein.new(need)
+  end
+
+  def need
+    double(:energy => double(:ideal => 53.45))
+  end
+end

data/spec/nemah/specific_need/salt_spec.rb

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

data/spec/nemah/specific_need/selenium_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Selenium do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :mg }
+  end
+
+  describe '#to_rounded_range' do
+    it 'returns a range between minimum and maximum allowed amounts, rounded to two decimals' do
+      expect(selenium.to_rounded_range).to eq(1.06..26.50)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(selenium.to_rounded_range(decimals: 1)).to eq(1.1..26.5)
+    end
+  end
+
+  describe '#ideal' do
+    it 'returns the ideal amount of selenium needed' do
+      expect(selenium.ideal).to eq(1.06)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(selenium.ideal(decimals: 1)).to eq(1.1)
+    end
+  end
+
+  describe '#min' do
+    it 'returns the minimum selenium need' do
+      expect(selenium.min).to eq(1.06)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(selenium.min(decimals: 1)).to eq(1.1)
+    end
+  end
+
+  describe '#max' do
+    it 'returns the maximum selenium need' do
+      expect(selenium.max).to eq(26.50)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(selenium.max(decimals: 0)).to eq(27)
+    end
+  end
+
+  private
+
+  def selenium
+    Nemah::SpecificNeed::Selenium.new(need)
+  end
+
+  def need
+    double(:horse => double(:weight_in_deciton => 5.3))
+  end
+end

data/spec/nemah/specific_need/solids_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Nemah::SpecificNeed::Solids do
+  it_behaves_like 'a specific need' do
+    let(:unit) { :kg }
+  end
+
+  describe '#to_rounded_range' do
+    it 'returns a range between minimum and maximum allowed amounts, rounded to two decimals' do
+      expect(solids.to_rounded_range).to eq(7.65..Float::INFINITY)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(solids.to_rounded_range(decimals: 0)).to eq(8..Float::INFINITY)
+    end
+  end
+
+  describe '#ideal' do
+    it 'returns the ideal amount of solids needed' do
+      expect(solids.ideal).to eq(7.65)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(solids.ideal(decimals: 1)).to eq(7.7)
+    end
+  end
+
+  describe '#min' do
+    it 'returns the minimum solids need' do
+      expect(solids.min).to eq(7.65)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(solids.min(decimals: 1)).to eq(7.7)
+    end
+  end
+
+  describe '#max' do
+    it 'returns the maximum solids need' do
+      expect(solids.max).to eq(Float::INFINITY)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(solids.max(decimals: 10)).to eq(Float::INFINITY)
+    end
+  end
+
+  private
+
+  def solids
+    Nemah::SpecificNeed::Solids.new(need)
+  end
+
+  def need
+    double(:horse => double(:weight_in_deciton => 5.1))
+  end
+end

data/spec/nemah/workload_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Nemah::Workload do
+  it 'can have the amount of walking set' do
+    expect(workload_with(walk: 30).walk).to eq(30)
+  end
+
+  it 'can have the amount of trot and canter set' do
+    expect(workload_with(trot_and_canter: 5).trot_and_canter).to eq(5)
+  end
+
+  it 'can have the number of days of exercise per week set' do
+    expect(workload_with(days_per_week: 3).days_per_week).to eq(3)
+  end
+
+  it 'does not allow days_per_week to be greater than 7' do
+    expect { workload_with(days_per_week: 10) }.to raise_error(ArgumentError, 'days_per_week must be between 0 and 7')
+  end
+
+  it 'does not allow days_per_week to be less than 0' do
+    expect { workload_with(days_per_week: -2) }.to raise_error(ArgumentError, 'days_per_week must be between 0 and 7')
+  end
+
+  it 'is equal to another workload with the same amount of work' do
+    workload = workload_with(walk: 30, trot_and_canter: 5, days_per_week: 3)
+    another_workload = workload_with(walk: 30, trot_and_canter: 5, days_per_week: 3)
+    expect(workload).to eq(another_workload)
+  end
+
+  private
+
+  def workload_with(args)
+    Nemah::Workload.new(args)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'nemah'
+Dir['./spec/support/**/*.rb'].sort.each { |file| require file }
+require 'byebug'

data/spec/support/shared_examples_for_a_mineral.rb

@@ -0,0 +1,73 @@
+shared_examples_for 'a mineral' do
+  describe '#to_rounded_range' do
+    it 'returns a range between minimum and maximum allowed amounts, rounded to two decimals' do
+      expect(mineral.to_rounded_range).to eq(no_workload_min_need..Float::INFINITY)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(mineral.to_rounded_range(decimals: 0)).to eq(no_workload_min_need.round(0)..Float::INFINITY)
+    end
+
+    context 'with a workload' do
+      it 'adjusts for a light workload' do
+        mineral = mineral_for_horse_with_workload_energy_need(10.0)
+        expect(mineral.to_rounded_range).to eq(light_workload_min_need..Float::INFINITY)
+      end
+
+      it 'adjusts for a medium workload' do
+        mineral = mineral_for_horse_with_workload_energy_need(12.0)
+        expect(mineral.to_rounded_range).to eq(medium_workload_min_need..Float::INFINITY)
+      end
+
+      it 'adjusts for a hard workload' do
+        mineral = mineral_for_horse_with_workload_energy_need(20.0)
+        expect(mineral.to_rounded_range).to eq(hard_workload_min_need..Float::INFINITY)
+      end
+
+      it 'adjusts for a very hard workload' do
+        mineral = mineral_for_horse_with_workload_energy_need(30.0)
+        expect(mineral.to_rounded_range).to eq(very_hard_workload_min_need..Float::INFINITY)
+      end
+    end
+  end
+
+  describe '#ideal' do
+    it 'returns the ideal need' do
+      expect(mineral.ideal).to eq(no_workload_min_need)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(mineral.ideal(decimals: 1)).to eq(no_workload_min_need.round(1))
+    end
+  end
+
+  describe '#min' do
+    it 'returns the minimum need' do
+      expect(mineral.min).to eq(no_workload_min_need)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(mineral.min(decimals: 0)).to eq(no_workload_min_need.round(0))
+    end
+  end
+
+  describe '#max' do
+    it 'returns the maximum need' do
+      expect(mineral.max).to eq(Float::INFINITY)
+    end
+
+    it 'optionally takes the number of decimals' do
+      expect(mineral.max(decimals: 0)).to eq(Float::INFINITY)
+    end
+  end
+
+  def mineral
+    mineral_for_horse_with_workload_energy_need(0.0)
+  end
+
+  def mineral_for_horse_with_workload_energy_need(workload)
+    workload_energy_need = double('energy', :for_maintenance => 40.0, :for_workload => workload)
+    fake_need = double('need', :horse => double(:weight_in_deciton => 5.3), :energy => workload_energy_need)
+    described_class.new(fake_need)
+  end
+end

data/spec/support/shared_examples_for_a_specific_need.rb

@@ -0,0 +1,12 @@
+shared_examples_for 'a specific need' do
+  subject(:need) { described_class.new(double('need for a horse')) }
+
+  describe 'the common interface' do
+    it { should respond_to(:to_rounded_range) }
+    it { should respond_to(:ideal) }
+    it { should respond_to(:min) }
+    it { should respond_to(:max) }
+  end
+
+  specify { expect(need.unit).to eq unit }
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: nemah
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Kim Persson
+- Lennart Fridén
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Nemah is a library for calculating the proper amount of fodder for your
+  horse.
+email:
+- forgetmenotox@notingham.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nemah.rb
+- lib/nemah/horse.rb
+- lib/nemah/need.rb
+- lib/nemah/specific_need/abstract_need.rb
+- lib/nemah/specific_need/calcium.rb
+- lib/nemah/specific_need/energy.rb
+- lib/nemah/specific_need/magnesium.rb
+- lib/nemah/specific_need/mineral_behaviour.rb
+- lib/nemah/specific_need/phosphor.rb
+- lib/nemah/specific_need/protein.rb
+- lib/nemah/specific_need/salt.rb
+- lib/nemah/specific_need/selenium.rb
+- lib/nemah/specific_need/solids.rb
+- lib/nemah/version.rb
+- lib/nemah/workload.rb
+- nemah.gemspec
+- spec/nemah/horse_spec.rb
+- spec/nemah/need_spec.rb
+- spec/nemah/specific_need/calcium_spec.rb
+- spec/nemah/specific_need/energy_spec.rb
+- spec/nemah/specific_need/magnesium_spec.rb
+- spec/nemah/specific_need/phosphor_spec.rb
+- spec/nemah/specific_need/protein_spec.rb
+- spec/nemah/specific_need/salt_spec.rb
+- spec/nemah/specific_need/selenium_spec.rb
+- spec/nemah/specific_need/solids_spec.rb
+- spec/nemah/workload_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples_for_a_mineral.rb
+- spec/support/shared_examples_for_a_specific_need.rb
+homepage: https://github.com/Lavinia/Nemah
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Horse fodder calculations library.
+test_files:
+- spec/nemah/horse_spec.rb
+- spec/nemah/need_spec.rb
+- spec/nemah/specific_need/calcium_spec.rb
+- spec/nemah/specific_need/energy_spec.rb
+- spec/nemah/specific_need/magnesium_spec.rb
+- spec/nemah/specific_need/phosphor_spec.rb
+- spec/nemah/specific_need/protein_spec.rb
+- spec/nemah/specific_need/salt_spec.rb
+- spec/nemah/specific_need/selenium_spec.rb
+- spec/nemah/specific_need/solids_spec.rb
+- spec/nemah/workload_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples_for_a_mineral.rb
+- spec/support/shared_examples_for_a_specific_need.rb