cooking 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@cooking

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cooking.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,25 @@
+==Cooking Units
+
+This package is originally units but since i can't find the project to fork on github, I made a gem. 
+Also, there were a few minor bugs (incorrect conversion calculations) and I extracted only the conversions 
+needed in the kitchen.
+
+== Usage
+
+  In a Rails3 App:
+
+  add: add the following to your Gemfile
+
+      gem 'cooking'
+
+  next: do it to it...
+    
+        1.lb.to_ounces # => 16.0
+        1.lb.to_gram # => 453.59
+
+Authors
+* Mark Sadegi mailto:mark.sadegi@gmail.com
+
+* Original package - Ruby Units http://rubyforge.org/projects/units)
+* Lucas Carlson
+* John Butler

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/cooking.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cooking/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cooking"
+  s.version     = Cooking::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mark Sadegi"]
+  s.email       = ["mark.sadegi@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A gem used for converting units of measurements in the kitchen}
+  s.description = %q{This package is originally units but since i can't find the project to fork on github, I made a gem. Also, there were a few minor bugs (incorrect conversion calculations) and I extracted only the conversions needed in the kitchen.}
+
+  s.rubyforge_project = "cooking"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  # s.add_development_dependency "rspec", "~> 2.0.0.beta.22"
+  s.add_development_dependency "rspec"
+end

data/lib/cooking.rb

@@ -0,0 +1 @@
+require 'cooking/base'

data/lib/cooking/base.rb

@@ -0,0 +1,173 @@
+class UnitsError < StandardError #:nodoc:
+end
+
+module Units
+  attr_reader :unit, :kind
+  alias :units :unit
+  
+  # The heart of unit conversion, it will handle methods like: to_seconds and cast the number accordingly.
+  def method_missing(symbol, *args)
+    symbol = symbol.to_s.sub(/^to_/,'').intern if symbol.to_s =~ /^to_.+/
+    
+    to_kind, to_unit = lookup_unit(symbol)
+    
+    # If there is a kind and this is conversion and the aliases include the provided symbol, convert
+    if to_kind && to_unit && self.class.all_unit_aliases(to_kind).include?(symbol)
+      from_unit = (@unit || to_unit)
+      from_kind = lookup_unit(from_unit).first
+
+      if from_kind != to_kind
+        raise UnitsError, "invalid conversion, cannot convert #{from_unit} (a #{from_kind}) to #{to_unit} (a #{to_kind})"
+
+      else
+        # The reason these numbers have to be floats instead of integers is that all similar integers are the same ones
+        # in memory, so that @kind and @unit couldn't be different for different numbers
+        case self.class.unit_conversions[to_kind]
+          when Hash
+            result = Float( self * self.class.unit_conversions[from_kind][from_unit] / self.class.unit_conversions[to_kind][to_unit] )
+          when Symbol
+            result = Float( self * send(self.class.unit_conversions[to_kind], from_unit, to_unit) )
+        end        
+      end
+      
+      result.instance_eval do
+        @unit = to_unit
+        @kind = to_kind
+      end
+
+      return result
+    else
+      super
+    end
+  end
+  
+  private
+  
+  # lookup a kind and base unit (like [:volume, :liters]) when you input :liter
+  def lookup_unit(symbol)
+    self.class.unit_conversions.keys.each do |kind|
+      if Symbol === self.class.unit_conversions[kind]
+        return kind, symbol if send(:"#{ self.class.unit_conversions[kind] }_include?", symbol)
+      else
+        if self.class.unit_conversions[kind].include? symbol
+          return kind, symbol
+        else
+          s = self.class.unit_aliases[kind].find { |k,v| v.include? symbol }
+          return kind, s[0] if s
+        end
+      end
+    end
+    return nil, nil
+  end
+
+  module ClassMethods #:nodoc:
+    def unit_conversions()            @@unit_conversions            end
+    def unit_aliases()                @@unit_aliases                end
+    def add_unit_conversions(hash={}) unit_conversions.update(hash) end
+    def add_unit_aliases(hash={})     unit_aliases.update(hash)     end
+
+    def init_units
+      @@unit_conversions = Hash.new
+      @@unit_aliases = Hash.new
+    end
+
+    def all_unit_aliases(kind)
+      results = Array.new
+      results += @@unit_conversions[kind].keys rescue nil
+      results += @@unit_aliases[kind].to_a.flatten rescue nil
+
+      return results.uniq
+    end
+  end
+
+  def self.append_features(base) #:nodoc:
+    super
+    base.extend ClassMethods
+    base.init_units
+  end
+end
+
+class Numeric
+  include Units
+end
+
+class Float
+  alias :add :+
+  # Add only numbers that both have units or both don't have units
+  def +(other)
+    if Float === other && kind && other.kind
+      add_with_units( unit == other.unit ? other : other.send(unit) )
+
+    elsif Numeric === other && (kind || other.kind) && (kind.nil? || other.kind.nil?)
+      raise UnitsError, "cannot add a number without units to one with units"
+
+    else
+      add other
+    end
+  end
+  def add_with_units(other)
+    add(other).send(unit)
+  end
+  
+  alias :multiply :*
+  # CURRENTLY: Scalar multiplication (a number with a unit to a number without a unit)
+  # TO COME: Non-scalar multiplication
+  # This will require keeping track of the exponents, like:
+  #   meters is [:meters, 1], square inches is [:inches, 2], cubic mililiters is [:milileters, 3]
+  # And then we can get rid of the silly :m3's in the volume conversion as well
+  # as add new units like:
+  #   :joules => [[:kilograms, 1], [:meters, 1], [:seconds, -2]]
+  def *(other)
+    if Numeric === other && kind && other.kind
+      raise UnitsError, "currently cannot mutiply two numers with units, try scalar multiplication instead"
+
+    elsif Numeric === other && kind.nil? && other.kind.nil?
+      multiply other
+
+    else
+      multiply_with_units other
+    end
+  end
+  def multiply_with_units(other)
+    multiply(other).send(unit || other.unit)
+  end
+end
+
+class Fixnum
+  alias :add :+
+  # Raise an error if the other number has a unit
+  def +(other)
+    if Numeric === other && other.kind
+      raise UnitsError, "cannot add a number without units to one with units"
+
+    else
+      add other
+    end
+  end
+
+  alias :multiply :*
+  # Allow for scalar multiplication
+  def *(other)
+    if Numeric === other && other.kind
+      multiply_with_units other
+
+    else
+      multiply other
+    end
+  end
+  def multiply_with_units(other)
+    multiply(other).send(unit || other.unit)
+  end
+end
+
+class String
+  alias :multiply :*
+  # Cannot multiply a String by anything Numeric with units
+  def *(other)
+    if Numeric === other && other.kind
+      raise UnitsError, "cannot multiply a String by anything Numeric with units"
+    else
+      multiply other
+    end
+  end
+end

data/lib/cooking/cook.rb

@@ -0,0 +1,155 @@
+require 'cooking/base'
+# module Cooking
+  class Numeric
+    WEIGHT = {
+               :pounds             =>  1.0,
+               :ounces             =>  0.0625,
+               :kilograms          =>  0.45359237,
+               :grams              =>  0.002204622621848776
+             }                     
+    WEIGHT_ALIASES = {             
+               :pounds             =>  [ :lb, :lbs, :pound       ],
+               :ounces             =>  [ :oz, :ozs, :ounce       ],
+               :kilograms          =>  [ :kg, :kgs, :kilogram    ],
+               :grams              =>  [ :gm, :gms, :gram        ]
+             }
+    VOLUME = {
+               :pints              =>  0.125, 
+               :milliliters        =>  0.000264172051, 
+               :cubic_feet         =>  7.48051945, 
+               # :cups               =>  0.0625,
+               :cups               =>  1, 
+               :microliters        =>  2.64172051, 
+               :cubic_inches       =>  0.00432900431, 
+               :liters             =>  0.264172051, 
+               :cubic_centimeters  =>  0.000264172051, 
+               :cubic_yards        =>  201.974025, 
+               :hectoliters        =>  26.4172051, 
+               :fluid_ounces       =>  0.0078125, 
+               :cubic_millimeters  =>  2.64172051, 
+               :gallons            =>  1, 
+               :deciliters         =>  0.0264172051, 
+               :tablespoons        =>  0.00390625, 
+               :cubic_meters       =>  264.172051, 
+               :quarts             =>  0.25, 
+               :centiliters        =>  0.00264172051, 
+               :teaspoons          =>  0.00130208333, 
+               :cubic_decimeters   =>  0.264172051
+             }
+    VOLUME_ALIASES = {
+               :liters             => [ :liter, :l              ],
+               :hectoliters        => [ :hectoliter, :hl        ],
+               :deciliters         => [ :deciliter, :dl         ],
+               :centiliters        => [ :centiliter, :cl        ],
+               :milliliters        => [ :milliliter, :ml        ],
+               :microliters        => [ :microliter, :ul        ],
+               :cubic_centimeters  => [ :cubic_centimeter, :cm3 ],
+               :cubic_millimeters  => [ :cubic_millimeter, :mm3 ],
+               :cubic_meters       => [ :cubic_meter, :m3       ],
+               :cubic_decimeters   => [ :cubic_decimeter, :dm3  ],
+               :cubic_feet         => [ :cubic_foot, :f3        ],
+               :cubic_inches       => [ :cubic_inch, :i3        ],
+               :cubic_yards        => [ :cubic_yard, :y3        ],
+               :gallons            => [ :gallon, :gal, :gals    ],
+               :quarts             => [ :quart, :qt, :qts       ],
+               :pints              => [ :pint, :pt, :pts        ],
+               :cups               => [ :cup                    ],
+               :gills              => [ :gill                   ],
+               :fluid_ounces       => [ :fluid_oz, :fluid_ozs   ],
+               :tablespoons        => [ :tablespoon, :tbsp      ],
+               :teaspoons          => [ :teaspoon, :tsp         ],
+               :fluid_drams        => [ :fluid_dram             ],
+               :minims             => [ :minim                  ]
+             }
+    TIME =   {                     
+               :seconds            =>  1.0,
+               :minutes            =>  60.0,
+               :hours              =>  3600.0,
+               :days               =>  86400.0,
+               :weeks              =>  604800.0,
+               :years              =>  31449600.0
+             }                   
+    TIME_ALIASES = {             
+               :seconds            =>  [ :sec, :second         ],
+               :minutes            =>  [ :min, :mins, :minute  ],
+               :hours              =>  [ :hour                 ],
+               :days               =>  [ :day                  ],
+               :weeks              =>  [ :week                 ],
+               :years              =>  [ :year                 ]
+             }
+    SIZE =   {
+               :bytes              =>  1.0,
+               :bits               =>  8.0,
+               :kilobytes          =>  1024.0,
+               :megabytes          =>  1048576.0,
+               :gigabytes          =>  1073741824.0,
+               :terabytes          =>  1099511627776.0,
+               :petabytes          =>  1.12589991e15
+             }                     
+    SIZE_ALIASES = {               
+               :bits               =>  [ :bit                  ],
+               :bytes              =>  [ :b, :byte             ],
+               :kilobytes          =>  [ :kb, :kilobyte        ],
+               :megabytes          =>  [ :mb, :megabyte        ],
+               :gigabytes          =>  [ :gb, :gigabyte        ],
+               :terabytes          =>  [ :tb, :terabyte        ],
+               :petabytes          =>  [ :pb, :petabyte        ]
+             }                     
+    LENGTH = {                     
+               :inches             =>  1.0,
+               :feet               =>  12.0,
+               :meters             =>  39.3700787,
+               :kilometers         =>  39370.0787,
+               :milimeters         =>  0.0393700787,
+               :centimeters        =>  0.393700787,
+               :miles              =>  63360.0
+             }
+    LENGTH_ALIASES = {
+               :inches             =>  [ :inch                 ],
+               :feet               =>  [ :foot                 ],
+               :miles              =>  [ :mile                 ],
+               :meters             =>  [ :m, :meter            ],
+               :kilometers         =>  [ :km, :kilometer       ],
+               :milimeters         =>  [ :mm, :milimeter       ],
+               :centimeters        =>  [ :cm, :centimeter      ]
+             }
+
+    add_unit_conversions(
+      :weight => WEIGHT,
+      :volume => VOLUME,
+      :time   => TIME,
+      :size   => SIZE,
+      :length => LENGTH
+    )
+
+    add_unit_aliases(
+      :weight => WEIGHT_ALIASES,
+      :volume => VOLUME_ALIASES,
+      :time => TIME_ALIASES,
+      :size => SIZE_ALIASES,
+      :length => LENGTH_ALIASES
+    )
+  end
+
+  class Float #:nodoc:
+    alias :_to_i :to_i
+    def to_i
+      case kind
+      when :time
+        to_seconds._to_i
+      when :size
+        to_bytes._to_i
+      end
+    end
+
+    alias :_to_int :to_int
+    def to_int
+      case kind
+      when :time
+        to_seconds._to_int
+      when :size
+        to_bytes._to_int
+      end
+    end
+  end
+# end

data/lib/cooking/version.rb

@@ -0,0 +1,3 @@
+module Cooking
+  VERSION = "0.0.2"
+end

data/spec/cooking_spec.rb

@@ -0,0 +1,11 @@
+require 'cooking/cook'
+
+describe Cooking::Cook do
+  it "broccoli is gross" do
+    Cooking::Cook.portray("Broccoli").should eql("Gross!")
+  end
+
+  it "anything else is delicious" do
+    Cooking::Cook.portray("Not Broccoli").should eql("Delicious!")
+  end
+end

data/test/cooking/base_test.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class BaseTest < Test::Unit::TestCase
+  def setup
+    @num1 = 1234.5678
+    @num2 = 9876.5432
+
+    [@num1, @num2].each do |n|
+      n.instance_eval do
+        self.class.add_unit_conversions(
+          :test_kind => {
+            :bases    => 1.0,
+            :biggers  => 10.0
+          },
+          :bad_kind => {
+            :flavors    => 1.0,
+          }
+        ) 
+        self.class.add_unit_aliases(
+          :test_kind => {
+            :bases =>   [ :base   ],
+            :biggers => [ :bigger ]
+          }
+        )
+      end
+    end
+  end
+  
+	def test_add_unit_conversions
+	  assert_equal :test_kind, @num1.to_bases.kind
+	  assert_equal :bad_kind, @num2.flavors.kind
+	  assert_equal :bases, @num1.to_bases.unit
+	  assert_equal :bases, @num1.to_bases.to_bases.unit
+	  assert_equal :biggers, @num2.to_biggers.unit
+	end
+	
+	def test_add_unit_aliases
+	  assert_equal :bases, @num1.to_base.unit
+	  assert_equal :biggers, @num2.to_bigger.unit
+  end
+  
+  def test_adding
+    assert_equal 11111.111, @num1 + @num2
+    assert_equal 11111.111, @num2 + @num1
+    
+    assert_equal 99999.9998, @num1.to_base + @num2.to_biggers
+    assert_equal 22222.2212, @num2.to_base + @num1.to_biggers
+    
+    assert_equal :bases, (@num1.to_base + @num2.to_biggers).units
+    assert_equal :biggers, (@num1.to_biggers + @num2.to_bases).units
+    
+    assert_raise(UnitsError) { @num1.to_base + 2 }
+    assert_raise(UnitsError) { 5 + @num1.to_base }
+    assert_raise(UnitsError) { @num1.to_base + 2.0 }
+    assert_raise(UnitsError) { 5.0 + @num1.to_base }
+  end
+
+  def test_multiplying
+    assert_equal 2469.1356, @num1 * 2
+    assert_equal 2469.1356, @num1.to_base * 2
+    assert_equal nil, (@num1 * 2).units
+    assert_equal :bases, (@num1.to_base * 2).units
+    
+    assert_raise(UnitsError) { @num1.to_base * @num2.to_base }
+    assert_raise(TypeError) { @num1.to_base * "string" }
+    assert_raise(UnitsError) { "string" * @num1.to_base }
+    assert_equal "stringstringstring", "string" * 3.0
+  end
+
+end

data/test/cooking/cooking_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CookingTest < Test::Unit::TestCase
+	def test_weight
+	   assert_equal 64.0, 4.pounds.to_ozs
+	   assert_equal :ounces, (4.pounds.to_ozs).units
+	   assert_equal :weight, (4.pounds.to_ozs).kind
+     puts "4 lbs = #{(4.pounds.to_ozs)} oz."
+	end
+
+  def test_weight2
+     assert_equal 1814.36948, 4.pounds.to_grams
+     assert_equal :grams, (4.pounds.to_grams).units
+     assert_equal :weight, (4.pounds.to_grams).kind
+     puts "1 lb = #{1.pounds.to_grams} grams"
+  end
+
+  def test_volume
+     assert_equal 4.0, 1.cups.to_quarts
+     assert_equal :quarts, (1.cups.to_quarts).units
+     assert_equal :volume, (1.cups.to_quarts).kind
+     puts "1 cup = #{1.cups.to_quarts} quarts"
+  end
+  
+  def test_volume2
+     assert_equal 1.056688204, 1.liter.to_quarts
+     assert_equal :quarts, (1.liter.to_quarts).units
+     assert_equal :volume, (1.liter.to_quarts).kind
+     puts "1 liter = #{1.liter.to_quarts} quarts"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'cooking/cook'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: cooking
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Mark Sadegi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: This package is originally units but since i can't find the project to fork on github, I made a gem. Also, there were a few minor bugs (incorrect conversion calculations) and I extracted only the conversions needed in the kitchen.
+email: 
+- mark.sadegi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- cooking.gemspec
+- lib/cooking.rb
+- lib/cooking/base.rb
+- lib/cooking/cook.rb
+- lib/cooking/version.rb
+- spec/cooking_spec.rb
+- test/cooking/base_test.rb
+- test/cooking/cooking_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cooking
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A gem used for converting units of measurements in the kitchen
+test_files: 
+- spec/cooking_spec.rb
+- test/cooking/base_test.rb
+- test/cooking/cooking_test.rb
+- test/test_helper.rb