gravitheque 0.3.0 → 0.4.0

data/test/calculators/test_alcohol.rb

@@ -4,32 +4,55 @@ require "calculators/alcohol"
 describe Calculate do
 
   it "must calculate alcohol by weight from original and terminal Plato" do
-    (Calculate.alcohol_by_weight 13, 2.5).must_equal 4.5
+    Calculate.alcohol_by_weight({ original: 13, terminal: 2.5 }).must_equal 4.5
   end
 
   it "must calculate alcohol by weight from original and terminal gravities" do
-    (Calculate.alcohol_by_weight 1.055, 1.011, :specific_gravity).must_equal 4.6
+    Calculate.alcohol_by_weight({
+      original: 1.055,
+      terminal: 1.011
+    }, :specific_gravity).must_equal 4.6
   end
 
   it "must calculate alcohol by weight from original and terminal Brix" do
-    (Calculate.alcohol_by_weight 15.5, 7.2, :brix).must_equal 5.9
+    Calculate.alcohol_by_weight({
+      original: 15.5,
+      terminal: 7.2
+    }, :brix).must_equal 5.9
   end
 
   it "must calculate alcohol by volume from original and terminal Plato" do
-    (Calculate.alcohol_by_volume 13, 2.5).must_equal 5.7
+    Calculate.alcohol_by_volume({ original: 13, terminal: 2.5 }).must_equal 5.7
   end
 
   it "must calculate alcohol by volume from original and terminal gravities" do
-    (Calculate.alcohol_by_volume 1.055, 1.011, :specific_gravity).must_equal 5.8
+    Calculate.alcohol_by_volume({
+      original: 1.055,
+      terminal: 1.011
+    }, :specific_gravity).must_equal 5.8
   end
 
   it "must calculate alcohol by volume from original and terminal Brix" do
-    (Calculate.alcohol_by_volume 15.5, 7.2, :brix).must_equal 7.4
+    Calculate.alcohol_by_volume({
+      original: 15.5,
+      terminal: 7.2
+    }, :brix).must_equal 7.4
   end
 
   it "must raise an exception when the extract unit is unrecognized" do
-    lambda { Calculate.alcohol_by_volume 392, 739, :wtf? }.must_raise ArgumentError
-    lambda { Calculate.alcohol_by_weight 392, 739, :wtf? }.must_raise ArgumentError
+    lambda {
+      Calculate.alcohol_by_volume({
+        original: 392,
+        terminal: 739
+      }, :wtf)
+    }.must_raise ArgumentError
+
+    lambda {
+      Calculate.alcohol_by_weight({
+        original: 392,
+        terminal: 739
+      }, :wtf)
+    }.must_raise ArgumentError
   end
 
 end

data/test/calculators/test_calories.rb

@@ -4,45 +4,86 @@ require "calculators/calories"
 describe Calculate do
 
   it "must calculate calories from alcohol using original and terminal Plato" do
-    (Calculate.calories_from_alcohol 13, 2.5).must_equal 151
+    Calculate.calories_from_alcohol({ original: 13, terminal: 2.5 }).must_equal 151
   end
 
   it "must calculate calories from alcohol using original and terminal gravities" do
-    (Calculate.calories_from_alcohol 1.05, 1.01, :specific_gravity).must_equal 139
+    Calculate.calories_from_alcohol({
+      original: 1.05,
+      terminal: 1.01
+    }, :specific_gravity).must_equal 139
   end
 
   it "must calculate calories from alcohol using original and terminal Brix" do
-    (Calculate.calories_from_alcohol 15.5, 7.2, :brix).must_equal 81
+    Calculate.calories_from_alcohol({
+      original: 15.5,
+      terminal: 7.2
+    }, :brix).must_equal 202
   end
 
   it "must calculate calories from extract using original and terminal Plato" do
-    (Calculate.calories_from_extract 13, 2.5).must_equal 83
+    Calculate.calories_from_extract({
+      original: 13,
+      terminal: 2.5
+    }).must_equal 83
   end
 
   it "must calculate calories from extract using original and terminal gravities" do
-    (Calculate.calories_from_extract 1.05, 1.01, :specific_gravity).must_equal 80
+    Calculate.calories_from_extract({
+      original: 1.05,
+      terminal: 1.01
+    }, :specific_gravity).must_equal 80
   end
 
   it "must calculate calories from extract using original and terminal Brix" do
-    (Calculate.calories_from_extract 15.5, 7.2, :brix).must_equal 224
+    Calculate.calories_from_extract({
+      original: 15.5,
+      terminal: 7.2
+    }, :brix).must_equal 80
   end
 
   it "must calculate calories per serving using original and terminal Plato" do
-    (Calculate.calories_per_serving 13, 2.5).must_equal 234
+    Calculate.calories_per_serving({
+      original: 13,
+      terminal: 2.5
+    }).must_equal 234
   end
 
   it "must calculate calories per serving using original and terminal gravities" do
-    (Calculate.calories_per_serving 1.05, 1.01, :specific_gravity).must_equal 219
+    Calculate.calories_per_serving({
+      original: 1.05,
+      terminal: 1.01
+    }, :specific_gravity).must_equal 219
   end
 
   it "must calculate calories per serving using original and terminal Brix" do
-    (Calculate.calories_per_serving 15.5, 7.2, :brix).must_equal 305
+    Calculate.calories_per_serving({
+      original: 15.5,
+      terminal: 7.2
+    }, :brix).must_equal 282
   end
 
   it "must raise an exception when the extract unit is unrecognized" do
-    lambda { Calculate.calories_from_alcohol 392, 739, :wtf? }.must_raise ArgumentError
-    lambda { Calculate.calories_from_extract 392, 739, :wtf? }.must_raise ArgumentError
-    lambda { Calculate.calories_per_serving  392, 739, :wtf? }.must_raise ArgumentError
+    lambda {
+      Calculate.calories_from_alcohol({
+        original: 392,
+        terminal: 739
+      }, :wtf)
+    }.must_raise ArgumentError
+
+    lambda {
+      Calculate.calories_from_extract({
+        original: 392,
+        terminal: 739
+      }, :wtf)
+    }.must_raise ArgumentError
+
+    lambda {
+      Calculate.calories_per_serving({
+        original: 392,
+        terminal: 739
+      }, :wtf)
+    }.must_raise ArgumentError
   end
 
 end

data/test/calculators/test_hops.rb

@@ -20,15 +20,24 @@ describe Calculate do
   end
 
   it "must calculate hop utilization from Plato" do
-    (Calculate.hop_utilization 15, 60).must_equal 0.21
+    Calculate.hop_utilization({
+      at: 60,
+      extract: 15
+    }).must_equal 0.21
   end
 
   it "must calculate hop utilization from Brix" do
-    (Calculate.hop_utilization 12, 30, :brix).must_equal 0.18
+    Calculate.hop_utilization({
+      at: 30,
+      extract: 12
+    }, :brix).must_equal 0.18
   end
 
   it "must calculate hop utilization from specific gravity" do
-    (Calculate.hop_utilization 1.065, 10, :specific_gravity).must_equal 0.07
+    Calculate.hop_utilization({
+      at: 10,
+      extract: 1.065
+    }, :specific_gravity).must_equal 0.07
   end
 
   it "must calculate IBUs from hop addition using Plato" do
@@ -48,7 +57,7 @@ describe Calculate do
       alpha: 5.0,
       mass: 2,
       volume: 19
-    }, { :mass => :ounces }).must_equal 34
+    }, { mass: :ounces }).must_equal 34
   end
 
   it "must calculate IBUs from hop addition using gallons" do
@@ -58,7 +67,7 @@ describe Calculate do
       alpha: 5.0,
       mass: 56,
       volume: 5
-    }, { :volume => :gallons }).must_equal 34
+    }, { volume: :gallons }).must_equal 34
   end
 
   it "must calculate IBUs from hop addition using Brix" do
@@ -68,7 +77,7 @@ describe Calculate do
       alpha: 5.0,
       mass: 56,
       volume: 19
-    }, { :extract => :brix }).must_equal 34
+    }, { extract: :brix }).must_equal 34
   end
 
   it "must calculate IBUs from hop addition using specific gravity" do
@@ -78,7 +87,7 @@ describe Calculate do
       alpha: 5.0,
       mass: 56,
       volume: 19
-    }, { :extract => :specific_gravity }).must_equal 34
+    }, { extract: :specific_gravity }).must_equal 34
   end
 
   it "must calculate hop mass required for a specific IBU contribution using specific gravity" do
@@ -88,7 +97,7 @@ describe Calculate do
       alpha: 5.0,
       ibus: 34,
       volume: 19
-    }, { :extract => :specific_gravity }).must_equal 56
+    }, { extract: :specific_gravity }).must_equal 56
   end
 
   it "must calculate hop mass required for a specific IBU contribution using Plato" do
@@ -108,7 +117,7 @@ describe Calculate do
       alpha: 5.0,
       ibus: 34,
       volume: 19
-    }, { :extract => :brix }).must_equal 56
+    }, { extract: :brix }).must_equal 56
   end
 
   it "must calculate hop mass required for a specific IBU contribution using gallons" do
@@ -118,7 +127,17 @@ describe Calculate do
       alpha: 5.0,
       ibus: 34,
       volume: 5
-    }, { :volume => :gallons }).must_equal 56
+    }, { volume: :gallons }).must_equal 56
+  end
+
+  it "must calculate hop mass required for a specific IBU contribution using ounces" do
+    Calculate.hop_mass_required({
+      extract: 12.3,
+      at: 60,
+      alpha: 5.0,
+      ibus: 75,
+      volume: 5
+    }, { mass: :ounces }).must_equal 1.2
   end
 
   it "must calculate milliliters of HopShot required for a specific IBU contribution using specific gravity" do
@@ -127,28 +146,28 @@ describe Calculate do
       at: 60,
       volume: 19,
       extract: 1.045
-    }, { :extract => :specific_gravity }).must_equal 3.5
+    }, { extract: :specific_gravity }).must_equal 3.5
 
     Calculate.hopshot_required({
       ibus: 80,
       at: 60,
       volume: 38,
       extract: 1.085
-    }, { :extract => :specific_gravity }).must_equal 17.6
+    }, { extract: :specific_gravity }).must_equal 17.6
 
     Calculate.hopshot_required({
       ibus: 80,
       at: 60,
       volume: 38,
       extract: 1.1
-    }, { :extract => :specific_gravity }).must_equal 19.2
+    }, { extract: :specific_gravity }).must_equal 19.2
 
     Calculate.hopshot_required({
       ibus: 60,
       at: 90,
       volume: 19,
       extract: 1.15
-    }, { :extract => :specific_gravity }).must_equal 7.2
+    }, { extract: :specific_gravity }).must_equal 7.2
   end
 
   it "must calculate milliliters of HopShot required for a specific IBU contribution using Plato" do
@@ -187,28 +206,28 @@ describe Calculate do
       at: 60,
       volume: 19,
       extract: 12.2
-    }, { :extract => :brix }).must_equal 3.5
+    }, { extract: :brix }).must_equal 3.5
 
     Calculate.hopshot_required({
       ibus: 80,
       at: 60,
       volume: 38,
       extract: 20.3
-    }, { :extract => :brix }).must_equal 17.6
+    }, { extract: :brix }).must_equal 17.6
 
     Calculate.hopshot_required({
       ibus: 80,
       at: 60,
       volume: 38,
       extract: 23.6
-    }, { :extract => :brix }).must_equal 19.2
+    }, { extract: :brix }).must_equal 19.2
 
     Calculate.hopshot_required({
       ibus: 60,
       at: 90,
       volume: 19,
       extract: 34.1
-    }, { :extract => :brix }).must_equal 7.2
+    }, { extract: :brix }).must_equal 7.2
   end
 
   it "must calculate milliliters of HopShot required for a specific IBU contribution using gallons" do
@@ -217,22 +236,22 @@ describe Calculate do
       at: 60,
       volume: 5,
       extract: 11.2
-    }, { :volume => :gallons }).must_equal 3.5
+    }, { volume: :gallons }).must_equal 3.5
   end
 
   it "must raise an exception for unrecognized units of measure" do
     lambda { Calculate.hop_extract_adjustment 99, :razor_blades }.must_raise ArgumentError
-    lambda { Calculate.hop_utilization 18, 90, :razor_blades }.must_raise ArgumentError
+    lambda { Calculate.hop_utilization({ at: 18, extract: 90 }, :razor_blades) }.must_raise ArgumentError
 
-    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { :extract => :razor_blades }) }.must_raise ArgumentError
-    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { :mass => :razor_blades }) }.must_raise ArgumentError
-    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { :volume => :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { extract: :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { mass: :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.ibus({ extract: 1.05, at: 60, alpha: 5.0, mass: 56, volume: 19 }, { volume: :razor_blades }) }.must_raise ArgumentError
 
-    lambda { Calculate.hop_mass_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { :extract => :razor_blades }) }.must_raise ArgumentError
-    lambda { Calculate.hop_mass_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { :volume => :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.hop_mass_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { extract: :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.hop_mass_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { volume: :razor_blades }) }.must_raise ArgumentError
 
-    lambda { Calculate.hopshot_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { :extract => :razor_blades }) }.must_raise ArgumentError
-    lambda { Calculate.hopshot_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { :volume => :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.hopshot_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { extract: :razor_blades }) }.must_raise ArgumentError
+    lambda { Calculate.hopshot_required({ extract: 1.05, at: 60, alpha: 5.0, ibus: 56, volume: 19 }, { volume: :razor_blades }) }.must_raise ArgumentError
   end
 
 end

data/test/calculators/test_mash.rb

@@ -3,25 +3,69 @@ require "calculators/mash"
 
 describe Calculate do
 
-  it "must calculate strike temperature using E.U. measures" do
-    (Calculate.strike_temperature 1.5, 21, 40).must_equal 45
+  it "must calculate strike temperature using metric measures" do
+    Calculate.strike_temperature({
+      ratio: 1.5,
+      initial: 21,
+      target: 40
+    }).must_equal 45
   end
 
   it "must calculate strike temperature using U.S. measures" do
-    (Calculate.strike_temperature 1.5, 70, 104, :us).must_equal 109
+    Calculate.strike_temperature({
+      ratio: 1.5,
+      initial: 70,
+      target: 104
+    }, :us).must_equal 109
   end
 
-  it "must calculate infusion volume using E.U. measures" do
-    (Calculate.infusion_volume 1, 40, 60, 3.6, 3.6).must_equal 2.5
+  it "must allow a loss adjustment when calculating strike temperature" do
+    Calculate.strike_temperature({
+      ratio: 1.5,
+      initial: 60,
+      target: 150,
+      loss: 1.015
+    }, :us).must_equal 164
+  end
+
+  it "must calculate infusion volume using metric measures" do
+    Calculate.infusion_volume({
+      ratio: 1,
+      initial: 40,
+      target: 60,
+      mass: 3.6,
+      volume: 3.6
+    }).must_equal 2.5
   end
 
   it "must calculate infusion volume using U.S. measures" do
-    (Calculate.infusion_volume 1, 104, 140, 8, 8, :us).must_equal 4.8
+    Calculate.infusion_volume({
+      ratio: 1,
+      initial: 104,
+      target: 140,
+      mass: 8,
+      volume: 8
+    }, :us).must_equal 4.8
   end
 
   it "must raise and exception when given an unknown unit" do
-    lambda { Calculate.strike_temperature 1, 1, 1, :imperial }.must_raise ArgumentError
-    lambda { Calculate.infusion_volume 1, 1, 1, 1, 1, :imperial }.must_raise ArgumentError
+    lambda {
+      Calculate.strike_temperature({
+        ratio: 1,
+        initial: 1,
+        target: 1
+      }, :imperial)
+    }.must_raise ArgumentError
+
+    lambda {
+      Calculate.infusion_volume({
+        ratio: 1,
+        initial: 1,
+        target: 1,
+        mass: 1,
+        volume: 1
+      }, :imperial)
+    }.must_raise ArgumentError
   end
 
 end

data/test/calculators/test_yeast.rb

@@ -4,75 +4,146 @@ require "calculators/yeast"
 describe Calculate do
 
   it "must calculate yeast cells needed for an ale" do
-    (Calculate.yeast_cells_required 12, 20).must_equal 180_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 20
+    }).must_equal 180_000_000_000
   end
 
   it "must calculate yeast cells needed for a hybrid" do
-    (Calculate.yeast_cells_required 12, 20, { :type => :hybrid }).must_equal 270_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 20,
+      type: :hybrid
+    }).must_equal 270_000_000_000
   end
 
   it "must calculate yeast cells needed for a lager" do
-    (Calculate.yeast_cells_required 12, 20, { :type => :lager }).must_equal 360_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 20,
+      type: :lager
+    }).must_equal 360_000_000_000
   end
 
   it "must calculate yeast cells needed for an ale using gallons" do
-    (Calculate.yeast_cells_required 12, 5.3, { :volume => :gallons }).must_equal 180_900_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 5.3
+    }, { volume: :gallons }).must_equal 180_900_000_000
   end
 
   it "must calculate yeast cells needed for an ale using specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 20, { :extract => :specific_gravity }).must_equal 178_500_000_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 20
+    }, { extract: :specific_gravity }).must_equal 178_500_000_000
   end
 
   it "must calculate yeast cells needed for an ale using Brix" do
-    (Calculate.yeast_cells_required 18.5, 20, { :extract => :brix }).must_equal 279_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 18.5,
+      volume: 20
+    }, { extract: :brix }).must_equal 279_000_000_000
   end
 
   it "must calculate yeast cells needed for an ale using gallons and specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 5.3, { :volume => :gallons, :extract => :specific_gravity }).must_equal 179_392_500_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 5.3
+    }, { extract: :specific_gravity, volume: :gallons }).must_equal 179_392_500_000
   end
 
   it "must calculate yeast cells needed for an hybrid using gallons" do
-    (Calculate.yeast_cells_required 12, 5.3, { :volume => :gallons, :type => :hybrid }).must_equal 271_350_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 5.3,
+      type: :hybrid
+    }, { volume: :gallons }).must_equal 271_350_000_000
   end
 
   it "must calculate yeast cells needed for an hybrid using specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 20, { :extract => :specific_gravity, :type => :hybrid }).must_equal 267_750_000_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 20,
+      type: :hybrid
+    }, { extract: :specific_gravity }).must_equal 267_750_000_000
   end
 
   it "must calculate yeast cells needed for an hybrid using Brix" do
-    (Calculate.yeast_cells_required 18.5, 20, { :extract => :brix, :type => :hybrid }).must_equal 418_500_000_000
+    Calculate.yeast_cells_required({
+      extract: 18.5,
+      volume: 20,
+      type: :hybrid
+    }, { extract: :brix }).must_equal 418_500_000_000
   end
 
   it "must calculate yeast cells needed for an hybrid using gallons and specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 5.3, { :volume => :gallons, :extract => :specific_gravity, :type => :hybrid }).must_equal 269_088_750_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 5.3,
+      type: :hybrid
+    }, { extract: :specific_gravity, volume: :gallons }).must_equal 269_088_750_000
   end
 
   it "must calculate yeast cells needed for an lager using gallons" do
-    (Calculate.yeast_cells_required 12, 5.3, { :volume => :gallons, :type => :lager }).must_equal 361_800_000_000
+    Calculate.yeast_cells_required({
+      extract: 12,
+      volume: 5.3,
+      type: :lager
+    }, { volume: :gallons }).must_equal 361_800_000_000
   end
 
   it "must calculate yeast cells needed for an lager using specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 20, { :extract => :specific_gravity, :type => :lager }).must_equal 357_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 20,
+      type: :lager
+    }, { extract: :specific_gravity }).must_equal 357_000_000_000
   end
 
   it "must calculate yeast cells needed for an lager using Brix" do
-    (Calculate.yeast_cells_required 18.5, 20, { :extract => :brix, :type => :lager }).must_equal 558_000_000_000
+    Calculate.yeast_cells_required({
+      extract: 18.5,
+      volume: 20,
+      type: :lager
+    }, { extract: :brix }).must_equal 558_000_000_000
   end
 
   it "must calculate yeast cells needed for an lager using gallons and specific gravity" do
-    (Calculate.yeast_cells_required 1.048, 5.3, { :volume => :gallons, :extract => :specific_gravity, :type => :lager }).must_equal 358_785_000_000
+    Calculate.yeast_cells_required({
+      extract: 1.048,
+      volume: 5.3,
+      type: :lager
+    }, { extract: :specific_gravity, volume: :gallons }).must_equal 358_785_000_000
   end
 
   it "must raise an exception when the beer type is unrecognized" do
-    lambda { Calculate.yeast_cells_required 15, 20, { :type => :wine } }.must_raise ArgumentError
+    lambda {
+      Calculate.yeast_cells_required({
+        extract: 15,
+        volume: 20,
+        type: :wine
+      })
+    }.must_raise ArgumentError
   end
 
   it "must raise an exception when the extract unit is unrecognized" do
-    lambda { Calculate.yeast_cells_required 15, 20, { :extract => :squeeze } }.must_raise ArgumentError
+    lambda {
+      Calculate.yeast_cells_required({
+        extract: 15,
+        volume: 20
+      }, { extract: :squeeze })
+    }.must_raise ArgumentError
   end
 
   it "must raise an exception when the volume unit is unrecognized" do
-    lambda { Calculate.yeast_cells_required 15, 20, { :volume => :barrels } }.must_raise ArgumentError
+    lambda {
+      Calculate.yeast_cells_required({
+        extract: 15,
+        volume: 20
+      }, { volume: :barrels })
+    }.must_raise ArgumentError
   end
 
 end