troelskn-handsoap 0.1.2 → 0.2.0

data/README.markdown

@@ -5,6 +5,10 @@ What
 ---
 Handsoap is a library for creating SOAP clients in Ruby.
 
+[Watch a tutorial](http://www.vimeo.com/4813848), showing how to use Handsoap. The final application can be found at: [http://github.com/troelskn/handsoap-example/tree/master](http://github.com/troelskn/handsoap-example/tree/master)
+
+![Handsoap](http://ny-image0.etsy.com/il_430xN.68558416.jpg)
+
 Why
 ---
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 2
+:minor: 2
+:patch: 0
 :major: 0
-:minor: 1

data/generators/handsoap/handsoap_generator.rb

@@ -1,30 +1,13 @@
-require 'open-uri'
-require 'uri'
-require 'cgi'
-require 'nokogiri'
-
-# TODO: inline builders, if they are only ever used in one place
-
-class Builders
-  def initialize(xsd)
-    @xsd = xsd
-    @builders = {}
-  end
-  def add(type)
-    @builders[type] = false unless @builders[type]
-  end
-  def each
-    results = []
-    while builder = @builders.find { |builder,is_rendered| !is_rendered }
-      results << yield(@xsd.get_complex_type(builder[0]))
-      @builders[builder[0]] = true
-    end
-    results.join("")
-  end
-end
-
-class HandsoapGenerator < Rails::Generator::NamedBase
-  attr_reader :wsdl
+# -*- coding: utf-8 -*-
+require "#{File.dirname(__FILE__)}/../../lib/handsoap/parser.rb"
+require "#{File.dirname(__FILE__)}/../../lib/handsoap/compiler.rb"
+
+# TODO
+# options:
+#   soap_actions (true/false)
+#   soap_version (1/2/auto)
+#   basename
+class HandsoapGenerator < Rails::Generator::Base
   def initialize(runtime_args, runtime_options = {})
     super
     # Wsdl argument is required.
@@ -33,281 +16,70 @@ class HandsoapGenerator < Rails::Generator::NamedBase
   end
 
   def banner
-		"WARNING: This generator is rather incomplete and buggy. Use at your own risk." +
-			"\n" + "Usage: #{$0} #{spec.name} name URI [options]" +
-      "\n" + "  name  Basename of the service class" +
-      "\n" + "  URI   URI of the WSDL to generate from"
+		"Generates the scaffold for a Handsoap binding."+
+      "\n" + "You still have to fill in most of the meat, but this gives you a head start." +
+			"\n" + "Usage: #{$0} #{spec.name} URI" +
+      "\n" + "  URI       URI of the WSDL to generate from"
   end
 
   def manifest
+    wsdl = Handsoap::Parser::Wsdl.read(@wsdl_uri)
+    protocol = wsdl.preferred_protocol
+    file_name = Handsoap::Compiler.service_basename(wsdl)
     record do |m|
-      @wsdl = Handsoap::Wsdl.new(@wsdl_uri)
-      @wsdl.parse!
-      @xsd = Handsoap::XsdSpider.new(@wsdl_uri)
-      @xsd.process!
       m.directory "app"
       m.directory "app/models"
-      @builders = Builders.new(@xsd)
-      m.template "gateway.rbt", "app/models/#{file_name}_service.rb"
-    end
-  end
-
-  def builders
-    @builders
-  end
-
-  def render_build(context_name, message_type, varname = nil, indentation = '    ')
-    if varname.nil?
-      ruby_name = message_type.ruby_name
-    else
-      ruby_name = "#{varname}[:#{message_type.ruby_name}]"
-    end
-    # message_type.namespaces
-    if message_type.attribute?
-      "#{context_name}.set_attr " + '"' + message_type.name + '", ' + ruby_name
-    elsif message_type.boolean?
-      "#{context_name}.add " + '"' + message_type.name + '", bool_to_str(' + ruby_name + ')'
-    elsif message_type.primitive?
-      "#{context_name}.add " + '"' + message_type.name + '", ' + ruby_name
-    elsif message_type.list?
-      list_type = @xsd.get_complex_type(message_type.type)
-      builders.add(list_type.type)
-      # TODO: a naming conflict waiting to happen hereabout
-      # TODO: indentation
-      "#{varname}.each do |#{message_type.ruby_name}|" + "\n" + indentation +
-      "  build_#{list_type.ruby_type}!(#{context_name}, #{message_type.ruby_name})" + "\n" + indentation +
-      "end"
-    else
-      builders.add(message_type.type)
-      "build_#{message_type.ruby_type}!(#{context_name}, " + ruby_name + ")"
-    end
-  end
-
-end
-
-module Handsoap
-
-  class Wsdl
-    attr_reader :uri, :soap_actions, :soap_ports, :target_namespace
-    def initialize(uri)
-      @uri = uri
-    end
-
-    def parse!
-      wsdl = Nokogiri.XML(Kernel.open(@uri).read)
-      @target_namespace = wsdl.namespaces['xmlns:tns'] || wsdl.namespaces['xmlns']
-      @soap_actions = []
-      @soap_ports = []
-      messages = {}
-
-      wsdl.xpath('//wsdl:message').each do |message|
-        message_name = message['name']
-        messages[message_name] = message.xpath('wsdl:part').map { |part| MessageType::Part.new(part['type'] || 'xs:element', part['name']) }
-      end
-
-      wsdl.xpath('//*[name()="soap:operation"]').each do |operation|
-        operation_name = operation.parent['name']
-        operation_spec = wsdl.xpath('//wsdl:operation[@name="' + operation_name + '"]').first
-        raise RuntimeError, "Couldn't find wsdl:operation node for #{operation_name}" if operation_spec.nil?
-        msg_type_in = operation_spec.xpath('./wsdl:input').first["message"]
-        raise RuntimeError, "Couldn't find wsdl:input node for #{operation_name}" if msg_type_in.nil?
-        raise RuntimeError, "Invalid message type #{msg_type_in} for #{operation_name}" if messages[msg_type_in].nil?
-        msg_type_out = operation_spec.xpath('./wsdl:output').first["message"]
-        raise RuntimeError, "Couldn't find wsdl:output node for #{operation_name}" if msg_type_out.nil?
-        raise RuntimeError, "Invalid message type #{msg_type_out} for #{operation_name}" if messages[msg_type_out].nil?
-        @soap_actions << SoapAction.new(operation, messages[msg_type_in], messages[msg_type_out])
+      m.file_contents "app/models/#{file_name}_service.rb" do |file|
+        file.write Handsoap::Compiler.compile_service(wsdl, protocol, :soap_actions)
       end
-      raise RuntimeError, "Could not parse WSDL" if soap_actions.empty?
-
-      wsdl.xpath('//wsdl:port', {"xmlns:wsdl" => 'http://schemas.xmlsoap.org/wsdl/'}).each do |port|
-        name = port['name'].underscore
-        location = port.xpath('./*[@location]').first['location']
-        @soap_ports << { :name => name, :soap_name => port['name'], :location => location }
+      m.directory "tests"
+      m.directory "tests/integration"
+      m.file_contents "tests/integration/#{file_name}_service_test.rb" do |file|
+        file.write Handsoap::Compiler.compile_test(wsdl, protocol)
       end
+      # TODO
+      # Ask user about which endpoints to use ?
+      # puts "Detected endpoints:"
+      # puts Handsoap::Compiler.compile_endpoints(wsdl, protocol)
     end
   end
 
-  class SoapAction
-    attr_reader :input_type, :output_type
-    def initialize(xml_node, input_type, output_type)
-      @xml_node = xml_node
-      @input_type = input_type
-      @output_type = output_type
-    end
-    def name
-      @xml_node.parent['name'].underscore
-    end
-    def soap_name
-      @xml_node.parent['name']
-    end
-    def href
-      @xml_node['soapAction']
-    end
-  end
-
-  module MessageType
+end
 
-    # complex-type is a spec (class), not an element ... (object)
-    # <xs:complexType name="User">
-		#   <xs:annotation>
-    #     <xs:documentation>The element specifies a user</xs:documentation>
-    #   </xs:annotation>
-    #   <xs:attribute name="dn" type="xs:string" use="required"/>
-    # </xs:complexType>
-    class ComplexType
-      def initialize(xml_node)
-        @xml_node = xml_node
-      end
-      def type
-        @xml_node['name']
-      end
-      def ruby_type
-        type.gsub(/^.*:/, "").underscore.gsub(/-/, '_')
-      end
-      def elements
-        @xml_node.xpath('./xs:attribute|./xs:all/xs:element|./xs:sequence').map do |node|
-          case
-            when node.node_name == 'attribute'
-            Attribute.new(node['type'], node['name'])
-            when node.node_name == 'element'
-            Element.new(node['type'], node['name'], []) # TODO: elements.elements
-            when node.node_name == 'sequence'
-            choice_node = node.xpath('./xs:choice').first
-            if choice_node
-              # TODO
-              Attribute.new('xs:choice', 'todo')
-            else
-              entity_node = node.xpath('./xs:element').first
-              Sequence.new(entity_node['type'], entity_node['name'])
-            end
-          else
-            puts node
-            raise "Unknown type #{node.node_name}"
+module Handsoap #:nodoc:
+  module Generator #:nodoc:
+    module Commands #:nodoc:
+      module Create
+        def file_contents(relative_destination, &block)
+          destination = destination_path(relative_destination)
+          temp_file = Tempfile.new("handsoap_generator")
+          temp_file_relative_path = relative_path(temp_file.path, File.expand_path(source_path("/.")))
+          begin
+            yield temp_file
+            temp_file.close
+            return self.file(temp_file_relative_path, relative_destination)
+          ensure
+            temp_file.unlink
           end
         end
-      end
-    end
-
-    class Base
-      attr_reader :type, :name
-      def initialize(type, name)
-        raise "'type' can't be nil" if type.nil?
-        raise "'name' can't be nil" if name.nil?
-        @type = type
-        @name = name
-      end
-      def ruby_type
-        type.gsub(/^.*:/, "").underscore.gsub(/-/, '_')
-      end
-      def ruby_name
-        name.underscore.gsub(/-/, '_')
-      end
-      def attribute?
-        false
-      end
-      def primitive?
-        /^xs:/.match type
-      end
-      def boolean?
-        type == "xs:boolean"
-      end
-      def list?
-        false
-      end
-    end
-
-    # Parts are shallow elements
-    # <wsdl:part name="widget-instance-id" type="xs:int" />
-    class Part < Base
-    end
-
-    # <wsdl:part name="widget-instance-id" type="xs:int" />
-    # <xs:element maxOccurs="1" minOccurs="0" name="description" type="xs:string"/>
-    class Element < Base
-      attr_reader :elements
-      def initialize(type, name, elements = [])
-        super(type, name)
-        @elements = elements
-      end
-    end
-
-    # <xs:attribute name="id" type="xs:int" use="required"/>
-    class Attribute < Base
-      def primitive?
-        true
-      end
-      def attribute?
-        true
-      end
-    end
-
-    # <xs:sequence>
-	  #   <xs:element maxOccurs="unbounded" minOccurs="0" name="widget-area" type="WidgetArea"/>
-	  # </xs:sequence>
-    class Sequence < Base
-      def list?
-        true
-      end
-    end
-  end
-end
-
-module Handsoap
-
-  class XsdSpider
-    def initialize(uri)
-      @queue = []
-      @wsdl_uri = uri
-    end
-
-    def results
-      @queue.map { |element| element[:data] }
-    end
 
-    def get_complex_type(name)
-      # TODO namespace
-      short_name = name.gsub(/^.*:/, "")
-      results.each do |data|
-        search = data[:document].xpath('//xs:complexType[@name="' + short_name + '"]')
-        if search.any?
-          return MessageType::ComplexType.new(search.first)
+        private
+
+        # Convert the given absolute path into a path
+        # relative to the second given absolute path.
+        # http://www.justskins.com/forums/file-relative-path-handling-97116.html
+        def relative_path(abspath, relative_to)
+          path = abspath.split(File::SEPARATOR)
+          rel = relative_to.split(File::SEPARATOR)
+          while (path.length > 0) && (path.first == rel.first)
+            path.shift
+            rel.shift
+          end
+          ('..' + File::SEPARATOR) * rel.length + path.join(File::SEPARATOR)
         end
       end
-      raise "Didn't find '#{name}' (short name #{short_name})"
-    end
-
-    def process!
-      spider_href(@wsdl_uri, nil)
-      while process_next do end
-    end
-
-    private
-
-    def add_href(href, namespace)
-      unless @queue.find { |element| element[:href] == href }
-        @queue << { :href => href, :namespace => namespace, :state => :new, :data => {} }
-      end
-    end
-
-    def process_next
-      next_element = @queue.find { |element| element[:state] == :new }
-      if next_element
-        next_element[:data] = spider_href(next_element[:href], next_element[:namespace])
-        next_element[:state] = :done
-        return true
-      end
-      return false
-    end
-
-    def spider_href(href, namespace)
-      raise "'href' must be a String" if href.nil?
-      xsd = Nokogiri.XML(Kernel.open(href).read)
-      # <xs:include schemaLocation="...xsd"/>
-      # <xs:import namespace="" schemaLocation="...xsd"/>
-      xsd.xpath('//*[@schemaLocation]').each do |inc|
-        add_href(inc['schemaLocation'], inc['namespace'] || namespace)
-      end
-      { :document => xsd, :namespace => namespace }
     end
   end
 end
+
+Rails::Generator::Commands::Create.send :include, Handsoap::Generator::Commands::Create

data/lib/handsoap/compiler.rb

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+module Handsoap
+  module Compiler
+    class CodeWriter
+
+      def initialize
+        @buffer = ""
+        @indentation = 0
+      end
+
+      def begin(text)
+        puts(text)
+        indent
+      end
+
+      def end(str = "end")
+        unindent
+        puts(str)
+      end
+
+      def puts(text = "")
+        @buffer << text.gsub(/^(.*)$/, ("  " * @indentation) + "\\1")
+        @buffer << "\n" # unless @buffer.match(/\n$/)
+      end
+
+      def indent
+        @indentation = @indentation + 1
+      end
+
+      def unindent
+        @indentation = @indentation - 1
+      end
+
+      def to_s
+        @buffer
+      end
+    end
+
+    def self.write
+      writer = CodeWriter.new
+      yield writer
+      writer.to_s
+    end
+
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+
+    def self.camelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) {
+        "::" + $1.upcase
+      }.gsub(/(^|_)(.)/) {
+        $2.upcase
+      }
+    end
+
+    def self.method_name(operation)
+      if operation.name.match /^(get|find|select|fetch)/i
+        "#{underscore(operation.name)}"
+      else
+        "#{underscore(operation.name)}!"
+      end
+    end
+
+    def self.service_basename(wsdl)
+      wsdl.service.gsub(/service$/, "")
+    end
+
+    def self.service_name(wsdl)
+      camelize(service_basename(wsdl)) + "Service"
+    end
+
+    def self.endpoint_name(wsdl)
+      "#{service_basename(wsdl).upcase}_SERVICE_ENDPOINT"
+    end
+
+    def self.detect_protocol(wsdl)
+      if endpoints.select { |endpoint| endpoint.protocol == :soap12 }.any?
+        :soap12
+      elsif endpoints.select { |endpoint| endpoint.protocol == :soap11 }.any?
+        :soap11
+      else
+        raise "Can't find any soap 1.1 or soap 1.2 endpoints"
+      end
+    end
+
+    def self.compile_endpoints(wsdl, protocol)
+      version = protocol == :soap12 ? 2 : 1
+      wsdl.endpoints.select { |endpoint| endpoint.protocol == protocol }.map do |endpoint|
+        write do |w|
+          w.puts "# wsdl: #{wsdl.url}"
+          w.begin "#{endpoint_name(wsdl)} = {"
+          w.puts ":uri => '#{endpoint.url}',"
+          w.puts ":version => #{version}"
+          w.end "}"
+        end
+      end
+    end
+
+    def self.compile_service(wsdl, protocol, *options)
+      binding = wsdl.bindings.find { |b| b.protocol == protocol }
+      raise "Can't find binding for requested protocol (#{protocol})" unless binding
+      write do |w|
+        w.puts "# -*- coding: utf-8 -*-"
+        w.puts "require 'handsoap'"
+        w.puts
+        w.begin "class #{service_name(wsdl)} < Handsoap::Service"
+        w.puts "endpoint #{endpoint_name(wsdl)}"
+        w.begin "on_create_document do |doc|"
+        w.puts "doc.alias 'tns', '#{wsdl.target_ns}'"
+        w.end
+        w.puts
+        w.puts "# public methods"
+        wsdl.interface.operations.each do |operation|
+          action = binding.actions.find { |a| a.name == operation.name }
+          raise "Can't find action for operation #{operation.name}" unless action
+          w.puts
+          w.begin "def #{method_name(operation)}"
+          # TODO allow :soap_action => :none
+          if operation.name != action.soap_action && options.include?(:soap_actions)
+            w.puts "soap_action = '#{action.soap_action}'"
+            maybe_soap_action = ", soap_action"
+          else
+            maybe_soap_action = ""
+          end
+          w.begin((operation.output ? 'response = ' : '') + "invoke('tns:#{operation.name}'#{maybe_soap_action}) do |message|")
+          w.puts 'raise "TODO"'
+          w.end
+          w.end
+        end
+        w.puts
+        w.puts "private"
+        w.puts "# helpers"
+        w.puts "# TODO"
+        w.end
+      end
+    end
+
+    def self.compile_test(wsdl, protocol)
+      binding = wsdl.bindings.find { |b| b.protocol == protocol }
+      raise "Can't find binding for requested protocol (#{protocol})" unless binding
+      write do |w|
+        w.puts "# -*- coding: utf-8 -*-"
+        w.puts "require 'test_helper'"
+        w.puts
+        w.puts "# #{service_name(wsdl)}.logger = $stdout"
+        w.puts
+        w.begin "class #{service_name(wsdl)}Test < Test::Unit::TestCase"
+        wsdl.interface.operations.each do |operation|
+          w.puts
+          w.begin "def test_#{underscore(operation.name)}"
+          w.puts "result = #{service_name(wsdl)}.#{method_name(operation)}"
+          w.end
+        end
+        w.end
+      end
+    end
+  end
+end

data/lib/handsoap/parser.rb

@@ -0,0 +1,219 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'open-uri'
+require 'uri'
+require 'nokogiri'
+
+module Handsoap
+  module Parser
+    class Interface
+      attr_accessor :name, :operations
+
+      def initialize(name, operations = [])
+        @name = name
+        @operations = operations || []
+      end
+    end
+
+    class Binding
+      attr_accessor :name, :protocol, :interface, :transport, :style, :encoding, :verb, :actions
+
+      def initialize(name, optional = {})
+        @name = name
+        @actions = optional[:actions] || []
+        @protocol = optional[:protocol]
+        @interface = optional[:interface]
+        @transport = optional[:transport]
+        @style = optional[:style]
+        @encoding = optional[:encoding]
+        @verb = optional[:verb]
+      end
+    end
+
+    class Endpoint
+      attr_accessor :name, :protocol, :binding, :url
+
+      def initialize(name, protocol, binding, url)
+        @name = name
+        @protocol = protocol
+        @binding = binding
+        @url = url
+      end
+    end
+
+    class Operation
+      attr_accessor :name, :input, :output
+
+      def initialize(name, optional = {})
+        @name = name
+        @input = optional[:input]
+        @output = optional[:output]
+      end
+    end
+
+    class Action
+      attr_accessor :name, :soap_action, :location
+
+      def initialize(name, optional = {})
+        @name = name
+        @soap_action = optional[:soap_action]
+        @location = optional[:location]
+      end
+    end
+
+    class Wsdl
+      attr_reader :url
+
+      def initialize(doc, url = "void://")
+        @doc = doc
+        @url = url
+      end
+
+      def self.read(url)
+        self.new(Nokogiri.XML(Kernel.open(url).read), url)
+      end
+
+      def ns
+        {
+          'wsdl1' => "http://schemas.xmlsoap.org/wsdl/",
+          'wsdl2' => "http://www.w3.org/ns/wsdl/",
+          'soap11' => "http://schemas.xmlsoap.org/wsdl/soap/",
+          'soap12' => "http://schemas.xmlsoap.org/wsdl/soap12/",
+          'http' => "http://schemas.xmlsoap.org/wsdl/http/"
+        }
+      end
+      private :ns
+
+      def protocol_from_ns(node)
+        case @doc.namespaces["xmlns:#{node.namespace}"]
+        when "http://schemas.xmlsoap.org/wsdl/soap/"
+          :soap11
+        when "http://schemas.xmlsoap.org/wsdl/soap12/"
+          :soap12
+        when "http://schemas.xmlsoap.org/wsdl/http/"
+          :http
+        else
+          raise "Unknown namespace '#{node.namespace}'"
+        end
+      end
+      private :protocol_from_ns
+
+      def is_wsdl2?(node)
+        case @doc.namespaces["xmlns:#{node.namespace}"]
+        when "http://schemas.xmlsoap.org/wsdl/"
+          false
+        when "http://www.w3.org/ns/wsdl/"
+          true
+        else
+          raise "Unknown namespace '#{node.namespace}'"
+        end
+      end
+      private :is_wsdl2?
+
+      def service
+        services = @doc.xpath("//wsdl1:service|//wsdl2:service", ns)
+        raise "Expected exactly 1 service in WSDL" if services.length != 1
+        services[0][:name]
+      end
+
+      def interface
+        tmp = interfaces
+        raise "Expected exactly 1 interface/portType in WSDL" if tmp.length != 1
+        tmp[0]
+      end
+
+      def target_ns
+        @doc.root[:targetNamespace] || raise("Attribute targetNamespace not defined")
+      end
+
+      def preferred_protocol
+        e = endpoints
+        if e.select { |endpoint| endpoint.protocol == :soap12 }.any?
+          :soap12
+        elsif e.select { |endpoint| endpoint.protocol == :soap11 }.any?
+          :soap11
+        else
+          raise "Can't find any soap 1.1 or soap 1.2 endpoints"
+        end
+      end
+
+      def interfaces
+        @doc.xpath("//wsdl1:portType|//wsdl2:interface", ns).map do |port_type|
+          operations = port_type.xpath("./wsdl1:operation|./wsdl2:operation", ns).map do |operation|
+            if is_wsdl2?(operation)
+              input_node = operation.xpath("./wsdl2:input", ns).first
+              input = input_node ? input_node[:element] : nil
+              output_node = operation.xpath("./wsdl2:output", ns).first
+              output = output_node ? output_node[:element] : nil
+            else
+              input_node = operation.xpath("./wsdl1:input", ns).first
+              input = input_node ? input_node[:message] : nil
+              output_node = operation.xpath("./wsdl1:output", ns).first
+              output = output_node ? output_node[:message] : nil
+            end
+            Operation.new(operation[:name], :input => input, :output => output)
+          end
+          Interface.new(port_type[:name], operations)
+        end
+      end
+
+      def endpoints
+        @doc.xpath("//wsdl1:service/wsdl1:port|//wsdl2:service/wsdl2:endpoint", ns).map do |port|
+          binding = port[:binding]
+          if is_wsdl2?(port)
+            location = port[:address]
+            protocol = :binding
+          else
+            address = port.xpath("./soap11:address|./soap12:address|./http:address", ns).first
+            location = address[:location]
+            protocol = protocol_from_ns(address)
+          end
+          Endpoint.new(port[:name], protocol, binding, location)
+        end
+      end
+
+      def bindings
+        @doc.xpath("//wsdl1:binding|//wsdl2:binding", ns).map do |binding|
+          raise "WSDL 2.0 not supported" if is_wsdl2?(binding)
+          soap_binding = binding.xpath("./soap11:binding|./soap12:binding|./http:binding", ns).first
+          protocol = protocol_from_ns(soap_binding)
+          actions = []
+          style = nil
+          encoding = nil
+          actions = binding.xpath("./wsdl1:operation", ns).map do |operation|
+            soap_operation = operation.xpath("./soap11:operation|./soap12:operation|./http:operation", ns).first
+            if soap_operation[:style]
+              raise "Mixed styles not supported" if style && style != soap_operation[:style]
+              style = soap_operation[:style]
+            end
+            xquery = []
+            ['soap11', 'soap12', 'http'].each do |version|
+              ['input', 'output'].each do |message_name|
+                ['header', 'body'].each do |part_name|
+                  xquery << "./wsdl1:#{message_name}/#{version}:#{part_name}"
+                end
+              end
+            end
+            operation.xpath(xquery.join('|'), ns).each do |thing|
+              raise "Mixed encodings not supported" if encoding && encoding != thing[:use]
+              encoding = thing[:use]
+            end
+            Action.new(
+                       operation[:name],
+                       :soap_action => soap_operation[:soapAction],
+                       :location => soap_operation[:location])
+          end
+          Binding.new(
+                      binding[:name],
+                      :protocol => protocol,
+                      :interface => binding[:type],
+                      :transport => soap_binding[:transport],
+                      :style => style,
+                      :encoding => encoding,
+                      :verb => soap_binding[:verb],
+                      :actions => actions)
+        end
+      end
+    end
+  end
+end

data/lib/handsoap/service.rb

@@ -4,6 +4,18 @@ require 'httpclient'
 require 'nokogiri'
 require 'curb'
 require 'handsoap/xml_mason'
+require 'time'
+require 'htmlentities'
+
+# Nokogiri doesn't have a way of getting plain strings out,
+# so this monkeypatch adds that capability ..
+module Utf8StringPatch
+  def to_utf8
+    HTMLEntities.decode_entities(self.serialize('UTF-8'))
+  end
+end
+Nokogiri::XML::Text.send :include, Utf8StringPatch
+Nokogiri::XML::Nodeset.send :include, Utf8StringPatch
 
 module Handsoap
 
@@ -47,10 +59,11 @@ module Handsoap
   end
 
   class Fault < Exception
-    attr_reader :code, :reason
-    def initialize(code, reason)
+    attr_reader :code, :reason, :details
+    def initialize(code, reason, details)
       @code = code
       @reason = reason
+      @details = details
     end
     def to_s
       "Handsoap::Fault { :code => '#{@code}', :reason => '#{@reason}' }"
@@ -68,7 +81,8 @@ module Handsoap
       if reason == ""
         reason = node.xpath('./faultstring/text()', ns).to_s
       end
-      self.new(fault_code, reason)
+      details = node.xpath('./detail/*', ns)
+      self.new(fault_code, reason, details)
     end
   end
 
@@ -87,6 +101,9 @@ module Handsoap
       end
       SOAP_NAMESPACE[@protocol_version]
     end
+    def self.request_content_type
+      @protocol_version == 1 ? "text/xml" : "application/soap+xml"
+    end
     def self.map_method(mapping)
       if @mapping.nil?
         @mapping = {}
@@ -126,23 +143,76 @@ module Handsoap
         super
       end
     end
-    def invoke(action, &block)
-      if action
-        doc = make_envelope do |body|
-          body.add action
-        end
-        if block_given?
-          yield doc.find(action)
-        end
-        dispatch doc
-      end
-    end
+		def invoke(action, options = { :soap_action => :auto }, &block)
+			if action
+				if options.kind_of? String
+					options = { :soap_action => options }
+				end
+				if options[:soap_action] == :auto
+					options[:soap_action] = action.gsub(/^.+:/, "")
+				elsif options[:soap_action] == :none
+					options[:soap_action] = nil
+				end
+				doc = make_envelope do |body|
+					body.add action
+				end
+				if block_given?
+					yield doc.find(action)
+				end
+				dispatch(doc, options[:soap_action])
+			end
+		end
     def on_before_dispatch
     end
     def on_fault(fault)
       raise fault
     end
     private
+    # Helper to serialize a node into a ruby string
+    def xml_to_str(node, xquery = nil)
+      begin
+        n = xquery ? node.xpath(xquery, ns).first : node
+        n.to_utf8
+      rescue Exception => ex
+        nil
+      end
+    end
+    # Helper to serialize a node into a ruby integer
+    def xml_to_int(node, xquery = nil)
+      begin
+        n = xquery ? node.xpath(xquery, ns).first : node
+        n.to_s.to_i
+      rescue Exception => ex
+        nil
+      end
+    end
+    # Helper to serialize a node into a ruby float
+    def xml_to_float(node, xquery = nil)
+      begin
+        n = xquery ? node.xpath(xquery, ns).first : node
+        n.to_s.to_f
+      rescue Exception => ex
+        nil
+      end
+    end
+    # Helper to serialize a node into a ruby boolean
+    def xml_to_bool(node, xquery = nil)
+      begin
+        n = xquery ? node.xpath(xquery, ns).first : node
+        n.to_s == "true"
+      rescue Exception => ex
+        nil
+      end
+    end
+    # Helper to serialize a node into a ruby Time object
+    def xml_to_date(node, xquery = nil)
+      begin
+        n = xquery ? node.xpath(xquery, ns).first : node
+        Time.iso8601(n.to_s)
+      rescue Exception => ex
+        nil
+      end
+    end
     def debug(message = nil)
       if @@logger
         if message
@@ -153,11 +223,12 @@ module Handsoap
         end
       end
     end
-    def dispatch(doc)
+    def dispatch(doc, action)
       on_before_dispatch()
       headers = {
-        "Content-Type" => "text/xml;charset=UTF-8"
+        "Content-Type" => "#{self.class.request_content_type};charset=UTF-8"
       }
+			headers["SOAPAction"] = action unless action.nil?
       body = doc.to_s
       debug do |logger|
         logger.puts "==============="

data/lib/handsoap/xml_mason.rb

@@ -96,6 +96,9 @@ module Handsoap
           yield self
         end
       end
+      def document
+        @parent.respond_to?(:document) ? @parent.document : @parent
+      end
       def full_name
         @prefix.nil? ? @node_name : (@prefix + ":" + @node_name)
       end
@@ -117,6 +120,7 @@ module Handsoap
         @attributes[name] = value
       end
       def find(name)
+        name = name.to_s if name.kind_of? Symbol
         if @node_name == name || full_name == name
           return self
         end
@@ -131,6 +135,7 @@ module Handsoap
         return nil
       end
       def find_all(name)
+        name = name.to_s if name.kind_of? Symbol
         result = []
         if @node_name == name || full_name == name
           result << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: troelskn-handsoap
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors: 
 - Troels Knak-Nielsen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-29 00:00:00 -07:00
+date: 2009-06-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.3.2
     version: 
+- !ruby/object:Gem::Dependency 
+  name: htmlentities
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 4.0.0
+    version: 
 description: Handsoap is a library for creating SOAP clients in Ruby
 email: troelskn@gmail.com
 executables: []
@@ -42,15 +52,16 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - README.markdown
-- Rakefile
 - VERSION.yml
 - generators/handsoap/USAGE
 - generators/handsoap/handsoap_generator.rb
-- generators/handsoap/templates/gateway.rbt
+- generators/handsoap/templates/DUMMY
 - lib/handsoap.rb
+- lib/handsoap/compiler.rb
+- lib/handsoap/parser.rb
 - lib/handsoap/service.rb
 - lib/handsoap/xml_mason.rb
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/troelskn/handsoap
 post_install_message: 
 rdoc_options: 
@@ -74,7 +85,7 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.2.0
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Handsoap is a library for creating SOAP clients in Ruby
 test_files: []
 

data/Rakefile

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "handsoap"
-    gemspec.summary = "Handsoap is a library for creating SOAP clients in Ruby"
-    gemspec.email = "troelskn@gmail.com"
-    gemspec.homepage = "http://github.com/troelskn/handsoap"
-    gemspec.description = gemspec.summary
-    gemspec.authors = ["Troels Knak-Nielsen"]
-    gemspec.add_dependency "nokogiri", ">= 1.2.3"
-    gemspec.add_dependency "curb", ">= 0.3.2"
-#    gemspec.add_dependency "httpclient", ">= 2.1.2"
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end

data/generators/handsoap/templates/gateway.rbt

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'handsoap'
-
-class <%= class_name %>Service < Handsoap::Service
-  endpoint <%= file_name.upcase %>_SERVICE_ENDPOINT
-  on_create_document do |doc|
-    doc.alias 'wsdl', "<%= wsdl.target_namespace %>"
-  end
-<% wsdl.soap_actions.each do |action| %>
-  def <%= action.name %>(<%= action.input_type.map { |message_type| message_type.ruby_name }.join(", ") %>)
-    response = invoke("wsdl:<%= action.soap_name %>") do |context|<% action.input_type.each do |message_type| %>
-      <%= render_build('context', message_type) %><% end %>
-    end
-    response.document.xpath('//*').map { |node| raise "TODO" }
-  end
-<% end %>
-  private
-  # builders
-<% builders.each do |type| %>
-  # <%= type.type %> ruby -> xml
-  def build_<%= type.ruby_type %>!(context, <%= type.ruby_type %>)<% type.elements.each do |element| %>
-    <%= render_build('context', element, type.ruby_type) %><% end %>
-  end
-<% end %>
-  # parsers
-  # TODO
-end