savon 0.3.2 → 0.5.0

data/lib/savon/request.rb

@@ -0,0 +1,103 @@
+module Savon
+  class Request
+    include Validation
+
+    # Content-Types by SOAP version.
+    ContentType = { 1 => "text/xml", 2 => "application/soap+xml" }
+
+    # Defines whether to log HTTP requests.
+    @log = true
+
+    # The default logger.
+    @logger = Logger.new STDOUT
+
+    # The default log level.
+    @log_level = :debug
+
+    class << self
+      # Sets whether to log HTTP requests.
+      attr_writer :log
+
+      # Returns whether to log HTTP requests.
+      def log?
+        @log
+      end
+
+      # Accessor for the default logger.
+      attr_accessor :logger
+
+      # Accessor for the default log level.
+      attr_accessor :log_level
+    end
+
+    # Expects an endpoint String.
+    def initialize(endpoint)
+      validate! :endpoint, endpoint
+      @endpoint = URI endpoint
+    end
+
+    # Returns the endpoint URI.
+    attr_reader :endpoint
+
+    # Retrieves WSDL document and returns the Net::HTTPResponse.
+    def wsdl
+      log "Retrieving WSDL from: #{@endpoint}"
+      http.get @endpoint.to_s
+    end
+
+    # Executes a SOAP request using a given Savon::SOAP (+soap+) instance
+    # and returns the Net::HTTPResponse.
+    def soap(soap)
+      @soap = soap
+      soap_request
+    end
+
+  private
+
+    # Logs the SOAP request.
+    def log_request
+      log "SOAP request: #{@endpoint}"
+      log http_header.map { |key, value| "#{key}: #{value}" }.join ", "
+      log @soap.body
+    end
+
+    # Executes a SOAP request and returns the Net::HTTPResponse.
+    def soap_request
+      log_request
+      @response = http.request_post @endpoint.path, @soap.body, http_header
+      log_response
+      @response
+    end
+
+    # Logs the SOAP response.
+    def log_response
+      log "SOAP response (status #{@response.code}):"
+      log @response.body
+    end
+
+    # Returns a Net::HTTP instance.
+    def http
+      unless @http
+        @http ||= Net::HTTP.new @endpoint.host, @endpoint.port
+        @http.use_ssl = true if @endpoint.ssl?
+      end
+      @http
+    end
+
+    # Returns a Hash containing the header for an HTTP request.
+    def http_header
+      { "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 logging is possible.
+    def log?
+      self.class.log? && self.class.logger.respond_to?(self.class.log_level)
+    end
+
+  end
+end

data/lib/savon/soap.rb

@@ -0,0 +1,71 @@
+module Savon
+  class SOAP
+    include WSSE
+
+    # 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 default SOAP version.
+    @version = 1
+
+    class << self
+
+      # Accessor for the default SOAP version.
+      attr_accessor :version
+
+    end
+
+    # Expects a SOAP +action+, +body+, +options+ and the +namespace_uri+.
+    def initialize(action, body, options, namespace_uri)
+      @action, @body = action, body
+      @options, @namespace_uri = options, namespace_uri
+    end
+
+    # Returns the SOAP action.
+    attr_reader :action
+
+    # Returns the SOAP options.
+    attr_reader :options
+
+    # Returns the XML for a SOAP request.
+    def body
+      builder = Builder::XmlMarkup.new
+
+      @xml_body ||= builder.env :Envelope, envelope_namespaces do |xml|
+        xml.env(:Header) { envelope_header xml }
+        xml.env(:Body) { envelope_body xml }
+      end
+    end
+
+    # Returns the SOAP version to use.
+    def version
+      @options[:soap_version] || self.class.version
+    end
+
+  private
+
+    # Returns a Hash of namespaces for the SOAP envelope.
+    def envelope_namespaces
+      { "xmlns:env" => SOAPNamespace[version], "xmlns:wsdl" => @namespace_uri }
+    end
+
+    # Expects an instance of Builder::XmlMarkup and returns the XML for the
+    # SOAP envelope header.
+    def envelope_header(xml)
+      wsse_header xml if wsse?
+    end
+
+    # Expects an instance of Builder::XmlMarkup and returns the XML for the
+    # SOAP envelope body.
+    def envelope_body(xml)
+      xml.wsdl(@action.to_sym) { xml << (@body.to_soap_xml rescue @body.to_s) }
+    end
+
+  end
+end

data/lib/savon/validation.rb

@@ -0,0 +1,57 @@
+module Savon
+  module Validation
+
+    # Validates a given +value+ of a given +type+. Raises an ArgumentError
+    # in case the value is not valid. 
+    def validate!(type, value)
+      case type
+        when :endpoint then validate_endpoint value
+        when :soap_version then validate_soap_version value
+        when :soap_body then validate_soap_body value
+        when :response_process then validate_response_process value
+        when :wsse_credentials then validate_wsse_credentials value
+      end
+      true
+    end
+
+  private
+
+    # Validates a given +endpoint+.
+    def validate_endpoint(endpoint)
+      invalid :endpoint, endpoint unless /^(http|https):\/\// === endpoint
+    end
+
+    # Validates a given +soap_version+.
+    def validate_soap_version(soap_version)
+      invalid :soap_version, soap_version unless SOAPVersions.include? soap_version
+    end
+
+    # Validates a given +soap_body+.
+    def validate_soap_body(soap_body)
+      invalid :soap_body, soap_body unless
+        soap_body.kind_of?(Hash) || soap_body.respond_to?(:to_s)
+    end
+
+    # Validates a given +response_process+.
+    def validate_response_process(response_process)
+      invalid :response_process, response_process unless
+        response_process.respond_to? :call
+    end
+
+    # Validates a given Hash of +wsse_credentials+.
+    def validate_wsse_credentials(wsse)
+      invalid :wsse_credentials unless wsse[:username] && wsse[:password]
+      invalid :wsse_username, wsse[:username] unless wsse[:username].respond_to? :to_s
+      invalid :wsse_password, wsse[:password] unless wsse[:password].respond_to? :to_s
+    end
+
+    # Raises an ArgumentError for a given +argument+. Also accepts the invalid
+    # +value+ and adds it to the error message.
+    def invalid(argument, value = nil)
+      message = "Invalid argument '#{argument}'"
+      message << ": #{value}" if value
+      raise ArgumentError, message
+    end
+
+  end
+end

data/lib/savon/wsdl.rb

@@ -1,70 +1,68 @@
 module Savon
 
-  # Savon::WSDL represents the WSDL document.
+  # Savon::WSDL
+  #
+  # Savon::WSDL represents a WSDL document. A WSDL document serves as a more
+  # or less qualitative API documentation.
   class WSDL
+    include Validation
 
-    # Returns the namespace URI.
-    def namespace_uri
-      @namespace ||= parse_namespace_uri
+    # Expects a Savon::Request object.
+    def initialize(request)
+      @request = request
     end
 
-    # Returns an Array of available SOAP actions.
-    def soap_actions
-      @soap_actions ||= parse_soap_actions
+    # Returns the namespace URI from the WSDL.
+    def namespace_uri
+      @namespace_uri ||= parse_namespace_uri
     end
 
-    # Returns an Array of choice elements.
-    def choice_elements
-      @choice_elements ||= parse_choice_elements
+    # Returns an Array of available SOAP actions from the WSDL.
+    def soap_actions
+      mapped_soap_actions.keys
     end
 
-    # Initializer expects the endpoint +uri+ and a Net::HTTP instance (+http+).
-    def initialize(uri, http)
-      @uri, @http = uri, http
+    # Returns a Hash of available SOAP actions and their original names.
+    def mapped_soap_actions
+      @mapped_soap_actions ||= parse_soap_actions.inject Hash.new do |hash, soap_action|
+        hash.merge soap_action.snakecase.to_sym => soap_action
+      end
     end
 
-    # Returns the body of the Net::HTTPResponse from the WSDL request.
+    # Returns the WSDL or +nil+ in case the WSDL could not be retrieved.
     def to_s
-      @response ? @response.body : nil
+      wsdl_response ? wsdl_response.body : nil
     end
 
   private
 
-    # Returns an Hpricot::Document of the WSDL. Retrieves the WSDL from the
-    # endpoint URI in case it wasn't retrieved already.
-    def document
-      unless @document
-        @response = @http.get("#{@uri.path}?#{@uri.query}")
-        @document = Hpricot.XML(@response.body)
-        raise ArgumentError, "Unable to find WSDL at: #{@uri}" if
-          !soap_actions || soap_actions.empty?
+    # Retrieves and returns the WSDL response. Raises an ArgumentError in
+    # case the WSDL seems to be invalid. 
+    def wsdl_response
+      unless @wsdl_response
+        @wsdl_response ||= @request.wsdl
+        invalid! :wsdl, @request.endpoint unless soap_actions && !soap_actions.empty?
       end
-      @document
+      @wsdl_response
+    end
+
+    # Returns a REXML::Document of the WSDL.
+    def document
+      @document ||= REXML::Document.new wsdl_response.body
     end
 
     # Parses the WSDL for the namespace URI.
     def parse_namespace_uri
-      definitions = document.at("//wsdl:definitions")
-      definitions.get_attribute("targetNamespace") if definitions
+      definitions = document.elements["//wsdl:definitions"]
+      definitions.attributes["targetNamespace"] if definitions
     end
 
     # Parses the WSDL for available SOAP actions.
     def parse_soap_actions
-      soap_actions = document.search("[@soapAction]")
-
-      soap_actions.collect do |soap_action|
-        soap_action.parent.get_attribute("name")
-      end if soap_actions
-    end
-
-    # Parses the WSDL for choice elements.
-    def parse_choice_elements
-      choice_elements = document.search("//xs:choice//xs:element")
-
-      choice_elements.collect do |choice_element|
-        choice_element.get_attribute("ref").sub(/(.+):/, "")
-      end if choice_elements
+      document.elements.collect "//[@soapAction]" do |element|
+        element.parent.attributes["name"]
+      end
     end
 
   end
-end
+end

data/lib/savon/wsse.rb

@@ -0,0 +1,111 @@
+module Savon
+
+  # Savon::WSSE
+  #
+  # Includes support methods for adding WSSE authentication to a SOAP request.
+  module WSSE
+
+    # Namespace for WS Security Secext.
+    WSENamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"
+
+    # Namespace for WS Security Utility.
+    WSUNamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"
+
+    # Default WSSE username.
+    @username = nil
+
+    # Default WSSE password.
+    @password = nil
+
+    # Default for whether to use WSSE digest.
+    @digest = false
+
+    class << self
+
+      # Accessor for the default WSSE username.
+      attr_accessor :username
+
+      # Accessor for the default WSSE password.
+      attr_accessor :password
+
+      # Sets whether to use WSSE digest by default.
+      attr_writer :digest
+
+      # Returns whether to use WSSE digest by default. 
+      def digest?
+        @digest
+      end
+
+    end
+
+    # Returns whether WSSE authentication was set via options.
+    def wsse?
+      options[:wsse] = {} unless options[:wsse].kind_of? Hash
+      wsse_username && wsse_password
+    end
+
+    # Takes a Builder::XmlMarkup instance and appends a WSSE header.
+    def wsse_header(xml)
+      options[:wsse] = {} unless options[:wsse].kind_of? Hash
+
+      xml.wsse :Security, "xmlns:wsse" => WSENamespace do
+        xml.wsse :UsernameToken, "xmlns:wsu" => WSUNamespace do
+          wsse_nodes xml
+        end
+      end
+    end
+
+  private
+
+    # Returns the WSSE username or false in case no username was found.
+    def wsse_username
+      username = options[:wsse][:username] || WSSE.username
+      username ? username : false
+    end
+
+    # Returns the WSSE password or false in case no password was found.
+    def wsse_password
+      password = options[:wsse][:password] || WSSE.password
+      password ? password : false
+    end
+
+    # Returns whether to use WSSE digest authentication based on options.
+    def digest?
+      digest = options[:wsse][:digest] || WSSE.digest?
+      digest ? true : false
+    end
+
+    # Takes a Builder::XmlMarkup instance and appends the credentials for
+    # WSSE authentication.
+    def wsse_nodes(xml)
+      xml.wsse :Username, wsse_username
+      xml.wsse :Nonce, wsse_nonce
+      xml.wsu :Created, wsse_timestamp
+      xml.wsse :Password, wsse_password_node
+    end
+
+    # Returns the WSSE password. Encrypts the password for digest authentication.
+    def wsse_password_node
+      return wsse_password unless digest?
+
+      token = wsse_nonce + wsse_timestamp + wsse_password
+      Base64.encode64(Digest::SHA1.hexdigest(token)).chomp!
+    end
+
+    # Returns a WSSE nonce.
+    def wsse_nonce
+      @wsse_nonce ||= Digest::SHA1.hexdigest random_string + wsse_timestamp
+    end
+
+    # Returns a WSSE timestamp.
+    def wsse_timestamp
+      @wsse_timestamp ||= Time.now.strftime Savon::SOAPDateTimeFormat
+    end
+
+    # Returns a random String of a given +length+.
+    def random_string(length = 100)
+      (0...length).map { ("a".."z").to_a[rand(26)] }.join
+    end
+
+  end
+end