savon 0.7.9 → 0.8.0.beta.1

data/lib/savon/soap/fault.rb

@@ -0,0 +1,48 @@
+require "savon/error"
+require "savon/soap/xml"
+
+module Savon
+  module SOAP
+
+    # = Savon::SOAP::Fault
+    #
+    # Represents a SOAP fault. Contains the original <tt>HTTPI::Response</tt>.
+    class Fault < Error
+
+      # Expects an <tt>HTTPI::Response</tt>.
+      def initialize(http)
+        self.http = http
+      end
+
+      # Accessor for the <tt>HTTPI::Response</tt>.
+      attr_accessor :http
+
+      # Returns whether a SOAP fault is present.
+      def present?
+        @present ||= http.body =~ /<soap:Fault>/
+      end
+
+      # Returns the SOAP fault message.
+      def to_s
+        return "" unless present?
+        @message ||= message_by_version to_hash[:fault]
+      end
+
+      # Returns the SOAP response body as a Hash.
+      def to_hash
+        @hash ||= Savon::SOAP::XML.to_hash http.body
+      end
+
+    private
+
+      def message_by_version(fault)
+        if fault[:faultcode]
+          "(#{fault[:faultcode]}) #{fault[:faultstring]}"
+        elsif fault[:code]
+          "(#{fault[:code][:value]}) #{fault[:reason][:text]}"
+        end
+      end
+
+    end
+  end
+end

data/lib/savon/soap/request.rb

@@ -0,0 +1,61 @@
+require "httpi"
+require "savon/soap/response"
+
+module Savon
+  module SOAP
+
+    # = Savon::SOAP::Request
+    #
+    # Executes SOAP requests.
+    class Request
+
+      # Content-Types by SOAP version.
+      ContentType = { 1 => "text/xml;charset=UTF-8", 2 => "application/soap+xml;charset=UTF-8" }
+
+      # Expects an <tt>HTTPI::Request</tt> and a <tt>Savon::SOAP::XML</tt> object.
+      def initialize(request, soap)
+        self.request = setup(request, soap)
+      end
+
+      # Accessor for the <tt>HTTPI::Request</tt>.
+      attr_accessor :request
+
+      # Executes the request and returns the response.
+      def response
+        @response ||= with_logging { HTTPI.post request }
+      end
+
+    private
+
+      # Sets up the +request+ using a given +soap+ object.
+      def setup(request, soap)
+        request.url = soap.endpoint
+        request.headers["Content-Type"] ||= ContentType[soap.version]
+        request.body = soap.to_xml
+        request
+      end
+
+      # Logs the HTTP request, yields to a given +block+ and returns a <tt>Savon::SOAP::Response</tt>.
+      def with_logging
+        log_request request.url, request.headers, request.body
+        response = yield
+        log_response response.code, response.body
+        SOAP::Response.new response
+      end
+
+      # Logs the SOAP request +url+, +headers+ and +body+.
+      def log_request(url, headers, body)
+        Savon.log "SOAP request: #{url}"
+        Savon.log headers.map { |key, value| "#{key}: #{value}" }.join(", ")
+        Savon.log body
+      end
+
+      # Logs the SOAP response +code+ and +body+.
+      def log_response(code, body)
+        Savon.log "SOAP response (status #{code}):"
+        Savon.log body
+      end
+
+    end
+  end
+end

data/lib/savon/soap/response.rb

@@ -0,0 +1,65 @@
+require "savon/soap/xml"
+require "savon/soap/fault"
+require "savon/http/error"
+
+module Savon
+  module SOAP
+
+    # = Savon::SOAP::Response
+    #
+    # Represents the SOAP response and contains the HTTP response.
+    class Response
+
+      # Expects an <tt>HTTPI::Response</tt> and handles errors.
+      def initialize(response)
+        self.http = response
+        raise_errors if Savon.raise_errors?
+      end
+
+      attr_accessor :http
+
+      # Returns whether the request was successful.
+      def success?
+        !soap_fault? && !http_error?
+      end
+
+      # Returns whether there was a SOAP fault.
+      def soap_fault?
+        soap_fault.present?
+      end
+
+      # Returns the <tt>Savon::SOAP::Fault</tt>.
+      def soap_fault
+        @soap_fault ||= Fault.new http
+      end
+
+      # Returns whether there was an HTTP error.
+      def http_error?
+        http_error.present?
+      end
+
+      # Returns the <tt>Savon::HTTP::Error</tt>.
+      def http_error
+        @http_error ||= HTTP::Error.new http
+      end
+
+      # Returns the SOAP response body as a Hash.
+      def to_hash
+        @hash ||= Savon::SOAP::XML.to_hash to_xml
+      end
+
+      # Returns the SOAP response XML.
+      def to_xml
+        http.body
+      end
+
+    private
+
+      def raise_errors
+        raise soap_fault if soap_fault?
+        raise http_error if http_error?
+      end
+
+    end
+  end
+end

data/lib/savon/soap/xml.rb

@@ -0,0 +1,132 @@
+require "builder"
+require "crack/xml"
+require "savon/soap"
+require "savon/core_ext/hash"
+
+module Savon
+  module SOAP
+
+    # = Savon::SOAP::XML
+    #
+    # Represents the SOAP request XML. Contains various global and per request/instance settings
+    # like the SOAP version, header, body and namespaces.
+    class XML
+
+      # XML Schema Type namespaces.
+      SchemaTypes = {
+        "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+        "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance"
+      }
+
+      def self.to_hash(xml)
+        (Crack::XML.parse(xml) rescue {}).find_soap_body
+      end
+
+      # Accepts an +endpoint+, an +input+ tag and a SOAP +body+.
+      def initialize(endpoint = nil, input = nil, body = nil)
+        self.endpoint = endpoint if endpoint
+        self.input = input if input
+        self.body = body if body
+      end
+
+      # Accessor for the SOAP +input+ tag.
+      attr_accessor :input
+
+      # Accessor for the SOAP +endpoint+.
+      attr_accessor :endpoint
+
+      # Sets the SOAP +version+.
+      def version=(version)
+        raise ArgumentError, "Invalid SOAP version: #{version}" unless SOAP::Versions.include? version
+        @version = version
+      end
+
+      # Returns the SOAP +version+. Defaults to <tt>Savon.soap_version</tt>.
+      def version
+        @version ||= Savon.soap_version
+      end
+
+      # Sets the SOAP +header+ Hash.
+      attr_writer :header
+
+      # Returns the SOAP +header+. Defaults to an empty Hash.
+      def header
+        @header ||= {}
+      end
+
+      # Sets the +namespaces+ Hash.
+      attr_writer :namespaces
+
+      # Returns the +namespaces+. Defaults to a Hash containing the <tt>xmlns:env</tt> namespace.
+      def namespaces
+        @namespaces ||= { "xmlns:env" => SOAP::Namespace[version] }
+      end
+
+      # Sets the default namespace identifier.
+      attr_writer :namespace_identifier
+
+      # Returns the default namespace identifier.
+      def namespace_identifier
+        @namespace_identifier ||= :wsdl
+      end
+
+      # Accessor for the default namespace URI.
+      attr_accessor :namespace
+
+      # Accessor for the <tt>Savon::WSSE</tt> object.
+      attr_accessor :wsse
+
+      # Accessor for 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_accessor :body
+
+      # Accepts a +block+ and yields a <tt>Builder::XmlMarkup</tt> object to let you create custom XML.
+      def xml
+        @xml = yield builder if block_given?
+      end
+
+      # Accepts an XML String and lets you specify a completely custom request body.
+      attr_writer :xml
+
+      # Returns the XML for a SOAP request.
+      def to_xml
+        @xml ||= builder.env :Envelope, complete_namespaces do |xml|
+          xml.env(:Header) { xml << header_for_xml } unless header_for_xml.empty?
+          xml.env(:Body) { xml.tag!(*input) { xml << body_to_xml } }
+        end
+      end
+
+    private
+
+      # Returns a new <tt>Builder::XmlMarkup</tt> object.
+      def builder
+        builder = Builder::XmlMarkup.new
+        builder.instruct!
+        builder
+      end
+
+      # Returns the complete Hash of namespaces.
+      def complete_namespaces
+        defaults = SchemaTypes.dup
+        defaults["xmlns:#{namespace_identifier}"] = namespace if namespace
+        defaults.merge namespaces
+      end
+
+      # Returns the SOAP header as an XML String.
+      def header_for_xml
+        header.to_soap_xml + wsse_header
+      end
+
+      # Returns the WSSE header or an empty String in case WSSE was not set.
+      def wsse_header
+        wsse.respond_to?(:to_xml) ? wsse.to_xml : ""
+      end
+
+      # Returns the SOAP body as an XML String.
+      def body_to_xml
+        body.respond_to?(:to_soap_xml) ? body.to_soap_xml : body.to_s
+      end
+
+    end
+  end
+end

data/lib/savon/version.rb

@@ -1,5 +1,5 @@
 module Savon
 
-  Version = "0.7.9"
+  Version = "0.8.0.beta.1"
 
-end
+end

data/lib/savon/wsdl/document.rb

@@ -0,0 +1,107 @@
+require "rexml/document"
+
+require "savon/wsdl/request"
+require "savon/wsdl/parser"
+
+module Savon
+  module WSDL
+
+    # = Savon::WSDL::Document
+    #
+    # Represents the WSDL of your service, including information like the namespace URI,
+    # the SOAP endpoint and available SOAP actions.
+    class Document
+
+      # Accepts an <tt>HTTPI::Request</tt> and a +document+.
+      def initialize(request = nil, document = nil)
+        self.request = request
+        self.document = document
+      end
+
+      # Accessor for the <tt>HTTPI::Request</tt> to use.
+      attr_accessor :request
+
+      def present?
+        !!@document
+      end
+
+      # Returns the namespace URI of the WSDL.
+      def namespace
+        @namespace ||= parser.namespace
+      end
+
+      # Sets the SOAP namespace.
+      attr_writer :namespace
+
+      # Returns the SOAP endpoint.
+      def endpoint
+        @endpoint ||= parser.endpoint
+      end
+
+      # Sets the SOAP endpoint.
+      attr_writer :endpoint
+
+      # Returns an Array of available SOAP actions.
+      def soap_actions
+        @soap_actions ||= parser.operations.keys
+      end
+
+      # Returns the SOAP action for a given +key+.
+      def soap_action(key)
+        operations[key][:action] if present? && operations[key]
+      end
+
+      # Returns the SOAP input for a given +key+.
+      def soap_input(key)
+        operations[key][:input].to_sym if present? && operations[key]
+      end
+
+      # Returns a Hash of SOAP operations.
+      def operations
+        @operations ||= parser.operations
+      end
+
+      # Sets the location of the WSDL document to use. This can either be a URL
+      # or a path to a local file.
+      attr_writer :document
+
+      # Returns the raw WSDL document.
+      def document
+        @wsdl_document ||= begin
+          raise ArgumentError, "No WSDL document given" if @document.blank?
+          remote? ? http_request : read_file
+        end
+      end
+
+      alias :to_xml :document
+
+    private
+
+      # Returns whether the WSDL document is located on the Web.
+      def remote?
+        @document =~ /^http/
+      end
+
+      # Executes an HTTP GET request to retrieve a remote WSDL document.
+      def http_request
+        request.url = @document
+        Request.new(request).response.body
+      end
+
+      # Reads the WSDL document from a local file.
+      def read_file
+        File.read @document
+      end
+
+      # Parses the WSDL document and returns the <tt>Savon::WSDL::Parser</tt>.
+      def parser
+        @parser ||= begin
+          parser = Parser.new
+          REXML::Document.parse_stream document, parser
+          parser
+        end
+      end
+
+    end
+  end
+end

data/lib/savon/wsdl/parser.rb

@@ -0,0 +1,90 @@
+require "savon/core_ext/object"
+require "savon/core_ext/string"
+
+module Savon
+  module WSDL
+
+    # = Savon::WSDL::Parser
+    #
+    # Serves as a stream listener for parsing WSDL documents.
+    class Parser
+
+      # The main sections of a WSDL document.
+      Sections = %w(definitions types message portType binding service)
+
+      def initialize
+        @path, @operations, @namespaces = [], {}, {}
+      end
+
+      # Returns the namespace URI.
+      attr_reader :namespace
+
+      # Returns the SOAP operations.
+      attr_reader :operations
+
+      # Returns the SOAP endpoint.
+      attr_reader :endpoint
+
+      # Hook method called when the stream parser encounters a starting tag.
+      def tag_start(tag, attrs)
+        # read xml namespaces if root element
+        read_namespaces(attrs) if @path.empty?
+
+        tag, namespace = tag.split(":").reverse
+        @path << tag
+
+        if @section == :binding && tag == "binding"
+          # ensure that we are in an wsdl/soap namespace
+          @section = nil unless @namespaces[namespace].starts_with? "http://schemas.xmlsoap.org/wsdl/soap"
+        end
+
+        @section = tag.to_sym if Sections.include?(tag) && depth <= 2
+
+        @namespace ||= attrs["targetNamespace"] if @section == :definitions
+        @endpoint ||= URI(URI.escape(attrs["location"])) if @section == :service && tag == "address"
+
+        operation_from tag, attrs if @section == :binding && tag == "operation"
+      end
+
+      # Returns our current depth in the WSDL document.
+      def depth
+        @path.size
+      end
+
+      # Reads namespace definitions from a given +attrs+ Hash.
+      def read_namespaces(attrs)
+        attrs.each do |key, value|
+          @namespaces[key.strip_namespace] = value if key.starts_with? "xmlns:"
+        end
+      end
+
+      # Hook method called when the stream parser encounters a closing tag.
+      def tag_end(tag)
+        @path.pop
+
+        if @section == :binding && @input && tag.strip_namespace == "operation"
+          # no soapAction attribute found till now
+          operation_from tag, "soapAction" => @input
+        end
+      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
+end