julianmorrison-savon 0.6.8

data/lib/savon/core_ext/symbol.rb

@@ -0,0 +1,8 @@
+class Symbol
+
+  # Returns the Symbol as a lowerCamelCase String.
+  def to_soap_key
+    to_s.lower_camelcase
+  end
+
+end

data/lib/savon/core_ext/uri.rb

@@ -0,0 +1,10 @@
+module URI
+  class HTTP
+
+    # Returns whether the URI hints to SSL.
+    def ssl?
+      /^https/ === @scheme
+    end
+
+  end
+end

data/lib/savon/request.rb

@@ -0,0 +1,159 @@
+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 and SSL client authentication.
+    def initialize(endpoint, options = {})
+      @endpoint = URI endpoint
+      @proxy = options[:proxy] ? URI(options[:proxy]) : URI("") 
+      @ssl = options[:ssl] if options[:ssl]
+    end
+
+    # Returns the endpoint URI.
+    attr_reader :endpoint
+
+    # Returns the proxy URI.
+    attr_reader :proxy
+
+    # Accessor for HTTP open timeout.
+    attr_accessor :open_timeout
+
+    # Accessor for HTTP read timeout.
+    attr_accessor :read_timeout
+
+    # Retrieves WSDL document and returns the Net::HTTPResponse.
+    def wsdl
+      log "Retrieving WSDL from: #{@endpoint}"
+      
+      query = @endpoint.path
+      query += ('?' + @endpoint.query) if @endpoint.query
+      req = Net::HTTP::Get.new query
+      req.basic_auth(@endpoint.user, @endpoint.password) if @endpoint.user
+      
+      http.start {|h| h.request(req) }
+    end
+
+    # Executes a SOAP request using a given Savon::SOAP instance and
+    # returns the Net::HTTPResponse.
+    def soap(soap)
+      @soap = soap
+      
+      log_request
+
+      req = Net::HTTP::Post.new @soap.endpoint.path, http_header
+      req.body = @soap.to_xml
+      req.basic_auth(@soap.endpoint.user, @soap.endpoint.password) if @soap.endpoint.user
+      
+      @response = http(@soap.endpoint).start {|h| h.request(req) }
+      
+      log_response
+      @response
+    end
+
+  private
+
+    # Logs the SOAP request.
+    def log_request
+      log "SOAP request: #{@soap.endpoint}"
+      log http_header.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 instance for a given +endpoint+.
+    def http(endpoint = @endpoint)
+      @http = Net::HTTP::Proxy(@proxy.host, @proxy.port).new endpoint.host, endpoint.port
+      set_http_timeout
+      set_ssl_options endpoint.ssl?
+      set_ssl_authentication if @ssl
+      @http
+    end
+
+    # Sets HTTP open and read timeout.
+    def set_http_timeout
+      @http.open_timeout = @open_timeout if @open_timeout
+      @http.read_timeout = @read_timeout if @read_timeout
+    end
+
+    # Sets basic SSL options to the +@http+ instance.
+    def set_ssl_options(use_ssl)
+      @http.use_ssl = use_ssl
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    # Sets SSL client authentication to the +@http+ instance.
+    def set_ssl_authentication
+      @http.verify_mode = @ssl[:verify] if @ssl[:verify].kind_of? Integer
+      @http.cert = @ssl[:client_cert] if @ssl[:client_cert]
+      @http.key = @ssl[:client_key] if @ssl[:client_key]
+      @http.ca_file = @ssl[:ca_file] if @ssl[:ca_file]
+    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/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
+
+    # Expects a Net::HTTPResponse and handles errors.
+    def initialize(response)
+      @response = response
+
+      handle_soap_fault
+      handle_http_error
+    end
+
+    # Returns whether there was a SOAP fault.
+    def soap_fault?
+      @soap_fault
+    end
+
+    # Returns the SOAP fault message.
+    attr_reader :soap_fault
+
+    # Returns whether there was an HTTP error.
+    def http_error?
+      @http_error
+    end
+
+    # Returns the HTTP error message.
+    attr_reader :http_error
+
+    # Returns the SOAP response as a Hash.
+    def to_hash
+      @body.find_regexp(/.+/).map_soap_response
+    end
+
+    # Returns the SOAP response XML.
+    def to_xml
+      @response.body
+    end
+
+    alias :to_s  :to_xml
+
+  private
+
+    # Returns the SOAP response body as a Hash.
+    def body
+      unless @body
+        body = Crack::XML.parse @response.body
+        @body = body.find_regexp [/.+:Envelope/, /.+:Body/]
+      end
+      @body
+    end
+
+    # 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_message if self.class.raise_errors?
+      end
+    end
+
+    # Returns a SOAP fault message in case a SOAP fault was found.
+    def soap_fault_message
+      unless @soap_fault_message
+        soap_fault = body.find_regexp [/.+:Fault/]
+        @soap_fault_message = soap_fault_message_by_version(soap_fault)
+      end
+      @soap_fault_message
+    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)
+      if soap_fault.keys.include? "faultcode"
+        "(#{soap_fault['faultcode']}) #{soap_fault['faultstring']}"
+      elsif soap_fault.keys.include? "Code"
+        # SOAP 1.2 error code element is capitalized, see: http://www.w3.org/TR/soap12-part1/#faultcodeelement
+        "(#{soap_fault['Code']['Value']}) #{soap_fault['Reason']['Text']}"
+      end
+    end
+
+    # Handles HTTP errors. Raises a Savon::HTTPError unless the default
+    # behavior of raising errors was turned off.
+    def handle_http_error
+      if @response.code.to_i >= 300
+        @http_error = "#{@response.message} (#{@response.code})"
+        @http_error << ": #{@response.body}" unless @response.body.empty?
+        raise Savon::HTTPError, http_error if self.class.raise_errors?
+      end
+    end
+
+  end
+end

data/lib/savon/soap.rb

@@ -0,0 +1,138 @@
+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
+
+    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, 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 << (header.to_soap_xml rescue header.to_s) + wsse_header
+      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 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