savon 2.15.1 → 2.17.4

data/lib/savon/response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "nori"
 require "savon/soap_fault"
 require "savon/http_error"
@@ -6,33 +7,37 @@ require "savon/http_error"
 module Savon
   class Response
     CRLF = /\r\n/
-    WSP  = /[#{%Q|\x9\x20|}]/
+    WSP  = /[\t ]/
 
-    def initialize(http, globals, locals)
-      @http    = http
-      @globals = globals
-      @locals  = locals
-      @attachments = []
-      @xml     = ''
-      @has_parsed_body = false
+    def initialize(transport_response, globals, locals)
+      @transport_response = transport_response
+      @globals            = globals
+      @locals             = locals
+      @attachments        = []
+      @xml                = ''
+      @has_parsed_body    = false
 
       build_soap_and_http_errors!
       raise_soap_and_http_errors! if @globals[:raise_errors]
     end
 
-    attr_reader :http, :globals, :locals, :soap_fault, :http_error
+    attr_reader :globals, :locals, :soap_fault, :http_error
+
+    def http
+      @transport_response
+    end
 
     def success?
       !soap_fault? && !http_error?
     end
-    alias_method :successful?, :success?
+    alias successful? success?
 
     def soap_fault?
-      SOAPFault.present?(@http, xml)
+      SOAPFault.present?(http, xml)
     end
 
     def http_error?
-      HTTPError.present? @http
+      HTTPError.present? http
     end
 
     def header
@@ -43,15 +48,21 @@ module Savon
       find('Body')
     end
 
-    alias_method :to_hash, :body
+    alias to_hash body
 
     def to_array(*path)
-      result = path.inject body do |memo, key|
+      result = path.inject(body) { |memo, key|
         return [] if memo[key].nil?
+
         memo[key]
-      end
+      }
+
+      result.is_a?(Array) ? result.compact : [result].compact
+    end
 
-      result.kind_of?(Array) ? result.compact : [result].compact
+    def hash
+      warn "Savon::Response#hash is deprecated and will be removed in version 3 - use #full_hash instead", uplevel: 1
+      full_hash
     end
 
     def full_hash
@@ -63,12 +74,12 @@ module Savon
         parse_body unless @has_parsed_body
         @xml
       else
-        @http.body
+        http.body
       end
     end
 
-    alias_method :to_xml, :xml
-    alias_method :to_s,   :xml
+    alias to_xml xml
+    alias to_s xml
 
     def doc
       @doc ||= Nokogiri.XML(xml)
@@ -102,19 +113,20 @@ module Savon
 
     def boundary
       return unless multipart?
+
       Mail::Field.new('content-type', http.headers['content-type']).parameters['boundary']
     end
 
     def parse_body
       http.body.force_encoding Encoding::ASCII_8BIT
       parts = http.body.split(/(?:\A|\r\n)--#{Regexp.escape(boundary)}(?=(?:--)?\s*$)/)
-      parts[1..-1].to_a.each_with_index do |part, index|
+      parts[1..].to_a.each_with_index do |part, index|
         header_part, body_part = part.lstrip.split(/#{CRLF}#{CRLF}|#{CRLF}#{WSP}*#{CRLF}(?!#{WSP})/m, 2)
         section = Mail::Part.new(
           body: body_part
         )
         section.header = header_part
-        if index == 0
+        if index.zero?
           @xml = section.body.to_s
         else
           @attachments << section
@@ -124,8 +136,8 @@ module Savon
     end
 
     def build_soap_and_http_errors!
-      @soap_fault = SOAPFault.new(@http, nori, xml) if soap_fault?
-      @http_error = HTTPError.new(@http) if http_error?
+      @soap_fault = SOAPFault.new(http, nori, xml) if soap_fault?
+      @http_error = HTTPError.new(http) if http_error?
     end
 
     def raise_soap_and_http_errors!
@@ -134,7 +146,7 @@ module Savon
     end
 
     def raise_invalid_response_error!
-      raise InvalidResponseError, "Unable to parse response body:\n" + xml.inspect
+      raise InvalidResponseError, "Unable to parse response body:\n#{xml.inspect}"
     end
 
     def xml_namespaces
@@ -145,17 +157,19 @@ module Savon
       return @nori if @nori
 
       nori_options = {
-        :delete_namespace_attributes => @globals[:delete_namespace_attributes],
-        :strip_namespaces            => @globals[:strip_namespaces],
-        :convert_tags_to             => @globals[:convert_response_tags_to],
-        :convert_attributes_to       => @globals[:convert_attributes_to],
-        :advanced_typecasting        => @locals[:advanced_typecasting],
-        :parser                      => @locals[:response_parser]
+        delete_namespace_attributes: @globals[:delete_namespace_attributes],
+        strip_namespaces: @globals[:strip_namespaces],
+        empty_tag_value: @globals[:empty_tag_value],
+        convert_dashes_to_underscores: @globals[:convert_dashes_to_underscores],
+        scrub_xml: @globals[:scrub_xml],
+        convert_tags_to: @globals[:convert_response_tags_to],
+        convert_attributes_to: @globals[:convert_attributes_to],
+        advanced_typecasting: @locals[:advanced_typecasting],
+        parser: @locals[:response_parser]
       }
 
       non_nil_nori_options = nori_options.reject { |_, value| value.nil? }
       @nori = Nori.new(non_nil_nori_options)
     end
-
   end
 end

data/lib/savon/soap_fault.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 module Savon
   class SOAPFault < Error
-
     def self.present?(http, xml = nil)
-      xml ||= http.body
-      fault_node  = xml.include?("Fault>")
-      soap1_fault = xml.match(/faultcode\/?\>/) && xml.match(/faultstring\/?\>/)
-      soap2_fault = xml.include?("Code>") && xml.include?("Reason>")
+      body = xml || http.body
+      body = body.scrub('') unless body.valid_encoding?
+      fault_node  = body.include?("Fault>")
+      soap1_fault = body.match(%r{faultcode/?>}) && body.match(%r{faultstring/?>})
+      soap2_fault = body.include?("Code>") && body.include?("Reason>")
 
       fault_node && (soap1_fault || soap2_fault)
     end
@@ -44,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,101 @@
+# 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)
+    #   * 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, locals)
+
+        log_request(url, headers, body) if log?
+
+        faraday_response = @connection.post(url, body, headers)
+        response = normalize_response(faraday_response)
+
+        log_response(response) if log?
+        response
+      end
+
+      # Normalizes a native Faraday::Response into a Transport::Response.
+      #
+      # @param faraday_response [Faraday::Response]
+      # @return                 [Transport::Response]
+      def normalize_response(faraday_response)
+        Response.from_faraday(faraday_response)
+      end
+
+      # Parses Set-Cookie headers into a Hash of name => value. Accepts both
+      # the Array and String form. Attributes after the first ';' are discarded.
+      def self.parse_cookies(headers)
+        raw = headers["set-cookie"] || headers["Set-Cookie"]
+        return {} unless raw
+
+        raw_array = raw.is_a?(Array) ? raw : raw.split(/,\s*/)
+        raw_array.each_with_object({}) do |cookie_str, hash|
+          name_value = cookie_str.split(";", 2).first.to_s.strip
+          name, value = name_value.split("=", 2)
+          hash[name] = value if name && !name.empty?
+        end
+      end
+
+      private
+
+      # Merges all header sources in precedence order:
+      # locals[:headers] > globals[:headers] > soap_headers
+      # Appends Cookie from locals[:cookies].
+      def build_headers(soap_headers, 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
+
+        cookie_header = format_cookies(locals[:cookies])
+        headers["Cookie"] = cookie_header if cookie_header
+
+        headers
+      end
+
+      # Builds the Cookie header from a given value.
+      # Accepts:
+      #   * String - passed through verbatim
+      #   * Hash   - formatted as "name=value; name=value" (browser style)
+      # Returns nil when no cookies were supplied.
+      def format_cookies(cookies)
+        return nil if cookies.nil?
+        return cookies if cookies.is_a?(String)
+
+        cookies.map { |name, value| "#{name}=#{value}" }.join("; ")
+      end
+    end
+  end
+end

data/lib/savon/transport/httpi.rb

@@ -0,0 +1,138 @@
+# 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?
+
+        httpi_response = ::HTTPI.post(http_request, @globals[:adapter])
+        response = normalize_response(httpi_response)
+
+        log_response(response) if log?
+        response
+      end
+
+      # Normalizes a native HTTPI::Response into a Transport::Response.
+      #
+      # @param httpi_response [HTTPI::Response]
+      # @return               [Transport::Response]
+      def normalize_response(httpi_response)
+        Response.from_httpi(httpi_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
+
+        http_request = ::HTTPI::Request.new
+        http_request.url = url
+        http_request.body = body
+        http_request.headers = headers
+        http_request.set_cookies(locals[:cookies]) if locals[:cookies]
+        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,73 @@
+# frozen_string_literal: true
+
+require "httpi"
+require "savon/transport/faraday"
+
+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.
+    #
+    # The shape of #cookies is transport-specific: HTTPI responses expose an
+    # Array of HTTPI::Cookie, while Faraday responses expose a plain Hash so
+    # Faraday users do not depend on HTTPI types.
+    class Response
+      # Builds a Response from an HTTPI::Response.
+      #
+      # @param httpi_response [HTTPI::Response]
+      # @return               [Transport::Response]
+      def self.from_httpi(httpi_response)
+        new(
+          httpi_response.code,
+          httpi_response.headers,
+          httpi_response.body,
+          cookies: ::HTTPI::Cookie.list_from_headers(httpi_response.headers)
+        )
+      end
+
+      # Builds a Response from a Faraday::Response.
+      #
+      # @param faraday_response [Faraday::Response]
+      # @return                 [Transport::Response]
+      def self.from_faraday(faraday_response)
+        new(
+          faraday_response.status,
+          faraday_response.headers.to_h,
+          faraday_response.body,
+          cookies: Savon::Transport::Faraday.parse_cookies(faraday_response.headers)
+        )
+      end
+
+      # @param code    [Integer] HTTP status code
+      # @param headers [Hash]    response headers
+      # @param body    [String]  response body
+      # @param cookies [Object]  parsed cookies in a transport-specific shape
+      def initialize(code, headers, body, cookies: nil)
+        @code    = code
+        @headers = headers
+        @body    = body
+        @cookies = cookies
+      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 the parsed cookies in a transport-specific shape.
+      # See class-level docs.
+      attr_reader :cookies
+
+      # 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.15.1'
+  VERSION = '2.17.4'
 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"