freight_kit 0.1.18 → 0.1.20

data/lib/freight_kit/carriers/wrds.rb

@@ -42,9 +42,9 @@ module FreightKit
       url = request_url(action)
 
       response = if @conf.dig(:api, :methods, action) == :post
-                   options[:params].blank? ? HTTParty.post(url) : HTTParty.post(url, query: options[:params])
+                   options[:params].blank? ? HTTPClient.post(url) : HTTPClient.post(url, query: options[:params])
                  else
-                   HTTParty.get(url)
+                   HTTPClient.get(url)
                  end
 
       response.parsed_response if response&.parsed_response
@@ -60,7 +60,7 @@ module FreightKit
       document_response = DocumentResponse.new(request: URI.parse(url))
 
       begin
-        response = HTTParty.get(url)
+        response = HTTPClient.get(url)
       rescue StandardError => e
         document_response.error = e
         return document_response

data/lib/freight_kit/carriers.rb

@@ -8,8 +8,7 @@ module FreightKit
 
     @registered = []
 
-    def register(class_name, autoload_require)
-      FreightKit.autoload(class_name, autoload_require)
+    def register(class_name)
       registered << class_name
     end
 
@@ -23,28 +22,28 @@ module FreightKit
   end
 end
 
-FreightKit::Carriers.register(:ABFS, 'freight_kit/carriers/abfs')
-FreightKit::Carriers.register(:BTVP, 'freight_kit/carriers/btvp')
-FreightKit::Carriers.register(:CCYQ, 'freight_kit/carriers/ccyq')
-FreightKit::Carriers.register(:CLNI, 'freight_kit/carriers/clni')
-FreightKit::Carriers.register(:CNWY, 'freight_kit/carriers/cnwy')
-FreightKit::Carriers.register(:DLDS, 'freight_kit/carriers/dlds')
-FreightKit::Carriers.register(:DPHE, 'freight_kit/carriers/dphe')
-FreightKit::Carriers.register(:DRRQ, 'freight_kit/carriers/drrq')
-FreightKit::Carriers.register(:FWDA, 'freight_kit/carriers/fwda')
-FreightKit::Carriers.register(:MTVL, 'freight_kit/carriers/mtvl')
-FreightKit::Carriers.register(:NUMK, 'freight_kit/carriers/numk')
-FreightKit::Carriers.register(:OTCL, 'freight_kit/carriers/otcl')
-FreightKit::Carriers.register(:PENS, 'freight_kit/carriers/pens')
-FreightKit::Carriers.register(:RDFS, 'freight_kit/carriers/rdfs')
-FreightKit::Carriers.register(:SAIA, 'freight_kit/carriers/saia')
-FreightKit::Carriers.register(:SEFL, 'freight_kit/carriers/sefl')
-FreightKit::Carriers.register(:TQYL, 'freight_kit/carriers/tqyl')
-FreightKit::Carriers.register(:WRDS, 'freight_kit/carriers/wrds')
+FreightKit::Carriers.register(:ABFS)
+FreightKit::Carriers.register(:BTVP)
+FreightKit::Carriers.register(:CCYQ)
+FreightKit::Carriers.register(:CLNI)
+FreightKit::Carriers.register(:CNWY)
+FreightKit::Carriers.register(:DLDS)
+FreightKit::Carriers.register(:DPHE)
+FreightKit::Carriers.register(:DRRQ)
+FreightKit::Carriers.register(:FWDA)
+FreightKit::Carriers.register(:MTVL)
+FreightKit::Carriers.register(:NUMK)
+FreightKit::Carriers.register(:OTCL)
+FreightKit::Carriers.register(:PENS)
+FreightKit::Carriers.register(:RDFS)
+FreightKit::Carriers.register(:SAIA)
+FreightKit::Carriers.register(:SEFL)
+FreightKit::Carriers.register(:TQYL)
+FreightKit::Carriers.register(:WRDS)
 
 # Based on Platform
-FreightKit::Carriers.register(:CTBV, 'freight_kit/carriers/ctbv')
-FreightKit::Carriers.register(:DCHA, 'freight_kit/carriers/dcha')
-FreightKit::Carriers.register(:JFJTransportation, 'freight_kit/carriers/jfj_transportation')
-FreightKit::Carriers.register(:FCSY, 'freight_kit/carriers/fcsy')
-FreightKit::Carriers.register(:TOTL, 'freight_kit/carriers/totl')
+FreightKit::Carriers.register(:CTBV)
+FreightKit::Carriers.register(:DCHA)
+FreightKit::Carriers.register(:JFJTransportation)
+FreightKit::Carriers.register(:FCSY)
+FreightKit::Carriers.register(:TOTL)

data/lib/freight_kit/errors/response_error.rb

@@ -9,7 +9,7 @@ module FreightKit
         super(response.message)
         @response = response
       else
-        super(response)
+        super
       end
     end
   end

data/lib/freight_kit/http_client/cache_store.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # Adapts an ActiveSupport::Cache::Store-like backend (#read, #write, #delete_matched)
+    # to the HTTPX cache store interface (#get, #set, #clear).
+    #
+    # HTTPX responses hold sockets and options, so only status, headers and body are stored.
+    class CacheStore
+      NAMESPACE = 'freight_kit/http_client'
+      VALIDATOR_HEADERS = ['if-modified-since', 'if-none-match'].freeze
+
+      def initialize(backend) = @backend = backend
+
+      # RedisCacheStore only supports glob strings, the other ActiveSupport stores only regular expressions
+      def clear
+        @backend.delete_matched(%r{\A#{Regexp.escape(NAMESPACE)}/})
+      rescue ArgumentError
+        @backend.delete_matched("#{NAMESPACE}/*")
+      end
+
+      def get(request)
+        entry = @backend.read(key(request))
+        return if entry.blank?
+
+        response = request.options.response_class.new(request, entry[:status], entry[:version], entry[:headers])
+        response.finish!
+        response.mark_as_cached!
+        response.body.write(entry[:body])
+        response.body.rewind
+        response
+      end
+
+      def set(request, response)
+        response.body.rewind
+
+        @backend.write(
+          key(request),
+          {
+            body: response.body.to_s,
+            headers: response.headers.to_h,
+            status: response.status,
+            version: response.version
+          },
+        )
+      end
+
+      private
+
+      # Unlike HTTPX's default key, every request header (e.g. Authorization, API keys) is
+      # part of the key so that responses are never shared across credentials.
+      # Query parameters given as `params:` are only part of the request path, not its URI.
+      def key(request)
+        headers = request.headers.to_a.reject { |field, _| VALIDATOR_HEADERS.include?(field) }.sort
+        digest = Digest::SHA256.hexdigest([request.verb, request.uri.merge(request.path).to_s, headers].to_json)
+
+        "#{NAMESPACE}/#{digest}"
+      end
+    end
+  end
+end

data/lib/freight_kit/http_client/log_device.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # HTTPX writes debug output to an IO-like object (#<<); this forwards it to a logger at debug level.
+    class LogDevice
+      def initialize(logger) = @logger = logger
+
+      def <<(message)
+        @logger.debug(message.chomp)
+        self
+      end
+    end
+  end
+end

data/lib/freight_kit/http_client/response.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # Like HTTParty::Response, unknown methods (e.g. #dig, #[]) are delegated to the parsed body.
+    class Response
+      JSON_CONTENT_TYPES = ['application/hal+json', 'application/json', 'application/vnd.api+json', 'text/json'].freeze
+      XML_CONTENT_TYPES = ['application/xml', 'text/xml'].freeze
+
+      attr_reader :body, :code, :content_type, :headers
+
+      # Delegation alone would make empty bodies (parsed as nil) look present
+      delegate :blank?, to: :parsed_response
+      delegate_missing_to :parsed_response
+
+      def initialize(response)
+        @body = response.body.to_s
+        @code = response.status
+        @content_type = response.content_type.mime_type
+        @headers = response.headers
+      end
+
+      def parsed_response
+        return @parsed_response if defined?(@parsed_response)
+
+        @parsed_response = if body.strip.empty? || body == 'null'
+                             nil
+                           elsif JSON_CONTENT_TYPES.include?(content_type)
+                             JSON.parse(body, allow_nan: true)
+                           elsif XML_CONTENT_TYPES.include?(content_type)
+                             MultiXML.parse(body)
+                           else
+                             body
+                           end
+      end
+
+      def to_s = body
+    end
+  end
+end

data/lib/freight_kit/http_client/revalidation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # HTTPX plugin making revalidated (304 Not Modified) responses look like the cached
+    # response they were revalidated against, so callers checking for 200 keep working.
+    #
+    # HTTPX renews freshness by mutating the cached response in memory, which serializing
+    # cache stores never see, so the refreshed response is stored again.
+    module Revalidation
+      module ResponseMethods
+        def copy_from_cached!
+          super
+          return unless (cached_response = @request.cached_response)
+
+          @status = cached_response.status
+          store = @request.options.response_cache_store
+          store.set(@request, self) if HTTPX::Plugins::ResponseCache.cacheable_response?(self)
+        end
+      end
+
+      class << self
+        def load_dependencies(klass) = klass.plugin(:response_cache)
+      end
+    end
+  end
+end

data/lib/freight_kit/http_client/safe_retries.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # HTTPX plugin keeping connections open (HTTPX's persistent plugin) without risking duplicate
+    # rates, pickups or tenders.
+    #
+    # The persistent plugin retries any request failing with a connection error, but a POST may
+    # already have been processed by then, so only idempotent requests are retried.
+    # Streams refused by an HTTP/2 GOAWAY are resent by HTTPX itself, independently of retries.
+    module SafeRetries
+      IDEMPOTENT_METHODS = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'PUT'].freeze
+
+      module InstanceMethods
+        private
+
+        def retryable_request?(request, *) = super && IDEMPOTENT_METHODS.include?(request.verb)
+      end
+
+      class << self
+        def load_dependencies(klass) = klass.plugin(:persistent)
+      end
+    end
+  end
+end

data/lib/freight_kit/http_client/zstd.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module FreightKit
+  class HTTPClient
+    # HTTPX plugin decoding Zstandard ("zstd") response bodies, modeled on HTTPX's brotli plugin.
+    module Zstd
+      class Inflater
+        def initialize = @inflater = ::Zstd::StreamingDecompress.new
+
+        def call(chunk) = @inflater.decompress(chunk)
+      end
+
+      module ResponseBodyClassMethods
+        def initialize_inflater_by_encoding(encoding, response, **) = encoding == 'zstd' ? Inflater.new : super
+      end
+
+      class << self
+        def load_dependencies(*) = require('zstd-ruby')
+
+        def extra_options(options)
+          supported_compression_formats = (['zstd'] + options.supported_compression_formats).freeze
+
+          headers = options.headers.merge('accept-encoding' => supported_compression_formats)
+
+          options.merge(headers: options.headers_class.new(headers), supported_compression_formats:)
+        end
+      end
+    end
+  end
+end

data/lib/freight_kit/http_client.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module FreightKit
+  # Thin wrapper around HTTPX that negotiates Brotli/Zstandard compression, keeps connections
+  # open between requests and revalidates cached responses with conditional requests (ETag/Last-Modified).
+  #
+  # The cache and logger are hookable; they default to the host Rails/Hanami app's logger:
+  #
+  #   FreightKit::HTTPClient.cache = Rails.cache
+  #   FreightKit::HTTPClient.logger = Rails.logger
+  class HTTPClient
+    @sessions = Concurrent::Map.new
+
+    class << self
+      def cache = @cache ||= ActiveSupport::Cache::MemoryStore.new
+
+      def cache=(store)
+        @cache = store
+        @sessions.clear
+      end
+
+      def logger = @logger || framework_logger || ::Logger.new($stdout, level: ENV.fetch('LOG_LEVEL', 'info'))
+
+      def logger=(logger)
+        @logger = logger
+        @sessions.clear
+      end
+
+      def get(url, **) = request(:get, url, **)
+
+      def post(url, **) = request(:post, url, **)
+
+      def request(verb, url, body: nil, headers: {}, proxy: nil, query: nil)
+        options = { headers: }
+        options[:params] = query if query.present?
+
+        # Like HTTParty, hashes are form-encoded regardless of the Content-Type header
+        if body.is_a?(Hash)
+          options[:form] = body if body.present?
+        elsif body.present?
+          options[:body] = body
+        end
+
+        response = session(proxy.presence).request(verb.to_s.upcase, url, **options)
+        raise response.error if response.is_a?(HTTPX::ErrorResponse)
+
+        Response.new(response)
+      end
+
+      private
+
+      def framework_logger
+        if defined?(::Rails) && ::Rails.respond_to?(:logger)
+          ::Rails.logger
+        elsif defined?(::Hanami) && ::Hanami.respond_to?(:app?) && ::Hanami.app?
+          ::Hanami.app['logger']
+        end
+      end
+
+      # Sessions own their connection pool, so they are built once (per proxy) and reused
+      def session(proxy)
+        @sessions.compute_if_absent(proxy) do
+          session = HTTPX
+                    .plugin(:brotli)
+                    .plugin(Zstd)
+                    .plugin(:follow_redirects)
+                    .plugin(:response_cache, response_cache_store: CacheStore.new(cache))
+                    .plugin(Revalidation)
+                    .plugin(SafeRetries)
+                    .with(close_on_fork: true)
+
+          logger = self.logger
+          session = session.with(debug: LogDevice.new(logger), debug_level: 2) if logger.level <= ::Logger::DEBUG
+
+          proxy ? session.plugin(:proxy).with(proxy: { uri: proxy }) : session
+        end
+      end
+    end
+  end
+end

data/lib/freight_kit/package.rb

@@ -304,7 +304,7 @@ module FreightKit # :nodoc:
         weight
       when :volumetric, :dimensional
         @volumetric_weight ||= begin
-          m = Measured::Weight.new((centimetres(:box_volume) / 6.0), :grams)
+          m = Measured::Weight.new(centimetres(:box_volume) / 6.0, :grams)
           @weight_unit_system == :imperial ? m.convert_to(:oz) : m
         end
       when :billable

data/lib/freight_kit/package_item.rb

@@ -31,7 +31,7 @@ module FreightKit # :nodoc:
         @weight
       when :volumetric, :dimensional
         @volumetric_weight ||= begin
-          m = Measured::Weight.new((centimetres(:box_volume) / 6.0), :grams)
+          m = Measured::Weight.new(centimetres(:box_volume) / 6.0, :grams)
           @unit_system == :imperial ? m.in_ounces : m
         end
       when :billable

data/lib/freight_kit/platforms/carrier_logistics.rb

@@ -58,13 +58,13 @@ module FreightKit
       url = build_url(action, query:)
       save_request(url)
 
-      HTTParty.get(url, logger: Logger.new($stdout))
+      HTTPClient.get(url)
     end
 
     def map_response_errors(response, not_found_error: DocumentNotFoundError)
       return ResponseError.new('Unknown response') if response.blank?
 
-      webspeed_error = (response.is_a?(String) || response.is_a?(HTTParty::Response)) &&
+      webspeed_error = (response.is_a?(String) || response.is_a?(HTTPClient::Response)) &&
                        response.include?('WebSpeed error')
       return ResponseError.new('Temporary error (WebSpeed error)') if webspeed_error
 
@@ -99,7 +99,7 @@ module FreightKit
       end
 
       begin
-        response = HTTParty.get(url)
+        response = HTTPClient.get(url)
       rescue StandardError => e
         document_response.error = e
         return document_response

data/lib/freight_kit/platforms/next.rb

@@ -66,9 +66,9 @@ module FreightKit
 
       response = case method
                  when :post
-                   HTTParty.post(url, headers:, body:)
+                   HTTPClient.post(url, headers:, body:)
                  else
-                   HTTParty.get(url, headers:)
+                   HTTPClient.get(url, headers:)
                  end
 
       JSON.parse(response.body) if response&.body

data/lib/freight_kit/platforms/the_great_information_factory.rb

@@ -447,7 +447,6 @@ module FreightKit
       service:,
       shipment:
     )
-
       shipper_phone = shipment.origin.contact.phone.gsub(/\s+/, '').gsub(/[()-+.]/, '')
       shipper_phone = shipper_phone[1..] if shipper_phone.length == 11
 
@@ -499,7 +498,7 @@ module FreightKit
 
       url = [base_url, query_parameter].join
 
-      response = HTTParty.get(url)
+      response = HTTPClient.get(url)
 
       image = response.deep_symbolize_keys.dig(:ImageRequest, :Image)
       image = image.last if image.is_a?(Array)

data/lib/freight_kit.rb

@@ -4,9 +4,10 @@ require 'active_model'
 require 'active_support/all'
 require 'active_utils'
 require 'business_time'
-require 'httparty'
+require 'httpx'
 require 'measured'
 require 'mimemagic'
+require 'multi_xml'
 require 'nokogiri'
 require 'open-uri'
 require 'place_kit'
@@ -20,6 +21,11 @@ module FreightKit
 
   class Inflector < Zeitwerk::Inflector
     def camelize(basename, abspath)
+      # Carriers are named after their four-letter SCAC (e.g. abfs.rb => ABFS)
+      if File.basename(File.dirname(abspath)) == 'carriers' && basename.match?(/\A[a-z]{4}\z/)
+        return basename.upcase
+      end
+
       if basename =~ /\Ahttp_(.*)/
         return "HTTP#{super(::Regexp.last_match(1), abspath)}"
       end
@@ -31,29 +37,14 @@ end
 
 loader = Zeitwerk::Loader.for_gem
 
+loader.collapse("#{__dir__}/freight_kit/api_clients")
+loader.collapse("#{__dir__}/freight_kit/carriers")
 loader.collapse("#{__dir__}/freight_kit/errors")
+loader.collapse("#{__dir__}/freight_kit/helpers")
 loader.collapse("#{__dir__}/freight_kit/models")
-
-# Carriers, platforms, helpers, and api_clients define top-level constants
-# under FreightKit:: (e.g. FreightKit::ABFS, FreightKit::Rateable) rather
-# than nested under the directory name, so they're loaded manually via the
-# explicit requires below.
-loader.ignore("#{__dir__}/freight_kit/api_clients.rb")
-loader.ignore("#{__dir__}/freight_kit/api_clients")
-loader.ignore("#{__dir__}/freight_kit/carriers.rb")
-loader.ignore("#{__dir__}/freight_kit/carriers")
-loader.ignore("#{__dir__}/freight_kit/helpers.rb")
-loader.ignore("#{__dir__}/freight_kit/helpers")
-loader.ignore("#{__dir__}/freight_kit/platforms.rb")
-loader.ignore("#{__dir__}/freight_kit/platforms")
+loader.collapse("#{__dir__}/freight_kit/platforms")
 
 loader.inflector = FreightKit::Inflector.new
+loader.inflector.inflect('jfj_transportation' => 'JFJTransportation')
 
 loader.setup
-
-require 'rmagick'
-
-require 'freight_kit/api_clients'
-require 'freight_kit/helpers'
-require 'freight_kit/platforms'
-require 'freight_kit/carriers'