nemah 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59e1b71fdd45cf09b6e19ad900d4c06ec6147e6d
-  data.tar.gz: 52ed2eb7953a641a03c5bf17a0e739d99211b184
+  metadata.gz: 1cf97baf48299379410e2eba6a236517e9f466c3
+  data.tar.gz: 164041b7b1042eaacabcbe5d08169d08c9cee769
 SHA512:
-  metadata.gz: d14843fe110208602459b8b29449fc4ab716c9f7d8619f883a57785dd65859f41d6545da30caaf024ddc7fb278f8526269454398e2b4030ecb5176dadcb6c319
-  data.tar.gz: 9ce324455ba1812396ebccfe661eb2c45bf44451874d0858b2adeb25d246b3ec7db13076f6aef1a9cbd0e7c990843664c7068bc063b7ed36178084c31cf170bd
+  metadata.gz: d3d16f09f03c521916efbf78140e8c6644eccfa664a7096462131a5612c96255fa08635b7a8cd01c07bbf60dd5a7a79a4bef02e42382ca41f5299638d46ce93f
+  data.tar.gz: f76931c24a2c49dd9ee521d508bf824d76fa34a6b6bbfb77dee2424c6fd8929b26bf4156967250619fe9578acfe3615facdb3caf63de6c92db645865004d9d29

data/.travis.yml

@@ -3,3 +3,5 @@ rvm:
   - ruby-head
   - 2.1.0
   - 2.0.0
+  - jruby-head
+

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in nemah.gemspec
 gemspec
+
+group :development, :test do
+  gem 'byebug', '~> 2.5', platforms: :mri
+end

data/README.md

@@ -4,7 +4,7 @@ Nemah is a library for calculating the proper amount of fodder for your horse. I
 
 ## Requirements
 
-Given that Nemah is an Arabian princess, she wants as many rubies as possible, but no fewer than 2.0.
+Given that Nemah is an Arabian princess, she wants as many rubies as possible, but no fewer than 2.0. Thus MRI and JRuby are supported, whereas Rubinius needs to [add support for keyword arguments](https://github.com/rubinius/rubinius/issues/2669).
 
 ## Installation.
 
@@ -22,18 +22,18 @@ Or install it yourself as:
 
 ## Usage
 
-### Initial version
+### Currently implemented functionality
 
-* Calculate a horse's need of energy, protein, solids, macrominerals, and selenium.
+* Calculate a working horse's need of energy, protein, solids, macrominerals, and selenium.
 * Calculations are made internally with at least three digits precision. Public methods will return values rounded to two decimals by default.
+* Balances, e.g. calcium-phosphor, protein-energy etc.
+* Rations, i.e. given a horse with a need, and a fodder list, does the horse get enough nutrients in proper balances?
 
 ### Yet to be implemented
 
-* Microminerals apart from selenium
-* Balances
-* Fodder
-* Rations
+* Microminerals and their specific balances apart from selenium.
 * Given a horse, its needs, and a list of fodder, calculate suitable rations.
+* Support horses with very specific needs, e.g. mares with foals, young horses, race horses etc.
 
 ## Contributing
 

data/lib/nemah.rb

@@ -1,2 +1,3 @@
+require 'nemah/nutrients'
 require 'nemah/specific_need/mineral_behaviour'
 Dir[File.join(File.dirname(__FILE__), 'nemah', '**', '*.rb')].sort.each { |file| require file }

data/lib/nemah/amount.rb

@@ -0,0 +1,18 @@
+module Nemah
+  class Amount
+    attr_reader :unit
+
+    def initialize(value, unit)
+      @value = value
+      @unit = unit
+    end
+
+    def value(specified_unit = unit)
+      if specified_unit == :kg && unit == :percent_per_kg
+        @value / 100.0
+      else
+        @value
+      end
+    end
+  end
+end

data/lib/nemah/fodder.rb

@@ -0,0 +1,18 @@
+module Nemah
+  class Fodder
+    attr_reader :name, *Nemah::Nutrients.names
+
+    def initialize(name, nutrients = {})
+      @name = name
+      set_nutrients nutrients
+    end
+
+    private
+
+    def set_nutrients(nutrients)
+      Nemah::Nutrients.default_input_unit_mappings.each do |nutrient, unit|
+        instance_variable_set "@#{nutrient}", Nemah::Amount.new(nutrients.fetch(nutrient, 0.0), unit)
+      end
+    end
+  end
+end

data/lib/nemah/fodder_list.rb

@@ -0,0 +1,45 @@
+module Nemah
+  class FodderList
+    def initialize(fodders = {})
+      self.fodders = Hash.new(0).merge fodders
+    end
+
+    def count
+      fodders.count
+    end
+
+    def amount_of(fodder)
+      fodders[fodder]
+    end
+
+    def add(fodder, amount = 0)
+      fodders[fodder] += amount
+      self
+    end
+
+    def remove(fodder, amount = :not_specified)
+      (amount == :not_specified) ? remove_fodder(fodder) : reduce_fodder(fodder, amount)
+      self
+    end
+
+    def to_h
+      fodders.dup
+    end
+
+    def each(&block)
+      fodders.each &block
+    end
+
+    private
+
+    attr_accessor :fodders
+
+    def reduce_fodder(fodder, amount)
+      fodders[fodder] = [fodders[fodder] - amount, 0].max
+    end
+
+    def remove_fodder(fodder)
+      fodders.delete_if { |key, _| key == fodder }
+    end
+  end
+end

data/lib/nemah/nutrients.rb

@@ -0,0 +1,20 @@
+module Nemah
+  class Nutrients
+    def self.default_input_unit_mappings
+      {
+        calcium: :g,
+        energy: :MJ,
+        magnesium: :g,
+        phosphor: :g,
+        protein: :g,
+        salt: :g,
+        selenium: :mg,
+        solids: :percent_per_kg
+      }
+    end
+
+    def self.names
+      default_input_unit_mappings.keys
+    end
+  end
+end

data/lib/nemah/ration.rb

@@ -0,0 +1,42 @@
+module Nemah
+  class Ration
+    attr_reader :fodder_list, :need
+
+    def initialize(need, fodder_list)
+      @need = need
+      @fodder_list = fodder_list
+    end
+
+    def balance(first_nutrient, second_nutrient)
+      total(first_nutrient) / total(second_nutrient)
+    end
+
+    def calcium_magnesium_in_balance?
+      (2.0..3.0).include? balance(:calcium, :magnesium)
+    end
+
+    def calcium_phosphor_in_balance?
+      (1.2..1.8).include? balance(:calcium, :phosphor)
+    end
+
+    def protein_energy_in_balance?
+      balance(:protein, :energy) >= 6.0
+    end
+
+    Nemah::Nutrients.names.each do |nutrient|                     # def enough_nutrient?
+      define_method("enough_#{nutrient}?") { enough?(nutrient) }  #   enough?(:nutrient)
+    end                                                           # end
+
+    private
+
+    def enough?(nutrient)
+      need.public_send(nutrient).min <= total(nutrient)
+    end
+
+    def total(nutrient)
+      fodder_list.each.inject(0) do |total, (fodder, amount)|
+        total += amount * fodder.public_send(nutrient).value(need.public_send(nutrient).unit)
+      end
+    end
+  end
+end

data/lib/nemah/specific_need/abstract_need.rb

@@ -23,6 +23,10 @@ module Nemah
         min(decimals: decimals)..max(decimals: decimals)
       end
 
+      def to_s
+        "#{min} #{unit}"
+      end
+
       def unit
         :g
       end

data/lib/nemah/version.rb

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

data/nemah.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |spec|
   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'

data/spec/nemah/amount_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Nemah::Amount do
+  describe '#unit' do
+    it 'returns the unit portion of the amount' do
+      amount = Nemah::Amount.new(5.5, :kg)
+      expect(amount.unit).to eq :kg
+    end
+  end
+
+  describe '#value' do
+    it 'returns the value portion of the amount' do
+      amount = Nemah::Amount.new(5.5, :kg)
+      expect(amount.value).to eq 5.5
+    end
+
+    it 'can convert from percent of kilograms to kilograms' do
+      amount = Nemah::Amount.new(60.0, :percent_per_kg)
+      expect(amount.value(:kg)).to eq 0.60
+    end
+  end
+end

data/spec/nemah/fodder_list_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Nemah::FodderList do
+  let(:fodder) { Nemah::Fodder.new('hay') }
+
+  it 'contains no fodders by default' do
+    fodder_list = build_fodder_list
+    expect(fodder_list.count).to eq 0
+  end
+
+  describe '#amount_of' do
+    it 'returns the amount of a given fodder' do
+      fodder_list = build_fodder_list(fodder => 5)
+      expect(fodder_list.amount_of fodder).to eq 5
+    end
+
+    it 'returns zero if the fodder is not in the list' do
+      fodder_list = build_fodder_list
+      expect(fodder_list.amount_of :non_existing_fodder).to eq 0
+    end
+  end
+
+  describe '#add' do
+    subject(:fodder_list) { build_fodder_list }
+
+    it 'adds a fodder to the list' do
+      fodder_list.add fodder
+      expect(fodder_list.count).to eq 1
+    end
+
+    it 'adds a specified amount of fodder to the list' do
+      fodder_list.add fodder, 0.5
+      expect(fodder_list.amount_of fodder).to eq 0.5
+    end
+
+    it 'increases the amount of a fodder already in the list' do
+      fodder_list.add fodder, 1
+      fodder_list.add fodder, 2
+      expect(fodder_list.amount_of fodder).to eq 3
+    end
+
+    it 'returns the fodder list' do
+      expect(fodder_list.add(fodder, 0.5)).to eq fodder_list
+    end
+  end
+
+  describe '#remove' do
+    subject(:fodder_list) { build_fodder_list(fodder => 5) }
+
+    it 'removes the fodder from the list if no amount is specified' do
+      fodder_list.remove fodder
+      expect(fodder_list.count).to eq 0
+    end
+
+    it 'removes the given amount of a fodder, without removing the fodder from the list' do
+      fodder_list.remove(fodder, 1.5)
+      expect(fodder_list.amount_of fodder).to eq 3.5
+    end
+
+    it 'does not reduce the amount below zero' do
+      fodder_list.remove(fodder, 100)
+      expect(fodder_list.amount_of fodder).to eq 0
+    end
+
+    it 'returns the fodder list' do
+      expect(fodder_list.remove fodder).to eq fodder_list
+    end
+  end
+
+  describe '#to_h' do
+    let(:fodders) { { fodder => 10.0 } }
+    subject(:fodder_list) { build_fodder_list(fodders) }
+
+    it 'returns a hash representation of the list' do
+      expect(fodder_list.to_h).to eq fodders
+    end
+
+    it 'changing the hash does not change the fodder list' do
+      fodder_list.to_h[fodder] = 0
+      expect(fodder_list.amount_of(fodder)).to eq 10.0
+    end
+  end
+
+  describe '#each' do
+    subject(:fodder_list) { build_fodder_list(fodder => 5.0) }
+
+    it 'returns an enumerator for the list when not given a block' do
+      expect(fodder_list.each.next).to eq [fodder, 5.0]
+    end
+
+    it 'yields the fodder and amount pairs in the list when given a block' do
+      yielded_fodder_and_amount = :not_set
+      fodder_list.each { |fodder_and_amount| yielded_fodder_and_amount = fodder_and_amount  }
+
+      expect(yielded_fodder_and_amount).to eq [fodder, 5.0]
+    end
+  end
+end
+
+def build_fodder_list(fodders = {})
+  Nemah::FodderList.new(fodders)
+end

data/spec/nemah/fodder_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+shared_examples_for 'a nutrient' do
+  it 'returns 0.0 by default' do
+    expect(build_fodder.send(nutrient).value).to eq 0.0
+  end
+
+  it 'returns the amount of the nutrient' do
+    fodder = build_fodder(nutrient => 1.5)
+    expect(fodder.send(nutrient).value).to eq 1.5
+  end
+
+  it 'returns the nutrient unit' do
+    fodder = build_fodder(nutrient => 1.5)
+    expect(fodder.send(nutrient).unit).to eq unit
+  end
+end
+
+describe Nemah::Fodder do
+  def build_fodder(nutrients = {})
+    Nemah::Fodder.new('hay', nutrients)
+  end
+
+  it 'has a name' do
+    expect(build_fodder.name).to eq 'hay'
+  end
+
+  describe '#calcium' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :calcium }
+      let(:unit) { :g }
+    end
+  end
+
+  describe '#energy' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :energy }
+      let(:unit) { :MJ }
+    end
+  end
+
+  describe '#magnesium' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :magnesium }
+      let(:unit) { :g }
+    end
+  end
+
+  describe '#phosphor' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :phosphor }
+      let(:unit) { :g }
+    end
+  end
+
+  describe '#protein' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :protein }
+      let(:unit) { :g }
+    end
+  end
+
+  describe '#salt' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :salt }
+      let(:unit) { :g }
+    end
+  end
+
+  describe '#selenium' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :selenium }
+      let(:unit) { :mg }
+    end
+  end
+
+  describe '#solids' do
+    it_behaves_like 'a nutrient' do
+      let(:nutrient) { :solids }
+      let(:unit) { :percent_per_kg }
+    end
+
+    it 'returns the amount of solids in kilograms if specified' do
+      fodder = build_fodder(solids: 67.5)
+      expect(fodder.solids.value(:kg)).to eq 0.675
+    end
+  end
+end

data/spec/nemah/ration_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+shared_examples_for 'a nutrient requirement' do
+  it "returns true when the horse's nutrient need is met" do
+    expect(ration.public_send("enough_#{nutrient}?")).to be_true
+  end
+
+  it 'returns false when the nutrient need is not met' do
+    expect(ration(0.1).public_send("enough_#{nutrient}?")).to be_false
+  end
+
+  def ration(modifier = 0)
+    nutrient_need = double(nutrient.to_s, min: nutrient_min + modifier, unit: nutrient_unit)
+    need = double('need', nutrient => nutrient_need)
+    fodder_list = Nemah::FodderList.new(fodders)
+    ration = Nemah::Ration.new(need, fodder_list)
+  end
+end
+
+describe Nemah::Ration do
+  describe '#enough_calcium?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :calcium }
+      let(:nutrient_min) { 35.6 }
+      let(:nutrient_unit) { :g }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 3.56 }) => 10 } }
+    end
+  end
+
+  describe '#enough_energy?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :energy }
+      let(:nutrient_min) { 65 }
+      let(:nutrient_unit) { :MJ }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 6.5 }) => 10 } }
+    end
+  end
+
+  describe '#enough_magnesium?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :magnesium }
+      let(:nutrient_min) { 25 }
+      let(:nutrient_unit) { :g }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 2.5 }) => 10 } }
+    end
+  end
+
+  describe '#enough_phosphor?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :phosphor }
+      let(:nutrient_min) { 24.4 }
+      let(:nutrient_unit) { :g }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 2.44 }) => 10 } }
+    end
+  end
+
+  describe '#enough_protein?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :protein }
+      let(:nutrient_min) { 330 }
+      let(:nutrient_unit) { :g }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 33 }) => 10 } }
+    end
+  end
+
+  describe '#enough_salt?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :salt }
+      let(:nutrient_min) { 7.8 }
+      let(:nutrient_unit) { :g }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 0.78 }) => 10 } }
+    end
+  end
+
+  describe '#enough_selenium?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :selenium }
+      let(:nutrient_min) { 12.1 }
+      let(:nutrient_unit) { :mg }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 1.21 }) => 10 } }
+    end
+  end
+
+  describe '#enough_solids?' do
+    it_behaves_like 'a nutrient requirement' do
+      let(:nutrient) { :solids }
+      let(:nutrient_min) { 7 }
+      let(:nutrient_unit) { :kg }
+      let(:fodders) { { Nemah::Fodder.new('hay', { nutrient => 70 }) => 10 } }
+    end
+  end
+
+  shared_examples_for 'a balance' do
+    let(:need) do
+      double('fake_need',
+        first_nutrient.name => double(first_nutrient.name.to_s, unit: first_nutrient.unit),
+        second_nutrient.name => double(second_nutrient.name.to_s, unit: second_nutrient.unit))
+    end
+
+    it 'returns true when the ratio is the lowest allowed' do
+      expect(ration(allowed.first).public_send("#{balance}_in_balance?")).to be_true
+    end
+
+    it 'returns true when the ratio is the highest allowed' do
+      expect(ration(allowed.last).public_send("#{balance}_in_balance?")).to be_true
+    end
+
+    it 'returns false when the ratio is below the allowed range' do
+      expect(ration(allowed.first - 0.01).public_send("#{balance}_in_balance?")).to be_false
+    end
+
+    it 'returns false when the ratio is above the allowed range' do
+      expect(ration(allowed.last + 0.01).public_send("#{balance}_in_balance?")).to be_false
+    end
+
+    private
+
+    def ration(value)
+      fodder_list = Nemah::FodderList.new({ Nemah::Fodder.new('hay', { first_nutrient.name => value, second_nutrient.name => 1 }) => 5 })
+      Nemah::Ration.new(need, fodder_list)
+    end
+  end
+
+  describe '#calcium_magnesium_in_balance?' do
+    it_behaves_like 'a balance' do
+      let(:balance) { :calcium_magnesium }
+      let(:first_nutrient) { double(name: :calcium, unit: :g) }
+      let(:second_nutrient) { double(name: :magnesium, unit: :g) }
+      let(:allowed) { 2.0..3.0 }
+    end
+  end
+
+  describe '#calcium_phosphor_in_balance?' do
+    it_behaves_like 'a balance' do
+      let(:balance) { :calcium_phosphor }
+      let(:first_nutrient) { double(name: :calcium, unit: :g) }
+      let(:second_nutrient) { double(name: :phosphor, unit: :g) }
+      let(:allowed) { 1.2..1.8 }
+    end
+  end
+
+  describe '#protein_energy_in_balance?' do
+    it 'returns true when at least 6g protein per MJ energy' do
+      expect(ration(protein: 6.0).protein_energy_in_balance?).to be_true
+    end
+
+    it 'returns false when less than 6g protein per MJ energy' do
+      expect(ration(protein: 5.9).protein_energy_in_balance?).to be_false
+    end
+
+    def ration(protein: :not_specified)
+      need = double('fake_need', energy: double('energy', unit: :MJ), protein: double('protein', unit: :g))
+      fodder_list = Nemah::FodderList.new({ Nemah::Fodder.new('hay', { :energy => 1, :protein => protein }) => 5 })
+      ration = Nemah::Ration.new(need, fodder_list)
+    end
+  end
+
+  describe 'balance' do
+    it 'returns the calcium-magnesium balance' do
+      expect(ration.balance(:calcium, :magnesium)).to eq 1.3
+    end
+
+    it 'returns the calcium-phosphor balance' do
+      expect(ration.balance(:calcium, :phosphor)).to eq 2.0
+    end
+
+    def ration
+      need = double('fake_need', calcium: double('calcium', unit: :g), magnesium: double('magnesium', unit: :g), phosphor: double('phosphor', unit: :g))
+      fodder_list = Nemah::FodderList.new({ Nemah::Fodder.new('hay', { calcium: 2.6, magnesium: 2.0, phosphor: 1.3 }) => 5 })
+      Nemah::Ration.new(need, fodder_list)
+    end
+  end
+end

data/spec/nemah/specific_need/abstract_need_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+class FakeNeed < Nemah::SpecificNeed::AbstractNeed
+  def min
+    78.67
+  end
+
+  def unit
+    'ghostscreams'
+  end
+end
+
+describe Nemah::SpecificNeed::AbstractNeed do
+  describe '#to_s' do
+    let(:fake_need) { FakeNeed.new(double) }
+
+    it 'combines the minimum need with the unit' do
+      expect(fake_need.to_s).to eq '78.67 ghostscreams'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,10 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+begin
+  require 'byebug'
+rescue LoadError
+  puts 'byebug not available'
+end
+
 require 'nemah'
 Dir['./spec/support/**/*.rb'].sort.each { |file| require file }
-require 'byebug'

data/spec/support/shared_examples_for_a_specific_need.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nemah
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kim Persson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-02 00:00:00.000000000 Z
+date: 2014-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,20 +25,6 @@ dependencies:
     - - "~>"
       - !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
@@ -112,8 +98,13 @@ files:
 - README.md
 - Rakefile
 - lib/nemah.rb
+- lib/nemah/amount.rb
+- lib/nemah/fodder.rb
+- lib/nemah/fodder_list.rb
 - lib/nemah/horse.rb
 - lib/nemah/need.rb
+- lib/nemah/nutrients.rb
+- lib/nemah/ration.rb
 - lib/nemah/specific_need/abstract_need.rb
 - lib/nemah/specific_need/calcium.rb
 - lib/nemah/specific_need/energy.rb
@@ -127,8 +118,13 @@ files:
 - lib/nemah/version.rb
 - lib/nemah/workload.rb
 - nemah.gemspec
+- spec/nemah/amount_spec.rb
+- spec/nemah/fodder_list_spec.rb
+- spec/nemah/fodder_spec.rb
 - spec/nemah/horse_spec.rb
 - spec/nemah/need_spec.rb
+- spec/nemah/ration_spec.rb
+- spec/nemah/specific_need/abstract_need_spec.rb
 - spec/nemah/specific_need/calcium_spec.rb
 - spec/nemah/specific_need/energy_spec.rb
 - spec/nemah/specific_need/magnesium_spec.rb
@@ -161,13 +157,18 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.0.rc.1
 signing_key: 
 specification_version: 4
 summary: Horse fodder calculations library.
 test_files:
+- spec/nemah/amount_spec.rb
+- spec/nemah/fodder_list_spec.rb
+- spec/nemah/fodder_spec.rb
 - spec/nemah/horse_spec.rb
 - spec/nemah/need_spec.rb
+- spec/nemah/ration_spec.rb
+- spec/nemah/specific_need/abstract_need_spec.rb
 - spec/nemah/specific_need/calcium_spec.rb
 - spec/nemah/specific_need/energy_spec.rb
 - spec/nemah/specific_need/magnesium_spec.rb