savon 2.16.0 → 2.17.0

data/lib/savon/soap_fault.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
+
 module Savon
   class SOAPFault < Error
-
     def self.present?(http, xml = nil)
       body = xml || http.body
       body = body.scrub('') unless body.valid_encoding?
       fault_node  = body.include?("Fault>")
-      soap1_fault = body.match(/faultcode\/?\>/) && body.match(/faultstring\/?\>/)
+      soap1_fault = body.match(%r{faultcode/?>}) && body.match(%r{faultstring/?>})
       soap2_fault = body.include?("Code>") && body.include?("Reason>")
 
       fault_node && (soap1_fault || soap2_fault)
@@ -45,6 +45,5 @@ module Savon
         "(#{code}) #{text}"
       end
     end
-
   end
 end

data/lib/savon/string_utils.rb

@@ -4,9 +4,9 @@ module Savon
   module StringUtils
     def self.snakecase(inputstring)
       str = inputstring.dup
-      str.gsub! /::/, '/'
-      str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
-      str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+      str.gsub!(/::/, '/')
+      str.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
       str.tr! ".", "_"
       str.tr! "-", "_"
       str.downcase!
@@ -14,4 +14,3 @@ module Savon
     end
   end
 end
-

data/lib/savon/transport/faraday.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "savon/transport/logging"
+require "savon/transport/response"
+
+module Savon
+  module Transport
+    # Faraday-backed HTTP transport for the opt-in Faraday path.
+    #
+    # Encapsulates everything Faraday-specific:
+    #   * header assembly (SOAP + global + local + cookies + Content-Length)
+    #   * request execution via the caller-configured Faraday::Connection
+    #
+    # Transport-level concerns (SSL, auth, proxy, timeouts, middleware) are
+    # the caller's responsibility via client.faraday before any call is made.
+    class Faraday
+      include Logging
+
+      # @param connection [Faraday::Connection] the memoized connection from client.faraday
+      # @param globals    [Savon::GlobalOptions] the client-level options
+      def initialize(connection, globals)
+        @connection = connection
+        @globals    = globals
+      end
+
+      # Assembles headers, executes the POST via the Faraday connection, and
+      # returns a Transport::Response. Logs the outbound request and inbound
+      # response when logging is enabled.
+      #
+      # @param url          [String]              the SOAP endpoint URL
+      # @param soap_headers [Hash]                SOAP-level headers (Content-Type, SOAPAction, etc.)
+      # @param body         [String]              the serialized SOAP envelope
+      # @param locals       [Savon::LocalOptions] per-request options
+      # @return             [Transport::Response]
+      def post(url, soap_headers, body, locals)
+        headers = build_headers(soap_headers, body, locals)
+
+        log_request(url, headers, body) if log?
+
+        faraday_response = @connection.post(url, body, headers)
+        response = Response.from_faraday(faraday_response)
+
+        log_response(response) if log?
+
+        response
+      end
+
+      private
+
+      # Merges all header sources in precedence order:
+      # locals[:headers] > globals[:headers] > soap_headers
+      # Appends Cookie from locals[:cookies] and Content-Length from body.
+      def build_headers(soap_headers, body, locals)
+        headers = {}
+        headers.merge!(@globals[:headers]) if @globals.include?(:headers)
+        headers.merge!(locals[:headers])   if locals.include?(:headers)
+
+        # soap_headers are lowest priority
+        soap_headers.each do |k, v| headers[k] ||= v end
+
+        if locals[:cookies]&.any?
+          headers["Cookie"] = locals[:cookies].map(&:name_and_value).join(";")
+        end
+
+        headers["Content-Length"] = body.bytesize.to_s
+        headers
+      end
+    end
+  end
+end

data/lib/savon/transport/httpi.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "httpi"
+require "savon/transport/logging"
+require "savon/transport/response"
+
+module Savon
+  module Transport
+    # HTTPI-backed HTTP transport for the default HTTP path.
+    #
+    # Encapsulates everything HTTPI-specific:
+    #   * header assembly
+    #   * proxy/SSL/auth/timeout configuration
+    #   * request execution
+    class HTTPI
+      include Logging
+
+      # @param globals [Savon::GlobalOptions] the client-level options
+      def initialize(globals)
+        @globals = globals
+      end
+
+      # Assembles and executes a SOAP request, returning a Transport::Response.
+      # Logs the outbound request and inbound response when logging is enabled.
+      #
+      # @param url          [String]              the SOAP endpoint URL
+      # @param soap_headers [Hash]                SOAP-level headers
+      # @param body         [String]              the serialized SOAP envelope
+      # @param locals       [Savon::LocalOptions] per-request options
+      # @return             [Transport::Response]
+      def post(url, soap_headers, body, locals)
+        http_request = to_httpi_request(url, soap_headers, body, locals)
+
+        log_request(http_request.url, http_request.headers, http_request.body) if log?
+
+        http_response = ::HTTPI.post(http_request, @globals[:adapter])
+        response = Response.from_httpi(http_response)
+
+        log_response(response) if log?
+
+        response
+      end
+
+      # Builds a fully-configured HTTPI::Request.
+      #
+      # @param url          [String]              the SOAP endpoint URL
+      # @param soap_headers [Hash]                SOAP-level headers
+      # @param body         [String]              the serialized SOAP envelope
+      # @param locals       [Savon::LocalOptions] per-request options
+      # @return             [HTTPI::Request]
+      def to_httpi_request(url, soap_headers, body, locals)
+        headers = {}
+        headers.merge!(@globals[:headers]) if @globals.include?(:headers)
+        headers.merge!(locals[:headers])   if locals.include?(:headers)
+
+        # soap_headers are lowest priority
+        soap_headers.each do |k, v| headers[k] ||= v end
+
+        if locals[:cookies]&.any?
+          headers["Cookie"] = locals[:cookies].map(&:name_and_value).join(";")
+        end
+
+        headers["Content-Length"] = body.bytesize.to_s
+
+        http_request = ::HTTPI::Request.new
+        http_request.url = url
+        http_request.body = body
+        http_request.headers = headers
+        configure_http_request(http_request)
+        http_request
+      end
+
+      # Returns a configured HTTPI::Request for Wasabi's WSDL resolver.
+      # Applies global headers and all transport-level options and
+      # leaves the rest to Wasabi.
+      #
+      # @return [HTTPI::Request]
+      def wsdl_request
+        http_request = ::HTTPI::Request.new
+        http_request.headers = @globals[:headers].dup if @globals.include?(:headers)
+        configure_http_request(http_request)
+        http_request
+      end
+
+      private
+
+      def configure_http_request(http_request)
+        configure_proxy(http_request)
+        configure_timeouts(http_request)
+        configure_ssl(http_request)
+        configure_auth(http_request)
+        configure_redirect_handling(http_request)
+      end
+
+      def configure_proxy(http_request)
+        http_request.proxy = @globals[:proxy] if @globals.include?(:proxy)
+      end
+
+      def configure_timeouts(http_request)
+        http_request.open_timeout  = @globals[:open_timeout]  if @globals.include?(:open_timeout)
+        http_request.read_timeout  = @globals[:read_timeout]  if @globals.include?(:read_timeout)
+        http_request.write_timeout = @globals[:write_timeout] if @globals.include?(:write_timeout)
+      end
+
+      # Configures SSL on the HTTPI::Request from all ssl globals.
+      # SSL option reference: https://github.com/savonrb/httpi/blob/main/lib/httpi/auth/ssl.rb
+      def configure_ssl(http_request)
+        ssl = http_request.auth.ssl
+        ssl.ssl_version       = @globals[:ssl_version]           if @globals.include?(:ssl_version)
+        ssl.min_version       = @globals[:ssl_min_version]       if @globals.include?(:ssl_min_version)
+        ssl.max_version       = @globals[:ssl_max_version]       if @globals.include?(:ssl_max_version)
+        ssl.verify_mode       = @globals[:ssl_verify_mode]       if @globals.include?(:ssl_verify_mode)
+        ssl.ciphers           = @globals[:ssl_ciphers]           if @globals.include?(:ssl_ciphers)
+        ssl.cert_key_file     = @globals[:ssl_cert_key_file]     if @globals.include?(:ssl_cert_key_file)
+        ssl.cert_key          = @globals[:ssl_cert_key]          if @globals.include?(:ssl_cert_key)
+        ssl.cert_file         = @globals[:ssl_cert_file]         if @globals.include?(:ssl_cert_file)
+        ssl.cert              = @globals[:ssl_cert]              if @globals.include?(:ssl_cert)
+        ssl.ca_cert_file      = @globals[:ssl_ca_cert_file]      if @globals.include?(:ssl_ca_cert_file)
+        ssl.ca_cert_path      = @globals[:ssl_ca_cert_path]      if @globals.include?(:ssl_ca_cert_path)
+        ssl.ca_cert           = @globals[:ssl_ca_cert]           if @globals.include?(:ssl_ca_cert)
+        ssl.cert_store        = @globals[:ssl_cert_store]        if @globals.include?(:ssl_cert_store)
+        ssl.cert_key_password = @globals[:ssl_cert_key_password] if @globals.include?(:ssl_cert_key_password)
+      end
+
+      def configure_auth(http_request)
+        http_request.auth.basic(*@globals[:basic_auth])   if @globals.include?(:basic_auth)
+        http_request.auth.digest(*@globals[:digest_auth]) if @globals.include?(:digest_auth)
+        http_request.auth.ntlm(*@globals[:ntlm])          if @globals.include?(:ntlm)
+      end
+
+      def configure_redirect_handling(http_request)
+        http_request.follow_redirect = @globals[:follow_redirects] if @globals.include?(:follow_redirects)
+      end
+    end
+  end
+end

data/lib/savon/transport/logging.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "savon/log_message"
+
+module Savon
+  module Transport
+    # Shared logging behaviour for HTTP transports.
+    #
+    # Expects the including class to expose @globals (Savon::GlobalOptions)
+    # so that log level, filters, and pretty-print settings can be accessed.
+    #
+    # log_request and log_response are intentionally private so that each
+    # transport drives them from its own post method.
+    module Logging
+      private
+
+      def log?
+        @globals[:log]
+      end
+
+      def log_headers?
+        @globals[:log_headers]
+      end
+
+      def logger
+        @globals[:logger]
+      end
+
+      # Logs the outbound request at INFO (URL and optional headers)
+      # and DEBUG (filtered/pretty-printed body).
+      #
+      # @param url     [String] the SOAP endpoint URL
+      # @param headers [Hash]   request headers
+      # @param body    [String] the serialized SOAP envelope
+      def log_request(url, headers, body)
+        logger.info  do "SOAP request: #{url}" end
+        logger.info  { headers_to_log(headers) } if log_headers?
+        logger.debug { body_to_log(body) }
+      end
+
+      # Logs the inbound response at INFO (status line)
+      # and DEBUG (headers and filtered/pretty-printed body).
+      #
+      # @param response [Transport::Response]
+      def log_response(response)
+        logger.info  do "SOAP response (status #{response.code})" end
+        logger.debug { headers_to_log(response.headers) } if log_headers?
+        logger.debug { body_to_log(response.body) }
+      end
+
+      def headers_to_log(headers)
+        headers.map { |key, value| "#{key}: #{value}" }.join("\n")
+      end
+
+      def body_to_log(body)
+        LogMessage.new(body, @globals[:filters], @globals[:pretty_print_xml]).to_s
+      end
+    end
+  end
+end

data/lib/savon/transport/response.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Savon
+  module Transport
+    # Transport-agnostic HTTP response value object.
+    #
+    # Every transport produces a Transport::Response so that higher-level code
+    # never depends on transport-specific code. Immutable once constructed.
+    class Response
+      # Creates a Transport::Response from an HTTPI::Response.
+      def self.from_httpi(httpi_response)
+        new(httpi_response.code, httpi_response.headers, httpi_response.body)
+      end
+
+      # Creates a Transport::Response from a Faraday::Response.
+      def self.from_faraday(faraday_response)
+        new(faraday_response.status, faraday_response.headers.to_h, faraday_response.body)
+      end
+
+      # @param code    [Integer] HTTP status code
+      # @param headers [Hash]    response headers
+      # @param body    [String]  response body
+      def initialize(code, headers, body)
+        @code    = code
+        @headers = headers
+        @body    = body
+      end
+
+      # Returns the HTTP status code.
+      attr_reader :code
+
+      # Returns the response headers hash.
+      attr_reader :headers
+
+      # Returns the response body string.
+      attr_reader :body
+
+      # Returns true when the HTTP status code indicates an error (>= 300).
+      def error?
+        @code >= 300
+      end
+    end
+  end
+end

data/lib/savon/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Savon
-  VERSION = '2.16.0'
+  VERSION = '2.17.0'
 end

data/lib/savon.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Savon
 
+module Savon
   Error                 = Class.new(RuntimeError)
   InitializationError   = Class.new(Error)
   UnknownOptionError    = Class.new(Error)
@@ -16,11 +16,10 @@ module Savon
   end
 
   def self.notify_observers(operation_name, builder, globals, locals)
-    observers.inject(nil) do |response, observer|
+    observers.inject(nil) do |_response, observer|
       observer.notify(operation_name, builder, globals, locals)
     end
   end
-
 end
 
 require "savon/version"