ideaoforder-shipping 1.6.0

data/Rakefile

@@ -0,0 +1,251 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require File.dirname(__FILE__) + '/lib/shipping'
+
+PKG_VERSION = Shipping::VERSION
+PKG_NAME = "shipping"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = "shipping"
+RUBY_FORGE_USER = ENV['RUBY_FORGE_USER'] || "cardmagic"
+RELEASE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+PKG_FILES = FileList[
+    "lib/**/*", "bin/*", "test/**/*", "[A-Z]*", "Rakefile", "doc/**/*"
+]
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+desc "Run all unit tests"
+Rake::TestTask.new("test") { |t|
+  t.libs << "lib"
+  t.pattern = 'test/*/*_test.rb'
+  t.verbose = true
+}
+
+# Make a console, useful when working on tests
+desc "Generate a test console"
+task :console do
+   verbose( false ) { sh "irb -I lib/ -r 'shipping'" }
+end
+
+# Genereate the RDoc documentation
+desc "Create documentation"
+Rake::RDocTask.new("doc") { |rdoc|
+  rdoc.title = "Ruby Shipping - UPS, FedEx, USPS"
+  rdoc.rdoc_dir = 'html'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}
+
+# Genereate the package
+spec = Gem::Specification.new do |s|
+
+  #### Basic information.
+
+  s.name = 'shipping'
+  s.version = PKG_VERSION
+  s.summary = <<-EOF
+   A general shipping module to find out the shipping prices via UPS or FedEx.
+  EOF
+  s.description = <<-EOF
+   A general shipping module to find out the shipping prices via UPS or FedEx.
+  EOF
+
+  #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
+
+  s.files = PKG_FILES
+
+  #### Load-time details: library and application (you will need one or both).
+
+  s.add_dependency('builder', '>= 1.2.0')
+  s.requirements << "An xml-builder library."
+
+  s.require_path = 'lib'
+  s.autorequire = 'shipping'
+
+  #### Documentation and testing.
+
+  s.has_rdoc = true
+
+  #### Author and project details.
+
+  s.author = "Lucas Carlson"
+  s.email = "lucas@rufy.com"
+  s.homepage = "http://shipping.rufy.com/"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(
+    ["Library", "lib"],
+    ["Units", "test"]
+  ).to_s
+end
+
+desc "Publish new documentation"
+task :publish do
+    Rake::RubyForgePublisher.new('shipping', 'cardmagic').upload
+    `ssh rufy update-shipping-doc`
+end
+
+desc "Publish the release files to RubyForge."
+task :upload => [:package] do
+    files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+
+    if RUBY_FORGE_PROJECT then
+        require 'net/http'
+        require 'open-uri'
+
+        project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+        project_data = open(project_uri) { |data| data.read }
+        group_id = project_data[/[?&]group_id=(\d+)/, 1]
+        raise "Couldn't get group id" unless group_id
+
+        # This echos password to shell which is a bit sucky
+        if ENV["RUBY_FORGE_PASSWORD"]
+            password = ENV["RUBY_FORGE_PASSWORD"]
+        else
+            password = Proc.new do
+              sync = STDOUT.sync
+              begin
+                echo false
+                STDOUT.sync = true
+                print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+                STDIN.gets.chomp
+              ensure
+                echo true
+                STDOUT.sync = sync
+                puts
+              end
+            end.call
+        end
+
+        login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+            data = [
+                "login=1",
+                "form_loginname=#{RUBY_FORGE_USER}",
+                "form_pw=#{password}"
+            ].join("&")
+            http.post("/account/login.php", data)
+        end
+
+        cookie = login_response["set-cookie"]
+        raise "Login failed" unless cookie
+        headers = { "Cookie" => cookie }
+
+        release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+        release_data = open(release_uri, headers) { |data| data.read }
+        package_id = release_data[/[?&]package_id=(\d+)/, 1]
+        raise "Couldn't get package id" unless package_id
+
+        first_file = true
+        release_id = ""
+
+        files.each do |filename|
+            basename  = File.basename(filename)
+            file_ext  = File.extname(filename)
+            file_data = File.open(filename, "rb") { |file| file.read }
+
+            puts "Releasing #{basename}..."
+
+            release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+                release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+                type_map = {
+                    ".zip"    => "3000",
+                    ".tgz"    => "3110",
+                    ".gz"     => "3110",
+                    ".gem"    => "1400"
+                }; type_map.default = "9999"
+                type = type_map[file_ext]
+                boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+                query_hash = if first_file then
+                  {
+                    "group_id" => group_id,
+                    "package_id" => package_id,
+                    "release_name" => RELEASE_NAME,
+                    "release_date" => release_date,
+                    "type_id" => type,
+                    "processor_id" => "8000", # Any
+                    "release_notes" => "",
+                    "release_changes" => "",
+                    "preformatted" => "1",
+                    "submit" => "1"
+                  }
+                else
+                  {
+                    "group_id" => group_id,
+                    "release_id" => release_id,
+                    "package_id" => package_id,
+                    "step2" => "1",
+                    "type_id" => type,
+                    "processor_id" => "8000", # Any
+                    "submit" => "Add This File"
+                  }
+                end
+
+                query = "?" + query_hash.map do |(name, value)|
+                    [name, URI.encode(value)].join("=")
+                end.join("&")
+
+                data = [
+                    "--" + boundary,
+                    "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+                    "Content-Type: application/octet-stream",
+                    "Content-Transfer-Encoding: binary",
+                    "", file_data, ""
+                    ].join("\x0D\x0A")
+
+                release_headers = headers.merge(
+                    "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+                )
+
+                target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+                http.post(target + query, data, release_headers)
+            end
+
+            if first_file then
+                release_id = release_response.body[/release_id=(\d+)/, 1]
+                raise("Couldn't get release id") unless release_id
+            end
+
+            first_file = false
+        end
+    end
+end
+
+begin
+  if !defined?(USE_TERMIOS) || USE_TERMIOS
+    require 'termios'
+  else
+    raise LoadError
+  end
+
+  # Enable or disable stdin echoing to the terminal.
+  def echo(enable)
+    term = Termios::getattr(STDIN)
+
+    if enable
+      term.c_lflag |= (Termios::ECHO | Termios::ICANON)
+    else
+      term.c_lflag &= ~Termios::ECHO
+    end
+
+    Termios::setattr(STDIN, Termios::TCSANOW, term)
+  end
+rescue LoadError
+  def echo(enable)
+  end
+end

data/lib/shipping/base.rb

@@ -0,0 +1,314 @@
+# Author::    Lucas Carlson  (mailto:lucas@rufy.com)
+# Copyright:: Copyright (c) 2005 Lucas Carlson
+# License::   LGPL
+
+# Updated:: 12-22-2008 by Mark Dickson (mailto:mark@sitesteaders.com)
+
+module Shipping
+	VERSION = "1.6.0"
+
+	class ShippingError < StandardError; end
+	class ShippingRequiredFieldError < StandardError; end
+
+	class Base
+		attr_reader :data, :response, :plain_response, :required, :services
+
+		attr_writer :ups_license_number, :ups_shipper_number, :ups_user, :ups_password, :ups_url, :ups_tool
+		attr_writer :fedex_account, :fedex_meter, :fedex_url, :fedex_package_weight_limit_in_lbs
+
+		attr_accessor :name, :phone, :company, :email, :address, :address2, :city, :state, :zip, :country
+		attr_accessor :sender_name, :sender_phone, :sender_company, :sender_email, :sender_address, :sender_city, :sender_state, :sender_zip, :sender_country
+
+		attr_accessor :weight, :weight_units, :insured_value, :declared_value, :transaction_type, :description
+		attr_accessor :measure_units, :measure_length, :measure_width, :measure_height
+		attr_accessor :package_total, :packaging_type, :service_type
+		
+		attr_accessor :price, :discount_price, :eta, :time_in_transit
+
+		attr_accessor :ship_date, :dropoff_type, :pay_type, :currency_code, :image_type, :label_type
+    
+    attr_accessor :weight_each, :quantity, :max_weight, :max_quantity, :items
+
+		def initialize(options = {})
+			prefs = File.expand_path(options[:prefs] || "~/.shipping.yml")
+			YAML.load(File.open(prefs)).each {|pref, value| eval("@#{pref} = #{value.inspect}")} if File.exists?(prefs)
+
+			@required = Array.new
+			@services = Array.new
+
+			# include all provided data
+			options.each do |method, value| 
+				instance_variable_set("@#{method}", value)
+			end
+			
+			case options[:carrier]
+		  when "fedex"
+		    fedex
+	    when "ups"
+	      ups
+      when nil
+      else
+        raise ShippingError, "unknown service"
+      end
+		end
+
+		# Initializes an instance of Shipping::FedEx with the same instance variables as the base object
+		def fedex
+			Shipping::FedEx.new prepare_vars
+		end
+
+		# Initializes an instance of Shipping::UPS with the same instance variables as the base object
+		def ups
+			Shipping::UPS.new prepare_vars
+		end
+		
+    # Attempt to package items in multiple boxes efficiently
+    # This doesn't use the bin-packing algorithm, but instead attempts to mirror how people pack boxes
+    # -- since people will most likely be packing them.
+    # -- It attempts to pack like items whenever possible.
+    # @items: array of weights
+    # @weight_each: can be used instead of array of items
+    # @variation_threshold: how much variety you'll allow (default to 10% variation [e.g. 10 items, 10 each])
+    # @weight_threshold: the minimum weight a box must be to close (default .5, i.e. half full by weight)
+    # @quantity_threshold: the minimum full a box must be to close (default .5, i.e. half full by the number of items that will fit)
+    def boxes
+      # See if we're dealing with an array of items
+      if @items.length > 0
+        @items.each {|item| item[:total_weight] = item[:weight] * item[:quantity]} # get weight totals
+        props = @items.inject({:weights => [], :quantities => [], :total_weights => []}) {|h, item| h[:weights] << item[:weight];h[:quantities] << item[:quantity]; h[:total_weights] << item[:total_weight];h}
+        @quantity = props[:quantities].sum
+        total_weight = props[:total_weights].sum
+        
+        # check to see if these are all the same weight
+        if props[:weights].uniq.length == 1
+          itemized = false
+          @weight_each = props[:weights].uniq[0]
+        else
+          itemized = true
+        end
+      else
+        @required = ['quantity', 'weight_each']
+        total_weight = @quantity.to_f * @weight_each
+        itemized = false
+      end
+  
+      max_weight = @max_weight || 150 # Fed Ex and UPS commercial max
+      max_quantity = @max_quantity || @quantity
+      variation_threshold = @variation_threshold || 0.1 # default to 10% variation (e.g. 10 items, 10 each)
+      weight_threshold = @weight_threshold || 0.5 # default to half full
+      quantity_threshold = @quantity_threshold || 0.5 #default to half full
+      box = Array.new
+      
+      # See if boxes should be divided by weight or number
+      bw = total_weight / max_weight
+      bq = @quantity.to_f / max_quantity
+      min_boxes = [bw.ceil, bq.ceil].max.to_i
+
+      # work with list of items
+      if itemized
+        leftovers = Array.new
+        variation = @items.length / @quantity.to_f # this shows us how much repetition there is
+
+        # First, we attempt to pack like items/weights
+        # we can skip this if variation is really high
+        if variation < variation_threshold
+          @items.each do |item|
+            while item[:quantity] > 0
+              max = (@max_weight / item[:weight]).truncate # how many of this weight can be packed in
+              this_num = [max, @max_quantity, item[:quantity]].min # should we pack by weight, number avail, or quantity
+              this_weight = this_num * item[:weight]
+              item[:quantity] -= this_num
+              
+              # if we haven't met the threshold
+              if (this_weight / @max_weight) <= weight_threshold and (this_num / @max_quantity) <= quantity_threshold
+                leftovers  << {:weight => this_weight, :quantity => this_num, :item => item[:id]}
+              else #otherwise, pack it
+                box << {:weight => this_weight, :quantity => this_num, :item => item[:id]}
+              end
+            end
+          end
+        else
+          leftovers = @items
+        end
+
+        # Then, we pack all the leftovers
+        leftover_box = {:weight => @max_weight, :quantity => @max_quantity}
+        this_box = {:weight => 0.0, :quantity => 0}       
+        leftovers.each do |item|
+          for i in 1..item[:quantity]
+            leftover_box[:weight] -= item[:weight]
+            leftover_box[:quantity] -= 1
+            if leftover_box[:weight] > 0 and leftover_box[:quantity] > 0
+              this_box[:weight] += item[:weight]
+              this_box[:quantity] += 1
+            elsif leftover_box[:weight] = 0 and leftover_box[:quantity] >= 0
+              this_box[:weight] += item[:weight]
+              this_box[:quantity] += 1
+              box << {:weight => this_box[:weight], :quantity => this_box[:quantity]}
+              leftover_box = {:weight => @max_weight, :quantity => @max_quantity}
+              this_box = {:weight => 0.0, :quantity => 0}
+            else
+              box << {:weight => this_box[:weight], :quantity => this_box[:quantity]}
+              leftover_box = {:weight => @max_weight, :quantity => @max_quantity}
+              this_box = {:weight => 0.0, :quantity => 0}
+            end
+          end
+        end
+        if this_box[:weight] > 0.0 and this_box[:quantity] > 0
+          box << {:weight => this_box[:weight], :quantity => this_box[:quantity]}
+        end
+                  
+        inefficiency = box.length / min_boxes
+
+      else # pack super efficiently
+        if bw > bq
+          box_weight = max_weight
+          box_quantity = max_weight / @weight_each
+        else
+          box_weight = max_quantity * @weight_each
+          box_quantity = max_quantity
+        end
+        
+        # fill the rest of the boxes
+        num_boxes = min_boxes - 1
+        (num_boxes).times do
+          box << {:weight => box_weight, :quantity => box_quantity}
+        end
+        
+        # if there is an uneven number for packaging
+        if @quantity % min_boxes != 0 or num_boxes == 0
+          excess_q = @quantity - (box_quantity * num_boxes)
+          excess_w = excess_q * @weight_each
+          box << {:weight => excess_w, :quantity => excess_q}
+        end
+        inefficiency = 0
+      end
+      return box
+    end
+
+		def self.state_from_zip(zip)
+			zip = zip.to_i
+			{
+				(99500...99929) => "AK", 
+				(35000...36999) => "AL", 
+				(71600...72999) => "AR", 
+				(75502...75505) => "AR", 
+				(85000...86599) => "AZ", 
+				(90000...96199) => "CA", 
+				(80000...81699) => "CO", 
+				(6000...6999) => "CT", 
+				(20000...20099) => "DC", 
+				(20200...20599) => "DC", 
+				(19700...19999) => "DE", 
+				(32000...33999) => "FL", 
+				(34100...34999) => "FL", 
+				(30000...31999) => "GA", 
+				(96700...96798) => "HI", 
+				(96800...96899) => "HI", 
+				(50000...52999) => "IA", 
+				(83200...83899) => "ID", 
+				(60000...62999) => "IL", 
+				(46000...47999) => "IN", 
+				(66000...67999) => "KS", 
+				(40000...42799) => "KY", 
+				(45275...45275) => "KY", 
+				(70000...71499) => "LA", 
+				(71749...71749) => "LA", 
+				(1000...2799) => "MA", 
+				(20331...20331) => "MD", 
+				(20600...21999) => "MD", 
+				(3801...3801) => "ME", 
+				(3804...3804) => "ME", 
+				(3900...4999) => "ME", 
+				(48000...49999) => "MI", 
+				(55000...56799) => "MN", 
+				(63000...65899) => "MO", 
+				(38600...39799) => "MS", 
+				(59000...59999) => "MT", 
+				(27000...28999) => "NC", 
+				(58000...58899) => "ND", 
+				(68000...69399) => "NE", 
+				(3000...3803) => "NH", 
+				(3809...3899) => "NH", 
+				(7000...8999) => "NJ", 
+				(87000...88499) => "NM", 
+				(89000...89899) => "NV", 
+				(400...599) => "NY", 
+				(6390...6390) => "NY", 
+				(9000...14999) => "NY", 
+				(43000...45999) => "OH", 
+				(73000...73199) => "OK", 
+				(73400...74999) => "OK", 
+				(97000...97999) => "OR", 
+				(15000...19699) => "PA", 
+				(2800...2999) => "RI", 
+				(6379...6379) => "RI", 
+				(29000...29999) => "SC", 
+				(57000...57799) => "SD", 
+				(37000...38599) => "TN", 
+				(72395...72395) => "TN", 
+				(73300...73399) => "TX", 
+				(73949...73949) => "TX", 
+				(75000...79999) => "TX", 
+				(88501...88599) => "TX", 
+				(84000...84799) => "UT", 
+				(20105...20199) => "VA", 
+				(20301...20301) => "VA", 
+				(20370...20370) => "VA", 
+				(22000...24699) => "VA", 
+				(5000...5999) => "VT", 
+				(98000...99499) => "WA", 
+				(49936...49936) => "WI", 
+				(53000...54999) => "WI", 
+				(24700...26899) => "WV", 
+				(82000...83199) => "WY"
+				}.each do |range, state|
+					return state if range.include? zip
+				end
+
+				raise ShippingError, "Invalid zip code"
+			end
+
+		private
+
+			def prepare_vars #:nodoc:
+				h = eval(%q{instance_variables.map {|var| "#{var.gsub("@",":")} => #{eval(var+'.inspect')}"}.join(", ").chomp(", ")})
+				return eval("{#{h}}")
+			end
+
+			# Goes out, posts the data, and sets the @response variable with the information
+			def get_response(url)
+				check_required
+				uri            = URI.parse url
+				http           = Net::HTTP.new uri.host, uri.port
+				if uri.port == 443
+					http.use_ssl	= true
+					http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+				end
+				@response_plain = http.post(uri.path, @data).body
+				@response       = @response_plain.include?('<?xml') ? REXML::Document.new(@response_plain) : @response_plain
+
+				@response.instance_variable_set "@response_plain", @response_plain
+				def @response.plain; @response_plain; end
+			end
+
+			# Make sure that the required fields are not empty
+			def check_required
+				for var in @required
+					raise ShippingRequiredFieldError, "The #{var} variable needs to be set" if eval("@#{var}").nil?
+				end
+			end
+
+			STATES = {"al" => "alabama", "ne" => "nebraska", "ak" => "alaska", "nv" => "nevada", "az" => "arizona", "nh" => "new hampshire", "ar" => "arkansas", "nj" => "new jersey", "ca" => "california", "nm" => "new mexico", "co" => "colorado", "ny" => "new york", "ct" => "connecticut", "nc" => "north carolina", "de" => "delaware", "nd" => "north dakota", "fl" => "florida", "oh" => "ohio", "ga" => "georgia", "ok" => "oklahoma", "hi" => "hawaii", "or" => "oregon", "id" => "idaho", "pa" => "pennsylvania", "il" => "illinois", "pr" => "puerto rico", "in" => "indiana", "ri" => "rhode island", "ia" => "iowa", "sc" => "south carolina", "ks" => "kansas", "sd" => "south dakota", "ky" => "kentucky", "tn" => "tennessee", "la" => "louisiana", "tx" => "texas", "me" => "maine", "ut" => "utah", "md" => "maryland", "vt" => "vermont", "ma" => "massachusetts", "va" => "virginia", "mi" => "michigan", "wa" => "washington", "mn" => "minnesota", "dc" => "district of columbia", "ms" => "mississippi", "wv" => "west virginia", "mo" => "missouri", "wi" => "wisconsin", "mt" => "montana", "wy" => "wyoming"}
+			
+			def self.initialize_for_fedex_service(xml)
+        s = Shipping::Base.new
+        s.fedex
+        s.eta = REXML::XPath.first(xml, "DeliveryDate").text unless REXML::XPath.match(xml, "DeliveryDate").empty?
+        s.service_type = REXML::XPath.first(xml, "Service").text
+        s.discount_price = REXML::XPath.first(xml, "EstimatedCharges/DiscountedCharges/BaseCharge").text
+        s.price = REXML::XPath.first(xml, "EstimatedCharges/DiscountedCharges/NetCharge").text
+        return s
+      end
+		end
+	end