active_shipping 1.0.0.pre2 → 1.0.0.pre3

data/lib/vendor/quantified/README.markdown

@@ -1,49 +0,0 @@
-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

@@ -1,13 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end

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

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

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

@@ -1,211 +0,0 @@
-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(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit) || BigDecimal.new(self.class.convert(amount, unit, other.unit).to_s) == BigDecimal.new(other.amount.to_s)
-    rescue NoMethodError
-      amount == other
-    end
-
-    def eql?(other)
-      self.class == other.class && BigDecimal.new(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit
-    end
-
-    def <=>(other)
-      if self.class == other.class
-        self.class.convert(amount, unit, other.unit) <=> other.amount
-      else
-        amount <=> other
-      end
-    end
-
-    def system
-      self.class.units_to_systems[unit]
-    end
-
-    def coerce(other)
-      [other, amount]
-    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, unit)
-        self.class.new(amount.send(meth, other_amount_in_self_units), unit)
-      else
-        amount.send(meth, *args)
-      end
-    end
-
-    def self.conversion_rate(from, to)
-      return nil unless conversions[from] and conversions[to]
-      conversions[from][to] ||=
-      (1.0 / conversions[to][from] if conversions[to][from]) || begin
-        shared_conversions = conversions[from].keys & conversions[to].keys
-        if shared_conversions.any?
-          primitive = shared_conversions.first
-          conversions[from][primitive] * (1.0 / conversions[to][primitive])
-        else
-          conversions[from].each do |conversion_unit, multiple|
-            if conversions[to].include?(conversion_unit)
-              return multiple * conversion_rate(conversion) * (1.0 / conversions[to][conversion_unit])
-            end
-          end
-          from_primitive = (conversions[from].keys & primitives).first
-          to_primitive = (conversions[to].keys & primitives).first
-          if from_primitive_to_primitive_multiple = conversion_rate(from_primitive, to_primitive)
-            return conversions[from][from_primitive] * from_primitive_to_primitive_multiple * (1.0 / conversions[to][to_primitive])
-          end
-          raise StandardError, "No conversion path from #{from} to #{to}"
-        end
-      end
-    end
-
-    def self.units(system = nil)
-      if system
-        systems_to_units[system.to_sym].dup
-      else
-        primitives | conversions.keys
-      end
-    end
-
-    def self.non_primitives
-      conversions.keys
-    end
-
-    def self.systems
-      systems_to_units.keys
-    end
-
-    def self.add_numeric_methods?
-      add_numeric_methods
-    end
-
-    def self.numeric_methods(*args)
-      args.each do |arg|
-        add_numeric_method_for(arg.to_sym)
-      end
-    end
-
-    protected
-
-    class << self
-      def primitives;              @primitives ||= [];             end
-      def add_numeric_methods;     @add_numeric_methods ||= false; end
-      attr_writer :add_numeric_methods
-      def conversions;             @conversions ||= {};            end
-      attr_reader :current_system
-      attr_writer :current_system
-      def systems_to_units;        @systems_to_units ||= {};       end
-      def units_to_systems;        @units_to_systems ||= {};       end
-    end
-
-    def self.system(system_name, &block)
-      old_system = 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
-      primitives << unit_sym
-      add_to_system(unit_sym)
-      add_methods_for(unit_sym, options)
-    end
-
-    def self.add_to_system(unit_sym)
-      if current_system
-        units_to_systems[unit_sym] ||= begin
-          sys_ary = systems_to_units[current_system] ||= []
-          sys_ary << unit_sym
-          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
-      conversions[multiple_unit] ||= {}
-      conversions[other_unit] ||= {}
-
-      if primitives.include?(multiple_unit) || primitives.include?(other_unit)
-        add_conversion(multiple_unit, other_unit, multiple)
-      else
-        [multiple_unit, other_unit].each do |this_unit|
-          conversions[this_unit].each do |this_other_unit, this_multiple|
-            if 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)
-      conversions[multiple_unit] ||= {}
-      conversions[multiple_unit][other_unit] = multiple
-      conversions[other_unit] ||= {}
-      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
-        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 == unit.to_s
-          self.class.new(self.class.convert(amount, 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 #{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

@@ -1,20 +0,0 @@
-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(0.0254, :metres)
-
-      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

@@ -1,19 +0,0 @@
-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

@@ -1,94 +0,0 @@
-require '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_mm_to_inches
-    assert_equal 12, Length.new(304.8, :millimetres).to_inches
-  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_in_epsilon Length.new(914.4, :millimetres).to_f, Length.new(1, :yards).to_millimetres.to_f
-  end
-
-  def test_convert_millimetres_to_yards
-    assert_in_epsilon Length.new(1, :yards).to_f, Length.new(914.4, :millimetres).to_yards.to_f
-  end
-
-  def test_convert_metres_to_inches
-    assert_in_epsilon 1.inches.to_f, (0.0254).metres.to_inches.to_f
-  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

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

@@ -1,96 +0,0 @@
-require 'test_helper'
-require 'quantified/mass'
-
-class MassTest < Test::Unit::TestCase
-  include Quantified
-  Mass.numeric_methods :grams, :kilograms, :ounces, :pounds
-
-  def setup
-    @mass = Mass.new(5, :pounds)
-  end
-
-  def test_inspect
-    assert_equal "#<Quantified::Mass: 5 pounds>", @mass.inspect
-  end
-
-  def test_to_s
-    assert_equal "5 pounds", @mass.to_s
-  end
-
-  def test_initialize_from_numeric
-    assert_equal "5 pounds", 5.pounds.to_s
-  end
-
-  def test_equalities
-    assert_equal 1.pounds, (1.0).pounds
-    # == based on value
-    assert_equal 4000.pounds, Mass.new(2, :short_tons)
-    # eql? based on value and unit
-    assert !4000.pounds.eql?(Mass.new(2, :short_tons))
-    # equal? based on object identity
-    assert !2.pounds.equal?(2.pounds)
-  end
-
-  def test_convert_short_tons_to_pounds
-    assert 4000.pounds.eql?(Mass.new(2, :short_tons).to_pounds)
-  end
-
-  def test_convert_pounds_to_short_tons
-    assert Mass.new(2, :short_tons).eql?(4000.pounds.to_short_tons)
-  end
-
-  def test_convert_short_tons_to_milligrams
-    assert Mass.new(907_184_740, :milligrams).eql?(Mass.new(1, :short_tons).to_milligrams)
-  end
-
-  def test_convert_milligrams_to_short_tons
-    assert Mass.new(1, :short_tons).eql?(Mass.new(907_184_740, :milligrams).to_short_tons)
-  end
-
-  def test_convert_grams_to_ounces
-    assert 1.ounces.eql?((28.349523125).grams.to_ounces)
-    assert 1.ounces.eql?((28.349523125).grams.in_ounces)
-  end
-
-  def test_comparison_with_numeric
-    assert 2.pounds > 1
-    assert 2.pounds == 2
-    assert 2.pounds <= 2
-    assert 2.pounds < 3
-  end
-
-  def test_method_missing_to_i
-    assert_equal 2, (2.4).pounds.to_i
-  end
-
-  def test_method_missing_to_f
-    assert_equal 2.4, (2.4).pounds.to_f
-  end
-
-  def test_method_missing_minus
-    assert_equal 2.pounds, 5.pounds - 3.pounds
-  end
-
-  def test_numeric_methods_not_added_for_some_units
-    assert_raises NoMethodError do
-      2.short_tons
-    end
-    assert_raises NoMethodError do
-      2.milligrams
-    end
-  end
-
-  def test_systems
-    assert_equal [:metric, :imperial], Mass.systems
-    assert_equal [:grams, :milligrams, :kilograms], Mass.units(:metric)
-    assert_equal [:ounces, :pounds, :stones, :short_tons], Mass.units(:imperial)
-  end
-
-  def test_right_side_comparison_with_fixnum
-    assert Mass.new(14, :grams) < 20
-  end
-
-  def test_left_side_comparison_with_fixnum
-    assert 20 > Mass.new(14, :grams)
-  end
-end