ruby-measurement 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.idea
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matt Huggins
+
+MIT License
+
+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.md

@@ -0,0 +1,153 @@
+# Measurement
+
+[ruby-measurement](https://github.com/mhuggins/ruby-measurement) is a simple
+Ruby gem for calculating and converting units of measure.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ruby-measurement'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby-measurement
+
+## Usage
+
+The `Measurement` class is responsible for parsing strings to determine the
+quantity entered as well as the unit of measure.  This can be done through the
+`parse` method.
+
+    Measurement.parse('3 feet')      # => 3.0 ft.
+    Measurement.parse('25 fl oz')    # => 25.0 fl. oz.
+    Measurement.parse('12 tonnes')   # => 12.0 t
+    Measurement.parse('25 "')        # => 25.0 in.
+
+The object returned by `Measurement.parse` is of type `Measurement`.
+
+    m = Measurement.parse('12 yd')   # => 12.0 yd.
+    Measurement.quantity             # => 12.0
+    Measurement.unit                 # => yd.
+
+The object returned by `Measurement#unit` is of type `Measurement::Unit`.
+
+    u = Measurement.unit             # => yd.
+    u.name                           # => "yd."
+    u.aliases                        # => ["yd.", "yd", "yard", "yards"]
+
+## Converting units
+
+This gem allows you to convert among compatible units as long as a conversion
+has been supplied when defining a unit.  The default supplied units include
+conversions among the same unit types (e.g.: converting feet to yards or meters
+to kilometers).
+
+    m = Measurement.parse('3 feet')  # => 3.0 ft.
+    m.convert_to(:yards)             # => 1.0 yd.
+    m.convert_to(:in)                # => 36.0 in.
+    m.convert_to(:inches)            # => 36.0 in.
+
+NOTE: Converting between metric and U.S. customary systems is currently not
+included by default.  It is intended to be shipped in a future release.
+
+## Calculations
+
+This gem allows you to add, subtract, multiply, or divide measurements that can
+be converted into one-another.
+
+    m1 = Measurement.parse('3 feet') # => 3.0 ft.
+    m2 = Measurement.parse('6 inch') # => 6.0 in.
+    m1 + m2                          # => 3.5 ft.
+
+Additionally, measurements can have basic math operations performed using basic
+numeric values.
+
+    m = Measurement.parse('2 yards') # => 2.0 yd.
+    m * 6                            # => 12.0 yd.
+    m / 5                            # => 0.4 yd.
+    m + 3                            # => 5.0 yd.
+    m - 1                            # => 1.0 yd.
+    m ** 2                           # => 4.0 yd.
+
+## Specifying units
+
+By default, ruby-measurement ships with common areas, lengths, volumes, and
+weights/masses for the metric and U.S. customary systems.  This happens
+automatically when requiring the gem in the following manner.
+
+    require 'ruby-measurement'
+
+To include just one of these systems of measure, require the gem in per the
+following.
+
+    require 'ruby-measurement/measurement'
+    
+    # Metric units/conversions
+    require 'ruby-measurement/definitions/metric'
+    
+    # U.S. customary units/conversions
+    require 'ruby-measurement/definitions/us_customary'
+
+Additionally, specific categories of units of measure can be included per
+system.
+
+    require 'ruby-measurement/measurement'
+    
+    # Metric units/conversions
+    require 'ruby-measurement/definitions/metric/area'
+    require 'ruby-measurement/definitions/metric/length'
+    require 'ruby-measurement/definitions/metric/volume'
+    require 'ruby-measurement/definitions/metric/weight'
+    
+    # U.S. customary units/conversions
+    require 'ruby-measurement/definitions/us_customary/area'
+    require 'ruby-measurement/definitions/us_customary/length'
+    require 'ruby-measurement/definitions/us_customary/volume'
+    require 'ruby-measurement/definitions/us_customary/weight'
+
+## Defining custom units & conversions
+
+This gem also enabled you to define units of measure that aren't included by
+default.
+
+    Measurement.define(:day) do |unit|
+      unit.alias :days
+      unit.convert_to(:week) { |value| value / 7.0 }
+      unit.convert_to(:year) { |value| value / 365.0 }
+    end
+    
+    Measurement.define(:wk) do |unit|
+      unit.alias :week, :weeks
+      unit.convert_to(:day) { |value| value * 7.0 }
+      unit.convert_to(:year) { |value| value / 52.0 }
+    end
+    
+    Measurement.define(:yr) do |unit|
+      unit.alias :year, :years
+      unit.convert_to(:day) { |value| value * 365.0 }
+      unit.convert_to(:week) { |value| value * 52.0 }
+    end
+
+Note that the first value passed to `Measurement.define` is the unit format
+that will be used when displaying a measurement.
+
+    Measurement.parse('3 yr')        # => 3.0 yr
+    Measurement.parse('3 year')      # => 3.0 yr
+    Measurement.parse('3 years')     # => 3.0 yr
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+ruby-measurement is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler/gem_tasks'
+
+Dir.glob('tasks/**/*.rake').each(&method(:import))

data/lib/ruby-measurement/definitions/metric/area.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+Measurement.define(:'km²') do |unit|
+  unit.alias :km2, :'km^2', :'km*km', :'sq km', :'square kilometer', :'square kilometers'
+  unit.convert_to(:ha) { |value| value * 100.0 }
+  unit.convert_to(:a) { |value| value * 10_000.0 }
+  unit.convert_to(:cm2) { |value| value * 10_000_000_000.0 }
+end
+
+Measurement.define(:ha) do |unit|
+  unit.alias :hectare, :hectares
+  unit.convert_to(:km2) { |value| value / 100.0 }
+  unit.convert_to(:a) { |value| value * 100.0 }
+  unit.convert_to(:cm2) { |value| value * 100_000_000.0 }
+end
+
+Measurement.define(:a) do |unit|
+  unit.alias :are, :ares
+  unit.convert_to(:km2) { |value| value / 10_000.0 }
+  unit.convert_to(:ha) { |value| value / 100.0 }
+  unit.convert_to(:cm2) { |value| value * 1_000_000.0 }
+end
+
+Measurement.define(:'cm²') do |unit|
+  unit.alias :cm2, :'cm^2', :'cm*cm', :'sq cm', :'square centimeter', :'square centimeters'
+  unit.convert_to(:km2) { |value| value / 10_000_000_000.0 }
+  unit.convert_to(:ha) { |value| value / 100_000_000.0 }
+  unit.convert_to(:a) { |value| value / 1_000_000.0 }
+end

data/lib/ruby-measurement/definitions/metric/capacity.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+Measurement.define(:kl) do |unit|
+  unit.alias :kiloliter, :kiloliters
+  unit.convert_to(:hl) { |value| value * 10.0 }
+  unit.convert_to(:dal) { |value| value * 100.0 }
+  unit.convert_to(:l) { |value| value * 1000.0 }
+  unit.convert_to(:dl) { |value| value * 10000.0 }
+  unit.convert_to(:cl) { |value| value * 100000.0 }
+  unit.convert_to(:ml) { |value| value * 1000000.0 }
+  unit.convert_to(:µl) { |value| value * 10000000.0 }
+end
+
+Measurement.define(:hl) do |unit|
+  unit.alias :hectoliter, :hectoliters
+  unit.convert_to(:kl) { |value| value / 10.0 }
+  unit.convert_to(:dal) { |value| value * 10.0 }
+  unit.convert_to(:l) { |value| value * 100.0 }
+  unit.convert_to(:dl) { |value| value * 1_000.0 }
+  unit.convert_to(:cl) { |value| value * 10_000.0 }
+  unit.convert_to(:ml) { |value| value * 100_000.0 }
+  unit.convert_to(:µl) { |value| value * 1_000_000.0 }
+end
+
+Measurement.define(:dal) do |unit|
+  unit.alias :dekaliter, :dekaliters
+  unit.convert_to(:kl) { |value| value / 100.0 }
+  unit.convert_to(:hl) { |value| value / 10.0 }
+  unit.convert_to(:l) { |value| value * 10.0 }
+  unit.convert_to(:dl) { |value| value * 100.0 }
+  unit.convert_to(:cl) { |value| value * 1_000.0 }
+  unit.convert_to(:ml) { |value| value * 10_000.0 }
+  unit.convert_to(:µl) { |value| value * 100_000.0 }
+end
+
+Measurement.define(:l) do |unit|
+  unit.alias :liter, :liters
+  unit.convert_to(:kl) { |value| value / 1_000.0 }
+  unit.convert_to(:hl) { |value| value / 100.0 }
+  unit.convert_to(:dal) { |value| value / 10.0 }
+  unit.convert_to(:dl) { |value| value * 10.0 }
+  unit.convert_to(:cl) { |value| value * 100.0 }
+  unit.convert_to(:ml) { |value| value * 1_000.0 }
+  unit.convert_to(:µl) { |value| value * 10_000.0 }
+end
+
+Measurement.define(:dl) do |unit|
+  unit.alias :deciliter, :deciliters
+  unit.convert_to(:kl) { |value| value / 10_000.0 }
+  unit.convert_to(:hl) { |value| value / 1_000.0 }
+  unit.convert_to(:dal) { |value| value / 100.0 }
+  unit.convert_to(:l) { |value| value / 10.0 }
+  unit.convert_to(:cl) { |value| value * 10.0 }
+  unit.convert_to(:ml) { |value| value * 100.0 }
+  unit.convert_to(:µl) { |value| value * 1_000.0 }
+end
+
+Measurement.define(:cl) do |unit|
+  unit.alias :centiliter, :centiliters
+  unit.convert_to(:kl) { |value| value / 10_0000.0 }
+  unit.convert_to(:hl) { |value| value / 10_000.0 }
+  unit.convert_to(:dal) { |value| value / 1_000.0 }
+  unit.convert_to(:l) { |value| value / 100.0 }
+  unit.convert_to(:dl) { |value| value / 10.0 }
+  unit.convert_to(:ml) { |value| value * 10.0 }
+  unit.convert_to(:µl) { |value| value * 100.0 }
+end
+
+Measurement.define(:ml) do |unit|
+  unit.alias :milliliter, :milliliters
+  unit.convert_to(:kl) { |value| value / 1_000_000.0 }
+  unit.convert_to(:hl) { |value| value / 100_000.0 }
+  unit.convert_to(:dal) { |value| value / 10_000.0 }
+  unit.convert_to(:l) { |value| value / 1_000.0 }
+  unit.convert_to(:dl) { |value| value / 100.0 }
+  unit.convert_to(:cl) { |value| value / 10.0 }
+  unit.convert_to(:µl) { |value| value * 10.0 }
+end
+
+Measurement.define(:µl) do |unit|
+  unit.alias :microliter, :microliters
+  unit.convert_to(:kl) { |value| value / 10_000_000.0 }
+  unit.convert_to(:hl) { |value| value / 1_000_000.0 }
+  unit.convert_to(:dal) { |value| value / 100_000.0 }
+  unit.convert_to(:l) { |value| value / 10_000.0 }
+  unit.convert_to(:dl) { |value| value / 1_000.0 }
+  unit.convert_to(:cl) { |value| value / 100.0 }
+  unit.convert_to(:ml) { |value| value / 10.0 }
+end

data/lib/ruby-measurement/definitions/metric/length.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+Measurement.define(:km) do |unit|
+  unit.alias :kilometer, :kilometers
+  unit.convert_to(:hm) { |value| value * 10.0 }
+  unit.convert_to(:dam) { |value| value * 100.0 }
+  unit.convert_to(:m) { |value| value * 1_000.0 }
+  unit.convert_to(:dm) { |value| value * 10_000.0 }
+  unit.convert_to(:cm) { |value| value * 100_000.0 }
+  unit.convert_to(:mm) { |value| value * 1_000_000.0 }
+  unit.convert_to(:µm) { |value| value * 10_000_000.0 }
+end
+
+Measurement.define(:hm) do |unit|
+  unit.alias :hectometer, :hectometers
+  unit.convert_to(:km) { |value| value / 10.0 }
+  unit.convert_to(:dam) { |value| value * 10.0 }
+  unit.convert_to(:m) { |value| value * 100.0 }
+  unit.convert_to(:dm) { |value| value * 1_000.0 }
+  unit.convert_to(:cm) { |value| value * 10_000.0 }
+  unit.convert_to(:mm) { |value| value * 100_000.0 }
+  unit.convert_to(:µm) { |value| value * 1_000_000.0 }
+end
+
+Measurement.define(:dam) do |unit|
+  unit.alias :dekameter, :dekameters
+  unit.convert_to(:km) { |value| value / 100.0 }
+  unit.convert_to(:hm) { |value| value / 10.0 }
+  unit.convert_to(:m) { |value| value * 10.0 }
+  unit.convert_to(:dm) { |value| value * 100.0 }
+  unit.convert_to(:cm) { |value| value * 1_000.0 }
+  unit.convert_to(:mm) { |value| value * 10_000.0 }
+  unit.convert_to(:µm) { |value| value * 100_000.0 }
+end
+
+Measurement.define(:m) do |unit|
+  unit.alias :meter, :meters
+  unit.convert_to(:km) { |value| value / 1_000.0 }
+  unit.convert_to(:hm) { |value| value / 100.0 }
+  unit.convert_to(:dam) { |value| value / 10.0 }
+  unit.convert_to(:dm) { |value| value * 10.0 }
+  unit.convert_to(:cm) { |value| value * 100.0 }
+  unit.convert_to(:mm) { |value| value * 1_000.0 }
+  unit.convert_to(:µm) { |value| value * 10_000.0 }
+end
+
+Measurement.define(:dm) do |unit|
+  unit.alias :decimeter, :decimeters
+  unit.convert_to(:km) { |value| value / 10_000.0 }
+  unit.convert_to(:hm) { |value| value / 1_000.0 }
+  unit.convert_to(:dam) { |value| value / 100.0 }
+  unit.convert_to(:m) { |value| value / 10.0 }
+  unit.convert_to(:cm) { |value| value * 10.0 }
+  unit.convert_to(:mm) { |value| value * 100.0 }
+  unit.convert_to(:µm) { |value| value * 1_000.0 }
+end
+
+Measurement.define(:cm) do |unit|
+  unit.alias :centimeter, :centimeters
+  unit.convert_to(:km) { |value| value / 100_000.0 }
+  unit.convert_to(:hm) { |value| value / 10_000.0 }
+  unit.convert_to(:dam) { |value| value / 1_000.0 }
+  unit.convert_to(:m) { |value| value / 100.0 }
+  unit.convert_to(:dm) { |value| value / 10.0 }
+  unit.convert_to(:mm) { |value| value * 10.0 }
+  unit.convert_to(:µm) { |value| value * 100.0 }
+end
+
+Measurement.define(:mm) do |unit|
+  unit.alias :millimeter, :millimeters
+  unit.convert_to(:km) { |value| value / 1_000_000.0 }
+  unit.convert_to(:hm) { |value| value / 100_000.0 }
+  unit.convert_to(:dam) { |value| value / 10_000.0 }
+  unit.convert_to(:m) { |value| value / 1_000.0 }
+  unit.convert_to(:dm) { |value| value / 100.0 }
+  unit.convert_to(:cm) { |value| value / 10.0 }
+  unit.convert_to(:µm) { |value| value * 10.0 }
+end
+
+Measurement.define(:µm) do |unit|
+  unit.alias :micrometer, :micrometers
+  unit.convert_to(:km) { |value| value / 10_000_000.0 }
+  unit.convert_to(:hm) { |value| value / 1_000_000.0 }
+  unit.convert_to(:dam) { |value| value / 100_000.0 }
+  unit.convert_to(:m) { |value| value / 10_000.0 }
+  unit.convert_to(:dm) { |value| value / 1_000.0 }
+  unit.convert_to(:cm) { |value| value / 100.0 }
+  unit.convert_to(:mm) { |value| value / 10.0 }
+end

data/lib/ruby-measurement/definitions/metric/volume.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+Measurement.define(:'m³') do |unit|
+  unit.alias :m3, :'m^3', :'m*m*m', :'cubic meter', :'cubic meters'
+  unit.convert_to(:dm3) { |value| value * 1_000.0 }
+  unit.convert_to(:cm3) { |value| value * 1_000_000.0 }
+end
+
+Measurement.define(:'dm³') do |unit|
+  unit.alias :dm3, :'dm^3', :'dm*dm*dm', :'cubic decimeter', :'cubic decimeters'
+  unit.convert_to(:m3) { |value| value / 1_000.0 }
+  unit.convert_to(:cm3) { |value| value * 1_000.0 }
+end
+
+Measurement.define(:'cm³') do |unit|
+  unit.alias :cm3, :'cm^3', :'cm*cm*cm', :'cubic centimeter', :'cubic centimeters'
+  unit.convert_to(:m3) { |value| value / 1_000_000.0 }
+  unit.convert_to(:dm3) { |value| value / 1_000.0 }
+end

data/lib/ruby-measurement/definitions/metric/weight.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+Measurement.define(:t) do |unit|
+  unit.alias :'metric tonne', :'metric tonnes', :tonne, :tonnes
+  unit.convert_to(:kg) { |value| value * 1_000.0 }
+  unit.convert_to(:hg) { |value| value * 10_000.0 }
+  unit.convert_to(:dag) { |value| value * 100_000.0 }
+  unit.convert_to(:g) { |value| value * 1_000_000.0 }
+  unit.convert_to(:dg) { |value| value * 10_000_000.0 }
+  unit.convert_to(:cg) { |value| value * 100_000_000.0 }
+  unit.convert_to(:mg) { |value| value * 1_000_000_000.0 }
+  unit.convert_to(:µg) { |value| value * 10_000_000_000.0 }
+end
+
+Measurement.define(:kg) do |unit|
+  unit.alias :kilogram, :kilograms
+  unit.convert_to(:t) { |value| value / 1_000.0 }
+  unit.convert_to(:hg) { |value| value * 10.0 }
+  unit.convert_to(:dag) { |value| value * 100.0 }
+  unit.convert_to(:g) { |value| value * 1_000.0 }
+  unit.convert_to(:dg) { |value| value * 10_000.0 }
+  unit.convert_to(:cg) { |value| value * 100_000.0 }
+  unit.convert_to(:mg) { |value| value * 1_000_000.0 }
+  unit.convert_to(:µg) { |value| value * 10_000_000.0 }
+end
+
+Measurement.define(:hg) do |unit|
+  unit.alias :hectogram, :hectograms
+  unit.convert_to(:t) { |value| value / 10_000.0 }
+  unit.convert_to(:kg) { |value| value / 10.0 }
+  unit.convert_to(:dag) { |value| value * 10.0 }
+  unit.convert_to(:g) { |value| value * 100.0 }
+  unit.convert_to(:dg) { |value| value * 1_000.0 }
+  unit.convert_to(:cg) { |value| value * 10_000.0 }
+  unit.convert_to(:mg) { |value| value * 100_000.0 }
+  unit.convert_to(:µg) { |value| value * 1_000_000.0 }
+end
+
+Measurement.define(:dag) do |unit|
+  unit.alias :dekagram, :dekagrams
+  unit.convert_to(:t) { |value| value / 100_000.0 }
+  unit.convert_to(:kg) { |value| value / 100.0 }
+  unit.convert_to(:hg) { |value| value / 10.0 }
+  unit.convert_to(:g) { |value| value * 10.0 }
+  unit.convert_to(:dg) { |value| value * 100.0 }
+  unit.convert_to(:cg) { |value| value * 1_000.0 }
+  unit.convert_to(:mg) { |value| value * 10_000.0 }
+  unit.convert_to(:µg) { |value| value * 100_000.0 }
+end
+
+Measurement.define(:g) do |unit|
+  unit.alias :gram, :grams
+  unit.convert_to(:t) { |value| value / 1_000_000.0 }
+  unit.convert_to(:kg) { |value| value / 1_000.0 }
+  unit.convert_to(:hg) { |value| value / 100.0 }
+  unit.convert_to(:dag) { |value| value / 10.0 }
+  unit.convert_to(:dg) { |value| value * 10.0 }
+  unit.convert_to(:cg) { |value| value * 100.0 }
+  unit.convert_to(:mg) { |value| value * 1_000.0 }
+  unit.convert_to(:µg) { |value| value * 10_000.0 }
+end
+
+Measurement.define(:dg) do |unit|
+  unit.alias :decigram, :decigrams
+  unit.convert_to(:t) { |value| value / 10_000_000.0 }
+  unit.convert_to(:kg) { |value| value / 10_000.0 }
+  unit.convert_to(:hg) { |value| value / 1_000.0 }
+  unit.convert_to(:dag) { |value| value / 100.0 }
+  unit.convert_to(:g) { |value| value / 10.0 }
+  unit.convert_to(:cg) { |value| value * 10.0 }
+  unit.convert_to(:mg) { |value| value * 100.0 }
+  unit.convert_to(:µg) { |value| value * 1_000.0 }
+end
+
+Measurement.define(:cg) do |unit|
+  unit.alias :centigram, :centigrams
+  unit.convert_to(:t) { |value| value / 100_000_000.0 }
+  unit.convert_to(:kg) { |value| value / 100_000.0 }
+  unit.convert_to(:hg) { |value| value / 10_000.0 }
+  unit.convert_to(:dag) { |value| value / 1_000.0 }
+  unit.convert_to(:g) { |value| value / 100.0 }
+  unit.convert_to(:dg) { |value| value / 10.0 }
+  unit.convert_to(:mg) { |value| value * 10.0 }
+  unit.convert_to(:µg) { |value| value * 100.0 }
+end
+
+Measurement.define(:mg) do |unit|
+  unit.alias :milligram, :milligrams
+  unit.convert_to(:t) { |value| value / 1_000_000_000.0 }
+  unit.convert_to(:kg) { |value| value / 1_000_000.0 }
+  unit.convert_to(:hg) { |value| value / 100_000.0 }
+  unit.convert_to(:dag) { |value| value / 10_000.0 }
+  unit.convert_to(:g) { |value| value / 1_000.0 }
+  unit.convert_to(:dg) { |value| value / 100.0 }
+  unit.convert_to(:cg) { |value| value / 10.0 }
+  unit.convert_to(:µg) { |value| value * 10.0 }
+end
+
+Measurement.define(:µg) do |unit|
+  unit.alias :microgram, :micrograms
+  unit.convert_to(:t) { |value| value / 10_000_000_000.0 }
+  unit.convert_to(:kg) { |value| value / 10_000_000.0 }
+  unit.convert_to(:hg) { |value| value / 1_000_000.0 }
+  unit.convert_to(:dag) { |value| value / 100_000.0 }
+  unit.convert_to(:g) { |value| value / 10_000.0 }
+  unit.convert_to(:dg) { |value| value / 1_000.0 }
+  unit.convert_to(:cg) { |value| value / 100.0 }
+  unit.convert_to(:mg) { |value| value / 10.0 }
+end

data/lib/ruby-measurement/definitions/metric.rb

@@ -0,0 +1,4 @@
+require 'ruby-measurement/definitions/metric/area'
+require 'ruby-measurement/definitions/metric/capacity'
+require 'ruby-measurement/definitions/metric/length'
+require 'ruby-measurement/definitions/metric/volume'

data/lib/ruby-measurement/definitions/us_customary/area.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+Measurement.define(:'mi²') do |unit|
+  unit.alias :mi2, :'mi*mi', :'sq mi', :'square mile', :'square miles'
+  unit.convert_to(:fur2) { |value| value * 64.0 }
+  unit.convert_to(:ch2) { |value| value * 6_400.0 }
+  unit.convert_to(:yd2) { |value| value * 3_097_600.0 }
+  unit.convert_to(:ft2) { |value| value * 27_878_400.0 }
+  unit.convert_to(:in2) { |value| value * 4_014_489_600.0 }
+end
+
+Measurement.define(:'fur²') do |unit|
+  unit.alias :fur2, :'fur*fur', :'sq fur', :'square furlong', :'square furlongs'
+  unit.convert_to(:mi2) { |value| value / 64.0 }
+  unit.convert_to(:ch2) { |value| value * 100.0 }
+  unit.convert_to(:yd2) { |value| value * 48_400.0 }
+  unit.convert_to(:ft2) { |value| value * 435_600.0 }
+  unit.convert_to(:in2) { |value| value * 62_726_400.0 }
+end
+
+Measurement.define(:'ch²') do |unit|
+  unit.alias :ch2, :'ch*ch', :'sq ch', :'square chain', :'square chains'
+  unit.convert_to(:mi2) { |value| value / 6_400.0 }
+  unit.convert_to(:fur2) { |value| value / 100.0 }
+  unit.convert_to(:yd2) { |value| value * 484.0 }
+  unit.convert_to(:ft2) { |value| value * 4_356.0 }
+  unit.convert_to(:in2) { |value| value * 627_264.0 }
+end
+
+Measurement.define(:'yd²') do |unit|
+  unit.alias :yd2, :'yd*yd', :'sq yd', :'square yard', :'square yard'
+  unit.convert_to(:mi2) { |value| value / 3_097_600.0 }
+  unit.convert_to(:fur2) { |value| value / 48_400.0 }
+  unit.convert_to(:ch2) { |value| value / 484.0 }
+  unit.convert_to(:ft2) { |value| value * 9.0 }
+  unit.convert_to(:in2) { |value| value * 1_296.0 }
+end
+
+Measurement.define(:'ft²') do |unit|
+  unit.alias :ft2, :'ft*ft', :'sq ft', :'square foot', :'square foot'
+  unit.convert_to(:mi2) { |value| value / 27_878_400.0 }
+  unit.convert_to(:fur2) { |value| value / 435_600.0 }
+  unit.convert_to(:ch2) { |value| value / 4_356.0 }
+  unit.convert_to(:yd2) { |value| value / 9.0 }
+  unit.convert_to(:in2) { |value| value * 144.0 }
+end
+
+Measurement.define(:'in²') do |unit|
+  unit.alias :in2, :'in*in', :'sq in', :'square inch', :'square inches'
+  unit.convert_to(:mi2) { |value| value / 4_014_489_600.0 }
+  unit.convert_to(:fur2) { |value| value / 62_726_400.0 }
+  unit.convert_to(:ch2) { |value| value / 627_264.0 }
+  unit.convert_to(:yd2) { |value| value / 1_296.0 }
+  unit.convert_to(:ft2) { |value| value / 144.0 }
+end

data/lib/ruby-measurement/definitions/us_customary/length.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+Measurement.define(:'lea.') do |unit|
+  unit.alias :lea, :league, :leagues
+  unit.convert_to(:mi) { |value| value * 3.45233834 }
+  unit.convert_to(:fur) { |value| value * 27.6187068 }
+  unit.convert_to(:ch) { |value| value * 276.187068 }
+  unit.convert_to(:ftm) { |value| value * 3_038.05774 }
+  unit.convert_to(:yd) { |value| value * 6_076.11549 }
+  unit.convert_to(:ft) { |value| value * 18_228.3465 }
+  unit.convert_to(:in) { |value| value * 218_740.157 }
+  unit.convert_to(:th) { |value| value * 218_740_157.0 }
+end
+
+Measurement.define(:'mi.') do |unit|
+  unit.alias :mi, :mile, :miles
+  unit.convert_to(:lea) { |value| value / 3.45233834 }
+  unit.convert_to(:fur) { |value| value * 8.0 }
+  unit.convert_to(:ch) { |value| value * 80.0 }
+  unit.convert_to(:ftm) { |value| value * 880.0 }
+  unit.convert_to(:yd) { |value| value * 1_760.0 }
+  unit.convert_to(:ft) { |value| value * 5_280.0 }
+  unit.convert_to(:in) { |value| value * 63_360.0 }
+  unit.convert_to(:th) { |value| value * 63_360_000.0 }
+end
+
+Measurement.define(:'fur.') do |unit|
+  unit.alias :fur, :furlong, :furlongs
+  unit.convert_to(:lea) { |value| value / 27.6187068 }
+  unit.convert_to(:mi) { |value| value / 8.0 }
+  unit.convert_to(:ch) { |value| value * 10.0 }
+  unit.convert_to(:ftm) { |value| value * 110.0 }
+  unit.convert_to(:yd) { |value| value * 220.0 }
+  unit.convert_to(:ft) { |value| value * 660.0 }
+  unit.convert_to(:in) { |value| value * 7_920.0 }
+  unit.convert_to(:th) { |value| value * 7_920_000.0 }
+end
+
+Measurement.define(:'ch.') do |unit|
+  unit.alias :ch, :chain, :chains
+  unit.convert_to(:lea) { |value| value / 276.187068 }
+  unit.convert_to(:mi) { |value| value / 80.0 }
+  unit.convert_to(:fur) { |value| value / 10.0 }
+  unit.convert_to(:ftm) { |value| value * 11.0 }
+  unit.convert_to(:yd) { |value| value * 22.0 }
+  unit.convert_to(:ft) { |value| value * 66.0 }
+  unit.convert_to(:in) { |value| value * 792.0 }
+  unit.convert_to(:th) { |value| value * 792_000.0 }
+end
+
+Measurement.define(:'ftm.') do |unit|
+  unit.alias :ftm, :fathom, :fathoms
+  unit.convert_to(:lea) { |value| value / 3_038.05774 }
+  unit.convert_to(:mi) { |value| value / 880.0 }
+  unit.convert_to(:fur) { |value| value / 110.0 }
+  unit.convert_to(:ch) { |value| value / 11.0 }
+  unit.convert_to(:yd) { |value| value * 2.0 }
+  unit.convert_to(:ft) { |value| value * 6.0 }
+  unit.convert_to(:in) { |value| value * 72.0 }
+  unit.convert_to(:th) { |value| value * 72_000.0 }
+end
+
+Measurement.define(:'yd.') do |unit|
+  unit.alias :yd, :yard, :yards
+  unit.convert_to(:lea) { |value| value / 6_076.11549 }
+  unit.convert_to(:mi) { |value| value / 1_760.0 }
+  unit.convert_to(:fur) { |value| value / 220.0 }
+  unit.convert_to(:ch) { |value| value / 22.0 }
+  unit.convert_to(:ftm) { |value| value / 2.0 }
+  unit.convert_to(:ft) { |value| value * 3.0 }
+  unit.convert_to(:in) { |value| value * 36.0 }
+  unit.convert_to(:th) { |value| value * 36_000.0 }
+end
+
+Measurement.define(:'ft.') do |unit|
+  unit.alias :ft, :foot, :feet, :"'"
+  unit.convert_to(:lea) { |value| value / 18_228.3465 }
+  unit.convert_to(:mi) { |value| value / 5_280.0 }
+  unit.convert_to(:ch) { |value| value / 66.0 }
+  unit.convert_to(:fur) { |value| value / 660.0 }
+  unit.convert_to(:yd) { |value| value / 3.0 }
+  unit.convert_to(:ftm) { |value| value / 6.0 }
+  unit.convert_to(:in) { |value| value * 12.0 }
+  unit.convert_to(:th) { |value| value * 12_000.0 }
+end
+
+Measurement.define(:'in.') do |unit|
+  unit.alias :in, :inch, :inches, :'"'
+  unit.convert_to(:lea) { |value| value / 218_740.157 }
+  unit.convert_to(:mi) { |value| value / 63_360.0 }
+  unit.convert_to(:fur) { |value| value / 7_920.0 }
+  unit.convert_to(:ch) { |value| value / 792.0 }
+  unit.convert_to(:ftm) { |value| value / 72.0 }
+  unit.convert_to(:yd) { |value| value / 36.0 }
+  unit.convert_to(:ft) { |value| value / 12.0 }
+  unit.convert_to(:th) { |value| value * 1000.0 }
+end
+
+Measurement.define(:'th.') do |unit|
+  unit.alias :th, :thou
+  unit.convert_to(:lea) { |value| value / 218_740_157.0 }
+  unit.convert_to(:mi) { |value| value / 63_360_000.0 }
+  unit.convert_to(:fur) { |value| value / 7_920_000.0 }
+  unit.convert_to(:ch) { |value| value / 792_000.0 }
+  unit.convert_to(:ftm) { |value| value / 72_000.0 }
+  unit.convert_to(:yd) { |value| value / 36_000.0 }
+  unit.convert_to(:ft) { |value| value / 12_000.0 }
+  unit.convert_to(:in) { |value| value / 1000.0 }
+end

data/lib/ruby-measurement/definitions/us_customary/volume.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+Measurement.define(:'gal.') do |unit|
+  unit.alias :gal, :gallon, :gallons
+  unit.convert_to(:qt) { |value| value * 4.0 }
+  unit.convert_to(:pt) { |value| value * 8.0 }
+  unit.convert_to(:c) { |value| value * 16.0 }
+  unit.convert_to(:'fl oz') { |value| value * 128.0 }
+  unit.convert_to(:tbsp) { |value| value * 256.0 }
+  unit.convert_to(:tsp) { |value| value * 768.0 }
+end
+
+Measurement.define(:'qt.') do |unit|
+  unit.alias :qt, :quart, :quarts
+  unit.convert_to(:gal) { |value| value / 4.0 }
+  unit.convert_to(:pt) { |value| value * 2.0 }
+  unit.convert_to(:c) { |value| value * 4.0 }
+  unit.convert_to(:'fl oz') { |value| value * 32.0 }
+  unit.convert_to(:tbsp) { |value| value * 64.0 }
+  unit.convert_to(:tsp) { |value| value * 192.0 }
+end
+
+Measurement.define(:'pt.') do |unit|
+  unit.alias :pt, :pint, :pints
+  unit.convert_to(:gal) { |value| value / 8.0 }
+  unit.convert_to(:qt) { |value| value / 2.0 }
+  unit.convert_to(:c) { |value| value * 2.0 }
+  unit.convert_to(:'fl oz') { |value| value * 16.0 }
+  unit.convert_to(:tbsp) { |value| value * 32.0 }
+  unit.convert_to(:tsp) { |value| value * 96.0 }
+end
+
+Measurement.define(:'c.') do |unit|
+  unit.alias :c, :cup, :cups
+  unit.convert_to(:gal) { |value| value / 16.0 }
+  unit.convert_to(:qt) { |value| value / 4.0 }
+  unit.convert_to(:pt) { |value| value / 2.0 }
+  unit.convert_to(:'fl oz') { |value| value * 8.0 }
+  unit.convert_to(:tbsp) { |value| value * 16.0 }
+  unit.convert_to(:tsp) { |value| value * 48.0 }
+end
+
+Measurement.define(:'fl. oz.') do |unit|
+  unit.alias :'fl oz', :'oz. fl.', :'fluid ounce', :'fluid ounces'
+  unit.convert_to(:gal) { |value| value / 128.0 }
+  unit.convert_to(:qt) { |value| value / 32.0 }
+  unit.convert_to(:pt) { |value| value / 16.0 }
+  unit.convert_to(:c) { |value| value / 8.0 }
+  unit.convert_to(:tbsp) { |value| value * 2.0 }
+  unit.convert_to(:tsp) { |value| value * 6.0 }
+end
+
+Measurement.define(:'tbsp.') do |unit|
+  unit.alias :tbsp, :tablespoon, :tablespoons
+  unit.convert_to(:gal) { |value| value / 256.0 }
+  unit.convert_to(:qt) { |value| value / 64.0 }
+  unit.convert_to(:pt) { |value| value / 32.0 }
+  unit.convert_to(:c) { |value| value / 16.0 }
+  unit.convert_to(:'fl oz') { |value| value / 2.0 }
+  unit.convert_to(:tsp) { |value| value * 3.0 }
+end
+
+Measurement.define(:'tsp.') do |unit|
+  unit.alias :tsp, :teaspoon, :teaspoons
+  unit.convert_to(:gal) { |value| value / 768.0 }
+  unit.convert_to(:qt) { |value| value / 192.0 }
+  unit.convert_to(:pt) { |value| value / 96.0 }
+  unit.convert_to(:c) { |value| value / 48.0 }
+  unit.convert_to(:'fl oz') { |value| value / 6.0 }
+  unit.convert_to(:tbsp) { |value| value / 3.0 }
+end

data/lib/ruby-measurement/definitions/us_customary/weight.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+Measurement.define(:ton) do |unit|
+  unit.alias :'short ton', :'short tons', :tons
+  unit.convert_to(:cwt) { |value| value * 20.0 }
+  unit.convert_to(:lb) { |value| value * 2000.0 }
+  unit.convert_to(:oz) { |value| value * 32_000.0 }
+  unit.convert_to(:dr) { |value| value * 512_000.0 }
+  unit.convert_to(:gr) { |value| value * 14_000_000.0 }
+end
+
+Measurement.define(:cwt) do |unit|
+  unit.alias :hundredweight, :hundredweights
+  unit.convert_to(:ton) { |value| value / 20.0 }
+  unit.convert_to(:lb) { |value| value * 100.0 }
+  unit.convert_to(:oz) { |value| value * 1_600.0 }
+  unit.convert_to(:dr) { |value| value * 28_672.0 }
+  unit.convert_to(:gr) { |value| value * 784_000.0 }
+end
+
+Measurement.define(:lb) do |unit|
+  unit.alias :lbs, :pound, :pounds
+  unit.convert_to(:ton) { |value| value / 2000.0 }
+  unit.convert_to(:cwt) { |value| value / 100.0 }
+  unit.convert_to(:oz) { |value| value * 16.0 }
+  unit.convert_to(:dr) { |value| value * 256.0 }
+  unit.convert_to(:gr) { |value| value * 7000.0 }
+end
+
+Measurement.define(:oz) do |unit|
+  unit.alias :ounce, :ounces
+  unit.convert_to(:ton) { |value| value / 32_000.0 }
+  unit.convert_to(:cwt) { |value| value / 1_600.0 }
+  unit.convert_to(:lb) { |value| value / 16.0 }
+  unit.convert_to(:dr) { |value| value * 16.0 }
+  unit.convert_to(:gr) { |value| value * 437.5 }
+end
+
+Measurement.define(:dr) do |unit|
+  unit.alias :dram, :drams
+  unit.convert_to(:ton) { |value| value / 512_000.0 }
+  unit.convert_to(:cwt) { |value| value / 28_672.0 }
+  unit.convert_to(:lb) { |value| value / 256.0 }
+  unit.convert_to(:oz) { |value| value / 16.0 }
+  unit.convert_to(:gr) { |value| value * 27.34375 }
+end
+
+Measurement.define(:gr) do |unit|
+  unit.alias :grain, :grains
+  unit.convert_to(:ton) { |value| value / 14_000_000.0 }
+  unit.convert_to(:cwt) { |value| value / 784_000.0 }
+  unit.convert_to(:lb) { |value| value / 7000.0 }
+  unit.convert_to(:oz) { |value| value / 437.5 }
+  unit.convert_to(:dr) { |value| value / 27.34375 }
+end

data/lib/ruby-measurement/definitions/us_customary.rb

@@ -0,0 +1,4 @@
+require 'ruby-measurement/definitions/us_customary/area'
+require 'ruby-measurement/definitions/us_customary/length'
+require 'ruby-measurement/definitions/us_customary/volume'
+require 'ruby-measurement/definitions/us_customary/weight'

data/lib/ruby-measurement/definitions.rb

@@ -0,0 +1,2 @@
+require 'ruby-measurement/definitions/metric'
+require 'ruby-measurement/definitions/us_customary'

data/lib/ruby-measurement/measurement.rb

@@ -0,0 +1,162 @@
+require 'ruby-measurement/unit'
+require 'ruby-measurement/version'
+
+class Measurement
+  SCIENTIFIC_NUMBER = %r{([+-]?\d*[.]?\d+(?:[Ee][+-]?)?\d*)}.freeze
+  RATIONAL_NUMBER   = /\A\(?([+-]?\d+)\/(\d+)\)?\z/.freeze
+  COMPLEX_NUMBER    = /\A#{SCIENTIFIC_NUMBER}?#{SCIENTIFIC_NUMBER}i\b\z/.freeze
+  
+  attr_reader :quantity, :unit
+  
+  class << self;  attr_accessor :units end
+  @units = {}
+  
+  def initialize(str)
+    parse(str)
+  end
+  
+  def inspect
+    to_s
+  end
+  
+  def to_s
+    "#{quantity} #{unit}"
+  end
+  
+  def +(obj)
+    case obj
+    when Numeric
+      self.class.new("#{quantity + obj.to_f} #{unit}")
+    when self.class
+      if obj.unit == unit
+        self.class.new("#{quantity + obj.quantity} #{unit}")
+      else
+        self + obj.convert_to(unit)
+      end
+    else
+      raise ArgumentError, "Invalid arithmetic: #{self} + #{obj}"
+    end
+  end
+  
+  def -(obj)
+    case obj
+    when Numeric
+      self.class.new("#{quantity - obj.to_f} #{unit}")
+    when self.class
+      if obj.unit == unit
+        self.class.new("#{quantity - obj.quantity} #{unit}")
+      else
+        self - obj.convert_to(unit)
+      end
+    else
+      raise ArgumentError, "Invalid arithmetic: #{self} - #{obj}"
+    end
+  end
+  
+  def *(obj)
+    case obj
+    when Numeric
+      self.class.new("#{quantity * obj.to_f} #{unit}")
+    when self.class
+      if obj.unit == unit
+        self.class.new("#{quantity * obj.quantity} #{unit}")
+      else
+        self * obj.convert_to(unit)
+      end
+    else
+      raise ArgumentError, "Invalid arithmetic: #{self} * #{obj}"
+    end
+  end
+  
+  def /(obj)
+    case obj
+    when Numeric
+      self.class.new("#{quantity / obj.to_f} #{unit}")
+    when self.class
+      if obj.unit == unit
+        self.class.new("#{quantity / obj.quantity} #{unit}")
+      else
+        self / obj.convert_to(unit)
+      end
+    else
+      raise ArgumentError, "Invalid arithmetic: #{self} / #{obj}"
+    end
+  end
+  
+  def **(obj)
+    case obj
+    when Numeric
+      self.class.new("#{quantity ** obj.to_f} #{unit}")
+    else
+      raise ArgumentError, "Invalid arithmetic: #{self} ** #{obj}"
+    end
+  end
+  
+  def ==(obj)
+    obj.kind_of?(self.class) && quantity == obj.quantity && unit == obj.unit
+  end
+  
+  def convert_to(unit_name)
+    unit = self.class.unit(unit_name)
+    raise ArgumentError, "Invalid unit: '#{unit_name}'" unless unit
+    
+    return dup if unit == @unit
+    
+    conversion = @unit.conversion(unit.name)
+    raise ArgumentError, "Invalid conversion: '#@unit' to '#{unit.name}'" unless conversion
+    
+    self.class.new("#{conversion.call(@quantity)} #{unit.name}")
+  end
+  
+  def convert_to!(unit_name)
+    measurement = convert_to(unit_name)
+    @unit, @quantity = measurement.unit, measurement.quantity
+    self
+  end
+  
+  def self.unit(unit_name)
+    unit_name = unit_name.to_s
+    @units.values.find { |unit| unit.aliases.include?(unit_name) }
+  end
+  
+  def self.parse(str = '0')
+    new(str)
+  end
+  
+  def self.define(unit_name, &block)
+    unit = Unit.new(unit_name, &block)
+    unit.aliases.each { |a| @units[a.downcase] = unit }
+  end
+  
+  private
+  
+  def parse(str)
+    value = str.strip
+    
+    quantity, unit_name = value.split(/\s+/, 2)
+    unit_name ||= 'count'
+    raise ArgumentError, "Missing quantity: '#{str}'" if !quantity || quantity.empty?
+    
+    @unit = self.class.units[unit_name.downcase]
+    raise ArgumentError, "Invalid unit: '#{unit_name}'" unless @unit
+    
+    if quantity =~ COMPLEX_NUMBER
+      real, imaginary = quantity.scan(COMPLEX_NUMBER).first
+      @quantity = Complex(real.to_f, imaginary.to_f).to_f
+    elsif quantity =~ RATIONAL_NUMBER
+      numerator, denominator = quantity.scan(RATIONAL_NUMBER).first
+      @quantity = Rational(numerator.to_i, denominator.to_i).to_f
+    else
+      @quantity = quantity.to_f
+    end
+  end
+  
+  define(:count) do |unit|
+    unit.convert_to(:dozen) { |value| value / 12.0 }
+  end
+  
+  define(:doz) do |unit|
+    unit.alias :dozen
+    unit.convert_to(:count) { |value| value * 12.0 }
+  end
+end

data/lib/ruby-measurement/unit.rb

@@ -0,0 +1,43 @@
+require 'set'
+
+class Measurement
+  class Unit
+    attr_reader :name, :aliases, :conversions
+    
+    def initialize(name, &block)
+      @name = name.to_s
+      @aliases = Set.new
+      @conversions = {}
+      
+      self.alias(name)
+      block.call(self) if block_given?
+    end
+    
+    def alias(*args)
+      args.each { |arg| @aliases << arg.to_s }
+    end
+    
+    def convert_to(name, &block)
+      @conversions[name.to_s] = block
+    end
+    
+    def conversion(name)
+      Measurement.unit(name).aliases.each do |a|
+        conversion = @conversions[a.to_s]
+        return conversion if conversion
+      end
+    end
+    
+    def inspect
+      to_s
+    end
+    
+    def to_s
+      name
+    end
+    
+    def ==(obj)
+      obj.kind_of?(self.class) && hash == obj.hash
+    end
+  end
+end

data/lib/ruby-measurement/version.rb

@@ -0,0 +1,3 @@
+class Measurement
+  VERSION = '0.0.1'
+end

data/lib/ruby-measurement.rb

@@ -0,0 +1,3 @@
+require 'ruby-measurement/version'
+require 'ruby-measurement/measurement'
+require 'ruby-measurement/definitions'

data/ruby-measurement.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-measurement/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ruby-measurement'
+  gem.version       = Measurement::VERSION
+  gem.author        = 'Matt Huggins'
+  gem.email         = 'matt.huggins@gmail.com'
+  gem.description   = 'Simple gem for calculating and converting measurements'
+  gem.summary       = 'Simple gem for calculating and converting measurements'
+  gem.homepage      = 'https://github.com/mhuggins/measurement'
+  
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_path  = 'lib'
+  
+  gem.add_development_dependency 'rake'
+end

data/tasks/debug.rake

@@ -0,0 +1,4 @@
+desc 'Open an irb session preloaded with this library'
+task :console do
+  sh 'irb -rubygems -I lib -r ruby-measurement.rb'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ruby-measurement
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Huggins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2160164820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160164820
+description: Simple gem for calculating and converting measurements
+email: matt.huggins@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby-measurement.rb
+- lib/ruby-measurement/definitions.rb
+- lib/ruby-measurement/definitions/metric.rb
+- lib/ruby-measurement/definitions/metric/area.rb
+- lib/ruby-measurement/definitions/metric/capacity.rb
+- lib/ruby-measurement/definitions/metric/length.rb
+- lib/ruby-measurement/definitions/metric/volume.rb
+- lib/ruby-measurement/definitions/metric/weight.rb
+- lib/ruby-measurement/definitions/us_customary.rb
+- lib/ruby-measurement/definitions/us_customary/area.rb
+- lib/ruby-measurement/definitions/us_customary/length.rb
+- lib/ruby-measurement/definitions/us_customary/volume.rb
+- lib/ruby-measurement/definitions/us_customary/weight.rb
+- lib/ruby-measurement/measurement.rb
+- lib/ruby-measurement/unit.rb
+- lib/ruby-measurement/version.rb
+- ruby-measurement.gemspec
+- tasks/debug.rake
+homepage: https://github.com/mhuggins/measurement
+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.10
+signing_key: 
+specification_version: 3
+summary: Simple gem for calculating and converting measurements
+test_files: []