convertable_values 0.0.1

data/.document

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

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Stephen Blankenship
+
+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,55 @@
+= Overview
+
+This gem provides 2 things:
+1. a simple unit conversion library, and
+2. a pattern for transparently converting to/from base units.
+
+Example scenario: You have a model that wants to store values with units (e.g., 200 lbs), 
+but you want (or at least should want) to store all the values in the same base unit (e.g., 90.718474 kg). 
+This gem makes using this design pattern totally transparent.
+
+The main goal behind this library is to enable transparent handling of unit conversions on a model. The obvious use-case 
+for this is to ensure all values of a similar system are stored in the same unit. The benefit is that you can then do batch 
+computations on the data-set without having to worry about the unit each record's value is stored in.
+
+The unit conversions in this library are done as simply as possible by extending Numeric. 
+Comprehensiveness and precision of the unit conversion capabilities are not on par with Ruby libraries such as Ruby-Units and Alchemist.
+If your needs are more based on converting in many different crazy systems then I suggest checking out those libraries.
+
+One last quick note. The simple conversion approach taken here is faster than ruby-units or alchemist. In most cases this 
+won't matter, but it's still worth noting...
+
+= Using It
+
+1. gem install convertable_values
+2. include ConvertableValues and "convert" your attributes
+
+In a standard class:
+
+	class MyNormalClass
+		include ConvertableValues
+		attr_accessor :value, :unit
+	
+		convert(:value, :unit)
+	end
+	
+Including for your entire Rails project:
+	
+	# Stick in a file in initializers or in environment file
+	ActiveRecord::Base.send(:include, ConvertableValues)
+
+== Contributing to convertable_values
+ 
+* 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) 2010 Stephen Blankenship. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,55 @@
+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 = "convertable_values"
+  gem.homepage = "http://github.com/stephenb/convertable_values"
+  gem.license = "MIT"
+  gem.summary = %Q{Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.}
+  gem.description = %Q{Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.
+                       Example usage: You have a model that wants to store values with units (e.g., 200 lbs), but you want (or at least should want)
+                       to store all the values in a base unit (e.g., 90.718474 kilograms). This gem makes using this design pattern totally transparent.}
+  gem.email = "stephenrb@gmail.com"
+  gem.authors = ["Stephen Blankenship"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "convertable_values #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/convertable_values.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{convertable_values}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Stephen Blankenship"]
+  s.date = %q{2010-11-14}
+  s.description = %q{Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.
+                       Example usage: You have a model that wants to store values with units (e.g., 200 lbs), but you want (or at least should want)
+                       to store all the values in a base unit (e.g., 90.718474 kilograms). This gem makes using this design pattern totally transparent.}
+  s.email = %q{stephenrb@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "convertable_values.gemspec",
+    "lib/convertable_values.rb",
+    "lib/numeric/numeric_units.rb",
+    "test/helper.rb",
+    "test/test_convertable_values.rb"
+  ]
+  s.homepage = %q{http://github.com/stephenb/convertable_values}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.}
+  s.test_files = [
+    "test/helper.rb",
+    "test/test_convertable_values.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/convertable_values.rb

@@ -0,0 +1,73 @@
+require 'numeric/numeric_units'
+
+module ConvertableValues
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    # Calling convert(value_attr_name, unit_attr_name) will set up that 
+    # pair of value/unit attributes to automatically convert the valu to/from the 
+    # given unit's base unit.
+    def convert(value_attr, unit_attr)
+      # Create override method for converting value to base unit when set
+      define_method "#{value_attr}=".to_sym do |new_value|
+        unit_str = send(unit_attr.to_sym)
+        
+        if new_value && unit_str
+          # store the value converted to the base unit corresponding to the given unit
+          # write_attribute(value_attr.to_sym, v.send(unit_attr.to_sym))
+          instance_variable_set("@#{value_attr}".to_sym, new_value.send(unit_str))
+        else
+          instance_variable_set("@#{value_attr}".to_sym, new_value)
+        end
+      end
+      
+      # Create override method for converting value to stored unit when accessed
+      define_method value_attr.to_sym do
+        unit_str = send(unit_attr.to_sym)
+        
+        if unit_str
+          # return the value converted back to whatever unit was stored
+          instance_variable_get("@#{value_attr}".to_sym).to(unit_str.to_sym)
+        else
+          instance_variable_get("@#{value_attr}".to_sym)
+        end
+      end
+      
+      # Create override method for updating value when unit is set/changed
+      define_method "#{unit_attr}=".to_sym do |new_unit|
+        old_unit = instance_variable_get("@#{unit_attr}".to_sym)
+        instance_variable_set("@#{unit_attr}".to_sym, new_unit)
+      
+        # Re-assign the value so it will be converted properly
+        value = instance_variable_get("@#{value_attr}".to_sym)
+        send("#{value_attr}=".to_sym, value) if value && old_unit.nil?
+
+        new_unit
+      end
+    end
+  
+    #### Base Units ####
+  
+    def base_mass_unit
+      :kilograms
+    end
+  
+    def base_volume_unit
+      :fluid_ounce
+    end
+
+    def base_length_unit
+      :meters
+    end
+
+    def base_time_unit
+      :seconds
+    end
+    
+  end
+
+end

data/lib/numeric/numeric_units.rb

@@ -0,0 +1,176 @@
+# This file extends the Numeric class to provide simple utility for unit conversions.
+# To properly use these extenstions, default units will/should be used:
+# => MASS = kilograms
+# => DISTANCE/MEASUREMENT = meters
+# => TIME = seconds
+# => VOLUME = fluid ounces 
+#
+# So, calling 3.pounds will return 1.36077711, which is the value converted to the base unit of kilograms.
+#
+# When retrieving the values, you can call one of the slew of to_* methods.
+# => 5.km.to_miles -> 3.10685596118667
+# whereas
+# => 5.km -> 5000  (meters)
+# 
+class Numeric
+  
+  ##### MASS #####
+  
+  def kilograms
+    self
+  end
+  alias :kilogram :kilograms
+  alias :kg       :kilograms
+  alias :kgs			:kilograms
+  
+  def pounds
+    self * 0.45359237.kilograms
+  end
+  alias :pound  :pounds
+  alias :lb     :pounds
+  alias :lbs    :pounds
+
+  def ounce
+    self * 0.0283495231.kilograms
+  end
+  alias :oz     :ounce
+  alias :ounces :ounce
+  
+  def stone
+    self * 6.35029318.kilograms
+  end
+  alias :stones :stone
+
+  def ton
+    self * 907.18474.kilograms
+  end
+  alias :tons :ton
+  
+  
+  ###### DISTANCE/MEASUREMENTS/LENGTH #####
+  
+  def meters
+    self
+  end
+  alias :m     :meters
+  alias :meter :meters
+  
+  def millimeters
+    self * 0.001.meters
+  end
+  alias :mm         :millimeters
+  alias :millimeter :millimeters
+  
+  def centimeters
+    self * 0.01.meters
+  end
+  alias :cm         :centimeters
+  alias :centimeter :centimeters
+  
+  def feet
+    self * 0.3048.meters
+  end
+  alias :ft   :feet
+  alias :foot :feet
+  
+  def inches
+    self * 0.0254.meters
+  end
+  alias :in   :inches
+  alias :inch :inches
+  
+  def yards
+    self * 3.feet
+  end
+  alias :yd   :yards
+  alias :yard :yards
+  
+  def miles
+    self * 1609.344.meters
+  end
+  alias :mi   :miles
+  alias :mile :miles
+  
+  def kilometers
+    self * 1000.meters
+  end
+  alias :km        :kilometers
+  alias :kilometer :kilometers
+  
+  
+  #### TIME ####
+  
+  def seconds
+    self
+  end
+  alias :second :seconds
+  alias :secs   :seconds
+  alias :sec    :seconds
+  
+  def minutes
+    self * 60.seconds
+  end
+  alias :min    :minutes
+  alias :minute :minutes
+  alias :mins   :minutes
+  
+  def hours
+    self * 60.minutes
+  end
+  alias :hr   :hours
+  alias :hrs  :hours
+  alias :hour :hours
+  
+  
+  #### VOLUME #####
+  
+  def fluid_ounce
+    self
+  end
+  alias :fluid_ounces :fluid_ounce
+  alias :fl_oz        :fluid_ounce
+  
+  def teaspoon
+    self * (1.0/6.0)
+  end
+  alias :teaspoons  :teaspoon
+  alias :tsp        :teaspoon
+  
+  def tablespoon
+    self * 0.5.fl_oz
+  end
+  alias :tablespoons  :tablespoon
+  alias :tbsp         :tablespoon
+  
+  def cup
+    self * 8.fl_oz
+  end
+  alias :cups :cup
+  
+  def pint
+    self * 16.fl_oz
+  end
+  alias :pints :pint
+  alias :pt    :pint
+  
+  def quart
+    self * 16.fl_oz
+  end
+  alias :quarts :quart
+  alias :qt     :quart
+  
+  # Helps convert back to a proper value
+  def method_missing(method, *args)
+    if match = /^to_([a-zA-Z_]*)$/.match(method.to_s)
+      self / 1.send(match[1]).to_f
+    else
+      super
+    end
+  end
+  
+  # Call using something like to(:pounds)
+  def to(unit)
+    self.send("to_#{unit.to_s}")
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+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 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'convertable_values'
+
+class Test::Unit::TestCase
+end

data/test/test_convertable_values.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+class TestConvertableValues < Test::Unit::TestCase
+  
+  P = 1**-10
+  
+  context "A Numeric object" do 
+    should "auto-convert numbers properly to their value in the base unit" do
+      assert_in_delta 1.pound, (1.kg * 0.45359237), P
+      assert_in_delta 1.mile, (1.m * 1609.344), P
+      assert_in_delta 1.hour, (1.sec * 60 * 60), P
+      assert_in_delta 1.teaspoon, (1.0.fl_oz / 6.0), P
+    end
+    
+    should "support to_unit" do
+      assert_in_delta 354.3.to_pounds, 781.097795, P
+      assert_in_delta 354.3.lbs.to_stones, 25.3071429, P
+    end
+    
+    should "support to(:unit)" do
+      assert_respond_to 354.3, :to
+      assert_in_delta 354.3.to(:pounds), 781.097795, P
+      assert_in_delta 354.3.lbs.to(:stones), 25.3071429, P
+    end
+    
+    should "convert compatible numbers equally" do
+      assert_equal 5.km, 5000.meters
+      assert_equal 60.secs, 1.min
+      assert_equal 3.feet, 1.yard
+      assert_equal 3.1068559611866697.mi, 5.km
+    end
+  end
+  
+  context "A class that includes ConvertableValues" do
+    setup do
+      class AClassIncludingConvertableValues
+        include ConvertableValues
+        attr_accessor :value, :unit
+        convert(:value, :unit)
+      end
+      @obj = AClassIncludingConvertableValues.new
+      
+      assert_nothing_raised do
+        @obj.unit = 'mi'
+        @obj.value = 3.10685596
+      end
+    end
+    
+    should "set the value converted to the base unit" do
+      assert_in_delta @obj.instance_variable_get(:@value), 5000, P # Bypass accessor
+    end
+    
+    should "set the value converted to the base unit" do
+      assert_in_delta @obj.value, 3.10685596, P
+    end
+    
+    should "return the set unit" do
+      assert_equal @obj.unit, 'mi'
+    end
+  end
+  
+  context "When setting the unit after the value" do
+    setup do
+      class AClassIncludingConvertableValues
+        include ConvertableValues
+        attr_accessor :value, :unit
+        convert(:value, :unit)
+      end
+      @obj = AClassIncludingConvertableValues.new
+      @obj.value = 3.10685596
+    end
+    
+    should "return the inputted value before setting unit" do
+      assert_equal @obj.value, 3.10685596
+    end
+    
+    should "return nil unit" do
+      assert_nil @obj.unit
+    end
+    
+    should "return the converted value after setting unit" do
+      @obj.unit = 'mi'
+      assert_in_delta @obj.instance_variable_get(:@value), 5000, P # Bypass accessor
+      assert_in_delta @obj.value, 3.10685596, P
+    end
+    
+    should "return the value converted to the latest unit after setting unit multiple times" do
+      @obj.unit = 'mi'
+      @obj.unit = 'km'
+      assert_in_delta @obj.instance_variable_get(:@value), 5000, P # Bypass accessor
+      assert_in_delta @obj.value, 5, P
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: convertable_values
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stephen Blankenship
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-14 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: rcov
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+description: |-
+  Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.
+                         Example usage: You have a model that wants to store values with units (e.g., 200 lbs), but you want (or at least should want)
+                         to store all the values in a base unit (e.g., 90.718474 kilograms). This gem makes using this design pattern totally transparent.
+email: stephenrb@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- convertable_values.gemspec
+- lib/convertable_values.rb
+- lib/numeric/numeric_units.rb
+- test/helper.rb
+- test/test_convertable_values.rb
+has_rdoc: true
+homepage: http://github.com/stephenb/convertable_values
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Convertable Values provides a simple unit conversion library and pattern for transparently storing base units.
+test_files: 
+- test/helper.rb
+- test/test_convertable_values.rb