simple-measures 1.0.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Colin Harris
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,30 @@
+= Simple Measures
+
+all the units you need to describe and convert recipes.
+
+==== volume
+  gallons, quarts, pints, cups, floz
+  liters
+
+==== weight
+  pounds, ounces
+  grams
+
+== Examples
+
+  require 'simple-measures'
+
+  SimpleMeasures.use_imperial_units!
+  SimpleMeasures.use_si_units!
+  SimpleMeasures.use_numeric_sugar!
+
+  ( 3.pounds + 2.oz ).to_grams
+  => #<SimpleMeasures::Unit:0x00000101108e20 @value=1417.4761562, @unit=:grams>
+
+  1.liter.to_quarts
+  => #<SimpleMeasures::Unit:0x00000101115568 @value=1.05668820943259, @unit=:quarts>
+
+
+== Copyright
+
+Copyright (c) 2010 Colin Harris. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.libs << 'lib'
+  t.warning = false
+  t.rcov = false
+  t.spec_opts = ["--colour"]
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Measurement #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+### Task: gem
+gemspec = Gem::Specification.new do |gem|
+  gem.name      = "simple-measures"
+  gem.version   = File.read('VERSION')
+
+  gem.summary     = "SimpleMeasures - simple unit conversions for everyday things"
+  gem.description = "SimpleMeasures is an easy and extensible measurement conversion library"
+
+  gem.authors  = "Colin Harris"
+  gem.email    = "qzzzq1@gmail.com"
+  gem.homepage = "http://github.com/aberant/simple-measures"
+
+  gem.has_rdoc = true
+
+  gem.files        = FileList['Rakefile', 'README.rdoc', 'VERSION', 'LICENSE', 'lib/**/*'].to_a
+  gem.test_files   = FileList['spec/**/*.rb']
+end
+
+Rake::GemPackageTask.new( gemspec ) do |task|
+  task.gem_spec = gemspec
+  task.need_tar = false
+  task.need_tar_gz = true
+  task.need_tar_bz2 = true
+  task.need_zip = true
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/simple-measures.rb

@@ -0,0 +1,30 @@
+# Measurement, all the units you need to describe and convert recipes.
+#
+# == Authors
+#
+# * Colin Harris (@aberant on twitter)
+#
+# == Copyright
+#
+# Copyright (c) 2010 Colin Harris
+#
+# This code released under the terms of the MIT license.
+
+require 'simple-measures/registry'
+require 'simple-measures/registry/unit_entry'
+require 'simple-measures/unit'
+require 'simple-measures/core_ext/symbol'
+
+module SimpleMeasures
+  VERSION = File.read( File.join( File.dirname( __FILE__ ), "..", "VERSION"))
+
+  class InvalidUnitError < StandardError ; end
+  class InvalidAliasError < StandardError ; end
+  class ConversionError < StandardError ; end
+
+  def self.use_si_units!() require 'simple-measures/systems/si'; end
+  def self.use_imperial_units!() require 'simple-measures/systems/imperial'; end
+  def self.use_numeric_sugar!() require 'simple-measures/core_ext/numeric'; end
+
+end
+

data/lib/simple-measures/core_ext/numeric.rb

@@ -0,0 +1,8 @@
+class Numeric
+  def method_missing( meth, *args )
+    unit = meth
+    super unless SimpleMeasures::Registry.valid_unit?( unit )
+
+    SimpleMeasures::Unit.new( self, unit )
+  end
+end

data/lib/simple-measures/core_ext/symbol.rb

@@ -0,0 +1,8 @@
+# Gives Ruby 1.8.X the Symbol#match method
+unless RUBY_VERSION.match(/1.9/)
+  class Symbol
+    def match( regex )
+      self.to_s.match( regex )
+    end
+  end
+end

data/lib/simple-measures/registry.rb

@@ -0,0 +1,65 @@
+#= SimpleMeasures::Registry
+# the central location where all units and aliases are stored
+module SimpleMeasures
+  class Registry
+    @units = {}
+    @aliases = {}
+
+    class << self
+      attr_reader :units
+      attr_reader :aliases
+
+      def add_unit( unit, value, type )
+        @units[unit] = UnitEntry.new( unit, value, type )
+      end
+
+      def add_alias( unit, unit_alias )
+        raise InvalidAliasError unless valid_unit?( unit )
+        @aliases[unit_alias] = unit
+      end
+
+      def unit_conversion_value( name )
+        unit( name ).value
+      end
+
+      def unit_type( name )
+        unit( name ).type
+      end
+
+      def normalized_unit_name( name )
+        aliased_name = @aliases[name]
+
+        return aliased_name if aliased_name
+        return name if @units.keys.include?( name )
+
+        raise InvalidUnitError
+      end
+
+      def compatible_types?( type_a, type_b )
+        unit_type( type_a ) == unit_type( type_b )
+      end
+
+      def clear!
+        @units = {}
+        @alises = {}
+      end
+
+      def valid_unit?( unit )
+        @units.keys.include?( unit ) || @aliases.keys.include?( unit )
+      end
+
+      def smallest_unit_for_type( type )
+        units_filtered_by_type = units.find_all{ |unit| unit[1].type == type }
+        result = units_filtered_by_type.sort{ |a, b| a[1].value <=> b[1].value }
+
+        # only interested in key, not associated struct
+        result[0][0]
+      end
+
+    private
+      def unit( name )
+        @units[normalized_unit_name( name )]
+      end
+    end
+  end
+end

data/lib/simple-measures/registry/unit_entry.rb

@@ -0,0 +1 @@
+UnitEntry = Struct.new( :unit, :value, :type )

data/lib/simple-measures/systems/imperial.rb

@@ -0,0 +1,31 @@
+# ==========
+# = Weight =
+# ==========
+SimpleMeasures::Registry.add_unit( :pound, 453_592.37, :weight )
+SimpleMeasures::Registry.add_unit( :ounce, 28_349.5231, :weight )
+
+
+SimpleMeasures::Registry.add_alias( :pound, :pounds )
+SimpleMeasures::Registry.add_alias( :pound, :lb )
+SimpleMeasures::Registry.add_alias( :pound, :lbs )
+
+SimpleMeasures::Registry.add_alias( :ounce, :ounces )
+SimpleMeasures::Registry.add_alias( :ounce, :oz )
+
+# ==========
+# = Volume =
+# ==========
+SimpleMeasures::Registry.add_unit( :fluid_ounce, 29.5735296, :volume )
+SimpleMeasures::Registry.add_unit( :cup, 236.588237, :volume )
+SimpleMeasures::Registry.add_unit( :pint, 473.176473, :volume )
+SimpleMeasures::Registry.add_unit( :quart, 946.352946, :volume )
+SimpleMeasures::Registry.add_unit( :gallon, 3_785.41178, :volume )
+
+SimpleMeasures::Registry.add_alias( :fluid_ounce, :floz )
+SimpleMeasures::Registry.add_alias( :fluid_ounce, :ozfl )
+SimpleMeasures::Registry.add_alias( :cup, :cups )
+SimpleMeasures::Registry.add_alias( :pint, :pints )
+SimpleMeasures::Registry.add_alias( :quart, :quarts )
+SimpleMeasures::Registry.add_alias( :quarts, :qt )
+SimpleMeasures::Registry.add_alias( :gallon, :gallons )
+SimpleMeasures::Registry.add_alias( :gallon, :gal )

data/lib/simple-measures/systems/si.rb

@@ -0,0 +1,29 @@
+# ==========
+# = Weight =
+# ==========
+SimpleMeasures::Registry.add_unit( :milligram, 1, :weight )
+SimpleMeasures::Registry.add_unit( :gram, 10 ** 3, :weight )
+SimpleMeasures::Registry.add_unit( :kilogram, 10 ** 6, :weight )
+
+
+SimpleMeasures::Registry.add_alias( :milligram, :milligrams )
+SimpleMeasures::Registry.add_alias( :milligram, :mg )
+
+SimpleMeasures::Registry.add_alias( :gram, :grams )
+SimpleMeasures::Registry.add_alias( :gram, :g )
+
+SimpleMeasures::Registry.add_alias( :kilogram, :kilograms )
+SimpleMeasures::Registry.add_alias( :kilogram, :kg )
+
+# ==========
+# = Volume =
+# ==========
+SimpleMeasures::Registry.add_unit( :milliliter, 1, :volume )
+SimpleMeasures::Registry.add_unit( :liter, 10 ** 3, :volume )
+
+
+SimpleMeasures::Registry.add_alias( :milliliter, :milliliters )
+SimpleMeasures::Registry.add_alias( :milliliter, :ml )
+
+SimpleMeasures::Registry.add_alias( :liter, :liters )
+SimpleMeasures::Registry.add_alias( :liter, :l )

data/lib/simple-measures/unit.rb

@@ -0,0 +1,112 @@
+module SimpleMeasures
+  class Unit
+    include Comparable
+
+    attr_reader :unit, :value
+
+    def initialize( value, unit )
+      raise InvalidUnitError, "Invalid Unit" unless Registry.valid_unit?( unit )
+      @value = value
+      @unit = unit
+    end
+
+    def <=>( other )
+      raise ArgumentError, "Cannot compare #{unit} to #{other.unit}" unless Registry.compatible_types?( unit, other.unit)
+      # we have to make some compromises here
+      # sometimes floats appear equal, but a bagillionth decimal place later
+      # there is some mystery number that screws this up.  thus we chop it off after the thousandths place.
+
+      # please enquire about the "enterprise" license which will give you precision to the ten thousandths place
+      other_value = ( other.convert_to( smallest_common_unit ).value * 1000 ).round
+      self_value = ( convert_to( smallest_common_unit ).value * 1000 ).round
+
+      other_value <=> self_value
+    end
+
+    def *( multiplier )
+      case multiplier
+      when Numeric
+        Unit.new( @value * multiplier, @unit )
+      else
+        raise ArgumentError, "Only able to acecpt Numeric types for multiplication"
+      end
+    end
+
+    def /( divisor )
+      case divisor
+      when Numeric
+        Unit.new( @value / divisor, @unit )
+      else
+        raise ArgumentError, "Only able to acecpt Numeric types for division"
+      end
+    end
+
+    def +( other )
+      raise ArgumentError, "Only able to add Measurement::Unit objects" unless other.class == Unit
+      raise ArgumentError, "Cannot add #{unit} to #{other.unit}" unless Registry.compatible_types?( unit, other.unit )
+
+      converted_self = convert_to( smallest_common_unit ).value
+      converted_other = other.convert_to( smallest_common_unit ).value
+
+      Unit.new( converted_self + converted_other, smallest_common_unit )
+    end
+
+    def -( other )
+      raise ArgumentError, "Only able to subtract Measurement::Unit objects" unless other.class == Unit
+      raise ArgumentError, "Cannot add #{unit} to #{other.unit}" unless Registry.compatible_types?( unit, other.unit )
+
+      converted_self = convert_to( smallest_common_unit ).value
+      converted_other = other.convert_to( smallest_common_unit ).value
+
+      Unit.new( converted_self - converted_other, smallest_common_unit )
+
+    end
+
+    def coerce( other )
+      return self, other
+    end
+
+    def convert_to( new_unit )
+      raise ConversionError, "Cannot convert #{unit} to #{new_unit}" unless Registry.compatible_types?( unit, new_unit )
+
+      old_unit = @unit
+
+      new_conversion = Registry.unit_conversion_value( new_unit )
+      old_conversion = Registry.unit_conversion_value( old_unit )
+
+      old_base = @value * old_conversion.to_f
+      new_value = old_base / new_conversion.to_f
+
+      Unit.new( new_value, new_unit )
+    end
+
+    def method_missing( meth, *args )
+      super unless meth.match( /^to_/ )
+
+      new_unit = meth.to_s.gsub( 'to_', '' ).to_sym
+      super unless Registry.valid_unit?( new_unit )
+
+      convert_to( new_unit )
+    end
+
+    def hash
+      unit.hash ^
+      value.hash
+    end
+
+    def eql?( other )
+      self.class.equal?( other.class ) &&
+      unit == other.unit &&
+      value == other.value
+    end
+
+    def to_s
+      "#{value} #{unit}"
+    end
+
+  private
+    def smallest_common_unit
+      Registry.smallest_unit_for_type( Registry.unit_type( unit) )
+    end
+  end
+end

data/spec/simple-measures/registry_spec.rb

@@ -0,0 +1,68 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+describe SimpleMeasures::Registry do
+  before :each do
+    SimpleMeasures::Registry.clear!
+  end
+
+  it "should be able to add units" do
+    SimpleMeasures::Registry.add_unit( :milligram, 1, :weight )
+    SimpleMeasures::Registry.units.should have_key( :milligram )
+  end
+
+  it "should be able to add an alias" do
+    SimpleMeasures::Registry.add_unit( :milligram, 1, :weight )
+    SimpleMeasures::Registry.add_alias( :milligram, :milligrams )
+
+    SimpleMeasures::Registry.aliases.should have_key( :milligrams )
+  end
+
+  it "should not be able to add an alias if there is no coresponding unit" do
+    lambda{
+      SimpleMeasures::Registry.add_alias( :milligram, :milligrams )
+    }.should raise_error( SimpleMeasures::InvalidAliasError )
+  end
+
+  it "should return the normalized unit name for a given alias" do
+    SimpleMeasures::Registry.add_unit( :milligram, 1, :weight )
+    SimpleMeasures::Registry.add_alias( :milligram, :bob )
+
+
+    SimpleMeasures::Registry.normalized_unit_name( :bob ).should == :milligram
+  end
+
+  it "should return the unit conversion value" do
+    SimpleMeasures::Registry.add_unit( :gram, 1000, :weight )
+
+    SimpleMeasures::Registry.unit_conversion_value( :gram ).should == 1000
+  end
+
+  it "should return the unit conversion value for an alias" do
+    SimpleMeasures::Registry.add_unit( :gram, 1000, :weight )
+    SimpleMeasures::Registry.add_alias( :gram, :grams )
+
+    SimpleMeasures::Registry.unit_conversion_value( :grams ).should == 1000
+  end
+
+  it "should return the unit type" do
+    SimpleMeasures::Registry.add_unit( :gram, 1000, :weight )
+
+    SimpleMeasures::Registry.unit_type( :gram ).should == :weight
+  end
+
+  it "should return the unit type for an alias" do
+    SimpleMeasures::Registry.add_unit( :gram, 1000, :weight )
+    SimpleMeasures::Registry.add_alias( :gram, :grams )
+
+    SimpleMeasures::Registry.unit_type( :grams ).should == :weight
+  end
+
+  it "should be able to return the smallest unit for a type" do
+    SimpleMeasures::Registry.add_unit( :gram, 1000, :weight )
+    SimpleMeasures::Registry.add_unit( :milligram, 1, :weight )
+    SimpleMeasures::Registry.add_unit :pound, 453_592.37, :weight
+    SimpleMeasures::Registry.add_unit( :fluid_ounces, 1, :volume )
+
+    SimpleMeasures::Registry.smallest_unit_for_type( :weight ).should == :milligram
+  end
+end

data/spec/simple-measures/unit_spec.rb

@@ -0,0 +1,154 @@
+require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
+
+describe SimpleMeasures::Unit do
+  before :each do
+    SimpleMeasures::Registry.clear!
+    SimpleMeasures::Registry.add_unit :gram, 1000, :weight
+    SimpleMeasures::Registry.add_alias :gram, :grams
+
+    SimpleMeasures::Registry.add_unit :milligram, 1, :weight
+    SimpleMeasures::Registry.add_alias :milligram, :milligrams
+
+    SimpleMeasures::Registry.add_unit :pound, 453_592.37, :weight
+    SimpleMeasures::Registry.add_alias :pound, :pounds
+
+    SimpleMeasures::Registry.add_unit :milliliter, 1, :volume
+    SimpleMeasures::Registry.add_alias :milliliter, :milliliters
+
+    SimpleMeasures::Registry.add_unit :fluid_ounce, 28.413, :volume
+    SimpleMeasures::Registry.add_alias :fluid_ounce, :fl_oz
+  end
+
+  describe "basics" do
+    it "does not accept units it doesn't know about" do
+      lambda {
+        SimpleMeasures::Unit.new( 42, :blarghs )
+      }.should raise_error( SimpleMeasures::InvalidUnitError )
+    end
+
+    it "should know aliases for the same unit" do
+      SimpleMeasures::Unit.new( 2, :grams ).should == SimpleMeasures::Unit.new( 2, :gram )
+    end
+  end
+
+  describe "equality" do
+    it "should know basic equality" do
+      weight1 = SimpleMeasures::Unit.new( 42, :grams )
+      weight2 = SimpleMeasures::Unit.new( 42, :grams )
+
+      weight1.should == weight2
+    end
+
+    it "should know equality between convertable units" do
+      weight1 = SimpleMeasures::Unit.new( 4, :grams )
+      weight2 = SimpleMeasures::Unit.new( 4000, :milligrams )
+
+      weight1.should == weight2
+    end
+  end
+
+  describe "conversion" do
+    it "should convert from grams to pounds" do
+      weight = SimpleMeasures::Unit.new( 907.18474, :grams )
+
+      weight.convert_to( :pounds ).should == SimpleMeasures::Unit.new( 2, :pounds )
+    end
+
+    it "should convert from grams to milligrams" do
+      weight = SimpleMeasures::Unit.new( 2, :grams )
+      weight.convert_to( :milligrams ).should == SimpleMeasures::Unit.new( 2000, :milligrams )
+    end
+
+    it "should have convience methods for the unit" do
+      weight = SimpleMeasures::Unit.new( 2, :grams )
+      weight.to_milligram.should == SimpleMeasures::Unit.new( 2000, :milligrams )
+    end
+
+    it "should have convience methods for the alias" do
+      weight = SimpleMeasures::Unit.new( 2, :grams )
+      weight.to_milligrams.should == SimpleMeasures::Unit.new( 2000, :milligrams )
+    end
+
+    it "blows up if there is not a unit for a convience method" do
+      weight = SimpleMeasures::Unit.new( 2, :grams )
+      lambda{
+        weight.to_blarghs
+      }.should raise_error( NoMethodError )
+    end
+
+    it "blows up if you try to convert between incompatible types" do
+      weight = SimpleMeasures::Unit.new( 2, :grams )
+      lambda{
+        weight.convert_to(:fl_oz)
+      }.should raise_error( SimpleMeasures::ConversionError )
+    end
+  end
+
+  describe "using coersion" do
+    it "is able to multiply" do
+      result = 2 * SimpleMeasures::Unit.new( 2,:pounds )
+      result.should == SimpleMeasures::Unit.new( 4, :pounds )
+    end
+
+    it "is able to divide" do
+      result = SimpleMeasures::Unit.new( 8,:pounds ) / 2
+      result.should == SimpleMeasures::Unit.new( 4, :pounds )
+    end
+  end
+
+  describe "addition" do
+    it "should be able to add two items of the exact same units" do
+      ( SimpleMeasures::Unit.new( 1, :gram ) +
+        SimpleMeasures::Unit.new( 1, :gram ) ).should == SimpleMeasures::Unit.new( 2, :grams )
+    end
+
+    it "should be able to add two items of the same units with one using an alias" do
+      ( SimpleMeasures::Unit.new( 1, :gram ) +
+        SimpleMeasures::Unit.new( 2, :grams ) ).should == SimpleMeasures::Unit.new( 3, :grams )
+    end
+
+    it "should be able to add two items of different but compatible units" do
+      ( SimpleMeasures::Unit.new( 1, :milligram ) +
+        SimpleMeasures::Unit.new( 1, :gram ) ).should == SimpleMeasures::Unit.new( 1.001, :grams )
+    end
+
+    it "should not be able to add items of different types" do
+      lambda {
+        SimpleMeasures::Unit.new( 1, :gram ) + SimpleMeasures::Unit.new( 1, :milliliter)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "subtraction" do
+    it "should be able to subtract two items of the exact same units" do
+      ( SimpleMeasures::Unit.new( 5, :gram ) -
+        SimpleMeasures::Unit.new( 1, :gram ) ).should == SimpleMeasures::Unit.new( 4, :grams )
+    end
+
+    it "should be able to subtract two items of the same units with one using an alias" do
+      ( SimpleMeasures::Unit.new( 6, :gram ) -
+        SimpleMeasures::Unit.new( 3, :grams ) ).should == SimpleMeasures::Unit.new( 3, :grams )
+    end
+
+    it "should be able to subtract two items of different but compatible units" do
+      ( SimpleMeasures::Unit.new( 1, :gram ) -
+        SimpleMeasures::Unit.new( 1, :milligram ) ).should == SimpleMeasures::Unit.new( 999, :milligrams )
+    end
+
+    it "should not be able to subtract items of different types" do
+      lambda {
+        SimpleMeasures::Unit.new( 1, :gram ) - SimpleMeasures::Unit.new( 1, :milliliter)
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "hashing" do
+    it "is correct so it can be used as a key" do
+      five_grams = SimpleMeasures::Unit.new( 5, :gram )
+      another_five_grams = SimpleMeasures::Unit.new( 5, :gram )
+
+      hash = {five_grams => 1 }.merge( another_five_grams => 2 )
+      hash.keys.size.should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'spec'
+require 'simple-measures'

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: simple-measures
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Colin Harris
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-15 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: SimpleMeasures is an easy and extensible measurement conversion library
+email: qzzzq1@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.rdoc
+- VERSION
+- LICENSE
+- lib/simple-measures/core_ext/numeric.rb
+- lib/simple-measures/core_ext/symbol.rb
+- lib/simple-measures/registry/unit_entry.rb
+- lib/simple-measures/registry.rb
+- lib/simple-measures/systems/imperial.rb
+- lib/simple-measures/systems/si.rb
+- lib/simple-measures/unit.rb
+- lib/simple-measures.rb
+has_rdoc: true
+homepage: http://github.com/aberant/simple-measures
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SimpleMeasures - simple unit conversions for everyday things
+test_files: 
+- spec/simple-measures/registry_spec.rb
+- spec/simple-measures/unit_spec.rb
+- spec/spec_helper.rb