savon-xaop 0.7.2.1

data/lib/savon/request.rb

@@ -0,0 +1,160 @@
+module Savon
+
+  # == Savon::Request
+  #
+  # Handles both WSDL and SOAP HTTP requests.
+  class Request
+
+    # Content-Types by SOAP version.
+    ContentType = { 1 => "text/xml", 2 => "application/soap+xml" }
+
+    # Whether to log HTTP requests.
+    @@log = true
+
+    # The default logger.
+    @@logger = Logger.new STDOUT
+
+    # The default log level.
+    @@log_level = :debug
+
+    # Sets whether to log HTTP requests.
+    def self.log=(log)
+      @@log = log
+    end
+
+    # Returns whether to log HTTP requests.
+    def self.log?
+      @@log
+    end
+
+    # Sets the logger.
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+    # Returns the logger.
+    def self.logger
+      @@logger
+    end
+
+    # Sets the log level.
+    def self.log_level=(log_level)
+      @@log_level = log_level
+    end
+
+    # Returns the log level.
+    def self.log_level
+      @@log_level
+    end
+
+    # Expects a SOAP +endpoint+ String. Also accepts an optional Hash
+    # of +options+ for specifying a proxy server.
+    def initialize(endpoint, options = {})
+      @endpoint = URI endpoint
+      @proxy = options[:proxy] ? URI(options[:proxy]) : URI("")
+    end
+
+    # Returns the endpoint URI.
+    attr_reader :endpoint
+
+    # Returns the proxy URI.
+    attr_reader :proxy
+
+    # Returns the HTTP headers for a SOAP request.
+    def headers
+      @headers ||= {}
+    end
+
+    # Sets the HTTP headers for a SOAP request.
+    def headers=(headers)
+      @headers = headers if headers.kind_of? Hash
+    end
+
+    # Sets the +username+ and +password+ for HTTP basic authentication.
+    def basic_auth(username, password)
+      @basic_auth = [username, password]
+    end
+    
+    # Sets the +username+ and +password+ for NTLM authentication.
+    def ntlm_auth(username, password)
+      @ntlm_auth = [username, password]
+    end
+    
+    # Retrieves WSDL document and returns the Net::HTTP response.
+    def wsdl
+      log "Retrieving WSDL from: #{@endpoint}"
+      http.endpoint @endpoint.host, @endpoint.port
+      http.use_ssl = @endpoint.ssl?
+      http.start { |h| h.request request(:wsdl) }
+    end
+
+    # Executes a SOAP request using a given Savon::SOAP instance and
+    # returns the Net::HTTP response.
+    def soap(soap)
+      @soap = soap
+      http.endpoint @soap.endpoint.host, @soap.endpoint.port
+      http.use_ssl = @soap.endpoint.ssl?
+
+      log_request
+      @response = http.start do |h|
+        h.request request(:soap) { |request| request.body = @soap.to_xml }
+      end
+      log_response
+      @response
+    end
+
+    # Returns the Net::HTTP object.
+    def http
+      @http ||= Net::HTTP::Proxy(@proxy.host, @proxy.port).new @endpoint.host, @endpoint.port
+    end
+
+  private
+
+    # Logs the SOAP request.
+    def log_request
+      log "SOAP request: #{@soap.endpoint}"
+      log headers.merge(soap_headers).map { |key, value| "#{key}: #{value}" }.join(", ")
+      log @soap.to_xml
+    end
+
+    # Logs the SOAP response.
+    def log_response
+      log "SOAP response (status #{@response.code}):"
+      log @response.body
+    end
+
+    # Returns a Net::HTTP request for a given +type+. Yields the request
+    # to an optional block.
+    def request(type)
+      request = case type
+        when :wsdl then Net::HTTP::Get.new @endpoint.to_s, headers
+        when :soap then Net::HTTP::Post.new @soap.endpoint.to_s, headers.merge(soap_headers)
+      end
+      if @basic_auth
+        request.basic_auth *@basic_auth
+      elsif @ntlm_auth
+        log "Using NTLM authentication"
+        require 'net/ntlm_http'
+        request.ntlm_auth *@ntlm_auth
+      end
+      yield request if block_given?
+      request
+    end
+
+    # Returns a Hash containing the SOAP headers for an HTTP request.
+    def soap_headers
+      { "Content-Type" => ContentType[@soap.version], "SOAPAction" => @soap.action }
+    end
+
+    # Logs a given +message+.
+    def log(message)
+      self.class.logger.send self.class.log_level, message if log?
+    end
+
+    # Returns whether to log.
+    def log?
+      self.class.log? && self.class.logger.respond_to?(self.class.log_level)
+    end
+
+  end
+end

data/lib/savon/response.rb

@@ -0,0 +1,108 @@
+module Savon
+
+  # == Savon::Response
+  #
+  # Represents the HTTP and SOAP response.
+  class Response
+
+    # The global setting of whether to raise errors.
+    @@raise_errors = true
+
+    # Sets the global setting of whether to raise errors.
+    def self.raise_errors=(raise_errors)
+      @@raise_errors = raise_errors
+    end
+
+    # Returns the global setting of whether to raise errors.
+    def self.raise_errors?
+      @@raise_errors
+    end
+    
+    # Sets a specific handler for errors to raise.
+    def self.error_handler(&blk)
+      @@error_handler = blk
+    end
+
+    # Expects a Net::HTTPResponse and handles errors.
+    def initialize(http)
+      @http = http
+
+      handle_soap_fault
+      handle_http_error
+    end
+
+    # Returns whether there was a SOAP fault.
+    def soap_fault?
+      @soap_fault ? true : false
+    end
+
+    # Returns the SOAP fault message.
+    attr_reader :soap_fault
+
+    # Returns whether there was an HTTP error.
+    def http_error?
+      @http_error ? true : false
+    end
+
+    # Returns the HTTP error message.
+    attr_reader :http_error
+
+    # Returns the SOAP response body as a Hash.
+    def to_hash
+      @body ||= (Crack::XML.parse(@http.body) rescue {}).find_soap_body
+    end
+
+    # Returns the SOAP response XML.
+    def to_xml
+      @http.body
+    end
+
+    # Returns the HTTP response object.
+    attr_reader :http
+	
+    alias :to_s :to_xml
+
+  private
+
+    # Handles SOAP faults. Raises a Savon::SOAPFault unless the default
+    # behavior of raising errors was turned off.
+    def handle_soap_fault
+      if soap_fault_message
+        @soap_fault = soap_fault_message
+        raise Savon::SOAPFault, @soap_fault if self.class.raise_errors?
+      end
+    end
+
+    # Returns a SOAP fault message in case a SOAP fault was found.
+    def soap_fault_message
+      @soap_fault_message ||= soap_fault_message_by_version to_hash[:fault]
+    end
+
+    # Expects a Hash that might contain information about a SOAP fault.
+    # Returns the SOAP fault message in case one was found.
+    def soap_fault_message_by_version(soap_fault)
+      return unless soap_fault
+      
+      if @@error_handler
+        @@error_handler.call(soap_fault)
+      else
+        if soap_fault.keys.include? :faultcode
+          "(#{soap_fault[:faultcode]}) #{soap_fault[:faultstring]}"
+        elsif soap_fault.keys.include? :code
+          "(#{soap_fault[:code][:value]}) #{soap_fault[:reason][:text]}"
+        end
+      end
+    end
+
+    # Handles HTTP errors. Raises a Savon::HTTPError unless the default
+    # behavior of raising errors was turned off.
+    def handle_http_error
+      if @http.code.to_i >= 300
+        @http_error = "#{@http.message} (#{@http.code})"
+        @http_error << ": #{@http.body}" unless @http.body.empty?
+        raise Savon::HTTPError, http_error if self.class.raise_errors?
+      end
+    end
+
+  end
+end

data/lib/savon/soap.rb

@@ -0,0 +1,176 @@
+module Savon
+
+  # == Savon::SOAP
+  #
+  # Represents the SOAP parameters and envelope.
+  class SOAP
+
+    # SOAP namespaces by SOAP version.
+    SOAPNamespace = {
+      1 => "http://schemas.xmlsoap.org/soap/envelope/",
+      2 => "http://www.w3.org/2003/05/soap-envelope"
+    }
+
+    # Content-Types by SOAP version.
+    ContentType = { 1 => "text/xml", 2 => "application/soap+xml" }
+
+    # The global SOAP version.
+    @@version = 1
+
+    # Returns the global SOAP version.
+    def self.version
+      @@version
+    end
+
+    # Sets the global SOAP version.
+    def self.version=(version)
+      @@version = version if Savon::SOAPVersions.include? version
+    end
+
+    # Sets the global SOAP header. Expected to be a Hash that can be translated
+    # to XML via Hash.to_soap_xml or any other Object responding to to_s.
+    def self.header=(header)
+      @@header = header
+    end
+
+    # Returns the global SOAP header. Defaults to an empty Hash.
+    def self.header
+      @@header ||= {}
+    end
+
+    # Sets the global namespaces. Expected to be a Hash containing the
+    # namespaces (keys) and the corresponding URI's (values).
+    def self.namespaces=(namespaces)
+      @@namespaces = namespaces if namespaces.kind_of? Hash
+    end
+
+    # Returns the global namespaces. A Hash containing the namespaces (keys)
+    # and the corresponding URI's (values).
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    # Initialzes the SOAP object.
+    def initialize
+      @builder = Builder::XmlMarkup.new
+    end
+
+    # Sets the WSSE options.
+    attr_writer :wsse
+
+    # Sets the SOAP action.
+    attr_writer :action
+
+    # Returns the SOAP action.
+    def action
+      @action ||= ""
+    end
+
+    # Sets the SOAP input.
+    attr_writer :input
+
+    # Returns the SOAP input.
+    def input
+      @input ||= ""
+    end
+
+    # Accessor for the SOAP endpoint.
+    attr_accessor :endpoint
+
+    # Sets the SOAP header. Expected to be a Hash that can be translated
+    # to XML via Hash.to_soap_xml or any other Object responding to to_s.
+    attr_writer :header
+
+    # Returns the SOAP header. Defaults to an empty Hash.
+    def header
+      @header ||= {}
+    end
+
+    # Sets the SOAP body. Expected to be a Hash that can be translated to
+    # XML via Hash.to_soap_xml or any other Object responding to to_s.
+    attr_writer :body
+
+    # Sets the namespaces. Expected to be a Hash containing the namespaces
+    # (keys) and the corresponding URI's (values).
+    attr_writer :namespaces
+
+    # Returns the namespaces. A Hash containing the namespaces (keys)
+    # and the corresponding URI's (values).
+    def namespaces
+      @namespaces ||= { "xmlns:env" => SOAPNamespace[version] }
+    end
+
+    # Convenience method for setting the "xmlns:wsdl" namespace.
+    def namespace=(namespace)
+      namespaces["xmlns:wsdl"] = namespace
+    end
+
+    # Sets the SOAP version.
+    def version=(version)
+      @version = version if Savon::SOAPVersions.include? version
+    end
+
+    # Returns the SOAP version. Defaults to the global default.
+    def version
+      @version ||= self.class.version
+    end
+
+    # Returns the SOAP envelope XML.
+    def to_xml
+      unless @xml_body
+        @xml_body = @builder.env :Envelope, all_namespaces do |xml|
+          xml_header xml
+          xml_body xml
+        end
+      end
+      @xml_body
+    end
+
+  private
+
+    # Adds a SOAP XML header to a given +xml+ Object.
+    def xml_header(xml)
+      xml.env(:Header) do
+        xml << all_header + wsse_header
+      end
+    end
+
+    # Returns a String containing the global and per request header.
+    def all_header
+      if self.class.header.kind_of?(Hash) && header.kind_of?(Hash)
+        self.class.header.merge(header).to_soap_xml
+      else
+        self.class.header.to_s + header.to_s
+      end
+    end
+
+    # Adds a SOAP XML body to a given +xml+ Object.
+    def xml_body(xml)
+      xml.env(:Body) do
+        xml.tag!(:wsdl, *input_array) do
+          xml << (@body.to_soap_xml rescue @body.to_s)
+        end
+      end
+    end
+
+    # Returns a Hash containing the global and per request namespaces.
+    def all_namespaces
+      self.class.namespaces.merge namespaces
+    end
+
+    # Returns an Array of SOAP input names to append to the :wsdl namespace.
+    # Defaults to use the name of the SOAP action and may be an empty Array
+    # in case the specified SOAP input seems invalid.
+    def input_array
+      return [input.to_sym] unless input.blank?
+      return [action.to_sym] unless action.blank?
+      []
+    end
+
+    # Returns the WSSE header or an empty String in case WSSE was not set.
+    def wsse_header
+      @wsse.respond_to?(:header) ? @wsse.header : ""
+    end
+
+  end
+end

data/lib/savon/wsdl.rb

@@ -0,0 +1,122 @@
+module Savon
+
+  # Savon::WSDL
+  #
+  # Represents the WSDL document.
+  class WSDL
+
+    # Initializer, expects a Savon::Request.
+    def initialize(request)
+      @request = request
+    end
+
+    # Sets whether to use the WSDL.
+    attr_writer :enabled
+
+    # Returns whether to use the WSDL. Defaults to +true+.
+    def enabled?
+      @enabled.nil? ? true : @enabled
+    end
+
+    # Returns the namespace URI of the WSDL.
+    def namespace_uri
+      @namespace_uri ||= stream.namespace_uri
+    end
+
+    # Returns an Array of available SOAP actions.
+    def soap_actions
+      @soap_actions ||= stream.operations.keys
+    end
+
+    # Returns a Hash of SOAP operations including their corresponding
+    # SOAP actions and inputs.
+    def operations
+      @operations ||= stream.operations
+    end
+
+    # Returns the SOAP endpoint.
+    def soap_endpoint
+      @soap_endpoint ||= stream.soap_endpoint
+    end
+
+    # Returns +true+ for available methods and SOAP actions.
+    def respond_to?(method)
+      return true if soap_actions.include? method
+      super
+    end
+
+    # Returns the raw WSDL document.
+    def to_s
+      @document ||= @request.wsdl.body
+    end
+
+  private
+
+    # Returns the Savon::WSDLStream.
+    def stream
+      unless @stream
+        @stream = WSDLStream.new
+        REXML::Document.parse_stream to_s, @stream
+      end
+      @stream
+    end
+
+  end
+
+  # Savon::WSDLStream
+  #
+  # Stream listener for parsing the WSDL document.
+  class WSDLStream
+
+    # The main sections of a WSDL document.
+    Sections = %w(definitions types message portType binding service)
+
+    def initialize
+      @depth, @operations = 0, {}
+    end
+
+    # Returns the namespace URI.
+    attr_reader :namespace_uri
+
+    # Returns the SOAP operations.
+    attr_reader :operations
+
+    # Returns the SOAP endpoint.
+    attr_reader :soap_endpoint
+
+    # Hook method called when the stream parser encounters a starting tag.
+    def tag_start(tag, attrs)
+      @depth += 1
+      tag = tag.strip_namespace
+
+      @section = tag.to_sym if @depth <= 2 && Sections.include?(tag)
+      @namespace_uri ||= attrs["targetNamespace"] if @section == :definitions
+      @soap_endpoint ||= URI(attrs["location"]) if @section == :service && tag == "address"
+
+      operation_from tag, attrs if @section == :binding && tag == "operation"
+    end
+
+    # Hook method called when the stream parser encounters a closing tag.
+    def tag_end(tag)
+      @depth -= 1
+    end
+
+    # Stores available operations from a given tag +name+ and +attrs+.
+    def operation_from(tag, attrs)
+      @input = attrs["name"] if attrs["name"]
+
+      if attrs["soapAction"]
+        @action = !attrs["soapAction"].blank? ? attrs["soapAction"] : @input
+        @input = @action.split("/").last if !@input || @input.empty?
+
+        @operations[@input.snakecase.to_sym] = { :action => @action, :input => @input }
+        @input, @action = nil, nil
+      end
+    end
+
+    # Catches calls to unimplemented hook methods.
+    def method_missing(method, *args)
+    end
+
+  end
+end

data/lib/savon/wsse.rb

@@ -0,0 +1,136 @@
+module Savon
+
+  # Savon::WSSE
+  #
+  # Represents parameters for WSSE authentication.
+  class WSSE
+
+    # Base address for WSSE docs.
+    BaseAddress = "http://docs.oasis-open.org/wss/2004/01"
+
+    # Namespace for WS Security Secext.
+    WSENamespace = BaseAddress + "/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+
+    # Namespace for WS Security Utility.
+    WSUNamespace = BaseAddress + "/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+
+    # URI for "wsse:Password/@Type" #PasswordText.
+    PasswordTextURI = BaseAddress + "/oasis-200401-wss-username-token-profile-1.0#PasswordText"
+
+    # URI for "wsse:Password/@Type" #PasswordDigest.
+    PasswordDigestURI = BaseAddress + "/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"
+
+    # Global WSSE username.
+    @@username = nil
+
+    # Returns the global WSSE username.
+    def self.username
+      @@username
+    end
+
+    # Sets the global WSSE username.
+    def self.username=(username)
+      @@username = username.to_s if username.respond_to? :to_s
+      @@username = nil if username.nil?
+    end
+
+    # Global WSSE password.
+    @@password = nil
+
+    # Returns the global WSSE password.
+    def self.password
+      @@password
+    end
+
+    # Sets the global WSSE password.
+    def self.password=(password)
+      @@password = password.to_s if password.respond_to? :to_s
+      @@password = nil if password.nil?
+    end
+
+    # Global setting of whether to use WSSE digest.
+    @@digest = false
+
+    # Returns the global setting of whether to use WSSE digest.
+    def self.digest?
+      @@digest
+    end
+
+    # Global setting of whether to use WSSE digest.
+    def self.digest=(digest)
+      @@digest = digest
+    end
+
+    # Sets the WSSE username per request.
+    def username=(username)
+      @username = username.to_s if username.respond_to? :to_s
+      @username = nil if username.nil?
+    end
+
+    # Returns the WSSE username. Defaults to the global setting.
+    def username
+      @username || self.class.username
+    end
+
+    # Sets the WSSE password per request.
+    def password=(password)
+      @password = password.to_s if password.respond_to? :to_s
+      @password = nil if password.nil?
+    end
+
+    # Returns the WSSE password. Defaults to the global setting.
+    def password
+      @password || self.class.password
+    end
+
+    # Sets whether to use WSSE digest per request.
+    attr_writer :digest
+
+    # Returns whether to use WSSE digest. Defaults to the global setting. 
+    def digest?
+      @digest || self.class.digest?
+    end
+
+    # Returns the XML for a WSSE header or an empty String unless both
+    # username and password were specified.
+    def header
+      return "" unless username && password
+
+      builder = Builder::XmlMarkup.new
+      builder.wsse :Security, "xmlns:wsse" => WSENamespace do |xml|
+        xml.wsse :UsernameToken, "xmlns:wsu" => WSUNamespace do
+          xml.wsse :Username, username
+          xml.wsse :Nonce, nonce
+          xml.wsu :Created, timestamp
+          xml.wsse :Password, password_node, :Type => password_type
+        end
+      end
+    end
+
+  private
+
+    # Returns the WSSE password. Encrypts the password for digest authentication.
+    def password_node
+      return password unless digest?
+
+      token = nonce + timestamp + password
+      Base64.encode64(Digest::SHA1.hexdigest(token)).chomp!
+    end
+
+    # Returns the URI for the "wsse:Password/@Type" attribute.
+    def password_type
+      digest? ? PasswordDigestURI : PasswordTextURI
+    end
+
+    # Returns a WSSE nonce.
+    def nonce
+      @nonce ||= Digest::SHA1.hexdigest String.random + timestamp
+    end
+
+    # Returns a WSSE timestamp.
+    def timestamp
+      @timestamp ||= Time.now.strftime Savon::SOAPDateTimeFormat
+    end
+
+  end
+end