they-savon 0.9.7

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Daniel Harrington
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+Savon [![Build Status](https://secure.travis-ci.org/rubiii/savon.png)](http://travis-ci.org/rubiii/savon)
+=====
+
+Heavy metal Ruby SOAP client
+
+[Documentation](http://savonrb.com) | [RDoc](http://rubydoc.info/gems/savon) |
+[Mailing list](https://groups.google.com/forum/#!forum/savonrb) | [Twitter](http://twitter.com/savonrb)
+
+Installation
+------------
+
+Savon is available through [Rubygems](http://rubygems.org/gems/savon) and can be installed via:
+
+```
+$ gem install savon
+```
+
+Introduction
+------------
+
+``` ruby
+require "savon"
+
+# create a client for your SOAP service
+client = Savon::Client.new("http://service.example.com?wsdl")
+
+client.wsdl.soap_actions
+# => [:create_user, :get_user, :get_all_users]
+
+# execute a SOAP request to call the "getUser" action
+response = client.request(:get_user) do
+  soap.body = { :id => 1 }
+end
+
+response.body
+# => { :get_user_response => { :first_name => "The", :last_name => "Hoff" } }
+```
+
+Documentation
+-------------
+
+Continue reading at [savonrb.com](http://savonrb.com)

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/lib/savon/client.rb

@@ -0,0 +1,168 @@
+require "httpi/request"
+require "akami"
+
+require "savon/wasabi/document"
+require "savon/soap/xml"
+require "savon/soap/request"
+require "savon/soap/response"
+
+module Savon
+
+  # = Savon::Client
+  #
+  # Savon::Client is the main object for connecting to a SOAP service.
+  class Client
+
+    # Initializes the Savon::Client for a SOAP service. Accepts a +block+ which is evaluated in the
+    # context of this object to let you access the +wsdl+, +http+, and +wsse+ methods.
+    #
+    # == Examples
+    #
+    #   # Using a remote WSDL
+    #   client = Savon::Client.new("http://example.com/UserService?wsdl")
+    #
+    #   # Using a local WSDL
+    #   client = Savon::Client.new File.expand_path("../wsdl/service.xml", __FILE__)
+    #
+    #   # Directly accessing a SOAP endpoint
+    #   client = Savon::Client.new do
+    #     wsdl.endpoint = "http://example.com/UserService"
+    #     wsdl.namespace = "http://users.example.com"
+    #   end
+    def initialize(wsdl_document = nil, &block)
+      wsdl.document = wsdl_document if wsdl_document
+      process 1, &block if block
+      wsdl.request = http
+    end
+
+    # Returns the <tt>Savon::Wasabi::Document</tt>.
+    def wsdl
+      @wsdl ||= Wasabi::Document.new
+    end
+
+    # Returns the <tt>HTTPI::Request</tt>.
+    def http
+      @http ||= HTTPI::Request.new
+    end
+
+    # Returns the <tt>Akami::WSSE</tt> object.
+    def wsse
+      @wsse ||= Akami.wsse
+    end
+
+    # Returns the <tt>Savon::SOAP::XML</tt> object. Please notice, that this object is only available
+    # in a block given to <tt>Savon::Client#request</tt>. A new instance of this object is created
+    # per SOAP request.
+    attr_reader :soap
+
+    # Executes a SOAP request for a given SOAP action. Accepts a +block+ which is evaluated in the
+    # context of this object to let you access the +soap+, +wsdl+, +http+ and +wsse+ methods.
+    #
+    # == Examples
+    #
+    #   # Calls a "getUser" SOAP action with the payload of "<userId>123</userId>"
+    #   client.request(:get_user) { soap.body = { :user_id => 123 } }
+    #
+    #   # Prefixes the SOAP input tag with a given namespace: "<wsdl:GetUser>...</wsdl:GetUser>"
+    #   client.request(:wsdl, "GetUser") { soap.body = { :user_id => 123 } }
+    #
+    #   # SOAP input tag with attributes: <getUser xmlns:wsdl="http://example.com">...</getUser>"
+    #   client.request(:get_user, "xmlns:wsdl" => "http://example.com")
+    def request(*args, &block)
+      raise ArgumentError, "Savon::Client#request requires at least one argument" if args.empty?
+
+      self.soap = SOAP::XML.new
+      preconfigure extract_options(args)
+      process &block if block
+      soap.wsse = wsse
+
+      response = SOAP::Request.new(http, soap).response
+      set_cookie response.http.headers
+      response
+    end
+
+  private
+
+    # Writer for the <tt>Savon::SOAP::XML</tt> object.
+    attr_writer :soap
+
+    # Accessor for the original self of a given block.
+    attr_accessor :original_self
+
+    # Passes a cookie from the last request +headers+ to the next one.
+    def set_cookie(headers)
+      http.headers["Cookie"] = headers["Set-Cookie"] if headers["Set-Cookie"]
+    end
+
+    # Expects an Array of +args+ and returns an Array containing the namespace (might be +nil+),
+    # the SOAP input and a Hash of attributes for the input tag (which might be empty).
+    def extract_options(args)
+      attributes = Hash === args.last ? args.pop : {}
+      namespace = args.size > 1 ? args.shift.to_sym : nil
+      input = args.first
+
+      [namespace, input, attributes]
+    end
+
+    # Expects an Array of +args+ to preconfigure the system.
+    def preconfigure(args)
+      soap.endpoint = wsdl.endpoint
+      soap.namespace_identifier = args[0]
+      soap.namespace = wsdl.namespace
+      soap.element_form_default = wsdl.element_form_default if wsdl.document?
+
+      body = args[2].delete(:body)
+      soap.body = body if body
+
+      wsdl.type_namespaces.each do |path, uri|
+        soap.use_namespace(path, uri)
+      end
+
+      wsdl.type_definitions.each do |path, type|
+        soap.types[path] = type
+      end
+
+      set_soap_action args[1]
+      set_soap_input *args
+    end
+
+    # Expects an +input+ and sets the +SOAPAction+ HTTP headers.
+    def set_soap_action(input_tag)
+      soap_action = wsdl.soap_action(input_tag.to_sym) if wsdl.document?
+      soap_action ||= Gyoku::XMLKey.create(input_tag).to_sym
+      http.headers["SOAPAction"] = %{"#{soap_action}"}
+    end
+
+    # Expects a +namespace+, +input+ and +attributes+ and sets the SOAP input.
+    def set_soap_input(namespace, input, attributes)
+      new_input_tag = wsdl.soap_input(input.to_sym) if wsdl.document?
+      new_input_tag ||= Gyoku::XMLKey.create(input)
+      soap.input = [namespace, new_input_tag.to_sym, attributes]
+    end
+
+    # Processes a given +block+. Yields objects if the block expects any arguments.
+    # Otherwise evaluates the block in the context of this object.
+    def process(offset = 0, &block)
+      block.arity > 0 ? yield_objects(offset, &block) : evaluate(&block)
+    end
+
+    # Yields a number of objects to a given +block+ depending on how many arguments
+    # the block is expecting.
+    def yield_objects(offset, &block)
+      yield *[soap, wsdl, http, wsse][offset, block.arity]
+    end
+
+    # Evaluates a given +block+ inside this object. Stores the original block binding.
+    def evaluate(&block)
+      self.original_self = eval "self", block.binding
+      instance_eval &block
+    end
+
+    # Handles calls to undefined methods by delegating to the original block binding.
+    def method_missing(method, *args, &block)
+      super unless original_self
+      original_self.send method, *args, &block
+    end
+
+  end
+end

data/lib/savon/core_ext/object.rb

@@ -0,0 +1,14 @@
+module Savon
+  module CoreExt
+    module Object
+
+      # Returns +true+ if the Object is nil, false or empty. Implementation from ActiveSupport.
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end unless method_defined?(:blank?)
+
+    end
+  end
+end
+
+Object.send :include, Savon::CoreExt::Object

data/lib/savon/core_ext/string.rb

@@ -0,0 +1,23 @@
+require "savon/soap"
+
+module Savon
+  module CoreExt
+    module String
+
+      # Returns the String in snake_case.
+      def snakecase
+        str = dup
+        str.gsub! /::/, '/'
+        str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+        str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+        str.tr! ".", "_"
+        str.tr! "-", "_"
+        str.downcase!
+        str
+      end unless method_defined?(:snakecase)
+
+    end
+  end
+end
+
+String.send :include, Savon::CoreExt::String

data/lib/savon/error.rb

@@ -0,0 +1,6 @@
+module Savon
+
+  # Base class for Savon errors.
+  class Error < RuntimeError; end
+
+end

data/lib/savon/global.rb

@@ -0,0 +1,129 @@
+require "logger"
+require "savon/soap"
+
+module Savon
+  module Global
+
+    # Sets whether to log HTTP requests.
+    attr_writer :log
+
+    # Returns whether to log HTTP requests. Defaults to +true+.
+    def log?
+      @log != false
+    end
+
+    # Sets the logger to use.
+    attr_writer :logger
+
+    # Returns the logger. Defaults to an instance of +Logger+ writing to STDOUT.
+    def logger
+      @logger ||= ::Logger.new STDOUT
+    end
+
+    # Sets the log level.
+    attr_writer :log_level
+
+    # Returns the log level. Defaults to :debug.
+    def log_level
+      @log_level ||= :debug
+    end
+
+    # Logs a given +message+.
+    def log(message)
+      logger.send log_level, filtered(message) if log?
+    end
+
+    # Sets the log filter.
+    attr_writer :log_filter
+
+    # Returns the log filter. Defaults to blank.
+    def log_filter
+      @log_filter ||= ''
+    end
+
+    # Filters Message based on log filter
+    def filtered(message)
+      xml = Nokogiri::XML(message)
+      return message if @log_filter.empty? || !xml.errors.empty?
+
+      @log_filter.each do |filter|
+        xml.xpath("//*[local-name()='#{filter}']").map { |node| node.content = '***FILTERED***' }
+      end
+      return xml.root.to_s
+    end
+
+    # Sets whether to raise HTTP errors and SOAP faults.
+    attr_writer :raise_errors
+
+    # Returns whether to raise errors. Defaults to +true+.
+    def raise_errors?
+      @raise_errors != false
+    end
+
+    # Sets the global SOAP version.
+    def soap_version=(version)
+      raise ArgumentError, "Invalid SOAP version: #{version}" unless SOAP::Versions.include? version
+      @version = version
+    end
+
+    # Returns SOAP version. Defaults to +DefaultVersion+.
+    def soap_version
+      @version ||= SOAP::DefaultVersion
+    end
+
+    # Returns whether to strip namespaces in a SOAP response Hash.
+    # Defaults to +true+.
+    def strip_namespaces?
+      Savon.deprecate("use Nori.strip_namespaces? instead of Savon.strip_namespaces?")
+      Nori.strip_namespaces?
+    end
+
+    # Sets whether to strip namespaces in a SOAP response Hash.
+    def strip_namespaces=(strip)
+      Savon.deprecate("use Nori.strip_namespaces= instead of Savon.strip_namespaces=")
+      Nori.strip_namespaces = strip
+    end
+
+    # Returns the global env_namespace.
+    attr_reader :env_namespace
+
+    # Sets the global env_namespace.
+    attr_writer :env_namespace
+
+    # Returns the global soap_header.
+    attr_reader :soap_header
+
+    # Sets the global soap_header.
+    attr_writer :soap_header
+
+    # Expects a +message+ and raises a warning if configured.
+    def deprecate(message)
+      warn("Deprecation: #{message}") if deprecate?
+    end
+
+    # Sets whether to warn about deprecations.
+    def deprecate=(deprecate)
+      @deprecate = deprecate
+    end
+
+    # Returns whether to warn about deprecation.
+    def deprecate?
+      @deprecate != false
+    end
+
+    # Reset to default configuration.
+    def reset_config!
+      self.log = true
+      self.logger = ::Logger.new STDOUT
+      self.log_level = :debug
+      self.raise_errors = true
+      self.soap_version = SOAP::DefaultVersion
+      self.strip_namespaces = true
+      self.env_namespace = nil
+      self.soap_header = {}
+      self.log_filter = ''
+    end
+
+  end
+end
+

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/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 ||= Nori.parse(http.body)[:envelope][: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,71 @@
+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
+      # to execute a SOAP request and returns the response.
+      def self.execute(request, soap)
+        new(request, soap).response
+      end
+
+      # 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)
+        url, body = soap.endpoint, soap.to_xml
+
+        request.url = url
+        request.body = body
+        request.headers["Content-Type"] ||= ContentType[soap.version]
+        request.headers["Content-Length"] ||= body.length.to_s
+
+        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,109 @@
+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
+
+      # Shortcut accessor for the SOAP response body Hash.
+      def [](key)
+        body[key]
+      end
+
+      # Returns the SOAP response header as a Hash.
+      def header
+        hash[:envelope][:header]
+      end
+
+      # Returns the SOAP response body as a Hash.
+      def body
+        hash[:envelope][:body]
+      end
+
+      alias to_hash body
+
+      # Traverses the SOAP response body Hash 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 to_array(*path)
+        result = path.inject body do |memo, key|
+          return [] unless memo[key]
+          memo[key]
+        end
+
+        result.kind_of?(Array) ? result.compact : [result].compact
+      end
+
+      # Returns the complete SOAP response XML without normalization.
+      def hash
+        @hash ||= Nori.parse(to_xml)
+      end
+
+      # Returns the SOAP response XML.
+      def to_xml
+        http.body
+      end
+
+      # Returns a <tt>Nokogiri::XML::Document</tt> for the SOAP response XML.
+      def doc
+        @doc ||= Nokogiri::XML(to_xml)
+      end
+
+      # Returns an Array of <tt>Nokogiri::XML::Node</tt> objects retrieved with the given +path+.
+      # Automatically adds all of the document's namespaces unless a +namespaces+ hash is provided.
+      def xpath(path, namespaces = nil)
+        doc.xpath(path, namespaces || xml_namespaces)
+      end
+
+    private
+
+      def raise_errors
+        raise soap_fault if soap_fault?
+        raise http_error if http_error?
+      end
+
+      def xml_namespaces
+        @xml_namespaces ||= doc.collect_namespaces
+      end
+
+    end
+  end
+end