savon 2.17.3 → 3.0.0.rc1

data/lib/savon/request.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+require "faraday"
+
+module Savon
+  class HTTPRequest
+
+    def initialize(globals, connection = nil)
+      @globals = globals
+      @connection = connection || Faraday::Connection.new
+    end
+
+    private
+
+    def configure_proxy
+      connection.proxy = @globals[:proxy] if @globals.include? :proxy
+    end
+
+    def configure_timeouts
+      connection.options.open_timeout = @globals[:open_timeout] if @globals.include? :open_timeout
+      connection.options.read_timeout = @globals[:read_timeout] if @globals.include? :read_timeout
+      connection.options.write_timeout = @globals[:write_timeout] if @globals.include? :write_timeout
+    end
+
+    def configure_ssl
+      connection.ssl.verify          = @globals[:ssl_verify]        if @globals.include? :ssl_verify
+      connection.ssl.ca_file         = @globals[:ssl_ca_cert_file]  if @globals.include? :ssl_ca_cert_file
+      connection.ssl.verify_hostname = @globals[:verify_hostname]   if @globals.include? :verify_hostname
+      connection.ssl.ca_path         = @globals[:ssl_ca_cert_path]  if @globals.include? :ssl_ca_cert_path
+      connection.ssl.verify_mode     = @globals[:ssl_verify_mode]   if @globals.include? :ssl_verify_mode
+      connection.ssl.cert_store      = @globals[:ssl_cert_store]    if @globals.include? :ssl_cert_store
+      connection.ssl.client_cert     = @globals[:ssl_cert]          if @globals.include? :ssl_cert
+      connection.ssl.client_key      = @globals[:ssl_cert_key]      if @globals.include? :ssl_cert_key
+      connection.ssl.certificate     = @globals[:ssl_certificate]   if @globals.include? :ssl_certificate
+      connection.ssl.private_key     = @globals[:ssl_private_key]   if @globals.include? :ssl_private_key
+      connection.ssl.verify_depth    = @globals[:verify_depth]      if @globals.include? :verify_depth
+      connection.ssl.version         = @globals[:ssl_version]       if @globals.include? :ssl_version
+      connection.ssl.min_version     = @globals[:ssl_min_version]   if @globals.include? :ssl_min_version
+      connection.ssl.max_version     = @globals[:ssl_max_version]   if @globals.include? :ssl_max_version
+
+      # No Faraday Equivalent out of box, see: https://lostisland.github.io/faraday/#/customization/ssl-options
+      # connection.ssl.cert_file       = @globals[:ssl_cert_file]     if @globals.include? :ssl_cert_file
+      # connection.ssl.cert_key_file   = @globals[:ssl_cert_key_file] if @globals.include? :ssl_cert_key_file
+      # connection.ssl.ca_cert         = @globals[:ssl_ca_cert]       if @globals.include? :ssl_ca_cert
+      # connection.ssl.ciphers         = @globals[:ssl_ciphers]       if @globals.include? :ssl_ciphers
+      # connection.ssl.cert_key_password = @globals[:ssl_cert_key_password] if @globals.include? :ssl_cert_key_password
+
+    end
+
+    def configure_auth
+      basic_auth if @globals.include?(:basic_auth)
+      ntlm_auth if @globals.include?(:ntlm)
+    end
+
+    def basic_auth
+      connection.request(:authorization, :basic, *@globals[:basic_auth])
+    end
+
+    def ntlm_auth
+      begin
+        require 'rubyntlm'
+        require 'faraday/net_http_persistent'
+        connection.adapter :net_http_persistent, pool_size: 5
+      rescue LoadError
+        raise LoadError, 'Using NTLM Auth requires both `rubyntlm` and `faraday-net_http_persistent` to be installed.'
+      end
+    end
+
+    def configure_redirect_handling
+      if @globals[:follow_redirects]
+        require 'faraday/follow_redirects'
+        connection.response :follow_redirects
+      end
+    end
+
+    def configure_adapter
+      connection.adapter(*@globals[:adapter]) unless @globals[:adapter].nil?
+    end
+
+    def configure_logging
+      connection.response(:logger, nil, headers: @globals[:log_headers], level: @globals[:logger].level) if @globals[:log]
+    end
+
+    protected
+    attr_reader :connection
+  end
+
+  class WSDLRequest < HTTPRequest
+
+    def build
+      configure_proxy
+      configure_timeouts
+      configure_ssl
+      configure_auth
+      configure_adapter
+      configure_logging
+      configure_headers
+      connection
+    end
+
+    private
+
+    def configure_headers
+      connection.headers = @globals[:headers] if @globals.include? :headers
+    end
+  end
+
+  class SOAPRequest < HTTPRequest
+
+    CONTENT_TYPE = {
+      1 => "text/xml;charset=%s",
+      2 => "application/soap+xml;charset=%s"
+    }
+
+    def build(options = {})
+      configure_proxy
+      configure_timeouts
+      configure_ssl
+      configure_auth
+      configure_headers(options[:soap_action], options[:headers])
+      configure_cookies(options[:cookies])
+      configure_adapter
+      configure_logging
+      configure_redirect_handling
+      yield(connection) if block_given?
+      connection
+    end
+
+    private
+
+    def configure_cookies(cookies)
+      connection.headers['Cookie'] = cookies.map do |key, value|
+        if value.nil?
+          key
+        else
+          "#{key}=#{value}"
+        end
+      end.join('; ') if cookies
+    end
+
+    def configure_headers(soap_action, headers)
+      connection.headers = @globals[:headers] if @globals.include? :headers
+      connection.headers.merge!(headers) if headers
+      connection.headers["SOAPAction"]   ||= %{"#{soap_action}"} if soap_action
+      connection.headers["Content-Type"] ||= CONTENT_TYPE[@globals[:soap_version]] % @globals[:encoding]
+    end
+  end
+end

data/lib/savon/request_logger.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "savon/log_message"
+
+module Savon
+  class RequestLogger
+
+    def initialize(globals)
+      @globals = globals
+    end
+
+    def log(request, &http_request)
+      log_request(request) if log?
+      response = http_request.call
+      log_response(response) if log?
+
+      response
+    end
+
+    def logger
+      @globals[:logger]
+    end
+
+    def log?
+      @globals[:log]
+    end
+
+    def log_headers?
+      @globals[:log_headers]
+    end
+    def log_request(request)
+      return unless log?
+      logger.info  { "SOAP request: #{request.path}" }
+      logger.info  { headers_to_log(request.headers) } if log_headers?
+      logger.debug { body_to_log(request.body) }
+    end
+
+    def log_response(response)
+      return response unless log?
+      logger.info  { "SOAP response (status #{response.status})" }
+      logger.debug { headers_to_log(response.headers) } if log_headers?
+      logger.debug { body_to_log(response.body) }
+      response
+    end
+
+    private
+
+
+    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

data/lib/savon/response.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "nori"
 require "savon/soap_fault"
 require "savon/http_error"
@@ -7,37 +6,33 @@ require "savon/http_error"
 module Savon
   class Response
     CRLF = /\r\n/
-    WSP  = /[\t ]/
+    WSP  = /[#{%Q|\x9\x20|}]/
 
-    def initialize(transport_response, globals, locals)
-      @transport_response = transport_response
-      @globals            = globals
-      @locals             = locals
-      @attachments        = []
-      @xml                = ''
-      @has_parsed_body    = false
+    def initialize(http, globals, locals)
+      @http    = http
+      @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 :globals, :locals, :soap_fault, :http_error
-
-    def http
-      @transport_response
-    end
+    attr_reader :http, :globals, :locals, :soap_fault, :http_error
 
     def success?
       !soap_fault? && !http_error?
     end
-    alias successful? success?
+    alias_method :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
@@ -48,21 +43,15 @@ module Savon
       find('Body')
     end
 
-    alias to_hash body
+    alias_method :to_hash, :body
 
     def to_array(*path)
-      result = path.inject(body) { |memo, key|
+      result = path.inject body do |memo, key|
         return [] if memo[key].nil?
-
         memo[key]
-      }
-
-      result.is_a?(Array) ? result.compact : [result].compact
-    end
+      end
 
-    def hash
-      warn "Savon::Response#hash is deprecated and will be removed in version 3 - use #full_hash instead", uplevel: 1
-      full_hash
+      result.kind_of?(Array) ? result.compact : [result].compact
     end
 
     def full_hash
@@ -74,12 +63,12 @@ module Savon
         parse_body unless @has_parsed_body
         @xml
       else
-        http.body
+        @http.body
       end
     end
 
-    alias to_xml xml
-    alias to_s xml
+    alias_method :to_xml, :xml
+    alias_method :to_s,   :xml
 
     def doc
       @doc ||= Nokogiri.XML(xml)
@@ -113,20 +102,19 @@ 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..].to_a.each_with_index do |part, index|
+      parts[1..-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.zero?
+        if index == 0
           @xml = section.body.to_s
         else
           @attachments << section
@@ -136,8 +124,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!
@@ -146,7 +134,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
@@ -157,19 +145,17 @@ module Savon
       return @nori if @nori
 
       nori_options = {
-        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]
+        :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]
       }
 
       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,13 +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(%r{faultcode/?>}) && body.match(%r{faultstring/?>})
-      soap2_fault = body.include?("Code>") && body.include?("Reason>")
+      xml ||= http.body
+      fault_node  = xml.include?("Fault>")
+      soap1_fault = xml.match(/faultcode\/?>/) && xml.match(/faultstring\/?>/)
+      soap2_fault = xml.include?("Code>") && xml.include?("Reason>")
 
       fault_node && (soap1_fault || soap2_fault)
     end
@@ -45,5 +44,6 @@ 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,3 +14,4 @@ module Savon
     end
   end
 end
+

data/lib/savon/version.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module Savon
-  VERSION = '2.17.3'
+  VERSION = '3.0.0.rc1'
 end

data/lib/savon.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
-
 module Savon
+
   Error                 = Class.new(RuntimeError)
   InitializationError   = Class.new(Error)
   UnknownOptionError    = Class.new(Error)
   UnknownOperationError = Class.new(Error)
   InvalidResponseError  = Class.new(Error)
 
+  class DeprecatedOptionError < Error
+    attr_accessor :option
+    def initialize(option)
+      @option = option
+      super("#{option} is deprecated as it is not supported in Faraday. See https://github.com/savonrb/savon/blob/main/UPGRADING.md for more information.")
+    end
+  end
+
   def self.client(globals = {}, &block)
     Client.new(globals, &block)
   end
@@ -16,10 +24,11 @@ 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"