simple_units 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

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

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem "activesupport"
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.8.0"
+  gem "rdoc", ">= 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.8.4"
+  gem "simplecov"
+end

data/Gemfile.lock

@@ -0,0 +1,42 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    diff-lcs (1.2.1)
+    git (1.2.5)
+    i18n (0.6.4)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    multi_json (1.6.1)
+    rake (10.0.3)
+    rdoc (4.0.0)
+      json (~> 1.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.0)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler (>= 1.0.0)
+  jeweler (>= 1.8.4)
+  rdoc (>= 3.12)
+  rspec (>= 2.8.0)
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Thomas
+
+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,19 @@
+= simple_units
+
+Description goes here.
+
+== Contributing to simple_units
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Thomas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "simple_units"
+  gem.homepage = "http://github.com/foxnewsnetwork/simple_units"
+  gem.license = "MIT"
+  gem.summary = %Q{Simple units implementation. Similar to ruby-units except with a lot less features and zero collisons with rails.}
+  gem.description = %Q{Sure, ruby is dynamic and that is one of its greatest strength. Object polymorphisms, duck typing, and the like is great in ruby, there is a time and place for everything. Sometimes, it just makes more sense to be strongly typed.}
+  gem.email = "foxnewsnetwork@gmail.com"
+  gem.authors = ["Thomas Chen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simple_units #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/simple_units.rb

@@ -0,0 +1,6 @@
+require "active_support"
+module SimpleUnits
+  require File.join(File.dirname(__FILE__), "simple_units", "composite")
+  require File.join(File.dirname(__FILE__), "simple_units", "context")
+  require File.join(File.dirname(__FILE__), "simple_units", "unit")
+end

data/lib/simple_units/composite.rb

@@ -0,0 +1,101 @@
+module SimpleUnits
+  class Composite
+
+    class << self
+      def from_context(context)
+        new.tap do |composite|
+          composite.append_numerators! context
+        end
+      end
+
+      def from_string(string)
+        from_context SimpleUnits::Context.get_context string
+      end
+    end
+
+    def append_numerators!(*contexts)
+      contexts.each { |context| append_numerator! context }
+      simplify!
+    end
+
+    def append_denominators!(*contexts)
+      contexts.each { |context| append_denominator! context }
+      simplify!
+    end
+
+    def append_numerator!(context)
+      modify_context_by_order!(context, 1)
+    end
+
+    def append_denominator!(context)
+      modify_context_by_order!(context, -1)
+    end
+
+    def modify_context_by_order!(context, order)
+      @contexts_hash ||= {}
+      if @contexts_hash[context.name.to_s].nil? 
+        @contexts_hash[context.name.to_s] = { :context => context, :order => order }
+      else
+        @contexts_hash[context.name.to_s][:order] += order
+      end
+    end
+
+
+    def numerators
+      @contexts_hash.reject do |name, hash|
+        hash[:order] < 0
+      end
+    end
+
+    def denominators
+      @contexts_hash.reject do |name, hash|
+        hash[:order] > 0
+      end
+    end
+
+
+    def inverse
+      self.class.new.tap do |composite|
+        (numerators.to_a + denominators.to_a).each { |name, hash| composite.modify_context_by_order!(hash[:context], -hash[:order]) }
+        composite.simplify!
+      end
+    end
+
+    def simplify!
+      @contexts_hash.reject! do |name, hash|
+        hash[:order].zero?
+      end
+    end
+
+    def inspector
+      if @contexts_hash.keys.count == 1 
+        @contexts_hash[@contexts_hash.keys.first][:context].inspector
+      end
+    end
+
+    def to_str
+      @contexts_hash.to_a.sort { |a,b| a.first <=> b.first }.inject("") do |str, package|
+        order = package.last[:order]
+        name = package.first
+        str + "(#{name}^#{order})"
+      end.gsub("^1", "")
+    end
+
+    def to_s; to_str; end
+
+    def *(other)
+      array = other.denominators.to_a + self.denominators.to_a + other.numerators.to_a + self.numerators.to_a
+      self.class.new.tap do |composite|
+        array.each do |name, hash|
+          composite.modify_context_by_order!(hash[:context], hash[:order])
+        end
+        composite.simplify!
+      end
+    end
+
+    def ==(other)
+      to_str == other.to_str
+    end
+
+  end
+end

data/lib/simple_units/context.rb

@@ -0,0 +1,24 @@
+module SimpleUnits
+  class Context
+
+    class << self
+      def define_unit(name, &block)
+        @contexts ||= {}
+        @contexts[name.to_s] = new(name, &block) 
+      end
+
+      def get_context(name)
+        throw :UndefinedUnitError if @contexts[name].nil?
+        @contexts[name.to_s]
+      end
+    end
+
+    attr_accessor :name, :type, :inspector
+    def initialize(name=nil, &block)
+      @name = name
+      yield(self)
+    end
+
+  end
+end
+

data/lib/simple_units/unit.rb

@@ -0,0 +1,104 @@
+module SimpleUnits
+  class Unit < Numeric
+    class MismatchError < Exception; end
+    class UnknownUnitError < Exception; end
+    class << self
+      def convert_dimension(to_unit, from_unit)
+        throw :CannotConvertDimension
+      end
+
+      # Not really implemented yet
+      def simplify_dimensions(unit)
+        unit
+      end
+    end
+
+    attr_accessor :value, :composite
+
+    def initialize(value, units)
+      @value = value
+      case units.class.to_s
+      when "String", "Symbol"
+        @composite = SimpleUnits::Composite.from_string units.to_s
+      when "SimpleUnits::Context"
+        @composite = SimpleUnits::Composite.from_context units
+      when "SimpleUnits::Composite"
+        @composite = units
+      else
+        raise UnknownUnitError.new("#{units} is a #{units.class}")
+      end
+      
+    end
+
+    def units
+      composite.to_s
+    end
+
+    def to_i
+      to_something("i")
+    end
+
+    def to_f
+      to_something("f")
+    end
+
+    def to_something(thing)
+      value.send("to_#{thing}")
+    end
+
+    def +(other)
+      if same_dimension? other
+        self.class.new(value + other.value, composite)
+      else
+        self + SimpleUnits::Unit.convert_dimension(self, other)
+      end
+    end
+
+    def -(other)
+      self + other.opposite
+    end
+
+    def *(other)
+      case other.class.to_s
+      when "Fixnum", "Float", "Integer", "Numeric"
+        new_value = value * other
+        new_composite = composite
+      when "SimpleUnits::Unit"
+        new_value = value * other.value
+        new_composite = composite * other.composite  
+      else
+        raise MismatchError.new "#{other} is a #{other.class.to_s}"
+      end
+      self.class.simplify_dimensions self.class.new(new_value, new_composite)
+    end
+
+    def /(other)
+      self * other.inverse
+    end
+
+    def opposite
+      self.class.new(-value, composite)
+    end
+
+    def inverse
+      self.class.new(1 / value.to_f, composite.inverse)
+    end
+
+    def inspect
+      if composite.inspector.nil?
+        "#{value} #{composite.to_s}"
+      else
+        composite.inspector.call(value)
+      end
+    end
+
+    def to_s; inspect; end
+
+    def to_str; to_s; end
+
+    def same_dimension?(other)
+      self.composite == other.composite
+    end
+
+  end
+end

data/spec/simple_units/composite_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+describe SimpleUnits::Composite do
+  let(:api) { SimpleUnits::Composite }
+  let(:cc) { SimpleUnits::Context }
+  before :each do
+    cc.define_unit("dog") { |unit| unit.type = :animal }
+    cc.define_unit("cat") { |unit| unit.type = :animal }
+    cc.define_unit("user") { |unit| unit.type = :person }
+  end
+  describe "::new" do
+    let(:composite) { api.new }
+    let(:dog) { cc.get_context "dog" }
+    let(:cat) { cc.get_context "cat" }
+    let(:user) { cc.get_context "user" }
+
+    specify { composite.should be_a api }
+
+    describe "#==" do
+      let(:pet_owner) { api.new }
+      let(:faggot) { api.new }
+      before :each do
+        pet_owner.append_numerators! dog
+        pet_owner.append_denominators! user
+        faggot.append_numerators! dog, cat, user, dog, cat
+        faggot.append_denominators! dog, cat, cat, user, user
+      end
+
+      it "should be equal since we simplify the units" do
+        pet_owner.should == faggot
+      end
+
+      it "should not equal to things with differing units" do
+        pet_owner.append_numerators! user
+        pet_owner.should_not == faggot
+      end
+    end
+
+    describe "#*" do
+      let(:dog_per_user) { api.new }
+      let(:cat_per_user) { api.new }
+      let(:dog_cat_per_user_squared) { dog_per_user * cat_per_user }
+      before :each do
+        dog_per_user.append_numerators! dog
+        dog_per_user.append_denominators! user
+        cat_per_user.append_numerators! cat
+        cat_per_user.append_denominators! user
+      end
+
+      context "reductions" do
+        describe "#inverse" do
+          let(:user_per_dog) { dog_per_user.inverse }
+          let(:user_per_cat) { cat_per_user.inverse }
+          it "should properly give me the units for user per dog" do
+            user_per_dog.to_s.should eq "(dog^-1)(user)"
+            dog_per_user.to_s.should eq "(dog)(user^-1)"
+            user_per_cat.to_s.should eq "(cat^-1)(user)"
+            cat_per_user.to_s.should eq "(cat)(user^-1)"
+          end
+
+          describe "#*" do
+            let(:scalar) { dog_per_user * user_per_dog }
+            it "should reduce down to a scalar if something is hit with its inverse" do
+              scalar.numerators.should eq({})
+              scalar.denominators.should eq({})
+              scalar.to_s.should eq ""
+            end
+          end
+        end
+      end
+
+      describe "#numerators" do
+        before :each do
+          @expected = {
+            "dog" => { :order => 1, :context => dog },
+            "cat" => { :order => 1, :context => cat }
+          }
+        end
+
+        it "should match the numerator list" do
+          dog_cat_per_user_squared.numerators.should eq @expected
+        end
+      end
+
+      describe "#denominators" do
+        before :each do
+          @expected = {
+            "user" => { :order => -2, :context => user }
+          }
+        end
+
+        it "should match the numerator list" do
+          dog_cat_per_user_squared.denominators.should eq @expected
+        end
+      end
+
+      describe "#to_str" do
+        before(:each) { @expected = "(cat)(dog)(user^-2)" }
+
+        specify { dog_cat_per_user_squared.to_str.should eq @expected }
+      end
+    end
+
+    describe "#append_numerators" do
+      before :each do
+        composite.append_numerators! dog, cat, user
+      end
+
+      describe "#numerators" do
+        before :each do
+          @expected = {
+            "dog" => {:order => 1, :context => dog} ,
+            "cat" => {:order => 1, :context => cat} ,
+            "user" => {:order => 1, :context => user} 
+          }
+        end
+
+        it "should spit out all the numerators involved in building my composite" do
+          composite.numerators.count.should eq @expected.count
+          composite.numerators.should eq @expected
+        end
+      end
+
+      describe "#denominators" do
+        specify { composite.denominators.should be_empty }
+      end
+
+      describe "#to_str" do
+        before :each do
+          @expected = "(cat)(dog)(user)"
+        end
+
+        it "should be an alias to to_s" do
+          composite.to_str.should eq composite.to_s
+        end
+
+        it "should give me the expected string result" do
+          composite.to_str.should eq @expected
+        end
+      end
+
+      describe "#append_denominators" do
+        before :each do
+          composite.append_denominators! dog, dog, dog
+        end
+
+        describe "#numerators" do
+          before :each do
+            @expected = {
+              "cat" => {:order => 1, :context => cat} ,
+              "user" => {:order => 1, :context => user}    
+            }
+          end
+
+          it "should spit out only the numerators as in things with order > 0" do
+            composite.numerators.should eq @expected
+          end
+        end
+
+        describe "#denominators" do
+          before :each do
+            @expected = {
+              "dog" => { :order => -2, :context => dog }
+            }
+          end
+          it "should have the denominators as per expectation" do
+            composite.denominators.should eq @expected
+          end
+        end
+
+        describe "#to_str" do
+          before :each do
+            @expected = "(cat)(dog^-2)(user)"
+          end
+          it "should give me the expected stringified version as well as match its alias" do
+            composite.to_s.should eq @expected
+            composite.to_str.should eq composite.to_s
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/simple_units/context_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe SimpleUnits::Context do
+  let(:api) { SimpleUnits::Context }
+  describe "::define" do
+    before(:each) do
+      api.define_unit("meter") do |unit|
+        unit.type = :length
+      end
+    end
+    describe "::get_context" do
+      it "should be able to fetch the context I just defined" do
+        api.get_context("meter").should be_a api
+        api.get_context("meter").name.should eq "meter"
+        api.get_context("meter").type.should eq :length
+      end
+    end
+  end
+end

data/spec/simple_units/unit_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe SimpleUnits::Unit do 
+  let(:model) { SimpleUnits::Unit }
+  let(:cc) { SimpleUnits::Context } 
+  context "usage" do
+    before :each do
+      cc.define_unit("user") do |unit|
+        unit.type = :people
+      end
+      cc.define_unit("faggots") do |unit|
+        unit.type = :people
+        unit.inspector = lambda { |value| "8==D #{value} G==8" }
+      end
+      cc.define_unit("baggage") do |unit|
+        unit.type = :stuff
+      end
+    end 
+
+    describe "::new" do
+      let(:four) { model.new 4, "user" }
+      let(:three) { model.new 3, "user" }
+      let(:five) { model.new 5, "faggots" }
+      let(:sixteen) { model.new 16, cc.get_context("baggage")}
+
+      context "crap" do
+        let(:crap) { model.new 33, RSpec }
+        it "should throw an error that indictates you've passed crap to try to start a new unit" do
+          expect { crap }.to raise_error(SimpleUnits::Unit::UnknownUnitError, "RSpec is a Module")
+        end
+      end
+      it "should give me an unit of the correct number" do
+        four.should be_a model
+        four.value.should eq 4
+        four.units.should eq "(user)"
+        sixteen.should be_a model
+        sixteen.value.should eq 16
+        sixteen.units.should eq "(baggage)"
+      end
+
+      describe "#to_i" do
+        it "should just give the absolute value of a current unit in integer form" do
+          five.to_i.should eq 5
+          three.to_i.should eq 3
+          four.to_i.should eq 4
+        end
+      end
+
+      describe "#to_f" do
+        it "should give the absolute value as a float" do
+          five.to_f.should eq 5.0
+          three.to_f.should eq 3.0
+          four.to_i.should eq 4.0
+        end
+      end
+
+      describe "#inverse" do
+        context "normal" do
+          let(:one_fifth) { five.inverse }
+          it "should properly invert a number" do
+            one_fifth.to_f.should eq 0.2
+          end
+          it "should have the correct units" do
+            one_fifth.units.to_s.should eq "(faggots^-1)"
+          end
+        end
+
+        context "infinity" do
+          let(:zero) { model.new 0, "faggots" }
+          let(:infinity) { zero.inverse }
+          it "should give me infinity" do
+            infinity.value.should eq Float::INFINITY
+          end
+          it "should still be the correct units" do
+            zero.units.to_s.should eq "(faggots)"
+            infinity.units.to_s.should eq "(faggots^-1)"
+          end
+        end
+      end
+
+      describe "#/" do
+        context "unitary" do
+          let(:eleven) { model.new 11, "faggots" }
+          let(:one) { eleven / eleven }
+          let(:one2) { eleven * eleven.inverse }
+          it "should support proper division" do
+            one.value.should eq 1.0
+          end
+
+          it "should become a scalar at this point" do
+            eleven.units.to_s.should eq "(faggots)"
+            eleven.inverse.units.to_s.should eq "(faggots^-1)"
+            one.units.to_s.should eq one2.units.to_s
+            one.units.to_s.should eq ""
+          end
+        end
+        
+      end
+
+      describe "#to_s" do
+        specify { five.to_s.should eq "8==D 5 G==8" }
+      end
+
+      describe "#same_dimension?" do
+        it "should be true when two units have the same context name" do
+          four.same_dimension?(three).should be_true
+          three.same_dimension?(four).should be_true
+        end
+      end
+      describe "#+" do
+        let(:seven) { four + three }
+        it "should be able to add users together and give me the correct resulting number" do
+          seven.should be_a model
+          seven.value.should eq 7
+          seven.units.should eq "(user)"
+        end
+      end
+      describe "#-" do
+        let(:one) { four - three }
+
+        it "should subtract an user from others" do
+          one.should be_a model
+          one.value.should eq 1
+          one.units.should eq "(user)"
+        end
+      end
+      describe "#*" do
+
+        context "dimensional" do
+          let(:twelve) { four * three }
+          it "should produce a squared user when two users are multiplied" do
+            twelve.should be_a model
+            twelve.value.should eq 12
+            twelve.units.should eq "(user^2)"
+          end
+
+          describe "#+" do
+            it "should throw an error when you attempt to add together things of differing units" do
+              expect { twelve + four }.to throw_symbol :CannotConvertDimension
+            end
+          end
+        end
+
+        context "scalar" do
+          let(:sixty_six) { three * 22 }
+          it "should still have the same model with the same units, but be scaled up 22 times" do
+            sixty_six.should be_a model
+            sixty_six.value.should eq 66
+            sixty_six.units.should eq three.units
+          end 
+        end
+
+        context "nonsensical" do
+          let(:crap) { three * RSpec }
+
+          it "should throw an error since it doesn't make sense to multiple numbers with units to random objects" do
+            expect { crap }.to raise_error( SimpleUnits::Unit::MismatchError, "RSpec is a Module" )
+          end
+        end
+      end
+      describe "#to_str" do
+        it "should stringify simply and predicably" do
+          four.to_str.should eq four.to_s
+          four.to_str.should eq "4 (user)"
+        end
+      end
+    end
+  end
+end

data/spec/simple_units_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SimpleUnits do
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require "simplecov"
+SimpleCov.start
+require File.expand_path("../../lib/simple_units", __FILE__)
+
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.fail_fast = true
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: simple_units
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sure, ruby is dynamic and that is one of its greatest strength. Object
+  polymorphisms, duck typing, and the like is great in ruby, there is a time and place
+  for everything. Sometimes, it just makes more sense to be strongly typed.
+email: foxnewsnetwork@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/simple_units.rb
+- lib/simple_units/composite.rb
+- lib/simple_units/context.rb
+- lib/simple_units/unit.rb
+- spec/simple_units/composite_spec.rb
+- spec/simple_units/context_spec.rb
+- spec/simple_units/unit_spec.rb
+- spec/simple_units_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/foxnewsnetwork/simple_units
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4292195142135224155
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple units implementation. Similar to ruby-units except with a lot less
+  features and zero collisons with rails.
+test_files: []