savon 1.2.0 → 2.0.0

data/lib/savon/operation.rb

@@ -0,0 +1,62 @@
+require "savon/options"
+require "savon/block_interface"
+require "savon/request"
+require "savon/builder"
+
+module Savon
+  class Operation
+
+    def self.create(operation_name, wsdl, globals)
+      if wsdl.document?
+        ensure_name_is_symbol! operation_name
+        ensure_exists! operation_name, wsdl
+      end
+
+      new(operation_name, wsdl, globals)
+    end
+
+    def self.ensure_exists!(operation_name, wsdl)
+      unless wsdl.soap_actions.include? operation_name
+        raise ArgumentError, "Unable to find SOAP operation: #{operation_name.inspect}\n" \
+                             "Operations provided by your service: #{wsdl.soap_actions.inspect}"
+      end
+    end
+
+    def self.ensure_name_is_symbol!(operation_name)
+      unless operation_name.kind_of? Symbol
+        raise ArgumentError, "Expected the first parameter (the name of the operation to call) to be a symbol\n" \
+                             "Actual: #{operation_name.inspect} (#{operation_name.class})"
+      end
+    end
+
+    def initialize(name, wsdl, globals)
+      @name = name
+      @wsdl = wsdl
+      @globals = globals
+    end
+
+    def call(locals = {}, &block)
+      @locals = LocalOptions.new(locals)
+
+      BlockInterface.new(@locals).evaluate(block) if block
+
+      builder = Builder.new(@name, @wsdl, @globals, @locals)
+      request = Request.new(@name, @wsdl, @globals, @locals)
+
+      response = Savon.notify_observers(@name, builder, @globals, @locals)
+      response ||= request.call(builder.to_s)
+
+      raise_expected_httpi_response! unless response.kind_of?(HTTPI::Response)
+
+      Response.new(response, @globals, @locals)
+    end
+
+    private
+
+    def raise_expected_httpi_response!
+      raise Error, "Observers need to return an HTTPI::Response to mock " \
+                   "the request or nil to execute the request."
+    end
+
+  end
+end

data/lib/savon/options.rb

@@ -0,0 +1,265 @@
+require "logger"
+require "httpi"
+
+module Savon
+  class Options
+
+    def initialize(options = {})
+      @options = {}
+      assign options
+    end
+
+    def [](option)
+      @options[option]
+    end
+
+    def []=(option, value)
+      value = [value].flatten
+      self.send(option, *value)
+    end
+
+    def include?(option)
+      @options.key? option
+    end
+
+    private
+
+    def assign(options)
+      options.each do |option, value|
+        self.send(option, value)
+      end
+    end
+
+  end
+
+  class GlobalOptions < Options
+
+    def initialize(options = {})
+      defaults = {
+        :encoding                  => "UTF-8",
+        :soap_version              => 1,
+        :logger                    => Logger.new($stdout),
+        :filters                   => [],
+        :pretty_print_xml          => false,
+        :raise_errors              => true,
+        :strip_namespaces          => true,
+        :convert_response_tags_to  => lambda { |tag| tag.snakecase.to_sym }
+      }
+
+      options = defaults.merge(options)
+
+      # these options are shortcuts on the logger which needs to be set
+      # before it can be modified to set these options.
+      delayed_log = options.delete(:log)
+      delayed_level = options.delete(:log_level)
+
+      super(options)
+
+      log(delayed_log) unless delayed_log.nil?
+      log_level(delayed_level) unless delayed_level.nil?
+    end
+
+    # Location of the local or remote WSDL document.
+    def wsdl(wsdl_address)
+      @options[:wsdl] = wsdl_address
+    end
+
+    # SOAP endpoint.
+    def endpoint(endpoint)
+      @options[:endpoint] = endpoint
+    end
+
+    # Target namespace.
+    def namespace(namespace)
+      @options[:namespace] = namespace
+    end
+
+    # The namespace identifer.
+    def namespace_identifier(identifier)
+      @options[:namespace_identifier] = identifier
+    end
+
+    # Proxy server to use for all requests.
+    def proxy(proxy)
+      @options[:proxy] = proxy
+    end
+
+    # A Hash of HTTP headers.
+    def headers(headers)
+      @options[:headers] = headers
+    end
+
+    # Open timeout in seconds.
+    def open_timeout(open_timeout)
+      @options[:open_timeout] = open_timeout
+    end
+
+    # Read timeout in seconds.
+    def read_timeout(read_timeout)
+      @options[:read_timeout] = read_timeout
+    end
+
+    # The encoding to use. Defaults to "UTF-8".
+    def encoding(encoding)
+      @options[:encoding] = encoding
+    end
+
+    # The global SOAP header. Expected to be a Hash.
+    def soap_header(header)
+      @options[:soap_header] = header
+    end
+
+    # Sets whether elements should be :qualified or unqualified.
+    # If you need to use this option, please open an issue and make
+    # sure to add your WSDL document for debugging.
+    def element_form_default(element_form_default)
+      @options[:element_form_default] = element_form_default
+    end
+
+    # Can be used to change the SOAP envelope namespace identifier.
+    # If you need to use this option, please open an issue and make
+    # sure to add your WSDL document for debugging.
+    def env_namespace(env_namespace)
+      @options[:env_namespace] = env_namespace
+    end
+
+    # Changes the SOAP version to 1 or 2.
+    def soap_version(soap_version)
+      @options[:soap_version] = soap_version
+    end
+
+    # Whether or not to raise SOAP fault and HTTP errors.
+    def raise_errors(raise_errors)
+      @options[:raise_errors] = raise_errors
+    end
+
+    # Whether or not to log.
+    def log(log)
+      if log
+        HTTPI.log = true
+        target = $stdout
+      else
+        HTTPI.log = false
+        windows = RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i
+        target = windows ? "NUL:" : "/dev/null"
+      end
+
+      @options[:logger] = Logger.new(target)
+    end
+
+    # The logger to use. Defaults to a Savon::Logger instance.
+    def logger(logger)
+      @options[:logger] = logger
+    end
+
+    # Changes the Logger's log level.
+    def log_level(level)
+      levels = { :debug => 0, :info => 1, :warn => 2, :error => 3, :fatal => 4 }
+
+      unless levels.include? level
+        raise ArgumentError, "Invalid log level: #{level.inspect}\n" \
+                             "Expected one of: #{levels.keys.inspect}"
+      end
+
+      @options[:logger].level = levels[level]
+    end
+
+    # A list of XML tags to filter from logged SOAP messages.
+    def filters(*filters)
+      @options[:filters] = filters.flatten
+    end
+
+    # Whether to pretty print request and response XML log messages.
+    def pretty_print_xml(pretty_print_xml)
+      @options[:pretty_print_xml] = pretty_print_xml
+    end
+
+    # Used by Savon to store the last response to pass
+    # its cookies to the next request.
+    def last_response(last_response)
+      @options[:last_response] = last_response
+    end
+
+    # HTTP basic auth credentials.
+    def basic_auth(*credentials)
+      @options[:basic_auth] = credentials.flatten
+    end
+
+    # HTTP digest auth credentials.
+    def digest_auth(*credentials)
+      @options[:digest_auth] = credentials.flatten
+    end
+
+    # WSSE auth credentials for Akami.
+    def wsse_auth(*credentials)
+      @options[:wsse_auth] = credentials.flatten
+    end
+
+    # Instruct Akami to enable wsu:Timestamp headers.
+    def wsse_timestamp(*timestamp)
+      @options[:wsse_timestamp] = timestamp.flatten
+    end
+
+    # Instruct Nori whether to strip namespaces from XML nodes.
+    def strip_namespaces(strip_namespaces)
+      @options[:strip_namespaces] = strip_namespaces
+    end
+
+    # Tell Gyoku how to convert Hash key Symbols to XML tags.
+    # Accepts one of :lower_camelcase, :camelcase, :upcase, or :none.
+    def convert_request_keys_to(converter)
+      @options[:convert_request_keys_to] = converter
+    end
+
+    # Tell Nori how to convert XML tags from the SOAP response into Hash keys.
+    # Accepts a lambda or a block which receives an XML tag and returns a Hash key.
+    # Defaults to convert tags to snakecase Symbols.
+    def convert_response_tags_to(converter = nil, &block)
+      @options[:convert_response_tags_to] = block || converter
+    end
+  end
+
+  class LocalOptions < Options
+
+    def initialize(options = {})
+      defaults = {
+        :advanced_typecasting => true,
+        :response_parser      => :nokogiri
+      }
+
+      super defaults.merge(options)
+    end
+
+    # The SOAP message to send. Expected to be a Hash or a String.
+    def message(message)
+      @options[:message] = message
+    end
+
+    # SOAP message tag (formerly known as SOAP input tag). If it's not set, Savon retrieves the name from
+    # the WSDL document (if available). Otherwise, Gyoku converts the operation name into an XML element.
+    def message_tag(message_tag)
+      @options[:message_tag] = message_tag
+    end
+
+    # Value of the SOAPAction HTTP header.
+    def soap_action(soap_action)
+      @options[:soap_action] = soap_action
+    end
+
+    # The SOAP request XML to send. Expected to be a String.
+    def xml(xml)
+      @options[:xml] = xml
+    end
+
+    # Instruct Nori to use advanced typecasting.
+    def advanced_typecasting(advanced)
+      @options[:advanced_typecasting] = advanced
+    end
+
+    # Instruct Nori to use :rexml or :nokogiri to parse the response.
+    def response_parser(parser)
+      @options[:response_parser] = parser
+    end
+
+  end
+end

data/lib/savon/qualified_message.rb

@@ -0,0 +1,49 @@
+require "gyoku"
+
+module Savon
+  class QualifiedMessage
+
+    def initialize(types, used_namespaces, key_converter)
+      @types = types
+      @used_namespaces = used_namespaces
+      @key_converter = key_converter
+    end
+
+    def to_hash(hash, path)
+      return unless hash
+      return hash.map { |value| add_namespaces_to_body(value, path) } if hash.kind_of?(Array)
+      return hash.to_s unless hash.kind_of? Hash
+
+      hash.inject({}) do |newhash, (key, value)|
+        camelcased_key = Gyoku.xml_tag(key, :key_converter => @key_converter).to_s
+        newpath = path + [camelcased_key]
+
+        if @used_namespaces[newpath]
+          newhash.merge(
+            "#{@used_namespaces[newpath]}:#{camelcased_key}" =>
+              add_namespaces_to_body(value, @types[newpath] ? [@types[newpath]] : newpath)
+          )
+        else
+          add_namespaces_to_values(value, path) if key == :order!
+          newhash.merge(key => value)
+        end
+      end
+    end
+
+    private
+
+    def add_namespaces_to_body(value, path)
+      QualifiedMessage.new(@types, @used_namespaces, @key_converter).to_hash(value, path)
+    end
+
+    def add_namespaces_to_values(values, path)
+      values.collect! { |value|
+        camelcased_value = Gyoku.xml_tag(value, :key_converter => @key_converter)
+        namespace_path = path + [camelcased_value.to_s]
+        namespace = @used_namespaces[namespace_path]
+        "#{namespace.blank? ? '' : namespace + ":"}#{camelcased_value}"
+      }
+    end
+
+  end
+end

data/lib/savon/request.rb

@@ -0,0 +1,92 @@
+require "httpi"
+require "savon/response"
+require "savon/log_message"
+
+module Savon
+  class Request
+
+    CONTENT_TYPE = {
+      1 => "text/xml;charset=%s",
+      2 => "application/soap+xml;charset=%s"
+    }
+
+    def initialize(operation_name, wsdl, globals, locals)
+      @operation_name = operation_name
+
+      @wsdl    = wsdl
+      @globals = globals
+      @locals  = locals
+      @http    = create_http_client
+    end
+
+    attr_reader :http
+
+    def call(xml)
+      @http.body = xml
+      @http.headers["Content-Length"] = xml.bytesize.to_s
+
+      log_request @http.url, @http.headers, @http.body
+      response = HTTPI.post(@http)
+      log_response response.code, response.body
+
+      response
+    end
+
+    private
+
+    def create_http_client
+      http = HTTPI::Request.new
+      http.url = @globals[:endpoint] || @wsdl.endpoint
+
+      http.proxy = @globals[:proxy] if @globals.include? :proxy
+      http.set_cookies @globals[:last_response] if @globals.include? :last_response
+
+      http.open_timeout = @globals[:open_timeout] if @globals.include? :open_timeout
+      http.read_timeout = @globals[:read_timeout] if @globals.include? :read_timeout
+
+      http.headers = @globals[:headers] if @globals.include? :headers
+      http.headers["SOAPAction"] ||= %{"#{soap_action}"} if soap_action
+      http.headers["Content-Type"] = CONTENT_TYPE[@globals[:soap_version]] % @globals[:encoding]
+
+      http.auth.basic(*@globals[:basic_auth]) if @globals.include? :basic_auth
+      http.auth.digest(*@globals[:digest_auth]) if @globals.include? :digest_auth
+
+      http
+    end
+
+    def soap_action
+      return if @locals.include?(:soap_action) && !@locals[:soap_action]
+      return @soap_action if defined? @soap_action
+
+      soap_action = @locals[:soap_action]
+      soap_action ||= @wsdl.soap_action(@operation_name.to_sym) if @wsdl.document?
+      soap_action ||= Gyoku.xml_tag(@operation_name, :key_converter => @globals[:convert_request_keys_to])
+
+      @soap_action = soap_action
+    end
+
+    def log_request(url, headers, body)
+      logger.info  "SOAP request: #{url}"
+      logger.info  headers_to_log(headers)
+      logger.debug body_to_log(body)
+    end
+
+    def log_response(code, body)
+      logger.info  "SOAP response (status #{code})"
+      logger.debug body_to_log(body)
+    end
+
+    def headers_to_log(headers)
+      headers.map { |key, value| "#{key}: #{value}" }.join(", ")
+    end
+
+    def body_to_log(body)
+      LogMessage.new(body, @globals[:filters], @globals[:pretty_print_xml]).to_s
+    end
+
+    def logger
+      @globals[:logger]
+    end
+
+  end
+end