benhutton-active_shipping 0.9.13

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

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

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/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
+end

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

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/quantified'

data/lib/vendor/test_helper.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+
+require 'test/unit'
+require 'active_shipping'
+
+begin
+  require 'mocha'
+rescue LoadError
+  require 'rubygems'
+  require 'mocha'
+end

data/lib/vendor/xml_node/README

@@ -0,0 +1,36 @@
+XML Node
+==========
+
+
+Example for generating xml:
+  
+  # Create an atom like document
+  
+  root = XmlNode.new 'feed' do |feed|
+    
+    feed << XmlNode.new('id', 'tag:atom.com,2007:1')
+    feed << XmlNode.new('title', 'Atom test feed')
+    feed << XmlNode.new('author') do |author|
+      author << XmlNode.new("name", "tobi")
+      author << XmlNode.new("email", "tobi@gmail.com")
+    end
+    
+    feed << XmlNode.new('entry') do |entry|
+      entry << XmlNode.new('title', 'First post')
+      entry << XmlNode.new('summary', 'Lorem ipsum', :type => 'xhtml')
+      entry << XmlNode.new('created_at', Time.now)
+    end
+    
+    feed << XmlNode.new('dc:published', Time.now)
+  end
+  
+  root.to_xml #=> Well formatted xml
+  
+  
+Example for parsing xml:
+
+
+  xml = XmlNode.parse('<feed attr="1"><element>text</element><element>text</element></feed>')
+  xml['attr'] #=> '1'
+  xml.children['element'].text #=> 'text'
+  xml.children.each { |e| e... }

data/lib/vendor/xml_node/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    = 'XmlNode'
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/vendor/xml_node/benchmark/bench_generation.rb

@@ -0,0 +1,32 @@
+require "benchmark"
+require File.dirname(__FILE__) + "/../lib/xml_node"
+
+class XmlNode
+  
+  def to_xml_as_array
+    xml = []
+    document = REXML::Document.new
+    document << REXML::XMLDecl.new('1.0')
+    document << @element
+    document.write( xml, 0)
+    xml.to_s    
+  end
+
+  def to_xml_no_format
+    xml = ''
+    document = REXML::Document.new
+    document << REXML::XMLDecl.new('1.0')
+    document << @element
+    document.write( xml)
+    xml    
+  end
+    
+end
+
+TESTS = 10000
+
+Benchmark.bmbm do |results|
+  results.report { TESTS.times do XmlNode.new('feed') { |n| n << XmlNode.new('element', 'test'); n << XmlNode.new('element') }.to_xml end }
+  results.report { TESTS.times do XmlNode.new('feed') { |n| n << XmlNode.new('element', 'test'); n << XmlNode.new('element') }.to_xml_as_array end }
+  results.report { TESTS.times do XmlNode.new('feed') { |n| n << XmlNode.new('element', 'test'); n << XmlNode.new('element') }.to_xml_no_format end }
+end

data/lib/vendor/xml_node/init.rb

@@ -0,0 +1 @@
+# Include hook code here

data/lib/vendor/xml_node/lib/xml_node.rb

@@ -0,0 +1,222 @@
+require 'rexml/document'
+
+class Object
+  def to_xml_value
+    to_s
+  end
+end
+
+class NilClass
+  def to_xml_value
+    nil
+  end
+end
+
+class TrueClass
+  def to_xml_value
+    to_s
+  end
+end 
+
+class FalseClass
+  def to_xml_value
+    to_s
+  end
+end 
+
+class Time
+  def to_xml_value
+    self.xmlschema
+  end
+end
+
+class DateTime
+  def to_xml_value
+    self.xmlschema
+  end
+end
+
+class Date
+  def to_xml_value
+    self.to_time.xmlschema
+  end
+end
+
+class REXML::Element
+  def to_xml_element
+    self
+  end
+end
+
+class XmlNode
+  attr_accessor :child_nodes
+  attr_reader :element 
+  
+  class List
+    include Enumerable
+    
+    def initialize(parent)
+      @parent = parent
+      @children = {}
+    end
+
+    def [](value)
+      node_for @parent.element.elements[value]
+    end
+    
+    def []=(value, key)
+      @parent.element.elements[value.to_s] = key.to_xml_element
+    end
+    
+    def each(&block)
+      @parent.element.each_element { |e| yield node_for(e) }
+    end
+    
+    private
+    
+    def node_for(element)
+      @parent.child_nodes[element] ||= XmlNode.new(element)
+    end
+  end
+  
+  # Allows for very pretty xml generation akin to xml builder.
+  #
+  # Example:
+  # 
+  #   # Create an atom like document
+  #   doc = Document.new 
+  #   doc.root = XmlNode.new 'feed' do |feed|
+  #     
+  #     feed << XmlNode.new('id', 'tag:atom.com,2007:1')
+  #     feed << XmlNode.new('title', 'Atom test feed')
+  #     feed << XmlNode.new('author') do |author|
+  #       author << XmlNode.new("name", "tobi")
+  #       author << XmlNode.new("email", "tobi@gmail.com")
+  #     end
+  #     
+  #     feed << XmlNode.new('entry') do |entry|
+  #       entry << XmlNode.new('title', 'First post')
+  #       entry << XmlNode.new('summary', 'Lorem ipsum', :type => 'xhtml')
+  #       entry << XmlNode.new('created_at', Time.now)
+  #     end
+  #     
+  #     feed << XmlNode.new('dc:published', Time.now)
+  #   end
+  #
+  def initialize(node, *args)
+    @element = if node.is_a?(REXML::Element)
+      node
+    else      
+      REXML::Element.new(node)    
+    end
+    
+    @child_nodes = {}
+    
+    if attributes = args.last.is_a?(Hash) ? args.pop : nil
+      attributes.each { |k,v| @element.add_attribute(k.to_s, v.to_xml_value) }
+    end
+    
+    if !args[0].nil?
+      @element.text = args[0].to_xml_value
+    end
+
+    if block_given?    
+      yield self 
+    end
+  end
+
+  def self.parse(xml)
+    self.new(REXML::Document.new(xml).root)
+  end
+  
+  def children
+    XmlNode::List.new(self)
+  end
+  
+  def []=(key, value)
+    @element.attributes[key.to_s] =  value.to_xml_value
+  end
+  
+  def [](key)
+    @element.attributes[key]
+  end
+  
+  # Add a namespace to the node
+  # Example
+  #
+  #   node.namespace 'http://www.w3.org/2005/Atom'
+  #   node.namespace :opensearch, 'http://a9.com/-/spec/opensearch/1.1/'
+  #
+  def namespace(*args) 
+    args[0] = args[0].to_s if args[0].is_a?(Symbol)
+    @element.add_namespace(*args)
+  end
+  
+  def cdata=(value)
+    new_cdata = REXML::CData.new( value )
+    @element.children.each do |c|
+      if c.is_a?(REXML::CData)
+        return @element.replace_child(c,new_cdata)
+      end
+    end    
+    @element << new_cdata
+  rescue RuntimeError => e            
+    @element << REXML::Text.new(e.message)
+  end
+  
+  def cdata
+    @element.cdatas.first.to_s
+  end
+  
+  def name
+    @element.name
+  end
+  
+  def text=(value)
+    @element.text = REXML::Text.new( value )    
+  end
+  
+  def text
+    @element.text
+  end
+  
+  def find(scope, xpath)    
+    case scope 
+    when :first
+      elem = @element.elements[xpath]
+      elem.nil? ? nil : child_nodes[elem] ||= XmlNode.new(elem)
+    when :all 
+      @element.elements.to_a(xpath).collect { |e| child_nodes[e] ||= XmlNode.new(e) }    
+    end
+  end
+  
+  def <<(elem)    
+    case elem
+    when nil then return
+    when Array 
+      elem.each { |e| @element << e.to_xml_element }
+    else
+      @element << elem.to_xml_element
+    end
+  end
+    
+  def to_xml_element
+    @element
+  end
+  
+  def to_s
+    @element.to_s
+  end
+  
+  # Use to get pretty formatted xml including DECL
+  # instructions
+  def to_xml
+    xml = []
+    document = REXML::Document.new
+    document << REXML::XMLDecl.new('1.0')
+    document << @element
+    document.write( xml, 0)
+    xml.join
+  end
+  
+end