active_shipping 0.0.1

data/lib/vendor/quantified/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 James MacAulay
+
+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/lib/vendor/quantified/README.markdown

@@ -0,0 +1,49 @@
+Quantified
+==========
+
+Pretty quantifiable measurements which feel like ActiveSupport::Duration.
+
+Access whichever included attributes you want like so:
+
+    require 'quantified/mass'
+    require 'quantified/length'
+
+Add methods to Numeric (only plural, must correspond with plural unit names):
+
+    Mass.numeric_methods :grams, :kilograms, :ounces, :pounds
+    Length.numeric_methods :metres, :centimetres, :inches, :feet
+
+Then you can do things like this:
+
+    1.feet == 12.inches
+    # => true
+    
+    18.inches.to_feet
+    # => #<Quantified::Length: 1.5 feet>
+    
+    (2.5).feet.in_millimetres.to_s
+    # => "762.0 millimetres"
+
+
+You can easily define new attributes. Here's length.rb:
+
+    module Quantified
+      class Length < Attribute
+        system :metric do
+          primitive :metre
+      
+          one :centimetre, :is => Length.new(0.01, :metres)
+          one :millimetre, :is => Length.new(0.1, :centimetres)
+          one :kilometre, :is => Length.new(1000, :metres)
+        end
+    
+        system :imperial do
+          primitive :inch
+          one :inch, :is => Length.new(2.540, :centimetres)
+      
+          one :foot, :plural => :feet, :is => Length.new(12, :inches)
+          one :yard, :is => Length.new(3, :feet)
+          one :mile, :is => Length.new(5280, :feet)
+        end
+      end
+    end

data/lib/vendor/quantified/Rakefile

@@ -0,0 +1,21 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the calculations plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Quantified'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/vendor/quantified/lib/quantified.rb

@@ -0,0 +1,6 @@
+$: << File.dirname(__FILE__)
+require 'rubygems'
+require 'activesupport'
+require 'bigdecimal'
+
+require 'quantified/attribute'

data/lib/vendor/quantified/lib/quantified/attribute.rb

@@ -0,0 +1,208 @@
+module Quantified
+  class Attribute
+    include Comparable
+    
+    attr_reader :amount, :unit
+    
+    def initialize(amount, unit)
+      raise ArgumentError, "amount must be a Numeric" unless amount.is_a?(Numeric)
+      @amount, @unit = amount, unit.to_sym
+    end
+    
+    def to_s
+      "#{amount} #{unit}"
+    end
+    
+    def inspect
+      "#<#{self.class.name}: #{amount} #{unit}>"
+    end
+    
+    def ==(other)
+      (BigDecimal.new(self.amount.to_s) == BigDecimal.new(other.amount.to_s) && self.unit == other.unit) || BigDecimal.new(self.class.convert(self.amount, self.unit, other.unit).to_s) == BigDecimal.new(other.amount.to_s)
+    rescue NoMethodError
+      self.amount == other
+    end
+    
+    def eql?(other)
+      self.class == other.class && BigDecimal.new(self.amount.to_s) == BigDecimal.new(other.amount.to_s) && self.unit == other.unit
+    end
+    
+    def <=>(other)
+      if self.class == other.class
+        self.class.convert(self.amount, self.unit, other.unit) <=> other.amount
+      else
+        self.amount <=> other
+      end
+    end
+    
+    def system
+      self.class.units_to_systems[unit]
+    end
+    
+    def method_missing(meth, *args)
+      if args.size == 1 && self.class == (other = args.first).class
+        other_amount_in_self_units = self.class.convert(other.amount, other.unit, self.unit)
+        self.class.new(amount.send(meth, other_amount_in_self_units), self.unit)
+      else
+        amount.send(meth, *args)
+      end
+    end
+    
+    def self.conversion_rate(from, to)
+      return nil unless self.conversions[from] and self.conversions[to]
+      return self.conversions[from][to] ||=
+      (1.0 / self.conversions[to][from] if self.conversions[to][from]) || begin
+        shared_conversions = self.conversions[from].keys & self.conversions[to].keys
+        if shared_conversions.any?
+          primitive = shared_conversions.first
+          self.conversions[from][primitive] * (1.0 / self.conversions[to][primitive])
+        else
+          self.conversions[from].each do |conversion_unit, multiple|
+            if self.conversions[to].include?(conversion_unit)
+              return multiple * conversion_rate(conversion) * (1.0 / self.conversions[to][conversion_unit])
+            end
+          end
+          from_primitive = (self.conversions[from].keys & self.primitives).first
+          to_primitive = (self.conversions[to].keys & self.primitives).first
+          if from_primitive_to_primitive_multiple = conversion_rate(from_primitive, to_primitive)
+            return self.conversions[from][from_primitive] * from_primitive_to_primitive_multiple * (1.0 / self.conversions[to][to_primitive])
+          end
+          raise StandardError, "No conversion path from #{from} to #{to}"
+        end
+      end
+    end
+    
+    def self.units(system=nil)
+      if system
+        self.systems_to_units[system.to_sym].dup
+      else
+        read_inheritable_attribute(:primitives) | self.conversions.keys
+      end
+    end
+    
+    def self.primitives
+      read_inheritable_attribute(:primitives).dup
+    end
+    
+    def self.non_primitives
+      self.conversions.keys
+    end
+    
+    def self.systems
+      self.systems_to_units.keys
+    end
+    
+    def self.add_numeric_methods?
+      self.add_numeric_methods
+    end
+    
+    def self.numeric_methods(*args)
+      args.each do |arg|
+        add_numeric_method_for(arg.to_sym)
+      end
+    end
+    
+    protected
+    
+    class_inheritable_accessor :add_numeric_methods, :primitives, :conversions, :current_system, :systems_to_units, :units_to_systems
+    self.add_numeric_methods = false
+    self.primitives = []
+    self.conversions = {}
+    self.current_system = nil
+    self.systems_to_units = {}
+    self.units_to_systems = {}
+    
+    def self.system(system_name, &block)
+      old_system = self.current_system
+      self.current_system = system_name.to_sym
+      yield
+      self.current_system = old_system
+    end
+    
+    def self.primitive(sym, options={})
+      unit_sym = (options[:plural] || sym.to_s.pluralize).to_sym
+      self.primitives << unit_sym
+      add_to_system(unit_sym)
+      add_methods_for(unit_sym, options)
+    end
+    
+    def self.add_to_system(unit_sym)
+      if self.current_system
+        self.units_to_systems[unit_sym] ||= begin
+          sys_ary = self.systems_to_units[self.current_system] ||= []
+          sys_ary << unit_sym
+          self.current_system
+        end
+      end
+    end
+    
+    def self.one(sym, options={})
+      unit_sym = (options[:plural] || sym.to_s.pluralize).to_sym
+      add_to_system(unit_sym)
+      register_unit(unit_sym, options[:is].unit, options[:is].amount)
+      add_methods_for(unit_sym, options)
+    end
+    
+    def self.register_unit(multiple_unit, other_unit, multiple)
+      multiple_unit, other_unit = multiple_unit.to_sym, other_unit.to_sym
+      self.conversions[multiple_unit] ||= {}
+      self.conversions[other_unit] ||= {}
+      
+      if self.primitives.include?(multiple_unit) || self.primitives.include?(other_unit)
+        add_conversion(multiple_unit, other_unit, multiple)
+      else
+        [multiple_unit, other_unit].each do |this_unit|
+          self.conversions[this_unit].each do |this_other_unit, this_multiple|
+            if self.primitives.include?(this_other_unit)
+              add_conversion(multiple_unit, this_other_unit, multiple * this_multiple)
+            end
+          end
+        end
+      end
+    end
+    
+    def self.add_conversion(multiple_unit, other_unit, multiple)
+      self.conversions[multiple_unit] ||={}
+      self.conversions[multiple_unit][other_unit] = multiple
+      self.conversions[other_unit] ||= {}
+      self.conversions[other_unit][multiple_unit] = (1.0 / multiple)
+    end
+    
+    def self.convert(amount, from, to)
+      from, to = from.to_sym, to.to_sym
+      amount * conversion_rate(from, to)
+    end
+    
+    def self.add_methods_for(sym, options={})
+      add_conversion_method_for(sym, options)
+      add_numeric_method = if options.has_key?(:add_numeric_methods)
+        options[:add_numeric_methods]
+      else
+        self.add_numeric_methods
+      end
+      add_numeric_method_for(sym.to_s, options) if add_numeric_method
+    end
+    
+    def self.add_conversion_method_for(sym, options={})
+      unit_name = sym.to_s
+      class_eval do
+        define_method("to_#{unit_name}") do
+          return self if unit_name == self.unit.to_s
+          self.class.new(self.class.convert(self.amount, self.unit, unit_name), unit_name)
+        end
+        alias_method("in_#{unit_name}","to_#{unit_name}")
+      end
+    end
+    
+    def self.add_numeric_method_for(unit_name, options={})
+      unit_name = unit_name.to_sym
+      raise ArgumentError, "#{unit_name.inspect} is not a unit in #{self.name}" unless units.include?(unit_name)
+      klass = self
+      Numeric.class_eval do
+        define_method(unit_name) do
+          klass.new(self, unit_name.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/vendor/quantified/lib/quantified/length.rb

@@ -0,0 +1,20 @@
+module Quantified
+  class Length < Attribute
+    system :metric do
+      primitive :metre
+      
+      one :centimetre, :is => Length.new(0.01, :metres)
+      one :millimetre, :is => Length.new(0.1, :centimetres)
+      one :kilometre, :is => Length.new(1000, :metres)
+    end
+    
+    system :imperial do
+      primitive :inch
+      one :inch, :is => Length.new(2.540, :centimetres)
+      
+      one :foot, :plural => :feet, :is => Length.new(12, :inches)
+      one :yard, :is => Length.new(3, :feet)
+      one :mile, :is => Length.new(5280, :feet)
+    end
+  end
+end

data/lib/vendor/quantified/lib/quantified/mass.rb

@@ -0,0 +1,19 @@
+module Quantified
+  class Mass < Attribute
+    system :metric do
+      primitive :gram
+      
+      one :milligram, :is => Mass.new(0.001, :grams)
+      one :kilogram, :is => Mass.new(1000, :grams)
+    end
+    
+    system :imperial do
+      primitive :ounce
+      one :ounce, :is => Mass.new(28.349523125, :grams)
+      
+      one :pound, :is => Mass.new(16, :ounces)
+      one :stone, :is => Mass.new(14, :pounds)
+      one :short_ton, :is => Mass.new(2000, :pounds)
+    end
+  end
+end

data/lib/vendor/quantified/test/length_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'quantified/length'
+
+class LengthTest < Test::Unit::TestCase
+  include Quantified
+  Length.numeric_methods :metres, :centimetres, :inches, :feet
+  
+  def setup
+    @length = Length.new(5, :feet)
+  end
+
+  def test_inspect
+    assert_equal "#<Quantified::Length: 5 feet>", @length.inspect
+  end
+
+  def test_to_s
+    assert_equal "5 feet", @length.to_s
+  end
+  
+  def test_initialize_from_numeric
+    assert_equal "5 feet", 5.feet.to_s
+  end
+  
+  def test_equalities
+    assert_equal 1.feet, (1.0).feet
+    # == based on value
+    assert_equal 6.feet, Length.new(2, :yards)
+    # eql? based on value and unit
+    assert !6.feet.eql?(Length.new(2, :yards))
+    # equal? based on object identity
+    assert !2.feet.equal?(2.feet)
+  end
+  
+  def test_convert_yards_to_feet
+    assert 6.feet.eql?(Length.new(2, :yards).to_feet)
+  end
+  
+  def test_convert_feet_to_yards
+    assert Length.new(2, :yards).eql?(6.feet.to_yards)
+  end
+  
+  def test_convert_yards_to_millimetres
+    assert Length.new(914.4, :millimetres).eql?(Length.new(1, :yards).to_millimetres)
+  end
+  
+  def test_convert_millimetres_to_yards
+    assert Length.new(1, :yards).eql?(Length.new(914.4, :millimetres).to_yards)
+  end
+  
+  def test_convert_metres_to_inches
+    assert_equal 1.inches, (0.0254).metres.to_inches
+    assert 1.inches.eql?((0.0254).metres.to_inches)
+    assert 1.inches.eql?((0.0254).metres.in_inches)
+  end
+  
+  def test_comparison_with_numeric
+    assert 2.feet > 1
+    assert 2.feet == 2
+    assert 2.feet <= 2
+    assert 2.feet < 3
+  end
+  
+  def test_method_missing_to_i
+    assert_equal 2, (2.4).feet.to_i
+  end
+  
+  def test_method_missing_to_f
+    assert_equal 2.4, (2.4).feet.to_f
+  end
+  
+  def test_method_missing_minus
+    assert_equal 2.feet, 5.feet - 3.feet
+  end
+  
+  def test_numeric_methods_not_added_for_some_units
+    assert_raises NoMethodError do
+      2.yards
+    end
+    assert_raises NoMethodError do
+      2.millimetres
+    end
+  end
+  
+  def test_systems
+    assert_equal [:metric, :imperial], Length.systems
+    assert_equal [:metres, :centimetres, :millimetres, :kilometres], Length.units(:metric)
+    assert_equal [:inches, :feet, :yards, :miles], Length.units(:imperial)
+    
+    assert_equal :metric, 2.centimetres.system
+    assert_equal :imperial, 2.feet.system
+  end
+end