savon 2.17.4 → 3.0.0.rc1

data/lib/savon/faraday_migration_hint.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require "uri"
-
-module Savon
-  # Formats the replacement Faraday setup for one HTTPI-only option.
-  class FaradayMigrationHint
-    VALUE_AWARE_OPTIONS = %i[
-      proxy
-      open_timeout
-      read_timeout
-      write_timeout
-      ssl_version
-      ssl_min_version
-      ssl_max_version
-      ssl_verify_mode
-      ssl_cert_key_file
-      ssl_cert_file
-      ssl_ca_cert_file
-      ssl_ciphers
-      ssl_ca_cert_path
-      adapter
-    ].freeze
-
-    STATIC_HINTS = {
-      ssl_cert_key: "client.faraday.ssl.client_key = key",
-      ssl_cert_key_password: [
-        "key = OpenSSL::PKey.read(File.read(key_path), password)",
-        "client.faraday.ssl.client_key = key"
-      ],
-      ssl_cert: "client.faraday.ssl.client_cert = cert",
-      ssl_ca_cert: [
-        "store = OpenSSL::X509::Store.new",
-        "store.set_default_paths",
-        "store.add_cert(cert)",
-        "client.faraday.ssl.cert_store = store"
-      ],
-      ssl_cert_store: "client.faraday.ssl.cert_store = store",
-      basic_auth: "client.faraday.request :authorization, :basic, user, pass",
-      digest_auth: [
-        "gem 'faraday-digestauth'",
-        "require 'faraday/digestauth'",
-        "client.faraday.request :digest, user, pass"
-      ],
-      ntlm: [
-        "gem 'faraday-ntlm_auth'",
-        "require 'faraday/ntlm_auth'",
-        "client.faraday.adapter :net_http_persistent",
-        "client.faraday.request :ntlm_auth, auth: [user, pass, domain]"
-      ],
-      follow_redirects: [
-        "gem 'faraday-follow_redirects'",
-        "require 'faraday/follow_redirects'",
-        "client.faraday.response :follow_redirects"
-      ]
-    }.freeze
-
-    OPTIONS = (VALUE_AWARE_OPTIONS + STATIC_HINTS.keys).freeze
-
-    def initialize(option, value)
-      @option = option
-      @value = value
-    end
-
-    def message
-      hint = hint_lines
-      return "  #{option} - Use: #{hint}" unless hint.is_a?(Array)
-
-      "  #{option} - Use:\n#{hint.map { |line| "    #{line}" }.join("\n")}"
-    end
-
-    private
-
-    attr_reader :option, :value
-
-    def hint_lines
-      case option
-      when :proxy
-        "client.faraday.proxy = #{redacted_proxy_value}"
-      when :open_timeout, :read_timeout, :write_timeout
-        "client.faraday.options.#{option} = #{value.inspect}"
-      when :ssl_version, :ssl_min_version, :ssl_max_version
-        ssl_version_hint
-      when :ssl_verify_mode
-        ssl_verify_mode_hint
-      when :ssl_cert_key_file
-        ssl_cert_key_file_hint
-      when :ssl_cert_file
-        ssl_cert_file_hint
-      when :ssl_ca_cert_file
-        "client.faraday.ssl.ca_file = #{value.inspect}"
-      when :ssl_ciphers
-        "client.faraday.ssl.ciphers = #{value.inspect}"
-      when :ssl_ca_cert_path
-        "client.faraday.ssl.ca_path = #{value.inspect}"
-      when :adapter
-        adapter_hint
-      else
-        STATIC_HINTS.fetch(option)
-      end
-    end
-
-    def redacted_proxy_value
-      uri = URI.parse(value.to_s)
-      return value.inspect unless uri.absolute? && uri.host
-
-      redacted = uri.dup
-      redacted.userinfo = "..." if redacted.userinfo
-      redacted.path = "" if redacted.respond_to?(:path=)
-      redacted.query = nil if redacted.respond_to?(:query=)
-      redacted.fragment = nil if redacted.respond_to?(:fragment=)
-      redacted.to_s.inspect
-    rescue URI::InvalidURIError
-      '"[redacted proxy URL]"'
-    end
-
-    def ssl_version_hint
-      faraday_option = {
-        ssl_version: "version",
-        ssl_min_version: "min_version",
-        ssl_max_version: "max_version"
-      }.fetch(option)
-
-      "client.faraday.ssl.#{faraday_option} = #{value.inspect}"
-    end
-
-    def ssl_cert_key_file_hint
-      [
-        "key = OpenSSL::PKey.read(File.read(#{value.inspect}))",
-        "client.faraday.ssl.client_key = key"
-      ]
-    end
-
-    def ssl_cert_file_hint
-      [
-        "cert = OpenSSL::X509::Certificate.new(File.read(#{value.inspect}))",
-        "client.faraday.ssl.client_cert = cert"
-      ]
-    end
-
-    def adapter_hint
-      case value
-      when :net_http
-        "client.faraday.adapter :net_http"
-      when :httpclient
-        [
-          "gem 'faraday-httpclient'",
-          "require 'faraday/httpclient'",
-          "client.faraday.adapter :httpclient"
-        ]
-      when :excon
-        [
-          "gem 'faraday-excon'",
-          "require 'faraday/excon'",
-          "client.faraday.adapter :excon"
-        ]
-      when :net_http_persistent
-        [
-          "gem 'faraday-net_http_persistent'",
-          "require 'faraday/net_http_persistent'",
-          "client.faraday.adapter :net_http_persistent"
-        ]
-      else
-        [
-          "choose and install a Faraday adapter matching #{value.inspect}",
-          "client.faraday.adapter :net_http"
-        ]
-      end
-    end
-
-    def ssl_verify_mode_hint
-      case value
-      when :none
-        "client.faraday.ssl.verify_mode = OpenSSL::SSL::VERIFY_NONE"
-      when :peer
-        "client.faraday.ssl.verify_mode = OpenSSL::SSL::VERIFY_PEER"
-      when :fail_if_no_peer_cert
-        "client.faraday.ssl.verify_mode = OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT"
-      when :client_once
-        "client.faraday.ssl.verify_mode = OpenSSL::SSL::VERIFY_CLIENT_ONCE"
-      else
-        "client.faraday.ssl.verify_mode = OpenSSL::SSL::VERIFY_PEER or OpenSSL::SSL::VERIFY_NONE"
-      end
-    end
-  end
-end

data/lib/savon/transport/faraday.rb

@@ -1,101 +0,0 @@
-# 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

@@ -1,138 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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