patient_http 1.3.0 → 1.5.0

data/lib/patient_http/synchronous_executor.rb

@@ -20,6 +20,7 @@ module PatientHttp
       @on_error = on_error
       @proxy_client = nil
       @request_preparer = RequestPreparer.new(config)
+      @response_reader = ResponseReader.new(nil, config: config)
     end
 
     # Execute the request synchronously.
@@ -62,11 +63,12 @@ module PatientHttp
               # flattened to a single joined string value.
               headers_hash = async_response.headers.to_h.transform_values(&:to_s)
 
-              body_content = read_response_body(async_response, headers_hash)
+              chunks = read_response_body(async_response, headers_hash)
+              body_content = @response_reader.decode_body(chunks, headers_hash)
 
               {
                 status: async_response.status,
-                headers: headers_hash,
+                headers: ResponseReader.rewrite_content_encoding(headers_hash),
                 body: body_content
               }
             end
@@ -133,19 +135,22 @@ module PatientHttp
 
     # Create HTTP client with config settings (retries, proxy, connection timeout).
     #
+    # The client is not wrapped in a Protocol::HTTP::AcceptEncoding middleware.
+    # That wrapper overwrites the request's accept-encoding header, which would
+    # ignore a caller opting out of compression, so response bodies are decoded
+    # by ResponseReader here exactly as they are on the async path.
+    #
     # @param url [String] the resolved request URL
-    # @return [Protocol::HTTP::AcceptEncoding] wrapped HTTP client
+    # @return [Async::HTTP::Client] the HTTP client
     def create_http_client(url)
       endpoint = Async::HTTP::Endpoint.parse(url)
       endpoint = configure_endpoint(endpoint) if @config.connection_timeout
 
-      client = if @config.proxy_url
+      if @config.proxy_url
         create_proxied_client(endpoint)
       else
         Async::HTTP::Client.new(endpoint, retries: @config.retries)
       end
-
-      Protocol::HTTP::AcceptEncoding.new(client)
     end
 
     # Create a proxied HTTP client.
@@ -174,11 +179,13 @@ module PatientHttp
       )
     end
 
-    # Read the response body with size validation.
+    # Read the raw response body chunks with size validation. The chunks are
+    # the wire bytes; ResponseReader#decode_body inflates and applies the
+    # charset, enforcing the same limit on the inflated bytes.
     #
     # @param async_response [Async::HTTP::Protocol::Response] the async HTTP response
     # @param headers_hash [Hash] the response headers
-    # @return [String, nil] the response body
+    # @return [Array<String>, nil] the raw body chunks or nil if no body present
     def read_response_body(async_response, headers_hash)
       return nil unless async_response.body
 
@@ -210,31 +217,7 @@ module PatientHttp
         async_response.body.close unless finished
       end
 
-      body = chunks.join.force_encoding(Encoding::ASCII_8BIT)
-
-      charset = extract_charset(headers_hash)
-      if charset
-        begin
-          encoding = Encoding.find(charset)
-          body.force_encoding(encoding)
-        rescue ArgumentError
-          # Invalid charset, keep binary
-        end
-      end
-
-      body
-    end
-
-    # Extract charset from Content-Type header.
-    def extract_charset(headers_hash)
-      content_type = headers_hash["content-type"]
-      return nil unless content_type
-
-      match = content_type.match(/;\s*charset\s*=\s*([^;\s]+)/i)
-      return nil unless match
-
-      charset = match[1].strip
-      charset.gsub(/\A["']|["']\z/, "")
+      chunks
     end
 
     # Invoke callback synchronously.

data/lib/patient_http.rb

@@ -30,6 +30,12 @@ module PatientHttp
 
   class ResponseTooLargeError < StandardError; end
 
+  # Raised when a request names a processor that is not configured. Handlers
+  # that support named processors raise this at enqueue time; the executing
+  # side raises it for a job that names an unconfigured processor so the job
+  # lands in the job system's retry mechanism instead of being dropped.
+  class UnknownProcessorError < StandardError; end
+
   # HTTP redirect status codes that should be followed
   FOLLOWABLE_REDIRECT_STATUSES = [301, 302, 303, 307, 308].freeze
 
@@ -45,6 +51,7 @@ module PatientHttp
   autoload :Client, File.join(__dir__, "patient_http/client")
   autoload :ClientError, File.join(__dir__, "patient_http/http_error")
   autoload :ClientPool, File.join(__dir__, "patient_http/client_pool")
+  autoload :CompletionExecutor, File.join(__dir__, "patient_http/completion_executor")
   autoload :Configuration, File.join(__dir__, "patient_http/configuration")
   autoload :Encryptor, File.join(__dir__, "patient_http/encryptor")
   autoload :Error, File.join(__dir__, "patient_http/error")
@@ -323,6 +330,8 @@ module PatientHttp
     # @param callback_args [Hash, nil] JSON-compatible callback arguments
     # @param preprocessors [String, Symbol, Array<String, Symbol>, nil] names of preprocessors
     #   registered on the configuration to apply to the request when it is sent
+    # @param processor [String, Symbol, nil] name of the processor that should execute
+    #   the request; handlers that support named processors route on this value
     # @return [Object] return value from the registered request handler
     def request(
       method,
@@ -335,7 +344,8 @@ module PatientHttp
       timeout: nil,
       raise_error_responses: nil,
       callback_args: nil,
-      preprocessors: nil
+      preprocessors: nil,
+      processor: nil
     )
       request = Request.new(
         method,
@@ -345,7 +355,8 @@ module PatientHttp
         headers: headers,
         params: params,
         timeout: timeout,
-        preprocessors: preprocessors
+        preprocessors: preprocessors,
+        processor: processor
       )
       execute(
         request: request,

data/patient_http.gemspec

@@ -43,6 +43,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency "async-http", "~> 0.60"
   spec.add_dependency "concurrent-ruby", "~> 1.2"
   spec.add_dependency "logger"
-
-  spec.add_development_dependency "bundler"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patient_http
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Brian Durand
@@ -65,20 +65,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: This gem provides a dedicated async HTTP processor that uses Ruby's Fiber
   scheduler for non-blocking I/O. Application threads hand off HTTP requests to the
   processor and return immediately. The processor handles hundreds of concurrent HTTP
@@ -103,6 +89,7 @@ files:
 - lib/patient_http/class_helper.rb
 - lib/patient_http/client.rb
 - lib/patient_http/client_pool.rb
+- lib/patient_http/completion_executor.rb
 - lib/patient_http/configuration.rb
 - lib/patient_http/encryptor.rb
 - lib/patient_http/error.rb
@@ -159,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Generic async HTTP connection pool for Ruby applications using Fiber-based
   concurrency