s-savon 0.8.6

data/lib/savon/http/error.rb

@@ -0,0 +1,42 @@
+require "savon/error"
+require "savon/soap/xml"
+
+module Savon
+  module HTTP
+
+    # = Savon::HTTP::Error
+    #
+    # Represents an HTTP error. Contains the original <tt>HTTPI::Response</tt>.
+    class Error < 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 an HTTP error is present.
+      def present?
+        http.error?
+      end
+
+      # Returns the HTTP error message.
+      def to_s
+        return "" unless present?
+        
+        @message ||= begin
+          message = "HTTP error (#{http.code})"
+          message << ": #{http.body}" unless http.body.empty?
+        end
+      end
+
+      # Returns the HTTP response as a Hash.
+      def to_hash
+        @hash = { :code => http.code, :headers => http.headers, :body => http.body }
+      end
+
+    end
+  end
+end

data/lib/savon/soap.rb

@@ -0,0 +1,24 @@
+module Savon
+
+  # = Savon::SOAP
+  #
+  # Contains various SOAP details.
+  module SOAP
+
+    # Default SOAP version.
+    DefaultVersion = 1
+
+    # Supported SOAP versions.
+    Versions = 1..2
+
+    # SOAP namespaces by SOAP version.
+    Namespace = {
+      1 => "http://schemas.xmlsoap.org/soap/envelope/",
+      2 => "http://www.w3.org/2003/05/soap-envelope"
+    }
+
+    # SOAP xs:dateTime Regexp.
+    DateTimeRegexp = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+
+  end
+end

data/lib/savon/soap/fault.rb

@@ -0,0 +1,59 @@
+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.include?("Fault>") && (soap1_fault? || soap2_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
+
+      # Returns whether the response contains a SOAP 1.1 fault.
+      def soap1_fault?
+        http.body.include?("faultcode>") && http.body.include?("faultstring>")
+      end
+
+      # Returns whether the response contains a SOAP 1.2 fault.
+      def soap2_fault?
+        http.body.include?("Code>") && http.body.include?("Reason>")
+      end
+
+      # Returns the SOAP fault message by version.
+      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,80 @@
+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 header as a Hash.
+      def header
+        @header_hash ||= basic_hash.find_soap_header
+      end
+
+      # Returns the SOAP response body as a Hash.
+      def to_hash
+        @hash ||= Savon::SOAP::XML.to_hash basic_hash
+      end
+
+      # Returns the SOAP response body as an Array.
+      def to_array(*path)
+        Savon::SOAP::XML.to_array to_hash, *path
+      end
+
+      # Returns the complete SOAP response XML without normalization.
+      def basic_hash
+        @basic_hash ||= Savon::SOAP::XML.parse http.body
+      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,187 @@
+require "builder"
+require "crack/xml"
+require "gyoku"
+
+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"
+      }
+
+      # Converts the given SOAP response +value+ (XML or Hash) into a normalized Hash.
+      def self.to_hash(value)
+        value = parse value unless value.kind_of? Hash
+        value.find_soap_body
+      end
+
+      # Converts a given SOAP response +xml+ to a Hash.
+      def self.parse(xml)
+        Crack::XML.parse(xml) rescue {}
+      end
+
+      # Expects a SOAP response XML or Hash, traverses it for a given +path+ of Hash keys
+      # and returns the value as an Array. Defaults to return an empty Array in case the
+      # path does not exist or returns nil.
+      def self.to_array(object, *path)
+        hash = object.kind_of?(Hash) ? object : to_hash(object)
+
+        result = path.inject hash do |memo, key|
+          return [] unless memo[key]
+          memo[key]
+        end
+
+        result.kind_of?(Array) ? result.compact : [result].compact
+      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 SOAP envelope namespace.
+      attr_writer :env_namespace
+
+      # Returns the SOAP envelope namespace. Defaults to :env.
+      def env_namespace
+        @env_namespace ||= :soap
+      end
+
+      # Sets the +namespaces+ Hash.
+      attr_writer :namespaces
+
+      # Returns the +namespaces+. Defaults to a Hash containing the SOAP envelope namespace.
+      def namespaces
+        @namespaces ||= begin
+          key = env_namespace.blank? ? "xmlns" : "xmlns:#{env_namespace}"
+          { key => SOAP::Namespace[version] }
+        end
+      end
+
+      # Sets the default namespace identifier.
+      attr_writer :namespace_identifier
+
+      # Returns the default namespace identifier.
+      def namespace_identifier
+        @namespace_identifier ||= :wsdl
+      end
+
+      # Returns whether all local elements should be namespaced. Might be set to :qualified,
+      # but defaults to :unqualified.
+      def element_form_default
+        @element_form_default ||= :unqualified
+      end
+
+      # Sets whether all local elements should be namespaced.
+      attr_writer :element_form_default
+
+      # 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 Gyoku.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 ||= tag(builder, :Envelope, complete_namespaces) do |xml|
+          tag(xml, :Header) { xml << header_for_xml } unless header_for_xml.empty?
+          input.nil? ? tag(xml, :Body) : tag(xml, :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
+
+      # Expects a builder +xml+ instance, a tag +name+ and accepts optional +namespaces+
+      # and a block to create an XML tag.
+      def tag(xml, name, namespaces = {}, &block)
+        return xml.tag! name, namespaces, &block if env_namespace.blank?
+        xml.tag! env_namespace, name, namespaces, &block
+      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_for_xml ||= Gyoku.xml(header) + 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
+        return body.to_s unless body.kind_of? Hash
+        unless namespace_identifier == :wsdl
+          Gyoku.xml body, :element_form_default => element_form_default
+        else
+          Gyoku.xml body, :element_form_default => element_form_default, :namespace => namespace_identifier
+        end
+      end
+
+    end
+  end
+end