friendly_shipping 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8c1f8749c1f3c1199a3ff41ec10d3a1d92f78dd
-  data.tar.gz: f22645471497c2e0350659b4d1dd9cb35e799f22
+  metadata.gz: 6e4447aa9686205e27c1a070e4e8e3b3aafb26d8
+  data.tar.gz: acf1e59a8cc7372eb1bb7a942f7014184f2fd1e5
 SHA512:
-  metadata.gz: fc5b536db417d7d087ae26a3121f61438b510b14b4fc8d94b13d3e25397f7e8f1e1b4c2cdaa18f13a4265c9aad1f6cdd1dcd6a3424bd6822d2ef8dc72a78cb7b
-  data.tar.gz: f65dd002fe51c318074e6d4ae841f56d80637f7997d1becfe935e4d75f0ccc9da0d7df8746abbc38d6851068490b21d8182e67d26b912f3a5cc0995855f2fde9
+  metadata.gz: 513617be6accfb94f386f77c675f6e5520de5e1ec03b06b7c4bea70b72a47ab06f9ce74e5bad582757dba9029041c81cb28a7985a55b03b599973e3373319cc9
+  data.tar.gz: da1618a49058b3b5981dddb2a23b412fbd1fe1a28886bb823e777c2626e1e3fe749ca5a9b442da9e833708c46c6c47be2b09a10441d070de302a8f90f77eadb7

data/friendly_shipping.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "dry-monads", "~> 1.0"
   spec.add_runtime_dependency "money", ">= 6.0.0"
   spec.add_runtime_dependency "nokogiri", ">= 1.6"
-  spec.add_runtime_dependency "physical", "~> 0.3.0"
+  spec.add_runtime_dependency "physical", "~> 0.4"
   spec.add_runtime_dependency "rest-client", "~> 2.0"
   spec.required_ruby_version = '>= 2.4'
 

data/lib/friendly_shipping/services/usps/choose_package_rate.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class ChoosePackageRate
+        class CannotDetermineRate < StandardError; end
+        # Some shipping rates use 'Flat Rate Boxes', indicating that
+        # they are available for ALL flat rate boxes.
+        FLAT_RATE_BOX = /Flat Rate Box/i.freeze
+
+        # Select the corresponding rate for a package from all the rates USPS returns to us
+        #
+        # @param [FriendlyShipping::ShippingMethod] shipping_method The shipping method we want to filter by
+        # @param [Physical::Package] package The package we want to match with a rate
+        # @param [Array<FriendlyShipping::Rate>] The rates we select from
+        #
+        # @return [FriendlyShipping::Rate] The rate that most closely matches our package
+        def self.call(shipping_method, package, rates)
+          # Keep all rates with the requested shipping method
+          rates_with_this_shipping_method = rates.select { |r| r.shipping_method == shipping_method }
+
+          # Keep only rates with the package type of this package
+          rates_with_this_package_type = rates_with_this_shipping_method.select do |r|
+            r.data[:box_name] == package.properties[:box_name] ||
+              r.data[:box_name] == :flat_rate_boxes && package.properties[:box_name]&.match?(FLAT_RATE_BOX)
+          end
+
+          # Filter by our package's `hold_for_pickup` option
+          rates_with_this_hold_for_pickup_option = rates_with_this_package_type.select do |r|
+            r.data[:hold_for_pickup] == !!package.properties[:hold_for_pickup]
+          end
+
+          # At this point we should be left with a single rate. If we are not, raise an error,
+          # as that means we're missing some code.
+          if rates_with_this_hold_for_pickup_option.length > 1
+            raise CannotDetermineRate
+          end
+
+          # As we only have one rate left, return that without the array.
+          rates_with_this_hold_for_pickup_option.first
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+require 'friendly_shipping/bad_request'
+require 'rest-client'
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class Client
+        extend Dry::Monads::Result::Mixin
+        class <<self
+          # USPS allows both GET and POST request. We're using POST here as those request
+          # are less limited in size.
+          def post(request)
+            http_response = ::RestClient.post(request.url, request.body)
+
+            Success(convert_to_friendly_response(http_response))
+          rescue ::RestClient::Exception => e
+            Failure(e)
+          end
+
+          private
+
+          def convert_to_friendly_response(http_response)
+            FriendlyShipping::Response.new(
+              status: http_response.code,
+              body: http_response.body,
+              headers: http_response.headers
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/machinable_package.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Usps
+      # USPS has certain size and weight requirements for packages to
+      # be considered machinable. Machinable packages are generally
+      # less expensive to ship. For more information see:
+      #   https://pe.usps.com/BusinessMail101?ViewName=Parcels
+      #
+      class MachinablePackage
+        attr_reader :package
+
+        MIN_LENGTH = Measured::Length(6, :inches)
+        MIN_WIDTH = Measured::Length(3, :inches)
+        MIN_HEIGHT = Measured::Length(0.25, :inches)
+
+        MAX_LENGTH = Measured::Length(27, :inches)
+        MAX_WIDTH = Measured::Length(17, :inches)
+        MAX_HEIGHT = Measured::Length(17, :inches)
+
+        MAX_WEIGHT = Measured::Weight(25, :pounds)
+
+        # @param [Physical::Package]
+        def initialize(package)
+          @package = package
+        end
+
+        def machinable?
+          at_least_minimum && at_most_maximum
+        end
+
+        private
+
+        def at_least_minimum
+          package.length >= MIN_LENGTH &&
+            package.width >= MIN_WIDTH &&
+            package.height >= MIN_HEIGHT
+        end
+
+        def at_most_maximum
+          package.length <= MAX_LENGTH &&
+            package.width <= MAX_WIDTH &&
+            package.height <= MAX_HEIGHT &&
+            package.weight <= MAX_WEIGHT
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/parse_package_rate.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class ParsePackageRate
+        # USPS returns all the info about a rate in a long string with a bit of gibberish.
+        ESCAPING_AND_SYMBOLS = /<\S*>/.freeze
+
+        # At the beginning of the long String, USPS keeps a copy of its own name. We know we're dealing with
+        # them though, so we can filter that out, too.
+        LEADING_USPS = /^USPS /.freeze
+
+        # This combines all the things we want to filter out.
+        SERVICE_NAME_SUBSTITUTIONS = /#{ESCAPING_AND_SYMBOLS}|#{LEADING_USPS}/.freeze
+
+        # Often we get a multitude of rates for the same service given some combination of
+        # Box type and (see below) and "Hold for Pickup" service. This creates a regular expression
+        # with groups named after the keys from the `Usps::CONTAINERS` constant.
+        # Unfortunately, the keys don't correspond directly to the codes we use when serializing the
+        # request.
+        BOX_REGEX = {
+          flat_rate_boxes: 'Flat Rate Boxes',
+          large_flat_rate_box: 'Large Flat Rate Box',
+          medium_flat_rate_box: 'Medium Flat Rate Box',
+          small_flat_rate_box: 'Small Flat Rate Box',
+          regional_rate_box_a: 'Regional Rate Box A',
+          regional_rate_box_b: 'Regional Rate Box B',
+          regional_rate_box_c: 'Regional Rate Box C',
+          flat_rate_envelope: 'Flat Rate Envelope',
+          legal_flat_rate_envelope: 'Legal Flat Rate Envelope',
+          padded_flat_rate_envelope: 'Padded Flat Rate Envelope',
+          gift_card_flat_rate_envelope: 'Gift Card Flat Rate Envelope',
+          window_flat_rate_envelope: 'Window Flat Rate Envelope',
+          small_flat_rate_envelope: 'Small Flat Rate Envelope',
+          large_envelope: 'Large Envelope',
+          parcel: 'Parcel',
+          postcards: 'Postcards'
+        }.map { |k, v| "(?<#{k}>#{v})" }.join("|").freeze
+
+        # We use this for identifying rates that use the Hold for Pickup service.
+        HOLD_FOR_PICKUP = /Hold for Pickup/i.freeze
+
+        # For most rate options, USPS will return how many business days it takes to deliver this
+        # package in the format "{1,2,3}-Day". We can filter this out using the below Regex.
+        DAYS_TO_DELIVERY = /(?<days>\d)-Day/.freeze
+
+        # When delivering to military ZIP codes, we don't actually get a timing estimate, but instead the string
+        # "Military". We use this to indicate that this rate is for a military zip code in the rates' data Hash.
+        MILITARY = /MILITARY/i.freeze
+
+        # The tags used in the rate node that we get information from.
+        SERVICE_CODE_TAG = 'CLASSID'
+        SERVICE_NAME_TAG = 'MailService'
+        RATE_TAG = 'Rate'
+        COMMERCIAL_RATE_TAG = 'CommercialRate'
+        CURRENCY = Money::Currency.new('USD').freeze
+
+        class << self
+          def call(rate_node, package)
+            # "A mail class identifier for the postage returned. Not necessarily unique within a <Package/>."
+            # (from the USPS docs). We save this on the data Hash, but do not use it for identifying shipping methods.
+            service_code = rate_node.attributes[SERVICE_CODE_TAG].value
+
+            # The long string discussed above.
+            service_name = rate_node.at(SERVICE_NAME_TAG).text
+
+            # Does this rate assume Hold for Pickup service?
+            hold_for_pickup = service_name.match?(HOLD_FOR_PICKUP)
+
+            # Is the destination a military ZIP code?
+            military = service_name.match?(MILITARY)
+
+            # If we get a days-to-delivery indication, save it in the `days_to_delivery` variable.
+            days_to_delivery_match = service_name.match(DAYS_TO_DELIVERY)
+            days_to_delivery = if days_to_delivery_match
+                                 days_to_delivery_match.named_captures.values.first.to_i
+                               end
+
+            # Clean up the long string
+            service_name.gsub!(SERVICE_NAME_SUBSTITUTIONS, '')
+
+            # Some USPS services only offer commercial pricing. Unfortunately, USPS then returns a retail rate of 0.
+            # In these cases, return the commercial rate instead of the normal rate.
+            # Some rates are available in both commercial and retail pricing - if we want the commercial pricing here,
+            # we need to specify the commercial_pricing property on the `Physical::Package`.
+            rate_value = if (package.properties[:commercial_pricing] || rate_node.at(RATE_TAG).text.to_d.zero?) && rate_node.at(COMMERCIAL_RATE_TAG)
+                           rate_node.at(COMMERCIAL_RATE_TAG).text.to_d
+                         else
+                           rate_node.at(RATE_TAG).text.to_d
+                         end
+
+            # The rate expressed as a RubyMoney objext
+            rate = Money.new(rate_value * CURRENCY.subunit_to_unit, CURRENCY)
+
+            # Which shipping method does this rate belong to? This is trickier than it sounds, because we match
+            # strings here, and we have a `Priority Mail` and `Priority Mail Express` shipping method.
+            # If we have multiple matches, we take the longest matching shipping method name so `Express` rates
+            # do not accidentally get marked as `Priority` only.
+            possible_shipping_methods = SHIPPING_METHODS.select do |sm|
+              service_name.tr('-', ' ').upcase.starts_with?(sm.service_code)
+            end.sort_by do |shipping_method|
+              shipping_method.name.length
+            end
+            shipping_method = possible_shipping_methods.last
+
+            # We find out the box name using a bit of Regex magic using named captures. See the `BOX_REGEX`
+            # constant above.
+            box_name_match = service_name.match(/#{BOX_REGEX}/)
+            box_name = if box_name_match
+                         box_name_match.named_captures.compact.keys.last.to_sym
+                       end
+
+            # Combine all the gathered information in a FriendlyShipping::Rate object.
+            # Careful: This rate is only for one package within the shipment, and we get multiple
+            # rates per package for the different shipping method/box/hold for pickup combinations.
+            FriendlyShipping::Rate.new(
+              shipping_method: shipping_method,
+              amounts: { package.id => rate },
+              data: {
+                package: package,
+                box_name: box_name,
+                hold_for_pickup: hold_for_pickup,
+                days_to_delivery: days_to_delivery,
+                military: military,
+                full_mail_service: service_name,
+                service_code: service_code
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/parse_rate_response.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/usps/parse_xml_response'
+require 'friendly_shipping/services/usps/parse_package_rate'
+require 'friendly_shipping/services/usps/choose_package_rate'
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class ParseRateResponse
+        class BoxNotFoundError < StandardError; end
+
+        class << self
+          # Parse a response from USPS' rating API
+          #
+          # @param [FriendlyShipping::Request] request The request that was used to obtain this Response
+          # @param [FriendlyShipping::Response] response The response that USPS returned
+          # @param [Physical::Shipment] shipment The shipment object we're trying to get results for
+          # @return [Result<Array<FriendlyShipping::Rate>>] When successfully parsing, an array of rates in a Success Monad.
+          def call(request:, response:, shipment:)
+            # Filter out error responses and directly return a failure
+            parsing_result = ParseXMLResponse.call(response.body, 'RateV4Response')
+            parsing_result.fmap do |xml|
+              # Get all the possible rates for each package
+              rates_by_package = rates_from_response_node(xml, shipment)
+
+              SHIPPING_METHODS.map do |shipping_method|
+                # For every package ...
+                matching_rates = rates_by_package.map do |package, rates|
+                  # ... choose the rate that fits this package best.
+                  ChoosePackageRate.call(shipping_method, package, rates)
+                end.compact # Some shipping rates are not available for every shipping method.
+
+                # in this case, go to the next shipping method.
+                next if matching_rates.empty?
+
+                # return one rate for all packages with the amount keys being the package IDs.
+                FriendlyShipping::Rate.new(
+                  amounts: matching_rates.map(&:amounts).reduce({}, :merge),
+                  shipping_method: shipping_method,
+                  data: matching_rates.first.data,
+                  original_request: request,
+                  original_response: response
+                )
+              end.compact
+            end
+          end
+
+          private
+
+          PACKAGE_NODE_XPATH = '//Package'
+          SERVICE_NODE_NAME = 'Postage'
+
+          # Iterate over all packages and parse the rates for each package
+          #
+          # @param [Nokogiri::XML::Node] xml The XML document containing packages and rates
+          # @param [Physical::Shipment] shipment The shipment we're trying to get rates for
+          #
+          # @return [Hash<Physical::Package => Array<FriendlyShipping::Rate>>]
+          def rates_from_response_node(xml, shipment)
+            xml.xpath(PACKAGE_NODE_XPATH).each_with_object({}) do |package_node, result|
+              package_id = package_node['ID']
+              corresponding_package = shipment.packages.detect { |p| p.id == package_id }
+
+              # There should always be a package in the original shipment that corresponds to the package ID
+              # in the USPS response.
+              raise BoxNotFoundError if corresponding_package.nil?
+
+              result[corresponding_package] = package_node.xpath(SERVICE_NODE_NAME).map do |service_node|
+                ParsePackageRate.call(service_node, corresponding_package)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/parse_xml_response.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class ParseXMLResponse
+        extend Dry::Monads::Result::Mixin
+        ERROR_ROOT_TAG = 'Error'
+
+        class << self
+          def call(response_body, expected_root_tag)
+            xml = Nokogiri.XML(response_body)
+
+            if xml.root.nil? || ![expected_root_tag, ERROR_ROOT_TAG].include?(xml.root.name)
+              Failure('Invalid document')
+            elsif request_successful?(xml)
+              Success(xml)
+            else
+              Failure(error_message(xml))
+            end
+          rescue Nokogiri::XML::SyntaxError => e
+            Failure(e)
+          end
+
+          private
+
+          def request_successful?(xml)
+            xml.xpath('Error/Number')&.text.blank?
+          end
+
+          def error_message(xml)
+            number = xml.xpath('Error/Number')&.text
+            desc = xml.xpath('Error/Description')&.text
+            [number, desc].select(&:present?).join(': ').presence || 'USPS could not process the request.'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/serialize_rate_request.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/usps/machinable_package'
+
+module FriendlyShipping
+  module Services
+    class Usps
+      class SerializeRateRequest
+        MAX_REGULAR_PACKAGE_SIDE = Measured::Length(12, :inches)
+
+        class << self
+          # @param [Physical::Shipment] shipment The shipment we want to get rates for
+          #   shipment.packages[0].properties[:box_code] Can be :rectangular, :variable,
+          #     or a flat rate container defined in CONTAINERS.
+          # @param [String] login The USPS login code
+          # @param [FriendlyShipping::ShippingMethod] service The shipping methods we want to get rates
+          #   for. If empty, we get all of them
+          # @return Array<[FriendlyShipping::Rate]> A set of Rates that this package may be sent with
+          def call(shipment:, login:, shipping_method: nil)
+            xml_builder = Nokogiri::XML::Builder.new do |xml|
+              xml.RateV4Request('USERID' => login) do
+                shipment.packages.each do |package|
+                  xml.Package('ID' => package.id) do
+                    xml.Service(service_code_by(shipping_method, package))
+                    if package.properties[:first_class_mail_type]
+                      xml.FirstClassMailType(FIRST_CLASS_MAIL_TYPES[package.properties[:first_class_mail_type]])
+                    end
+                    xml.ZipOrigination(shipment.origin.zip)
+                    xml.ZipDestination(shipment.destination.zip)
+                    xml.Pounds(0)
+                    xml.Ounces(ounces_for(package))
+                    size_code = size_code_for(package)
+                    container = CONTAINERS[package.properties[:box_name] || :rectangular]
+                    xml.Container(container)
+                    xml.Size(size_code)
+                    xml.Width("%0.2f" % package.width.convert_to(:inches).value.to_f)
+                    xml.Length("%0.2f" % package.length.convert_to(:inches).value.to_f)
+                    xml.Height("%0.2f" % package.height.convert_to(:inches).value.to_f)
+                    xml.Girth("%0.2f" % girth(package))
+                    xml.Machinable(machinable(package))
+                  end
+                end
+              end
+            end
+            xml_builder.to_xml
+          end
+
+          private
+
+          def machinable(package)
+            MachinablePackage.new(package).machinable? ? 'TRUE' : 'FALSE'
+          end
+
+          def size_code_for(package)
+            if package.dimensions.max <= MAX_REGULAR_PACKAGE_SIDE
+              'REGULAR'
+            else
+              'LARGE'
+            end
+          end
+
+          def service_code_by(shipping_method, package)
+            return 'ALL' unless shipping_method
+
+            if package.properties[:commercial_pricing]
+              "#{shipping_method.service_code} COMMERCIAL"
+            else
+              shipping_method.service_code
+            end
+          end
+
+          def ounces_for(package)
+            ounces = package.weight.convert_to(:ounces).value.to_f.round(2).ceil
+            ounces == 16 ? 15.999 : [ounces, 1].max
+          end
+
+          def strip_zip(zip)
+            zip.to_s.scan(/\d{5}/).first || zip
+          end
+
+          def girth(package)
+            width, length = package.dimensions.sort.first(2)
+            (width.scale(2) + length.scale(2)).convert_to(:inches).value.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/friendly_shipping/services/usps/shipping_methods.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module FriendlyShipping
+  module Services
+    class Usps
+      CONTAINERS = {
+        variable: 'VARIABLE',
+        rectangular: 'RECTANGULAR',
+        large_flat_rate_box: 'LG FLAT RATE BOX',
+        medium_flat_rate_box: 'MD FLAT RATE BOX',
+        small_flat_rate_box: 'SM FLAT RATE BOX',
+        regional_rate_box_a: 'REGIONALRATEBOXA',
+        regional_rate_box_b: 'REGIONALRATEBOXB',
+        flat_rate_envelope: 'FLAT RATE ENVELOPE',
+        legal_flat_rate_envelope: 'LEGAL FLAT RATE ENVELOPE',
+        padded_flat_rate_envelope: 'PADDED FLAT RATE ENVELOPE',
+        gift_card_flat_rate_envelope: 'GIFT CARD FLAT RATE ENVELOPE',
+        window_flat_rate_envelope: 'WINDOW FLAT RATE ENVELOPE',
+        small_flat_rate_envelope: 'SM FLAT RATE ENVELOPE',
+        cubic_soft_pack: 'CUBIC SOFT PACK',
+        cubic_parcels: 'CUBIC_PARCELS'
+      }.freeze
+
+      FIRST_CLASS_MAIL_TYPES = {
+        letter: 'LETTER',
+        flat: 'FLAT',
+        parcel: 'PARCEL',
+        post_card: 'POSTCARD',
+        package_service: 'PACKAGESERVICE'
+      }.freeze
+
+      SHIPPING_METHODS = [
+        'First-Class',
+        'First-Class Package Service',
+        'Priority',
+        'Priority Mail Express',
+        'Standard Post',
+        'Retail Ground',
+        'Media Mail',
+        'Library Mail',
+      ].map do |shipping_method_name|
+        FriendlyShipping::ShippingMethod.new(
+          origin_countries: [Carmen::Country.coded('US')],
+          name: shipping_method_name,
+          service_code: shipping_method_name.tr('-', ' ').upcase,
+          domestic: true,
+          international: false
+        )
+      end.freeze
+    end
+  end
+end

data/lib/friendly_shipping/services/usps.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'friendly_shipping/services/usps/client'
+require 'friendly_shipping/services/usps/shipping_methods'
+require 'friendly_shipping/services/usps/serialize_rate_request'
+require 'friendly_shipping/services/usps/parse_rate_response'
+
+module FriendlyShipping
+  module Services
+    class Usps
+      include Dry::Monads::Result::Mixin
+
+      attr_reader :test, :login, :client
+
+      CARRIER = FriendlyShipping::Carrier.new(
+        id: 'usps',
+        name: 'United States Postal Service',
+        code: 'usps',
+        shipping_methods: SHIPPING_METHODS
+      )
+
+      TEST_URL = 'https://stg-secure.shippingapis.com/ShippingAPI.dll'
+      LIVE_URL = 'https://secure.shippingapis.com/ShippingAPI.dll'
+
+      RESOURCES = {
+        rates: 'RateV4',
+      }.freeze
+
+      def initialize(login:, test: true, client: Client)
+        @login = login
+        @test = test
+        @client = client
+      end
+
+      def carriers
+        Success([CARRIER])
+      end
+
+      # Get rate estimates from USPS
+      #
+      # @param [Physical::Shipment] shipment The shipment object we're trying to get results for
+      #   USPS returns rates on a package-by-package basis, so the options for obtaining rates are
+      #   set on the [Physical::Package.container.properties] hash. The possible options are:
+      #   @property [Symbol] box_name The type of box we want to get rates for. Has to be one of the keys
+      #      of FriendlyShipping::Services::Usps::CONTAINERS.
+      #   @property [Boolean] commercial_pricing Whether we prefer commercial pricing results or retail results
+      #   @property [Boolean] hold_for_pickup Whether we want a rate with Hold For Pickup Service
+      # @param [Physical::ShippingMethod] shipping_method The shipping method ("service" in USPS parlance) we want
+      #   to get rates for.
+      #
+      # @return [Result<Array<FriendlyShipping::Rate>>] When successfully parsing, an array of rates in a Success Monad.
+      #   When the parsing is not successful or USPS can't give us rates, a Failure monad containing something that
+      #   can be serialized into an error message using `to_s`.
+      def rate_estimates(shipment, _carriers, shipping_method: nil)
+        rate_request_xml = SerializeRateRequest.call(shipment: shipment, login: login, shipping_method: shipping_method)
+        request = FriendlyShipping::Request.new(url: base_url, body: "API=#{RESOURCES[:rates]}&XML=#{CGI.escape rate_request_xml}")
+
+        client.post(request).bind do |response|
+          ParseRateResponse.call(response: response, request: request, shipment: shipment)
+        end
+      end
+
+      private
+
+      def base_url
+        test ? TEST_URL : LIVE_URL
+      end
+    end
+  end
+end

data/lib/friendly_shipping/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FriendlyShipping
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/friendly_shipping.rb

@@ -12,6 +12,7 @@ require "friendly_shipping/rate"
 
 require "friendly_shipping/services/ship_engine"
 require "friendly_shipping/services/ups"
+require "friendly_shipping/services/usps"
 
 module FriendlyShipping
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: friendly_shipping
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Martin Meyerhoff
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-07-04 00:00:00.000000000 Z
+date: 2019-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: data_uri
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -181,6 +181,15 @@ files:
 - lib/friendly_shipping/services/ups/serialize_package_node.rb
 - lib/friendly_shipping/services/ups/serialize_rating_service_selection_request.rb
 - lib/friendly_shipping/services/ups/shipping_methods.rb
+- lib/friendly_shipping/services/usps.rb
+- lib/friendly_shipping/services/usps/choose_package_rate.rb
+- lib/friendly_shipping/services/usps/client.rb
+- lib/friendly_shipping/services/usps/machinable_package.rb
+- lib/friendly_shipping/services/usps/parse_package_rate.rb
+- lib/friendly_shipping/services/usps/parse_rate_response.rb
+- lib/friendly_shipping/services/usps/parse_xml_response.rb
+- lib/friendly_shipping/services/usps/serialize_rate_request.rb
+- lib/friendly_shipping/services/usps/shipping_methods.rb
 - lib/friendly_shipping/shipping_method.rb
 - lib/friendly_shipping/version.rb
 homepage: https://github.com/friendly_cart/friendly_shipping