reactive_shipping 3.0.0

data/lib/reactive_shipping/rate_response.rb

@@ -0,0 +1,33 @@
+module ReactiveShipping
+
+  # The `RateResponse` object is returned by the {ReactiveShipping::Carrier#find_rates}
+  # call. The most important method is {#rates}, which will return a list of possible
+  # shipping options with an estimated price.
+  #
+  # @note Some carriers provide more information than others, so not all attributes
+  #   will be set, depending on what carrier you are using.
+  #
+  # @!attribute rates
+  #    The available rate options for the shipment, with an estimated price.
+  #    @return [Array<ReactiveShipping::RateEstimate>]
+  class RateResponse < Response
+
+    attr_reader :rates
+
+    # Initializes a new RateResponse instance.
+    #
+    # @param success (see ReactiveShipping::Response#initialize)
+    # @param message (see ReactiveShipping::Response#initialize)
+    # @param params (see ReactiveShipping::Response#initialize)
+    # @option options (see ReactiveShipping::Response#initialize)
+    # @option options [Array<ReactiveShipping::RateEstimate>] :rates The rate estimates to
+    #   populate the {#rates} method with.
+    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/reactive_shipping/response.rb

@@ -0,0 +1,44 @@
+module ReactiveShipping #:nodoc:
+
+  # Basic Response class for requests against a carrier's API.
+  class Response
+    attr_reader :params
+    attr_reader :message
+    attr_reader :test
+    attr_reader :xml
+    attr_reader :request
+
+    # @param success [Boolean] Whether the request was considered successful, i.e. this
+    #   response object will have the expected data set.
+    # @param message [String] A status message. Usuaully set when `success` is `false`,
+    #   but can also be set for successful responses.
+    # @param params [Hash] Response parameters
+    # @param options [Hash]
+    # @option options [Boolean] :test (default: false) Whether this reponse was a result
+    #   of a request executed against the sandbox or test environment of the carrier's API.
+    # @option options [String] :xml The raw XML of the response.
+    # @option options [String] :request The payload of the request.
+    # @option options [Boolean] :allow_failure Allows a failed response without raising.
+    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 || options[:allow_failure]
+    end
+
+    # Whether the request was executed successfully or not.
+    # @return [Boolean] Should only return `true` if the attributes of teh response
+    #   instance are set with useful values.
+    def success?
+      @success ? true : false
+    end
+
+    # Whether this request was executed against the sandbox or test environment instead of
+    # the production environment of the carrier.
+    # @return [Boolean]
+    def test?
+      @test ? true : false
+    end
+  end
+end

data/lib/reactive_shipping/shipment_event.rb

@@ -0,0 +1,22 @@
+module ReactiveShipping
+  class ShipmentEvent
+    attr_reader :name, :time, :location, :message, :type_code
+
+    def initialize(name, time, location, message = nil, type_code = nil)
+      @name, @time, @location, @message, @type_code = name, time, location, message, type_code
+    end
+
+    def delivered?
+      status == :delivered
+    end
+
+    def status
+      @status ||= name.downcase.gsub("\s", "_").to_sym
+    end
+
+    def ==(other)
+      attributes = %i(name time location message type_code)
+      attributes.all? { |attr| self.public_send(attr) == other.public_send(attr) }
+    end
+  end
+end

data/lib/reactive_shipping/shipment_packer.rb

@@ -0,0 +1,108 @@
+module ReactiveShipping
+  class ShipmentPacker
+    class OverweightItem < StandardError
+    end
+
+    EXCESS_PACKAGE_QUANTITY_THRESHOLD = 10_000
+    class ExcessPackageQuantity < StandardError; end
+
+    # items           - array of hashes containing quantity, grams and price.
+    #                   ex. `[{:quantity => 2, :price => 1.0, :grams => 50}]`
+    # dimensions      - `[5.0, 15.0, 30.0]`
+    # maximum_weight  - maximum weight in grams
+    # currency        - ISO currency code
+
+    class << self
+      def pack(items, dimensions, maximum_weight, currency)
+        return [] if items.empty?
+        packages = []
+        items.map!(&:symbolize_keys)
+
+        # Naive in that it assumes weight is equally distributed across all items
+        # Should raise early enough in most cases
+        validate_total_weight(items, maximum_weight)
+        items_to_pack = items.map(&:dup).sort_by! { |i| i[:grams].to_i }
+
+        state = :package_empty
+        while state != :packing_finished
+          case state
+          when :package_empty
+            package_weight, package_value = 0, 0
+            state = :filling_package
+          when :filling_package
+            validate_package_quantity(packages.count)
+
+            items_to_pack.each do |item|
+              quantity = determine_fillable_quantity_for_package(item, maximum_weight, package_weight)
+              package_weight += item_weight(quantity, item[:grams])
+              package_value += item_value(quantity, item[:price])
+              item[:quantity] = item[:quantity].to_i - quantity
+            end
+
+            items_to_pack.reject! { |i| i[:quantity].to_i == 0 }
+            state = :package_full
+          when :package_full
+            packages << ReactiveShipping::Package.new(package_weight, dimensions, value: package_value, currency: currency)
+            state = items_to_pack.any? ? :package_empty : :packing_finished
+          end
+        end
+
+        packages
+      end
+
+      private
+
+      def validate_total_weight(items, maximum_weight)
+        total_weight = 0
+        items.each do |item|
+          total_weight += item[:quantity].to_i * item[:grams].to_i
+
+          if overweight_item?(item[:grams], maximum_weight)
+            raise OverweightItem, "The item with weight of #{item[:grams]}g is heavier than the allowable package weight of #{maximum_weight}g"
+          end
+
+          raise_excess_quantity_error if maybe_excess_package_quantity?(total_weight, maximum_weight)
+        end
+      end
+
+      def validate_package_quantity(number_of_packages)
+        raise_excess_quantity_error if number_of_packages >= EXCESS_PACKAGE_QUANTITY_THRESHOLD
+      end
+
+      def raise_excess_quantity_error
+        raise ExcessPackageQuantity, "Unable to pack more than #{EXCESS_PACKAGE_QUANTITY_THRESHOLD} packages"
+      end
+
+      def overweight_item?(grams, maximum_weight)
+        grams.to_i > maximum_weight
+      end
+
+      def maybe_excess_package_quantity?(total_weight, maximum_weight)
+        total_weight > (maximum_weight * EXCESS_PACKAGE_QUANTITY_THRESHOLD)
+      end
+
+      def determine_fillable_quantity_for_package(item, maximum_weight, package_weight)
+        item_grams = item[:grams].to_i
+        item_quantity = item[:quantity].to_i
+
+        if item_grams <= 0
+          item_quantity
+        else
+          # Grab the max amount of this item we can fit into this package
+          # Or, if there are fewer than the max for this item, put
+          # what is left into this package
+          available_grams = (maximum_weight - package_weight).to_i
+          [available_grams / item_grams, item_quantity].min
+        end
+      end
+
+      def item_weight(quantity, grams)
+        quantity * grams.to_i
+      end
+
+      def item_value(quantity, price)
+        quantity * Package.cents_from(price)
+      end
+    end
+  end
+end

data/lib/reactive_shipping/shipping_response.rb

@@ -0,0 +1,34 @@
+module ReactiveShipping
+
+  # Responce object class for calls to {ReactiveShipping::Carrier#create_shipment}.
+  #
+  # @note Some carriers provide more information that others, so not all attributes
+  #   will be set, depending on what carrier you are using.
+  #
+  # @!attribute shipping_id
+  #   The unique identifier of the shipment, which can be used to further interact
+  #   with the carrier's API.
+  #   @return [String]
+  #
+  # @!attribute tracking_number
+  #   The tracking number of the shipments, which can be shared with the customer and
+  #   be used for {ReactiveShipping::Carrier#find_tracking_info}.
+  #   @return [String]
+  class ShippingResponse < Response
+    attr_reader :shipping_id, :tracking_number
+
+    # Initializes a new ShippingResponse instance.
+    #
+    # @param success (see ReactiveShipping::Response#initialize)
+    # @param message (see ReactiveShipping::Response#initialize)
+    # @param params (see ReactiveShipping::Response#initialize)
+    # @option options (see ReactiveShipping::Response#initialize)
+    # @option options [String] :shipping_id Populates {#shipping_id}.
+    # @option options [String] :tracking_number Populates {#tracking_number}.
+    def initialize(success, message, params = {}, options = {})
+      @shipping_id = options[:shipping_id]
+      @tracking_number = options[:tracking_number]
+      super
+    end
+  end
+end

data/lib/reactive_shipping/tracking_response.rb

@@ -0,0 +1,120 @@
+module ReactiveShipping
+
+  # Represents the response to a {ReactiveShipping::Carrier#find_tracking_info} call.
+  #
+  # @note Some carriers provide more information than others, so not all attributes
+  #   will be set, depending on what carrier you are using.
+  #
+  # @!attribute carrier
+  #   @return [Symbol]
+  #
+  # @!attribute carrier_name
+  #   @return [String]
+  #
+  # @!attribute status
+  #   @return [Symbol]
+  #
+  # @!attribute status_code
+  #   @return [string]
+  #
+  # @!attribute status_description
+  #   @return [String]
+  #
+  # @!attribute ship_time
+  #   @return [Date, Time]
+  #
+  # @!attribute scheduled_delivery_date
+  #   @return [Date, Time]
+  #
+  # @!attribute actual_delivery_date
+  #   @return [Date, Time]
+  #
+  # @!attribute attempted_delivery_date
+  #   @return [Date, Time]
+  #
+  # @!attribute delivery_signature
+  #   @return [String]
+  #
+  # @!attribute tracking_number
+  #   @return [String]
+  #
+  # @!attribute shipment_events
+  #   @return [Array<ReactiveShipping::ShipmentEvent>]
+  #
+  # @!attribute shipper_address
+  #   @return [ReactiveShipping::Location]
+  #
+  # @!attribute origin
+  #   @return [ReactiveShipping::Location]
+  #
+  # @!attribute destination
+  #   @return [ReactiveShipping::Location]
+  class TrackingResponse < Response
+    attr_reader :carrier,:carrier_name,
+                :status,:status_code, :status_description,
+                :ship_time, :scheduled_delivery_date, :actual_delivery_date, :attempted_delivery_date,
+                :delivery_signature, :tracking_number, :shipment_events,
+                :shipper_address, :origin, :destination
+
+    # @params (see ReactiveShipping::Response#initialize)
+    def initialize(success, message, params = {}, options = {})
+      @carrier = options[:carrier].parameterize.to_sym
+      @carrier_name = options[:carrier]
+      @status = options[:status]
+      @status_code = options[:status_code]
+      @status_description = options[:status_description]
+      @ship_time = options[:ship_time]
+      @scheduled_delivery_date = options[:scheduled_delivery_date]
+      @actual_delivery_date = options[:actual_delivery_date]
+      @attempted_delivery_date = options[:attempted_delivery_date]
+      @delivery_signature = options[:delivery_signature]
+      @tracking_number = options[:tracking_number]
+      @shipment_events = Array(options[:shipment_events])
+      @shipper_address = options[:shipper_address]
+      @origin = options[:origin]
+      @destination = options[:destination]
+      super
+    end
+
+    # The latest tracking event for this shipment, i.e. the current status.
+    # @return [ReactiveShipping::ShipmentEvent]
+    def latest_event
+      @shipment_events.last
+    end
+
+    # Returns `true` if the shipment has arrived at the destination.
+    # @return [Boolean]
+    def is_delivered?
+      @status == :delivered
+    end
+
+    # Returns `true` if something out of the ordinary has happened during
+    # the delivery of this package.
+    # @return [Boolean]
+    def has_exception?
+      @status == :exception
+    end
+
+    alias_method :exception_event, :latest_event
+    alias_method :delivered?, :is_delivered?
+    alias_method :exception?, :has_exception?
+    alias_method :scheduled_delivery_time, :scheduled_delivery_date
+    alias_method :actual_delivery_time, :actual_delivery_date
+    alias_method :attempted_delivery_time, :attempted_delivery_date
+
+    def ==(other)
+      attributes = %i(carrier carrier_name status status_code status_description ship_time scheduled_delivery_date
+        actual_delivery_date attempted_delivery_date delivery_signature tracking_number shipper_address
+        origin destination
+      )
+
+      attributes.all? { |attr| self.public_send(attr) == other.public_send(attr) } && compare_shipment_events(other)
+    end
+
+    private
+    # Ensure order doesn't matter when comparing shipment_events
+    def compare_shipment_events(other)
+      shipment_events.sort_by(&:time) == other.shipment_events.sort_by(&:time)
+    end
+  end
+end

data/lib/reactive_shipping/version.rb

@@ -0,0 +1,3 @@
+module ReactiveShipping
+  VERSION = "3.0.0"
+end

data/reactive_shipping.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path("../lib/", __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+
+require "reactive_shipping/version"
+
+Gem::Specification.new do |s|
+  s.name          = "reactive_shipping"
+  s.version       = ReactiveShipping::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Sub Pop Records"]
+  s.email         = ["webmaster@subpop.com"]
+  s.homepage      = "http://github.com/realsubpop/reactive_shipping"
+  s.summary       = "Simple shipping abstraction library"
+  s.description   = "Get rates and tracking info from various shipping carriers. A fork of Shopify's original ActiveShipping gem."
+  s.license       = "MIT"
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_path  = "lib"
+  s.post_install_message = "Thanks for installing ReactiveShipping! https://github.com/realsubpop/reactive_shipping/blob/master/CHANGELOG.md."
+
+
+  s.add_dependency("measured", ">= 2.0")
+  s.add_dependency("activesupport", ">= 4.2", "< 6.1")
+  s.add_dependency("active_utils", "~> 3.3.1")
+  s.add_dependency("nokogiri", ">= 1.6")
+
+  s.add_development_dependency("minitest")
+  s.add_development_dependency("minitest-reporters")
+  s.add_development_dependency("rake")
+  s.add_development_dependency("mocha", "~> 1")
+  s.add_development_dependency("timecop")
+  s.add_development_dependency("business_time")
+  s.add_development_dependency("pry")
+  s.add_development_dependency("pry-byebug")
+  s.add_development_dependency("vcr")
+  s.add_development_dependency("webmock")
+end

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config

data/test/console.rb

@@ -0,0 +1,39 @@
+require 'pry'
+require 'reactive_shipping'
+require 'test_helper'
+
+include ReactiveShipping
+include ReactiveShipping::Test::Credentials
+include ReactiveShipping::Test::Fixtures
+
+def create_carrier(klass, creds)
+  options = credentials(creds).merge(:test => true)
+  klass.new(options)
+rescue NoCredentialsFound
+  STDERR.puts "No credentials found for #{creds}"
+  nil
+end
+
+def px(xml_s)
+  puts Nokogiri.XML(xml_s)
+end
+
+def reload!
+  # Supress a billion constant redefinition warnings
+  warn_level = $VERBOSE
+  $VERBOSE = nil
+
+  files = $LOADED_FEATURES.select { |feat| feat =~ /\/reactive_shipping\// }
+  files.each { |file| load file }
+
+  $VERBOSE = warn_level
+  files
+end
+
+# Prebuilt objects for most common carriers
+@canpo    = create_carrier(CanadaPost,:canada_post)
+@fedex    = create_carrier(FedEx,:fedex)
+@shipwire = create_carrier(Shipwire,:shipwire)
+@usps     = create_carrier(USPS,:usps)
+# Tips: call reload! to reload all the reactive_shipping files, use fixtures from test_helpers for parameters
+binding.pry