savon 1.1.0 → 1.2.0

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.2.0 (2012-09-15)
+
+* Fix: [#312](https://github.com/rubiii/savon/pull/312) recursively determines the proper namespaces
+  for SOAP body Hashes with nested Arrays of Hashes.
+
+* Improvement: [#318](https://github.com/rubiii/savon/pull/318) isolates building the request to
+  improve threadsafety.
+
+* Refactoring: Use the `Wasabi::Document` with resolver instead of the custom `Savon::Wasabi::Document`.
+
 ## 1.1.0 (2012-06-28)
 
 * Improvement: Changed Savon's core dependencies to be more strict and only allow bug fix changes.
@@ -5,7 +15,7 @@
   This should improve the stability of the library and make it easier to update, because changes
   to these core dependencies will be documented here as well.
 
-* Fix: The latest version of Wasabi should now correctly detect the names of you operations.
+* Fix: The latest version of Wasabi should now correctly detect the names of your operations.
   So you should be able to just get the names of some operation:
 
     ``` ruby
@@ -13,19 +23,19 @@
     # => [:authenticate, :find_user]
     ```
 
-  and pass the Symbol to execute a request:
+    and pass the Symbol to execute a request:
 
     ``` ruby
     client.request :authenticate, body: { token: "secret" }
     ```
 
-  If you still pass anything other than a single Symbol to that method, please open an issue!
-  You shouldn't need to specify a namespace or additional attributes for the tag.
+    If you still pass anything other than a single Symbol to that method, please open an issue!
+    You shouldn't need to specify a namespace or additional attributes for the tag.
 
 * Refactoring: Moved code that sets the cookies from the last response for the
   next request to `HTTPI::Request#set_cookies`.
 
-## 1.0.0 (2012-06-09)
+### 1.0.0 (2012-06-09)
 
 * Fix: `Savon.client` didn't pass the optional block.
 
@@ -34,7 +44,7 @@
   the result of the callback to continue the request. It can also not call the callback block and return
   some `HTTPI::Response` to mock the SOAP request.
 
-  As this change affects `savon_spec`, you need to update `savon_spec` to v1.3.0.
+    As this change affects `savon_spec`, you need to update `savon_spec` to v1.3.0.
 
 ### 0.9.14 (2012-06-07)
 
@@ -99,8 +109,8 @@
   The global config is cloned when a new client is initialized and gets used instead of the global one.
   In addition, for `Savon::Model` classes, the config is cloned per class.
 
-  Closes [#84](https://github.com/rubiii/savon/issues/84) by allowing one logger per client and 
-  [#270](https://github.com/rubiii/savon/issues/270) by allowing to specify error handling per client.
+    Closes [#84](https://github.com/rubiii/savon/issues/84) by allowing one logger per client and 
+    [#270](https://github.com/rubiii/savon/issues/270) by allowing to specify error handling per client.
 
 * Feature: Added an option to pretty print XML in log messages. Closes [#256](https://github.com/rubiii/savon/issues/256)
   and [#280](https://github.com/rubiii/savon/issues/280).
@@ -309,16 +319,16 @@
     Gyoku.xml(:first_name => "Mac")  # => "<FirstName></Firstname>"
     ```
 
-  You can even define your own conversion formular.
+    You can even define your own conversion formular.
 
     ``` ruby
     Gyoku.convert_symbols_to { |key| key.upcase }
     Gyoku.xml(:first_name => "Mac")  # => "<FIRST_NAME></FIRST_NAME>"
     ```
 
-  This should also work for the SOAP input tag and SOAPAction header. So if you had to use a String for
-  the SOAP action to call because your services uses CamelCase instead of lowerCamelCase, you can now
-  change the default and use Symbols instead.
+    This should also work for the SOAP input tag and SOAPAction header. So if you had to use a String for
+    the SOAP action to call because your services uses CamelCase instead of lowerCamelCase, you can now
+    change the default and use Symbols instead.
 
     ``` ruby
     Gyoku.convert_symbols_to(:camelcase)
@@ -382,25 +392,31 @@
 
 * Changed `Savon::WSSE` to be based on a Hash instead of relying on builder ([4cebc3](https://github.com/rubiii/savon/commit/4cebc3)).
 
-  `Savon::WSSE` now supports wsse:Timestamp headers ([issue #122](https://github.com/rubiii/savon/issues/122)) by setting
-  `Savon::WSSE#timestamp` to `true`:
+    `Savon::WSSE` now supports wsse:Timestamp headers ([issue #122](https://github.com/rubiii/savon/issues/122)) by setting
+    `Savon::WSSE#timestamp` to `true`:
 
-      client.request :some_method do
-        wsse.timestamp = true
-      end
+    ``` ruby
+    client.request :some_method do
+      wsse.timestamp = true
+    end
+    ```
 
-   or by setting `Savon::WSSE#created_at` or `Savon::WSSE#expires_at`:
+     or by setting `Savon::WSSE#created_at` or `Savon::WSSE#expires_at`:
 
-      client.request :some_method do
-        wsse.created_at = Time.now
-        wsse.expires_at = Time.now + 60
-      end
+    ``` ruby
+    client.request :some_method do
+      wsse.created_at = Time.now
+      wsse.expires_at = Time.now + 60
+    end
+    ```
 
-  You can also add custom tags to the WSSE header ([issue #69](https://github.com/rubiii/savon/issues/69)):
+    You can also add custom tags to the WSSE header ([issue #69](https://github.com/rubiii/savon/issues/69)):
 
-      client.request :some_method do
-        wsse["wsse:Security"]["wsse:UsernameToken"] = { "Organization" => "ACME", "Domain" => "acme.com" }
-      end
+    ``` ruby
+    client.request :some_method do
+      wsse["wsse:Security"]["wsse:UsernameToken"] = { "Organization" => "ACME", "Domain" => "acme.com" }
+    end
+    ```
 
 ### 0.8.1 (2010-12-22)
 
@@ -430,8 +446,10 @@
   ([6df6a6](https://github.com/rubiii/savon/commit/6df6a6)). The method now accepts multiple arguments representing the response
   Hash keys to traverse and returns the result as an Array or an empty Array in case the key is nil or does not exist.
 
-      response.to_array :get_user_response, :return
-      # => [{ :id => 1, :name => "foo"}, { :id => 2, :name => "bar"}]
+    ``` ruby
+    response.to_array :get_user_response, :return
+    # => [{ :id => 1, :name => "foo"}, { :id => 2, :name => "bar"}]
+    ```
 
 ### 0.8.0.beta.3 (2010-11-06)
 
@@ -444,6 +462,7 @@
   the SOAP response Hash when a pattern (specified as an Array of Regexps and Symbols) matches the response. If for example
   your response always looks like ".+Response/return" as in:
 
+    ``` xml
       <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
         <soap:Body>
           <ns2:authenticateResponse xmlns:ns2="http://v1_0.ws.user.example.com">
@@ -453,23 +472,30 @@
           </ns2:authenticateResponse>
         </soap:Body>
       </soap:Envelope>
+    ```
 
-  you could set the response pattern to:
+    you could set the response pattern to:
 
-      Savon.configure do |config|
-        config.response_pattern = [/.+_response/, :return]
-      end
+    ``` ruby
+    Savon.configure do |config|
+      config.response_pattern = [/.+_response/, :return]
+    end
+    ```
 
-  then instead of calling:
+    then instead of calling:
 
-      response.to_hash[:authenticate_response][:return]  # :some => "thing"
+    ``` ruby
+    response.to_hash[:authenticate_response][:return]  # :some => "thing"
+    ```
 
-  to get the actual content, Savon::SOAP::Response#to_hash will try to apply given the pattern:
+    to get the actual content, Savon::SOAP::Response#to_hash will try to apply given the pattern:
 
-      response.to_hash  # :some => "thing"
+    ``` ruby
+    response.to_hash  # :some => "thing"
+    ```
 
-  Please notice, that if you don't specify a response pattern or if the pattern doesn't match the
-  response, Savon will behave like it always did.
+    Please notice, that if you don't specify a response pattern or if the pattern doesn't match the
+    response, Savon will behave like it always did.
 
 * Added `Savon::SOAP::Response#to_array` (which also uses the response pattern).
 
@@ -478,42 +504,52 @@
 * Changed `Savon::Client.new` to accept a block instead of multiple Hash arguments. You can access the
   wsdl, http and wsse objects inside the block to configure your client for a particular service.
 
-			# Instantiating a client to work with a WSDL document
-      client = Savon::Client.new do
-        wsdl.document = "http://example.com?wsdl"
-      end
+    ``` ruby
+    # Instantiating a client to work with a WSDL document
+    client = Savon::Client.new do
+      wsdl.document = "http://example.com?wsdl"
+    end
+    ```
 
-			# Directly accessing the SOAP endpoint
-			client = Savon::Client.new do
-        wsdl.endpoint = "http://example.com"
-        wsdl.namespace = "http://v1.example.com"
-      end
+    ``` ruby
+    # Directly accessing the SOAP endpoint
+    client = Savon::Client.new do
+      wsdl.endpoint = "http://example.com"
+      wsdl.namespace = "http://v1.example.com"
+    end
+    ```
 
 * Fix for [issue #77](https://github.com/rubiii/savon/issues/77), which means you can now use
   local WSDL documents:
 
-      client = Savon::Client.new do
-        wsdl.document = "../wsdl/service.xml"
-      end
+    ``` ruby
+    client = Savon::Client.new do
+      wsdl.document = "../wsdl/service.xml"
+    end
+    ```
 
 * Changed the way SOAP requests are being dispatched. Instead of using method_missing, you now use
   the new `request` method, which also accepts a block for you to access the wsdl, http, wsse and
   soap object. Please notice, that a new soap object is created for every request. So you can only
   access it inside this block.
 
-      # A simple request to an :authenticate method
-      client.request :authenticate do
-        soap.body = { :id => 1 }
-      end
+    ``` ruby
+    # A simple request to an :authenticate method
+    client.request :authenticate do
+      soap.body = { :id => 1 }
+    end
+    ```
 
 * The new `Savon::Client#request` method fixes issues [#37](https://github.com/rubiii/savon/issues/37),
   [#61](https://github.com/rubiii/savon/issues/61) and [#64](https://github.com/rubiii/savon/issues/64),
   which report problems with namespacing the SOAP input tag and attaching attributes to it.
   Some usage examples:
 
-      client.request :get_user                  # Input tag: <getUser>
-      client.request :wsdl, "GetUser"           # Input tag: <wsdl:GetUser>
-      client.request :get_user :active => true  # Input tag: <getUser active="true">
+    ``` ruby
+    client.request :get_user                  # Input tag: <getUser>
+    client.request :wsdl, "GetUser"           # Input tag: <wsdl:GetUser>
+    client.request :get_user :active => true  # Input tag: <getUser active="true">
+    ```
 
 * Savon's new `request` method respects the given namespace. If you don't give it a namespace,
   Savon will set the target namespace to "xmlns:wsdl". But if you do specify a namespace, it will
@@ -571,13 +607,17 @@
 * Added support for gzipped requests and responses (http://github.com/lucascs). While gzipped SOAP
   responses are decoded automatically, you have to manually instruct Savon to gzip SOAP requests:
 
-      client = Savon::Client.new "http://example.com/UserService?wsdl", :gzip => true
+    ``` ruby
+    client = Savon::Client.new "http://example.com/UserService?wsdl", :gzip => true
+    ```
 
 * Fix for [issue #51](https://github.com/rubiii/savon/issues/51). Added the :soap_endpoint option to
   `Savon::Client.new` which lets you specify a SOAP endpoint per client instance:
 
-      client = Savon::Client.new "http://example.com/UserService?wsdl",
-        :soap_endpoint => "http://localhost/UserService"
+    ``` ruby
+    client = Savon::Client.new "http://example.com/UserService?wsdl",
+      :soap_endpoint => "http://localhost/UserService"
+    ```
 
 * Fix for [issue #50](https://github.com/rubiii/savon/issues/50). Savon still escapes special characters
   in SOAP request Hash values, but you can now append an exclamation mark to Hash keys specifying that
@@ -667,28 +707,38 @@ Pay attention to the following list and read the updated Wiki: http://wiki.githu
 
   * SSL client authentication needs to be defined directly on the `Net::HTTP` object:
 
+      ``` ruby
       client.request.http.client_cert = ...
+      ```
 
     I added a shortcut method for setting all options through a Hash similar to the previous implementation:
 
+      ``` ruby
       client.request.http.ssl_client_auth :client_cert => ...
+      ```
 
   * Open and read timeouts also need to be set on the `Net::HTTP` object:
-  
+
+      ``` ruby
       client.request.http.open_timeout = 30
       client.request.http.read_timeout = 30
+      ```
 
   * Please refer to the `Net::HTTP` documentation for more details:
     http://www.ruby-doc.org/stdlib/libdoc/net/http/rdoc/index.html
 
 * Thanks to JulianMorrison, Savon now supports HTTP basic authentication:
 
+    ``` ruby
     client.request.http.basic_auth "username", "password"
+    ```
 
 * Julian also added a way to explicitly specify the order of Hash keys and values, so you should now be able
   to work with services requiring a specific order of input parameters while still using Hash input.
 
-      client.find_user { |soap| soap.body = { :name => "Lucy", :id => 666, :@inorder => [:id, :name] } }
+    ``` ruby
+    client.find_user { |soap| soap.body = { :name => "Lucy", :id => 666, :@inorder => [:id, :name] } }
+    ```
 
 * `Savon::Response#to_hash` now returns the content inside of "soap:Body" instead of trying to go one
   level deeper and return it's content. The previous implementation only worked when the "soap:Body" element
@@ -696,7 +746,9 @@ Pay attention to the following list and read the updated Wiki: http://wiki.githu
 
 * Added `Savon::SOAP#namespace` as a shortcut for setting the "xmlns:wsdl" namespace.
 
+    ``` ruby
     soap.namespace = "http://example.com"
+    ```
 
 ### 0.6.8 (2010-01-01)
 
@@ -709,9 +761,11 @@ Pay attention to the following list and read the updated Wiki: http://wiki.githu
   please take a look at the `action` and `input` methods of the `Savon::SOAP` object.
   One specific problem I know of is working with the createsend WSDL and its namespaced actions.
 
-  To make it work, call the SOAP action without namespace and specify the input manually:
+    To make it work, call the SOAP action without namespace and specify the input manually:
 
+    ``` ruby
       client.get_api_key { |soap| soap.input = "User.GetApiKey" }
+    ```
 
 ### 0.6.7 (2009-12-18)
 
@@ -743,11 +797,13 @@ Pay attention to the following list and read the updated Wiki: http://wiki.githu
 
 * Replaced WSDL document with stream parsing.
 
-    Benchmarks (1000 SOAP calls):
+    ```
+      Benchmarks (1000 SOAP calls):
     
-           user        system     total       real
-    0.6.4  72.180000   8.280000   80.460000   (750.799011)
-    0.6.3  192.900000  19.630000  212.530000  (914.031865)
+             user        system     total       real
+      0.6.4  72.180000   8.280000   80.460000   (750.799011)
+      0.6.3  192.900000  19.630000  212.530000  (914.031865)
+    ```
 
 ### 0.6.3 (2009-12-11)
 
@@ -755,19 +811,23 @@ Pay attention to the following list and read the updated Wiki: http://wiki.githu
 
 * Added global and per request options for disabling `Savon::WSDL`.
 
+    ```
     Benchmarks (1000 SOAP calls):
     
                    user        system     total       real
     WSDL           192.900000  19.630000  212.530000  (914.031865)
     disabled WSDL  5.680000    1.340000   7.020000    (298.265318)
+    ```
 
 * Improved XPath expressions for parsing the WSDL document.
 
+    ```
     Benchmarks (1000 SOAP calls):
     
            user        system     total       real
     0.6.3  192.900000  19.630000  212.530000  (914.031865)
     0.6.2  574.720000  78.380000  653.100000  (1387.778539)
+    ```
 
 ### 0.6.2 (2009-12-06)
 

data/lib/savon/client.rb

@@ -1,10 +1,11 @@
+require "wasabi/document"
 require "httpi/request"
 require "akami"
 
-require "savon/wasabi/document"
 require "savon/soap/xml"
 require "savon/soap/request"
 require "savon/soap/response"
+require "savon/soap/request_builder"
 
 module Savon
 
@@ -40,7 +41,7 @@ module Savon
     # Accessor for the <tt>Savon::Config</tt>.
     attr_accessor :config
 
-    # Returns the <tt>Savon::Wasabi::Document</tt>.
+    # Returns the <tt>Wasabi::Document</tt>.
     def wsdl
       @wsdl ||= Wasabi::Document.new
     end
@@ -55,13 +56,9 @@ module Savon
       @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.
+    # context of the <tt>SOAP::RequestBuilder</tt> object to let you access its +soap+, +wsdl+,
+    # +http+ and +wsse+ methods.
     #
     # == Examples
     #
@@ -76,12 +73,17 @@ module Savon
     def request(*args, &block)
       raise ArgumentError, "Savon::Client#request requires at least one argument" if args.empty?
 
-      self.soap = SOAP::XML.new(config)
-      preconfigure extract_options(args)
-      process &block if block
-      soap.wsse = wsse
+      options = extract_options(args)
+
+      request_builder = SOAP::RequestBuilder.new(options.delete(:input), options)
+      request_builder.wsdl = wsdl
+      request_builder.http = http.dup
+      request_builder.wsse = wsse.dup
+      request_builder.config = config.dup
 
-      response = SOAP::Request.new(config, http, soap).response
+      post_configuration = lambda { process(0, request_builder, &block) if block }
+
+      response = request_builder.request(&post_configuration).response
       http.set_cookies(response.http)
 
       if wsse.verify_response
@@ -93,91 +95,68 @@ module Savon
 
     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
-
-    # 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).
+    # Expects an Array of +args+ and returns a Hash containing the SOAP input,
+    # the namespace (might be +nil+), the SOAP action (might be +nil+),
+    # the SOAP body (might be +nil+), 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
+      body = attributes.delete(:body)
+      soap_action = attributes.delete(:soap_action)
 
-      [namespace, input, attributes]
-    end
-
-    # Expects an Array of +args+ to preconfigure the system.
-    def preconfigure(args)
-      soap.endpoint = wsdl.endpoint
-      soap.element_form_default = wsdl.element_form_default
-
-      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
-
-      soap_action = args[2].delete(:soap_action) || args[1]
-      set_soap_action soap_action
-
-      if wsdl.document? && (operation = wsdl.operations[args[1]]) && operation[:namespace_identifier]
-        soap.namespace_identifier = operation[:namespace_identifier].to_sym
-        soap.namespace = wsdl.parser.namespaces[soap.namespace_identifier.to_s]
-
-        # Override nil namespace with one specified in WSDL
-        args[0] = soap.namespace_identifier unless args[0]
-      else
-        soap.namespace_identifier = args[0]
-        soap.namespace = wsdl.namespace
-      end
-
-      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
+      namespace_identifier = args.size > 1 ? args.shift.to_sym : nil
+      input = args.first
 
-    # 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]
+      remove_blank_values(
+        :namespace_identifier => namespace_identifier,
+        :input                => input,
+        :attributes           => attributes,
+        :body                 => body,
+        :soap_action          => soap_action
+      )
     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)
+    # Otherwise evaluates the block in the context of +instance+.
+    def process(offset = 0, instance = self,  &block)
+      block.arity > 0 ? yield_objects(offset, instance, &block) : evaluate(instance, &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]
+    def yield_objects(offset, instance, &block)
+      to_yield = [:soap, :wsdl, :http, :wsse]
+      yield *(to_yield[offset, block.arity].map { |obj_name| instance.send(obj_name) })
     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
+    # Evaluates a given +block+ inside +instance+. Stores the original block binding.
+    def evaluate(instance, &block)
+      original_self = eval "self", block.binding
+
+      # A proxy that attemps to make method calls on +instance+. If a NoMethodError is
+      # raised, the call will be made on +original_self+.
+      proxy = Object.new
+      proxy.instance_eval do
+        class << self
+          attr_accessor :original_self, :instance
+        end
+
+        def method_missing(method, *args, &block)
+          instance.send(method, *args, &block)
+        rescue NoMethodError
+          original_self.send(method, *args, &block)
+        end
+      end
+
+      proxy.instance = instance
+      proxy.original_self = original_self
+
+      proxy.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
+    # Removes all blank values from a given +hash+.
+    def remove_blank_values(hash)
+      hash.delete_if { |_, value| value.respond_to?(:empty?) ? value.empty? : !value }
     end
 
   end