savon 1.2.0 → 2.0.0

data/README.md

@@ -1,4 +1,4 @@
-Savon [![Build Status](https://secure.travis-ci.org/rubiii/savon.png?branch=master)](http://travis-ci.org/rubiii/savon)
+Savon [![Build Status](https://secure.travis-ci.org/savonrb/savon.png?branch=version2)](http://travis-ci.org/savonrb/savon)
 =====
 
 Heavy metal SOAP client
@@ -6,13 +6,14 @@ Heavy metal 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
-------------
+Version 2
+---------
 
-Savon is available through [Rubygems](http://rubygems.org/gems/savon) and can be installed via:
+Savon 2.0 is almost feature-complete and I would really appreciate your feedback!  
+To get started, add the following line to your Gemfile:
 
-```
-$ gem install savon
+``` ruby
+gem "savon", github: "savonrb/savon", branch: "version2"
 ```
 
 Introduction
@@ -22,14 +23,14 @@ Introduction
 require "savon"
 
 # create a client for your SOAP service
-client = Savon.client("http://service.example.com?wsdl")
+client = Savon.client(wsdl: "http://service.example.com?wsdl")
 
-client.wsdl.soap_actions
+client.operations
 # => [: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 }
+response = client.call(:get_user) do
+  message(user_id: 1)
 end
 
 response.body
@@ -39,4 +40,4 @@ response.body
 Documentation
 -------------
 
-Continue reading at [savonrb.com](http://savonrb.com)
+Continue reading at [savonrb.com](http://savonrb.com/version2.html)

data/Rakefile

@@ -10,11 +10,5 @@ RSpec::Core::RakeTask.new "spec:integration" do |t|
   t.pattern = "spec/integration/**/*_spec.rb"
 end
 
-# http://stackoverflow.com/q/5771758/279024
-task :require_ruby_18 do
-  raise "This must be run on Ruby 1.8" unless RUBY_VERSION =~ /^1\.8/
-end
-task :release => [:require_ruby_18]
-
 task :default => :spec
 task :test => :spec

data/lib/savon.rb

@@ -1,23 +1,25 @@
-require "savon/version"
-require "savon/config"
-require "savon/client"
-require "savon/model"
-
 module Savon
-  extend self
 
-  def client(*args, &block)
-    Client.new(*args, &block)
-  end
+  class Error < RuntimeError; end
+  class InitializationError < Error; end
+  class InvalidResponseError < Error; end
 
-  def configure
-    yield config
+  def self.client(globals = {}, &block)
+    Client.new(globals, &block)
   end
 
-  def config
-    @config ||= Config.default
+  def self.observers
+    @observers ||= []
   end
 
-  attr_writer :config
+  def self.notify_observers(operation_name, builder, globals, locals)
+    observers.inject(nil) do |response, observer|
+      observer.notify(operation_name, builder, globals, locals)
+    end
+  end
 
 end
+
+require "savon/version"
+require "savon/client"
+require "savon/model"

data/lib/savon/block_interface.rb

@@ -0,0 +1,26 @@
+module Savon
+  class BlockInterface
+
+    def initialize(target)
+      @target = target
+    end
+
+    def evaluate(block)
+      if block.arity > 0
+        block.call(@target)
+      else
+        @original = eval("self", block.binding)
+        instance_eval(&block)
+      end
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      @target.send(method, *args, &block)
+    rescue NoMethodError
+      @original.send(method, *args, &block)
+    end
+
+  end
+end

data/lib/savon/builder.rb

@@ -0,0 +1,142 @@
+require "savon/header"
+require "savon/message"
+require "builder"
+require "gyoku"
+
+module Savon
+  class Builder
+
+    SCHEMA_TYPES = {
+      "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+      "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance"
+    }
+
+    SOAP_NAMESPACE = {
+      1 => "http://schemas.xmlsoap.org/soap/envelope/",
+      2 => "http://www.w3.org/2003/05/soap-envelope"
+    }
+
+    def initialize(operation_name, wsdl, globals, locals)
+      @operation_name = operation_name
+
+      @wsdl    = wsdl
+      @globals = globals
+      @locals  = locals
+
+      @types = convert_type_definitions_to_hash
+      @used_namespaces = convert_type_namespaces_to_hash
+    end
+
+    def to_s
+      return @locals[:xml] if @locals.include? :xml
+
+      tag(builder, :Envelope, namespaces) do |xml|
+        tag(xml, :Header) { xml << header.to_s } unless header.empty?
+        tag(xml, :Body)   { xml.tag!(*namespaced_message_tag) { xml << message.to_s } }
+      end
+    end
+
+    private
+
+    def convert_type_definitions_to_hash
+      @wsdl.type_definitions.inject({}) do |memo, (path, type)|
+        memo[path] = type
+        memo
+      end
+    end
+
+    def convert_type_namespaces_to_hash
+      @wsdl.type_namespaces.inject({}) do |memo, (path, uri)|
+        key, value = use_namespace(path, uri)
+        memo[key] = value
+        memo
+      end
+    end
+
+    def use_namespace(path, uri)
+      @internal_namespace_count ||= 0
+
+      unless identifier = namespace_by_uri(uri)
+        identifier = "ins#{@internal_namespace_count}"
+        namespaces["xmlns:#{identifier}"] = uri
+        @internal_namespace_count += 1
+      end
+
+      [path, identifier]
+    end
+
+    def namespaces
+      @namespaces ||= begin
+        namespaces = SCHEMA_TYPES.dup
+        namespaces["xmlns:#{namespace_identifier}"] = @globals[:namespace] || @wsdl.namespace
+
+        key = ["xmlns"]
+        key << env_namespace if env_namespace && env_namespace != ""
+        namespaces[key.join(":")] = SOAP_NAMESPACE[@globals[:soap_version]]
+
+        namespaces
+      end
+    end
+
+    def env_namespace
+      @env_namespace ||= @globals[:env_namespace] || :env
+    end
+
+    def header
+      @header ||= Header.new(@globals, @locals)
+    end
+
+    def namespaced_message_tag
+      return [namespace_identifier, message_tag] unless @used_namespaces[[@operation_name.to_s]]
+      [@used_namespaces[[@operation_name.to_s]], message_tag]
+    end
+
+    def message_tag
+      message_tag = @locals[:message_tag]
+      message_tag ||= @wsdl.soap_input(@operation_name.to_sym) if @wsdl.document?
+      message_tag ||= Gyoku.xml_tag(@operation_name, :key_converter => @globals[:convert_request_keys_to])
+
+      @message_tag = message_tag.to_sym
+    end
+
+    def message
+      element_form_default = @globals[:element_form_default] || @wsdl.element_form_default
+      # TODO: clean this up! [dh, 2012-12-17]
+      Message.new(@operation_name, namespace_identifier, @types, @used_namespaces, @locals[:message],
+                  element_form_default, @globals[:convert_request_keys_to])
+    end
+
+    def namespace_identifier
+      return @globals[:namespace_identifier] if @globals.include? :namespace_identifier
+      return @namespace_identifier if @namespace_identifier
+
+      operation = @wsdl.operations[@operation_name] if @wsdl.document?
+      namespace_identifier = operation[:namespace_identifier] if operation
+      namespace_identifier ||= "wsdl"
+
+      @namespace_identifier = namespace_identifier.to_sym
+    end
+
+    def namespace_by_uri(uri)
+      namespaces.each do |candidate_identifier, candidate_uri|
+        return candidate_identifier.gsub(/^xmlns:/, '') if candidate_uri == uri
+      end
+      nil
+    end
+
+    def builder
+      builder = ::Builder::XmlMarkup.new
+      builder.instruct!(:xml, :encoding => @globals[:encoding])
+      builder
+    end
+
+    def tag(xml, name, namespaces = {}, &block)
+      if env_namespace && env_namespace != ""
+        xml.tag! env_namespace, name, namespaces, &block
+      else
+        xml.tag! name, namespaces, &block
+      end
+    end
+
+  end
+end

data/lib/savon/client.rb

@@ -1,162 +1,63 @@
-require "wasabi/document"
-require "httpi/request"
-require "akami"
-
-require "savon/soap/xml"
-require "savon/soap/request"
-require "savon/soap/response"
-require "savon/soap/request_builder"
+require "savon/operation"
+require "savon/options"
+require "savon/block_interface"
+require "wasabi"
 
 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)
-      self.config = Savon.config.clone
-      wsdl.document = wsdl_document if wsdl_document
+    def initialize(globals = {}, &block)
+      @globals = GlobalOptions.new(globals)
 
-      process 1, &block if block
-      wsdl.request = http
-    end
+      BlockInterface.new(@globals).evaluate(block) if block
 
-    # Accessor for the <tt>Savon::Config</tt>.
-    attr_accessor :config
+      unless wsdl_or_endpoint_and_namespace_specified?
+        raise_initialization_error!
+      end
 
-    # Returns the <tt>Wasabi::Document</tt>.
-    def wsdl
-      @wsdl ||= Wasabi::Document.new
+      @wsdl = Wasabi::Document.new
+      @wsdl.document  = @globals[:wsdl]      if @globals.include? :wsdl
+      @wsdl.endpoint  = @globals[:endpoint]  if @globals.include? :endpoint
+      @wsdl.namespace = @globals[:namespace] if @globals.include? :namespace
     end
 
-    # Returns the <tt>HTTPI::Request</tt>.
-    def http
-      @http ||= HTTPI::Request.new
-    end
+    attr_reader :globals
 
-    # Returns the <tt>Akami::WSSE</tt> object.
-    def wsse
-      @wsse ||= Akami.wsse
+    def operations
+      raise_missing_wsdl_error! unless @wsdl.document?
+      @wsdl.soap_actions
     end
 
-    # Executes a SOAP request for a given SOAP action. Accepts a +block+ which is evaluated in the
-    # context of the <tt>SOAP::RequestBuilder</tt> object to let you access its +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?
-
-      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
-
-      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
-        WSSE::VerifySignature.new(response.http.body).verify!
-      end
+    def operation(operation_name)
+      Operation.create(operation_name, @wsdl, @globals)
+    end
 
+    def call(operation_name, locals = {}, &block)
+      response = operation(operation_name).call(locals, &block)
+      persist_last_response(response)
       response
     end
 
     private
 
-    # 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 : {}
-      body = attributes.delete(:body)
-      soap_action = attributes.delete(:soap_action)
-
-      namespace_identifier = args.size > 1 ? args.shift.to_sym : nil
-      input = args.first
-
-      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 +instance+.
-    def process(offset = 0, instance = self,  &block)
-      block.arity > 0 ? yield_objects(offset, instance, &block) : evaluate(instance, &block)
+    def persist_last_response(response)
+      @globals[:last_response] = response.http
     end
 
-    # Yields a number of objects to a given +block+ depending on how many arguments
-    # the block is expecting.
-    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) })
+    def wsdl_or_endpoint_and_namespace_specified?
+      @globals.include?(:wsdl) || (@globals.include?(:endpoint) && @globals.include?(:namespace))
     end
 
-    # 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
+    def raise_initialization_error!
+      raise InitializationError,
+            "Expected either a WSDL document or the SOAP endpoint and target namespace options.\n\n" \
+            "Savon.client(wsdl: '/Users/me/project/service.wsdl')                              # to use a local WSDL document\n" \
+            "Savon.client(wsdl: 'http://example.com?wsdl')                                     # to use a remote WSDL document\n" \
+            "Savon.client(endpoint: 'http://example.com', namespace: 'http://v1.example.com')  # if you don't have a WSDL document"
     end
 
-    # Removes all blank values from a given +hash+.
-    def remove_blank_values(hash)
-      hash.delete_if { |_, value| value.respond_to?(:empty?) ? value.empty? : !value }
+    def raise_missing_wsdl_error!
+      raise "Unable to inspect the service without a WSDL document."
     end
 
   end