ski_binding_calculator 0.6.1 → 0.6.5

data/lib/ski_binding_calculator/calculator.rb

@@ -22,8 +22,7 @@ class SkiBinding::Calculator
       hashy[:shoe_size] = attrs[:shoe_size].to_f || attrs["shoe_size"].to_f
       hashy[:birthday] = attrs[:birthday] || attrs["birthdate"]
       hashy[:type] = attrs[:type] || attrs["type"]
-      attrs = hashy
-      attrs
+      hashy
     end
     
     def self.age(attrs)
@@ -82,7 +81,7 @@ class SkiBinding::Calculator
       settings.each do |s|
         if s.shoe_size_range.include?(attrs[:shoe_size])
           unless s.z_value.nil?
-            return {"z_value" => s.z_value}
+            return {:z_value => s.z_value}
           else
             raise ArgumentError, "Please calculate z-index by hand."
           end

data/ski_binding_calculator.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name        = 'ski_binding_calculator'
-  s.version     = '0.6.1'
+  s.version     = '0.6.5'
   s.summary     = "Ski Binding Calculator"
   s.description = "Calculates the z-value according to ISO 11088."
   s.authors     = ["Jonas Ruef, Felix Langenegger"]
@@ -13,6 +13,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "spork", "~> 0.9.2"
   s.add_development_dependency "simplecov", "~> 0.7.1"
   s.add_development_dependency "timecop", "~> 0.6.3"
+  s.add_development_dependency "fuubar", "~> 1.1.1"
 
   s.files =  Dir.glob("{config,lib,spec}/**/*")
   s.files += %w(Rakefile ski_binding_calculator.gemspec)

data/spec/lib/calculator_spec.rb

@@ -1,144 +1,170 @@
 require 'spec_helper'
 require 'timecop'
 
+# The scenario: according to table B.1 in ISO 11088 a skier which is
+# type 2, 70 kg of weight, 170cm of height, has a sole length of 
+# 315mm, and is born 01/01/1983 has code "L" or in our notation 11 
+# (see readme for details on codes). Furthermore it's z_value is 6.
 describe SkiBinding::Calculator do
+  subject(:skiers_parameters) do
+    { :type => "Type2", 
+     :weight => "70", 
+     :height => "170", 
+     :shoe_size => "315", 
+     :birthday => "1983-01-01" }  
+  end
+  subject(:expected_preped) do
+    { :type => "Type2", 
+     :weight => 70.0, 
+     :height => 170.0, 
+     :shoe_size => 315.0, 
+     :birthday => "1983-01-01" }  
+  end
+  subject(:expected_aged) do
+    { :type => "Type2", 
+     :weight => 70.0, 
+     :height => 170.0, 
+     :shoe_size => 315.0, 
+     :age => 30 }  
+  end
+  subject(:expected_validated) do
+    { :type => 1, 
+     :weight => 70.0, 
+     :height => 170.0, 
+     :shoe_size => 315.0, 
+     :age => 30 }  
+  end
+  subject(:expected_code) { 11 }
+  subject(:expected_setting) do
+    { :z_value => 6 }
+  end
+  
   before(:all) do
-    @hash = {:type => "Type2", 
-             :weight => "70", 
-             :height => "170", 
-             :shoe_size => "315", 
-             :birthday => "1983-01-01"}  
-    #We freeze time so birthday will always be 30 years back
+    #freeze time! so birthday will always be 30 years back
     Timecop.freeze(2013, 8, 13)                  
   end
 
   describe "#new" do
-    it "returns a BindingCalculator class" do
-      SkiBinding::Calculator.new.class.should == SkiBinding::Calculator
-    end
+    it { SkiBinding::Calculator.new.class.should == SkiBinding::Calculator }
   end
   
   describe "#prep_attributes" do
-    it "returns a valid hash" do
-      expected_hash = {:type => "Type2", 
-                       :weight => 70.0, 
-                       :height => 170.0, 
-                       :shoe_size => 315.0, 
-                       :birthday => "1983-01-01"}
-      SkiBinding::Calculator.prep_attributes(@hash).should == expected_hash
-    end
+    subject(:calculated_preped) { SkiBinding::Calculator.prep_attributes(parameters) }
+    let(:parameters) { skiers_parameters }
+    
+    it { calculated_preped.should == expected_preped }
     
-    it "returns argument error if weight < 10kg" do
-      @hash[:weight] = "9"
-      expect { SkiBinding::Calculator.prep_attributes(@hash) }
-      .to raise_error(ArgumentError, "Weight must be at least 10kg")
-      @hash[:weight] = "70"
+    context "when weight < 10kg" do
+      let(:parameters) do
+        skiers_parameters[:weight] = 9 
+        skiers_parameters
+      end
+      it { expect { calculated_preped }
+           .to raise_error(ArgumentError, "Weight must be at least 10kg") }
     end
   end
   
   describe "#age" do
-    before(:all) do
-      @preped_hash = SkiBinding::Calculator.prep_attributes(@hash)
-    end
+    subject(:calculated_aged) { SkiBinding::Calculator.age(preped) }
+    let(:preped) { expected_preped }
     
-    it "returns a hash with an age" do
-      result = SkiBinding::Calculator.age(@preped_hash)
-      result[:age].should == 30
-    end
+    it { calculated_aged.should == expected_aged }
   end
   
   describe "#validate_type" do
-    before :all do
-      preped_hash = SkiBinding::Calculator.prep_attributes(@hash)
-      @aged_hash = SkiBinding::Calculator.age(preped_hash)
-    end
+    subject(:calculated_validated) { SkiBinding::Calculator.validate_type(aged) }
+    let(:aged) { expected_aged }
     
     it "sets \"Type2\" to 1" do
-      result = SkiBinding::Calculator.validate_type(@aged_hash)
-      result[:type].should == 1
+      calculated_validated.should == expected_validated
     end
     
-    it "raises argument error on type \"unknown\"" do
-      wrong_aged_hash = {:type => "unknown", 
-               :weight => 70, 
-               :height => 170, 
-               :shoe_size => 315, 
-               :age => 30}
-      expect { SkiBinding::Calculator.validate_type(wrong_aged_hash) }
-      .to raise_error(ArgumentError, "You have entered an invalid type.")
+    context "when type is \"unknown\"" do
+      let(:aged) do
+        expected_aged[:type] = "unknown"
+        expected_aged
+      end
+      
+      it{ expect { calculated_validated }
+          .to raise_error(ArgumentError, "You have entered an invalid type.") }
     end
   end
      
-  
   describe "#binding_code" do
-    before :each do
-      preped_hash = SkiBinding::Calculator.prep_attributes(@hash)
-      aged_hash = SkiBinding::Calculator.age(preped_hash)
-      @type_validated_hash = SkiBinding::Calculator.validate_type(aged_hash)
-    end
+    subject(:calculated_code) { SkiBinding::Calculator.binding_code(validated) }
+    let(:validated) { expected_validated }
     
-    it "returns a valid code" do
-      SkiBinding::Calculator.binding_code(@type_validated_hash).should == 11
-    end
+    it{ calculated_code.should == 11 }
     
-    it "returns unchanged code if weight less than 13kg" do
-      # because we set "Type2" the code would be changed by 1
-      @type_validated_hash[:weight] = 12 
-      SkiBinding::Calculator.binding_code(@type_validated_hash).should == 0
+    context "when weight < 13kg" do
+      let(:validated) do
+        expected_validated[:weight] = 12
+        expected_validated
+      end
+      #because "Type 2" is given the code would be changed to 1
+      it{ calculated_code.should == 0 }
     end
     
-    it "raises argumentError if no code was found" do
-      @type_validated_hash[:weight] = -1
-      @type_validated_hash[:height] = -1
-      expect { SkiBinding::Calculator.binding_code(@type_validated_hash) }
-      .to raise_error(ArgumentError, "You have entered invalid weight and/or height")
+    context "when no code found" do
+      let(:validated) do 
+        expected_validated[:weight] = -1
+        expected_validated[:height] = -1
+        expected_validated
+      end
+      
+      it { expect { calculated_code }.
+           to raise_error(ArgumentError, "You have entered invalid weight and/or height") }
     end
     
-    context "returns code one less if age >= 50 || age < 10" do
-      before :each do
-        preped_hash = SkiBinding::Calculator.prep_attributes(@hash)
-        aged_hash = SkiBinding::Calculator.age(preped_hash)
-        @type_validated_hash_age_context = SkiBinding::Calculator.validate_type(aged_hash)
-        @code = SkiBinding::Calculator.binding_code(@type_validated_hash_age_context)
+    context "when age >= 50 || age < 10" do             
+      context "age is 50" do
+        let(:validated) do
+          expected_validated[:age] = 50
+          expected_validated
+        end
+        
+        it { calculated_code.should == (expected_code - 1) }                                  
       end
       
-      it "age is 50" do
-        @type_validated_hash_age_context[:age] = 50
-        lambda { @code = SkiBinding::Calculator.binding_code(@type_validated_hash_age_context) }
-                                              .should change{@code}.by(-1)                                  
+      context "age is 51" do
+        let(:validated) do
+          expected_validated[:age] = 51
+          expected_validated
+        end
+        
+        it { calculated_code.should == (expected_code - 1) }
       end
       
-      it "age is 51" do
-        @type_validated_hash_age_context[:age] = 51
-        lambda { @code = SkiBinding::Calculator.binding_code(@type_validated_hash_age_context) }
-                                              .should change{@code}.by(-1)
+      context "age is 9" do
+        let(:validated) do
+          expected_validated[:age] = 9
+          expected_validated
+        end
+        
+        it { calculated_code.should == (expected_code - 1) }
       end
     end
   end
-  
+ 
   describe "#binding_setting" do
-    before :each do
-      preped_hash = SkiBinding::Calculator.prep_attributes(@hash)
-      aged_hash = SkiBinding::Calculator.age(preped_hash)
-      @type_validated_hash = SkiBinding::Calculator.validate_type(aged_hash)
-    end
+    subject(:calculated_setting) { SkiBinding::Calculator.binding_setting(validated, binding_code) }
+    let(:binding_code) { expected_code }
+    let(:validated) { expected_validated }
     
-    it "returns a valid setting" do
-      SkiBinding::Calculator.binding_setting(@type_validated_hash, 11).should == 
-      {"z_value"=>6}
-    end
+    it{ calculated_setting.should == expected_setting }
     
-    it "raises argument error if no settings found" do
-      expect { SkiBinding::Calculator.binding_setting(@type_validated_hash, 0) }
-      .to raise_error(ArgumentError, "Please calculate z-index by hand.")
+    context "when no setting found" do
+      let(:binding_code) { 0 }
+      it{ expect { calculated_setting }
+          .to raise_error(ArgumentError, "Please calculate z-index by hand.") }
     end
   end
-  
+ 
   describe "#setting" do
-    it "returns a valid setting" do
-      SkiBinding::Calculator.setting(@hash).should == 
-      {"z_value"=>6}
-    end
+    subject(:all_at_once_calculated) { SkiBinding::Calculator.setting(parameters) }
+    let(:parameters) { skiers_parameters }
+    
+    it{ all_at_once_calculated.should == expected_setting }
   end
   
   after(:all) do

data/spec/lib/code_spec.rb

@@ -7,18 +7,9 @@ describe SkiBinding::Code do
     end
   end
     
-  context "instantiated Code class" do
-    before :all do
-      @code = SkiBinding::Code.new
-    end
-    
-    it "has attribute weight" do
-      @code.should respond_to :weight
-    end
-    
-    it "has attribute heigth" do
-      @code.should respond_to :height
-    end
+  context "when instantiated Code class" do
+    it { should respond_to :weight }
+    it { should respond_to :height }
   end
 end
 

data/spec/lib/config_loader_spec.rb

@@ -1,69 +1,33 @@
 require 'spec_helper'
 
+# For original table with codes referred to in this tests see iso 11088 
+# Table B.1
 describe "ConfigLoader" do 
-
-  before(:all) do
-    @range = 0..15 #cause 16 settings
-    @dummy_class = DummyClass.new
-    @dummy_class.extend(SkiBinding::ConfigLoader)
-  end
+  subject(:dummy_class) { DummyClass.new.extend(SkiBinding::ConfigLoader) }
 
   describe "loading binding codes:" do
-    it "something gets loaded" do
-      @dummy_class.load_binding_codes.class.should_not == nil
-    end
+    it { dummy_class.load_binding_codes.class.should_not == nil }
     
-    context "loaded codes" do
-      before :all do
-        @codes = @dummy_class.load_binding_codes
-      end
-      
-      it "is array" do
-        @codes.class.should == Array
-      end
+    context "when loaded codes" do
+      subject(:codes) { dummy_class.load_binding_codes }
       
-      it "first element is code" do
-        @codes[0].class.should == SkiBinding::Code
-      end
-      
-      it "has 15 codes" do
-        @codes.size.should == 13
-      end
+      it{ codes.class.should == Array }
+      it{ codes[0].class.should == SkiBinding::Code }
+      it{ codes.size.should == 13 }
     end
   end
   
   describe "loading binding settings for all codes" do
-    it "something gets loaded" do
-      @range.each do |index|
-        @dummy_class.load_binding_settings(index).class.should_not == nil
-      end
+    subject(:settings_all_codes) do
+      settings = []
+      (0..15).each { |i| settings << dummy_class.load_binding_settings(i) }
+      settings
     end
     
-    context "loaded settings for each code" do
-      before :all do
-        @settings_all_codes = []
-        @range.each do |index|
-          @settings_all_codes << @dummy_class.load_binding_settings(index)
-        end
-      end
-      
-      it "is array" do
-        @settings_all_codes.each do |s|
-          s.class.should == Array
-        end
-      end
-      
-      it "first element is setting" do
-        @settings_all_codes.each do |s|
-          s[0].class.should == SkiBinding::Setting
-        end
-      end
-      
-      it "has 6 settings" do
-        @settings_all_codes.each do |s|
-         s.size.should == 8
-        end
-      end
+    context "for each code" do
+      it { settings_all_codes.each { |s| s.class.should == Array } }
+      it { settings_all_codes.each { |s| s[0].class.should == SkiBinding::Setting } }
+      it { settings_all_codes.each { |s| s.size.should == 8 } }
     end
   end
 end

data/spec/lib/setting_spec.rb

@@ -7,25 +7,10 @@ describe SkiBinding::Setting do
     end
   end
     
-  context "instantiated Setting class" do
-    before :all do
-      @setting = SkiBinding::Setting.new
-    end
-    
-    it "has attribute shoe_size_range" do
-      @setting.should respond_to :shoe_size_range
-    end
-    
-    it "has attribute z_value" do
-      @setting.should respond_to :z_value
-    end
-    
-    it "has attribute twist" do
-      @setting.should respond_to :twist
-    end
-    
-    it "has attribute forward_lean" do
-      @setting.should respond_to :forward_lean
-    end
+  context "when instantiated Setting class" do
+    it { should respond_to :shoe_size_range }
+    it { should respond_to :z_value }
+    it { should respond_to :twist }
+    it { should respond_to :forward_lean }
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ski_binding_calculator
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -75,6 +75,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
 description: Calculates the z-value according to ISO 11088.
 email: support@fadendaten.ch
 executables: []