measurements 0.3.0

data/.gitignore

@@ -0,0 +1,5 @@
+Gemfile.lock
+.yardoc
+doc/*
+.DS_Store*
+gems/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.yardopts

@@ -0,0 +1,3 @@
+--no-private
+--protected
+--markup markdown

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Guardfile

@@ -0,0 +1,19 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/README.md

@@ -0,0 +1,102 @@
+# Measurements Ruby Gem
+This gem was created to assist in converting cooking measurements when scaling up a recipe.
+I was having fun with it so I decided to go a little above and beyond.
+
+**Note:** This project ended up getting bigger than I had expected and now there are quite a few things that need fixing.
+I should have had a plan from the beginning...
+
+## Using the Gem
+
+Install it with
+
+```shell
+gem install measurements
+```
+
+and enjoy.
+
+## Documentation
+```shell
+yardoc
+```
+
+## Usage Examples
+Create an Ounce object with a quantity of 3oz
+
+```ruby
+ounce = Measurements.new_unit :ounce, 3
+```
+
+Convert that 3oz object to a Pound object
+
+```ruby
+pound = ounce.convert_to :pound
+```
+
+Convert the current unit by altering the unit itself
+
+```ruby
+ounce.convert_to! :pound
+```
+
+Create an Ounce object with a type of solid. This would be used to make sure when you convert
+using the smart convert (not yet implemented) the unit doesn't get converted to a fluid measurement
+
+```ruby
+ounce = Measurements.new_unit :ounce, 3.5, :solid
+```
+	
+Get the list of available units
+
+```ruby
+Measurements.available_units
+=> [:ounce, :pound, :teaspoon, :tablespoon, :cup, :pint, :quart, :gallon, :inch, :foot, :yard, :furlong, :chain, :mile, :thou, :league]
+```
+	
+Get the list of available types of units. ex: Solid, Fluid or Neutral
+
+```ruby
+Measurements.available_types
+=> [:solid, :fluid, :neutral, :base] 
+```
+	
+## Getting Started with Development
+Make sure you have rubygems installed. You can find instructions at [rubygems.org](http://docs.rubygems.org/read/chapter/3)
+
+Have bundler installed on your system
+
+	gem install bundler
+	
+Run bundler to make sure you have all the right gems
+
+	bundle install
+	
+Generate some docs to browse while I work on getting some tests ready. After running the following command
+browse to the doc directory and open the index.html file in your favorite browser.
+
+	yardoc
+
+Right now when I've been testing the gem inside irb I've been running the ruby line.
+
+```ruby
+$LOAD_PATH.unshift(File.dirname(__FILE__)+"/lib"); require 'measurements'
+```
+
+You should also note that this only works if you launch irb from within the measurements directory.
+
+If you want to be snazy and grab this line to load without using a text editor you can run one of these commands
+
+##### Unix
+
+```shell
+cat README.md | grep "LOAD_PATH"
+```
+
+##### Windows
+
+```shell
+type README.md | find "LOAD_PATH"
+```
+	
+## Copyright
+Copyright (c) 2012 Casey Stehlik.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run tests"
+task :test => :spec
+
+task :default => :spec

data/lib/measurements.rb

@@ -0,0 +1,19 @@
+# Always make the version available
+require 'measurements/version'
+
+# @author Casey Stehlik
+module Measurements
+    
+    # This is the local to use when looking up abbreviations. Later on you will be able 
+    #   to select other locales, but for now you get only english
+    LOCALE = "en"
+    
+    autoload :Type,      'measurements/type'
+    autoload :System,    'measurements/system'
+    autoload :Unit,      'measurements/unit'
+    autoload :Exception, 'measurements/exception'
+
+    # Load in the helper methods to be able to access them
+    require 'measurements/helpers'
+
+end

data/lib/measurements/config/abbreviations.yml

@@ -0,0 +1,34 @@
+abbreviations:
+  en:
+    singular:
+      pound: lb
+      cup: c
+      ounce: oz
+      tablespoon: tbsp
+      teaspoon: tsp
+      quart: qt
+      pint: pt
+      gallon: gal
+      inch: in
+      foot: ft
+      mile: mi
+      furlong: fur
+      thou: th
+      chain: ch
+      league: lea
+    plural:
+      pound: lbs
+      cup: c
+      ounce: oz
+      tablespoon: tbsp
+      teaspoon: tsp
+      quart: qt
+      pint: pt
+      gallon: gal
+      inch: in
+      foot: ft
+      mile: mi
+      furlong: fur
+      thou: th
+      chain: ch
+      league: lea

data/lib/measurements/config/conversions.yml

@@ -0,0 +1,31 @@
+conversions:
+  cooking:
+    solid:
+      base: pound
+      cup: 2
+      ounce: 16
+      tablespoon: 32
+      teaspoon: 96
+    fluid:
+      base: gallon
+      quart: 4
+      pint: 8
+      cup: 16
+      ounce: 128
+      tablespoon: 256
+      teaspoon: 768
+    neutral:
+      base: cup
+      ounce: 8
+      tablespoon: 16
+      teaspoon: 48
+  imperial:
+    base:
+      base: league
+      mile: 3
+      furlong: 24 
+      chain: 240
+      yard: 5280
+      foot: 15840
+      inch: 190080
+      thou: 190080000

data/lib/measurements/exception.rb

@@ -0,0 +1,22 @@
+module Measurements
+    module Exception
+        
+        # This is an extention of the StandardError and it will be raised when
+        #   you try to convert to a unit that doesn't exist. An example would
+        #   be Ounce.new(3).convert_to :fake_unit
+        class NoUnitError < StandardError
+        end
+        
+        # This is an extention of the StandardError and it will be raised when
+        #   you try to convert a unit to a new unit that isn't in the same
+        #   system type. Such as converting an ounce to a foot.
+        class InvalidConversionError < StandardError
+        end
+        
+        # This is an extention of the StandardError and it will be raised when
+        #   you try to set the type of a unit that doesn't allow it.
+        class InvalidTypeSettingError < StandardError
+        end
+        
+    end
+end

data/lib/measurements/helpers.rb

@@ -0,0 +1,38 @@
+module Measurements
+
+    # Helper method to get what units are currently implemented
+    # @return [Array] an Array of currently implemented units
+    def available_units
+        Measurements::Unit.available_units
+    end
+    
+    # Helper method to get what types are available
+    # @return [Array] an Array of types that are available
+    def available_types
+        Measurements::Type.available_types
+    end
+
+    # Helper method to create a unit class without having to explicitly
+    #   call {Measurements::Unit::BaseUnit#initialize}
+    # @param [Symbol] klass the class of the unit you wish to initialize
+    # @param [Float] quantity the amount of the unit
+    # @param [Symbol] type optional unit type such as :solid or :fluid
+    # @return [BaseUnit] a new unit instance of class = klass
+    def new_unit(klass, quantity, type = nil)
+        if available_units.include? klass
+            unit = eval('Measurements::Unit::' + klass.to_s.capitalize).new quantity, type
+            Measurements::Unit::Unit.new(unit)
+        else
+            raise Measurements::Exception::NoUnitError, "The unit requested does not exist."
+        end
+    end
+
+    module_function :new_unit
+    module_function :available_units
+    module_function :available_types
+
+    class << self
+        alias_method :create_unit, :new_unit
+    end
+
+end

data/lib/measurements/system.rb

@@ -0,0 +1,14 @@
+module Measurements
+    module System
+        
+        # System type for metric units
+        SI = "metric"
+        
+        # System type for United States units
+        IMPERIAL = "imperial"
+        
+        # System type for cooking units
+        COOK = "cooking"
+        
+    end
+end

data/lib/measurements/type.rb

@@ -0,0 +1,27 @@
+module Measurements
+    module Type
+        
+        # Measurement state for unit of type solid
+        SOLID = "solid"
+        
+        # Measurement state for unit of type fluid
+        FLUID = "fluid"
+        
+        # Measurement state for unit that can be either a fluid or solid measure
+        NEUTRAL = "neutral"
+        
+        # Measurement state for the unit that is not a cooking unit
+        BASE = "base"
+        
+        # Helper method to get what types are available
+        # @deprecated Use {Measurements#available_types} instead of this method because
+        #   it's a more obvious method to use instead of diving down to the Type module.
+        # @return [Array] an Array of types that are available
+        def available_types
+            self.constants.map{|types| types.downcase.to_sym}
+        end
+        
+        module_function :available_types
+        
+    end
+end

data/lib/measurements/unit.rb

@@ -0,0 +1,51 @@
+require 'yaml'
+
+module Measurements
+    module Unit
+        
+        # All conversions are loaded from the conversions.yml.
+        #   The conversions.yml file lives in the /measurements directory of the project
+        CONVERSIONS = YAML::load(File.open(File.join(File.dirname(__FILE__), 'config', 'conversions.yml')))
+        
+        # All abbreviations are loaded from the abbreviations.yml.
+        #   The abbreviations.yml file lives in the /measurements/config directory of the project
+        ABBREVIATIONS = YAML::load(File.open(File.join(File.dirname(__FILE__), 'config', 'abbreviations.yml')))
+        
+        autoload :BaseUnit,   'measurements/unit/baseunit'
+        autoload :Unit,       'measurements/unit/unit'
+        
+        # Cooking Units
+        autoload :Ounce,      'measurements/unit/ounce'
+        autoload :Pound,      'measurements/unit/pound'
+        autoload :Teaspoon,   'measurements/unit/teaspoon'
+        autoload :Tablespoon, 'measurements/unit/tablespoon'
+        autoload :Cup,        'measurements/unit/cup'
+        autoload :Pint,       'measurements/unit/pint'
+        autoload :Quart,      'measurements/unit/quart'
+        autoload :Gallon,     'measurements/unit/gallon'
+        
+        # Imperial Units
+        autoload :Inch,       'measurements/unit/inch'
+        autoload :Foot,       'measurements/unit/foot'
+        autoload :Yard,       'measurements/unit/yard'
+        autoload :Furlong,    'measurements/unit/furlong'
+        autoload :Chain,      'measurements/unit/chain'
+        autoload :Mile,       'measurements/unit/mile'
+        autoload :Thou,       'measurements/unit/thou'
+        autoload :League,     'measurements/unit/league'
+                
+        # Helper method to get what units are currently implemented
+        # @deprecated Use {Measurements#available_units} instead of this method because
+        #   it's a more obvious method to use instead of diving down to the Unit module.
+        # @return [Array] an Array of currently implemented units
+        def available_units
+            self.constants.reject{|unit| unit.eql?(:BaseUnit) || 
+                                         unit.eql?(:Unit) ||
+                                         unit.eql?(:CONVERSIONS) || 
+                                         unit.eql?(:ABBREVIATIONS)}.map{|unit| unit.to_s.downcase.to_sym}
+        end
+        
+        module_function :available_units
+        
+    end
+end

data/lib/measurements/unit/baseunit.rb

@@ -0,0 +1,186 @@
+module Measurements
+    module Unit        
+        module BaseUnit
+                        
+            # @attribute [rw]
+            # The quantity of a unit
+            attr_accessor :quantity
+            
+            def initialize(quantity, type = nil)
+                @quantity = quantity.to_f
+                
+                if !type.nil?
+                    self.type = type
+                else
+                    @type = type
+                end
+            end
+            
+            # Set the unit type of a unit manually. A type can only be set for units with the
+            #   unit type of "neutral", any other unit type will raise and error.
+            # @attribute [w]
+            # @param [String] type the type of unit the unit should be.
+            def type=(type)
+                if self.unit_type.eql? "neutral"
+                    @type = type
+                else
+                    raise Measurements::Exception::InvalidTypeSettingError, "Types can only be set on neutral units."
+                end
+            end
+            
+            # @attribute [r]
+            # The manual set unit_type
+            def type
+                @type
+            end
+            
+            # @attribute [r]
+            # The type of the editable type of the unit. This is
+            #   used to limit the conversions from fluid to solid
+            def unit
+                self.class.name.split('::').last.downcase.to_s
+            end
+            
+            # @attribute [r]
+            # The system of measurement of the unit
+            def unit_system
+                eval(self.class.to_s + "::UNIT_SYSTEM")
+            end
+            
+            # @attribute [r]
+            # The class type of the unit, such as Liquid or Neutral
+            def unit_type
+                eval(self.class.to_s + "::UNIT_TYPE")
+            end
+            
+            # @attribute [r]
+            # The abbreviation of the unit depending on the locale
+            def unit_abbr
+                if @quantity <= 1
+                    Measurements::Unit::ABBREVIATIONS["abbreviations"][Measurements::LOCALE]["singular"][self.unit]
+                else
+                    Measurements::Unit::ABBREVIATIONS["abbreviations"][Measurements::LOCALE]["plural"][self.unit]
+                end
+            end
+            
+            # When you look at a unit object the quantity will be displayed.
+            #   It seemed like a nicer way to display the unit, kind of like a [Float]
+            def inspect
+                @quantity
+            end
+            
+            # Convert the current unit into a new unit of the type given
+            # @param [Symbol] type the type of unit to convert to
+            # @return [BaseUnit] the new unit, it will be a subclass of [BaseUnit].
+            # @raise [InvalidConversionError] gets raised if the type of conversion is not valid.
+            def convert_to(type)
+                type = type.to_s
+                
+                if !validate_system(type)
+                    raise Measurements::Exception::InvalidConversionError, "A conversion must be from the same system type."
+                end
+                
+                if validate_conversion(type)
+                    base = convert_to_base(self, type)
+                    return convert_to_type(base, type)
+                else
+                    raise Measurements::Exception::InvalidConversionError, "A conversion must be from the same type or neutral."
+                end
+            end
+            
+            # Convert the current unit into a new unit of highest bestfit unit that
+            #   would make sense while measuring something. An example would be that a better way
+            #   to display 6 tsps would be 2 tbsps.
+            # @return [BaseUnit] the new unit, it will be the unit that is the bestfit conversion.
+            def smart_convert
+                #TODO
+            end
+            
+            private
+            
+            # Get the unit type of the class passed in as a string
+            # @param [String] type the class name as a string
+            # @return [String] the unit type of the class that was passed in.
+            def unit_type_from_type(type)
+                eval("Measurements::Unit::" + type.capitalize + "::UNIT_TYPE")
+            end
+            
+            # Get the unit system of the class passed in as a string
+            # @param [String] type the class name as a string
+            # @return [String] the unit system of the class that was passed in.
+            def unit_system_from_type(type)
+                eval("Measurements::Unit::" + type.capitalize + "::UNIT_SYSTEM")
+            end
+            
+            # Validate if the systems of the converting units match. A conversion will only
+            #   be allowed if the two units are from the same unit system.
+            # @param [String] to the unit type to convert to
+            # @return [Boolean] true if the conversion is valid.
+            # @raise [NoUnitError] gets raised if the from or to units could not be found
+            def validate_system(to)
+                from = self.unit
+                
+                begin
+                    from = unit_system_from_type from
+                    to = unit_system_from_type to
+                rescue
+                    raise Measurements::Exception::NoUnitError, "The unit you're trying to convert to does not exist."
+                end
+                
+                from.eql? to
+            end
+
+            # Validate if a conversion will be valid. A conversion will be valid if one
+            #   of the units types are neutral or if the unit types are the same.
+            # @param [String] to the unit type to convert to
+            # @return [Boolean] True if the conversion is valid.
+            # @raise [NoUnitError] gets raised if the from or to units could not be found
+            def validate_conversion(to)
+                from = self.unit
+                
+                begin
+                    from = unit_type_from_type from
+                    to = unit_type_from_type to
+                rescue
+                    raise Measurements::Exception::NoUnitError, "The unit you're trying to convert to does not exist."
+                end
+                
+                (from.eql?("neutral") || to.eql?("neutral") || from.eql?(to)) && (self.type.nil? || self.type.eql?("neutral") || self.type.eql?(to))
+            end
+            
+            # Convert the current unit into the base unit for its type.
+            # @param [BaseUnit] current the unit to be converted, it should be a subclass of [BaseUnit]
+            # @return [BaseUnit] the base unit.
+            def convert_to_base(current, type)
+                unit_type = unit_type_from_type type
+                
+                if !unit_type.eql? "neutral"
+                    measurement_list = Measurements::Unit::CONVERSIONS["conversions"][current.unit_system][unit_type]
+                else
+                    measurement_list = Measurements::Unit::CONVERSIONS["conversions"][current.unit_system][current.unit_type]
+                end
+                
+                quantity_to_mst = measurement_list[current.unit].to_f != 0.0 ? measurement_list[current.unit] : 1.0
+                base_type = measurement_list["base"]
+
+                eval("Measurements::Unit::" + base_type.capitalize).new(current.quantity / quantity_to_mst, current.type)
+            end
+            
+            # Take the base unit and convert it to the requested type. If the type requested
+            #   is the same type as the base, just return the base unit back.
+            # @param [BaseUnit] base the base unit to be converted
+            # @param [String] type the type of unit the base should be converted to
+            # @return [BaseUnit] the new unit, it will be a subclass of [BaseUnit]
+            def convert_to_type(base, type)
+                if base.unit.eql? type
+                    return base
+                else
+                    measurement_list = Measurements::Unit::CONVERSIONS["conversions"][base.unit_system][base.unit_type]
+                    quantity_to_type = measurement_list[type]
+                    
+                    eval("Measurements::Unit::" + type.capitalize).new(base.quantity * quantity_to_type, base.type)
+                end
+            end
+        end
+    end
+end

data/lib/measurements/unit/chain.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a chain. A chain is a unit that belongs to the imperial unit 
+        #   system.
+        class Chain
+            include BaseUnit
+            
+            # Type for the Chain unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Chain unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/cup.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a cup. A cup is a neutral unit that belongs to the cooking unit 
+        #   system.
+        class Cup
+            include BaseUnit
+            
+            # Type for the Cup unit
+            UNIT_TYPE = Measurements::Type::NEUTRAL
+            
+            # System type for the Cup unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/foot.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a foot. A foot is a unit that belongs to the imperial unit 
+        #   system.
+        class Foot
+            include BaseUnit
+            
+            # Type for the Foot unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Foot unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/furlong.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a furlong. A furlong is a unit that belongs to the imperial unit 
+        #   system.
+        class Furlong
+            include BaseUnit
+            
+            # Type for the Furlong unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Furlong unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/gallon.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a gallon. A gallon is a fluid unit that belongs to the cooking unit 
+        #   system.
+        class Gallon
+            include BaseUnit
+            
+            # Type for the Gallon unit
+            UNIT_TYPE = Measurements::Type::FLUID
+            
+            # System type for the Gallon unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/inch.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a inch. A inch is a unit that belongs to the imperial unit 
+        #   system.
+        class Inch
+            include BaseUnit
+            
+            # Type for the Inch unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Inch unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/league.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a league. A league is a unit that belongs to the imperial unit 
+        #   system.
+        class League
+            include BaseUnit
+            
+            # Type for the League unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the League unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/mile.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a mile. A mile is a unit that belongs to the imperial unit 
+        #   system.
+        class Mile
+            include BaseUnit
+            
+            # Type for the Mile unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Mile unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/ounce.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a ounce. A ounce is a neutral unit that belongs to the cooking unit 
+        #   system.
+        class Ounce
+            include BaseUnit
+            
+            # Type for the Ounce unit
+            UNIT_TYPE = Measurements::Type::NEUTRAL
+            
+            # System type for the Ounce unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/pint.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a pint. A pint is a fluid unit that belongs to the cooking unit 
+        #   system.
+        class Pint
+            include BaseUnit
+            
+            # Type for the Pint unit
+            UNIT_TYPE = Measurements::Type::FLUID
+            
+            # System type for the Pint unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/pound.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a pound. A pound is a solid unit that belongs to the cooking unit 
+        #   system.
+        class Pound
+            include BaseUnit
+                        
+            # Type for the Pound unit
+            UNIT_TYPE = Measurements::Type::SOLID
+            
+            # System type for the Pound unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/quart.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a quart. A quart is a fluid unit that belongs to the cooking unit 
+        #   system.
+        class Quart
+            include BaseUnit
+            
+            # Type for the Quart unit
+            UNIT_TYPE = Measurements::Type::FLUID
+            
+            # System type for the Quart unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/tablespoon.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a teaspoon. A teaspoon is a neutral unit that belongs to the cooking unit 
+        #   system.
+        class Tablespoon       
+            include BaseUnit
+            
+            # Type for the Tablespoon unit
+            UNIT_TYPE = Measurements::Type::NEUTRAL
+            
+            # System type for the Tablespoon unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/teaspoon.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a teaspoon. A teaspoon is a neutral unit that belongs to the cooking unit 
+        #   system.
+        class Teaspoon
+            include BaseUnit
+            
+            # Type for the Teaspoon unit
+            UNIT_TYPE = Measurements::Type::NEUTRAL
+            
+            # System type for the Teaspoon unit
+            UNIT_SYSTEM = Measurements::System::COOK
+        end
+        
+    end
+end

data/lib/measurements/unit/thou.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a thou. A thou is a unit that belongs to the imperial unit 
+        #   system.
+        class Thou
+            include BaseUnit
+            
+            # Type for the Thou unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Thou unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/unit/unit.rb

@@ -0,0 +1,85 @@
+module Measurements
+    module Unit
+
+        # A wrapper for all of the units, this class was added to make the conversion of classes
+        #   keep the same object class instead of changing everytime you convert a unit.
+        class Unit
+
+            def initialize(klass)
+                @klass = klass
+            end
+
+            # @see Measurements::Unit::BaseUnit#inspect
+            def inspect
+                self.quantity
+            end
+
+            # A pretty print method that will return a human readable version
+            #   of a unit
+            # @return [String] a human readable unit description
+            def humanize
+                return "#{self.quantity.to_s} #{self.unit_abbr}"
+            end
+
+            # @see Measurements::Unit::BaseUnit#type=
+            def type=(type)
+                @klass.type = type
+            end
+
+            # @see Measurements::Unit::BaseUnit#type
+            def type
+                @klass.type
+            end
+
+            # Get the quantity of the unit
+            # @return [Float] the quantitiy of the unit
+            def quantity
+                @klass.quantity
+            end
+
+            # Set the quantity of a unit
+            # @param [Float] quanity the quantity of the unit
+            def quantity=(quantity)
+                @klass.quantity = quantity
+            end
+
+            # @see Measurements::Unit::BaseUnit#unit
+            def unit
+                @klass.unit
+            end
+
+            # @see Measurements::Unit::BaseUnit#unit_type
+            def unit_type
+                @klass.unit_type
+            end
+
+            # @see Measurements::Unit::BaseUnit#unit_system
+            def unit_system
+                @klass.unit_system
+            end
+
+            # @see Measurements::Unit::BaseUnit#unit_abbr
+            def unit_abbr
+                @klass.unit_abbr
+            end
+
+            # This method will call the current units convert_to method. This is the dangerous version and it will
+            #   change the callers unit.
+            # @see Measurements::Unit::BaseUnit#convert_to
+            def convert_to!(type)
+                @klass = @klass.convert_to(type)
+            end
+
+            # The safe version of converting a unit. This method will duplicate the caller object and return the new
+            #   version of the object instead of the original caller
+            # @param [Symbol] type the unit to be converted to
+            # @return [Unit] the new Unit object
+            def convert_to(type)
+                new_unit = self.dup
+                new_unit.convert_to!(type)
+                new_unit
+            end
+        end
+
+    end
+end

data/lib/measurements/unit/yard.rb

@@ -0,0 +1,17 @@
+module Measurements
+    module Unit
+        
+        # The implementation of a yard. A yard is a unit that belongs to the imperial unit 
+        #   system.
+        class Yard
+            include BaseUnit
+            
+            # Type for the Yard unit
+            UNIT_TYPE = Measurements::Type::BASE
+            
+            # System type for the Yard unit
+            UNIT_SYSTEM = Measurements::System::IMPERIAL
+        end
+        
+    end
+end

data/lib/measurements/version.rb

@@ -0,0 +1,7 @@
+module Measurements
+    
+    # The current version of the gem, the numbers stand for
+    #   major.minor.patch
+    Version = "0.3.0"
+    
+end

data/measurements.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../lib/', __FILE__)
+require 'measurements/version'
+
+Gem::Specification.new do |spec|
+    spec.name = 'measurements'
+    spec.author = 'Casey Stehlik'
+    spec.email = 'casey.stehlik@stehlikc.net'
+    spec.homepage = 'http://www.stehlikc.net/'
+    spec.add_development_dependency 'yard'
+    spec.add_development_dependency 'redcarpet'
+    spec.add_development_dependency 'rspec'
+    spec.add_development_dependency 'guard-rspec'
+    spec.version = Measurements::Version
+    spec.require_paths = ['lib']
+    spec.files = `git ls-files`.split("\n")
+    spec.description = "A measurement conversion gem"
+    spec.summary = "A measurement conversion"
+end

data/spec/helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__)+ '/lib')
+
+require 'measurements'
+

data/spec/measurements_spec.rb

@@ -0,0 +1,101 @@
+require 'helper'
+
+describe Measurements do
+    it "should return the available system types" do
+        Measurements.available_types.should == Measurements::Type.available_types
+    end
+    
+    it "should return the available units that are implemented" do
+        Measurements.available_units.should == Measurements::Unit.available_units
+    end
+
+    it "should create a 3 ounces object" do
+        ounce = Measurements.create_unit :ounce, 3
+        ounce.unit.should == "ounce" && ounce.quantity.should == 3
+    end
+
+    it "should create a 4 pound object" do
+        pound = Measurements.new_unit :pound, 4
+        pound.unit.should == "pound" && pound.quantity.should == 4
+    end
+
+    it "should raise an error if the unit requested has not been implemented" do
+        expect{ Measurements.new_unit(:unimplemented_unit, 2) }.should raise_error()
+    end
+
+    it "should convert 1 quart to 4 cups" do
+        quart = Measurements.new_unit :quart, 1
+        cup = quart.convert_to :cup
+        cup.quantity.should == 4
+    end
+
+    it "should convert 8 cups to 0.5 gallons" do
+        cup = Measurements.new_unit :cup, 8
+        gallon = cup.convert_to :gallon
+        gallon.quantity.should == 0.5
+    end
+    
+    it "should convert 6 teaspoons to 2 tablespoons" do
+        teaspoon = Measurements.new_unit :teaspoon, 6
+        tablespoon = teaspoon.convert_to :tablespoon
+        tablespoon.quantity.should == 2
+    end
+    
+    it "should raise an error if the unit type is set to solid and you try to convert to a fluid" do
+        cup = Measurements.new_unit :cup, 2, :solid
+        expect{ ounce = cup.convert_to(:gallon) }.should raise_error()
+    end
+    
+    it "should raise an error if the unit type is set to fluid and you try to convert to a solid" do
+        cup = Measurements.new_unit :gallon, 1
+        expect{ ounce = cup.convert_to(:pound) }.should raise_error()
+    end
+    
+    it "should raise an error if you try to set the unit type of a fluid only unit" do
+        expect{ gallon = Measurements.new_unit :gallon, 1, :fluid }.should raise_error()
+    end
+    
+    it "should raise an error if you try to set the unit type of a solid only unit" do
+        expect{ pound = Measurements.new_unit :pound, 2, :solid }.should raise_error()
+    end
+    
+    it "should raise an error when trying to set the unit type of a unit on the fly" do
+        cup = Measurements.new_unit :gallon, 2
+        expect { cup.type = :solid }.should raise_error()
+    end
+    
+    it "should convert 2 feet to 24 inches" do
+        feet = Measurements.new_unit :foot, 2
+        inches = feet.convert_to :inch
+        inches.quantity.should == 24
+    end
+    
+    it "should convert 30 inches to 1.5 feet" do
+        inches = Measurements.new_unit :inch, 30
+        feet = inches.convert_to :foot
+        feet.quantity.should == 2.5
+    end
+    
+    it "should raise an error if you try to convert a unit across system types" do
+        inches = Measurements.new_unit :inch, 55
+        expect { cup = inches.convert_to :cup }.should raise_error()
+    end
+    
+    it "should raise an error if you try to set a type manually for imperial units" do
+        expect { inch = Measurements.new_unit :inch, 51, :solid }.should raise_error()
+    end
+    
+    it "should convert 2.5 leagues to 475200 inches" do
+        leagues = Measurements.new_unit :league, 2.5
+        inches = leagues.convert_to :inch
+        inches.quantity.should == 475200
+    end
+    
+    it "should humanize 3.5 ounces to 3.5 oz" do
+        Measurements.new_unit(:ounce, 3.5).humanize.should == "3.5 oz"
+    end
+    
+    it "should humanize 4 pounds to 4 lbs" do
+        Measurements.new_unit(:pound, 4).humanize.should == "4.0 lbs"
+    end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: measurements
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Casey Stehlik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70325023315160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325023315160
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &70325023314240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325023314240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70325023313740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325023313740
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70325023312860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70325023312860
+description: A measurement conversion gem
+email: casey.stehlik@stehlikc.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .yardopts
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/measurements.rb
+- lib/measurements/config/abbreviations.yml
+- lib/measurements/config/conversions.yml
+- lib/measurements/exception.rb
+- lib/measurements/helpers.rb
+- lib/measurements/system.rb
+- lib/measurements/type.rb
+- lib/measurements/unit.rb
+- lib/measurements/unit/baseunit.rb
+- lib/measurements/unit/chain.rb
+- lib/measurements/unit/cup.rb
+- lib/measurements/unit/foot.rb
+- lib/measurements/unit/furlong.rb
+- lib/measurements/unit/gallon.rb
+- lib/measurements/unit/inch.rb
+- lib/measurements/unit/league.rb
+- lib/measurements/unit/mile.rb
+- lib/measurements/unit/ounce.rb
+- lib/measurements/unit/pint.rb
+- lib/measurements/unit/pound.rb
+- lib/measurements/unit/quart.rb
+- lib/measurements/unit/tablespoon.rb
+- lib/measurements/unit/teaspoon.rb
+- lib/measurements/unit/thou.rb
+- lib/measurements/unit/unit.rb
+- lib/measurements/unit/yard.rb
+- lib/measurements/version.rb
+- measurements.gemspec
+- spec/helper.rb
+- spec/measurements_spec.rb
+homepage: http://www.stehlikc.net/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A measurement conversion
+test_files: []
+has_rdoc: