omniship 0.1.0

data/lib/omniship/rate_response.rb

@@ -0,0 +1,16 @@
+module Omniship #:nodoc:
+  class RateResponse < Response
+      
+    attr_reader :rates
+     
+    def initialize(success, message, params = {}, options = {})
+      @rates = Array(options[:estimates] || options[:rates] || options[:rate_estimates])
+      super
+    end
+      
+    alias_method :estimates, :rates
+    alias_method :rate_estimates, :rates
+      
+  end
+    
+end

data/lib/omniship/response.rb

@@ -0,0 +1,42 @@
+module Omniship #:nodoc:
+  class Error < StandardError
+  end
+    
+  class ResponseError < Error
+    attr_reader :response
+     
+    def initialize(response = nil)
+      if response.is_a? Response
+        super(response.message)
+        @response = response
+      else
+        super(response)
+      end
+    end      
+  end
+    
+  class Response
+    
+    attr_reader :params
+    attr_reader :message
+    attr_reader :test
+    attr_reader :xml
+    attr_reader :request
+        
+    def initialize(success, message, params = {}, options = {})
+      @success, @message, @params = success, message, params.stringify_keys
+      @test = options[:test] || false
+      @xml = options[:xml]
+      @request = options[:request]
+      raise ResponseError.new(self) unless success
+    end
+    
+    def success?
+      @success ? true : false
+    end
+
+    def test?
+      @test ? true : false
+    end
+  end
+end

data/lib/omniship/shipment_event.rb

@@ -0,0 +1,12 @@
+module Omniship #:nodoc:
+      
+  class ShipmentEvent
+    attr_reader :name, :time, :location, :message
+      
+    def initialize(name, time, location, message=nil)
+      @name, @time, @location, @message = name, time, location, message
+    end
+      
+  end
+    
+end

data/lib/omniship/tracking_response.rb

@@ -0,0 +1,18 @@
+module Omniship #:nodoc:
+  class TrackingResponse < Response
+    attr_reader :tracking_number # string
+    attr_reader :shipment_events # array of ShipmentEvents in chronological order
+    attr_reader :origin, :destination
+      
+    def initialize(success, message, params = {}, options = {})
+      @tracking_number = options[:tracking_number]
+      @shipment_events = Array(options[:shipment_events])
+      @origin, @destination = options[:origin], options[:destination]
+      super
+    end
+      
+    def latest_event
+      @shipment_events.last
+    end
+  end
+end

data/lib/omniship/version.rb

@@ -0,0 +1,3 @@
+module Omniship 
+  VERSION = "0.1.0"
+end

data/lib/omniship.rb

@@ -0,0 +1,73 @@
+#--
+# Copyright (c) 2009 Jaded Pixel
+#
+# 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.
+#++
+
+### TODO Working on creating code for using an initializer for configuration ###
+	 
+def Omniship.setup
+  @root   = Rails.root 
+  @boot   = File.join(@root, "config", "boot.rb").freeze
+  @config = File.join(@root, "config", "omniship.yml").freeze
+  @keys   = %w{ username password key }.map { |v| v.freeze }.freeze
+  require boot unless defined? Rails.env
+  @@config = YAML.load_file(@config) rescue false
+  if @@config != false
+    raise "Invalid fedex configuration file: #{@config}" unless @@config.is_a?(Hash)
+    if (@@config.keys & @keys).sort == @keys.sort and !@@config.has_key?(Rails.env)
+      @@config[Rails.env] = {
+        "ups"   => @@config["ups"],
+        "fedex" => @@config["fedex"],
+        "usps"  => @@config["usps"]
+      }
+    end
+    @@config[Rails.env].freeze
+  end
+end
+
+$:.unshift File.dirname(__FILE__)
+
+begin
+  require 'active_support/all'
+rescue LoadError => e
+  require 'rubygems'
+  gem "activesupport", ">= 2.3.5"
+  require "active_support/all"
+end
+
+autoload :XmlNode, 'vendor/xml_node/lib/xml_node'
+autoload :Quantified, 'vendor/quantified/lib/quantified'
+
+require 'net/https'
+require 'active_utils'
+require 'nokogiri'
+
+require 'omniship/base'
+require 'omniship/contact'
+require 'omniship/response'
+require 'omniship/rate_response'
+require 'omniship/tracking_response'
+require 'omniship/package'
+require 'omniship/address'
+require 'omniship/rate_estimate'
+require 'omniship/carrier'
+require 'omniship/carriers'
+require 'omniship/shipment_event'

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/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
+        self.primitives | self.conversions.keys
+      end
+    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 << self
+      def primitives;              @primitives ||= [];             end
+      def add_numeric_methods;     @add_numeric_methods ||= false; end
+      def add_numeric_methods=(v); @add_numeric_methods = v;       end
+      def conversions;             @conversions ||= {};            end
+      def current_system;          @current_system;                end
+      def current_system=(v);      @current_system = v;            end
+      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 = 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/lib/quantified.rb

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

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