soap5r 2.0.0

data/lib/wsdl/soap/classNameCreator.rb

@@ -0,0 +1,55 @@
+# encoding: ASCII-8BIT
+# WSDL4R - Class name creator.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+
+
+module WSDL
+module SOAP
+
+
+class ClassNameCreator
+  include XSD::CodeGen::GenSupport
+
+  def initialize
+    @classname = {}
+  end
+
+  def assign_name(qname, modulepath = nil)
+    key = [modulepath, qname]
+    unless @classname.key?(key)
+      if klass = ::SOAP::TypeMap[qname]
+        name =
+          ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name
+      else
+        name = safeconstname(qname.name)
+        if modulepath
+          name = [modulepath, name].join('::')
+        end
+        while @classname.value?(name)
+          name += '_'
+        end
+        check_classname(name)
+      end
+      @classname[key] = name.freeze
+    end
+    @classname[key]
+  end
+
+  def check_classname(name)
+    if Object.constants.include?(name)
+      warn("created definition re-opens an existing toplevel class: #{name}.  consider to use --module_path option of wsdl2ruby.rb")
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/clientSkeltonCreator.rb

@@ -0,0 +1,107 @@
+# encoding: ASCII-8BIT
+# WSDL4R - Creating client skelton code from WSDL.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'wsdl/info'
+require 'wsdl/soap/classDefCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+class ClientSkeltonCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions, name_creator, modulepath = nil)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+  end
+
+  def dump(service_name)
+    services = @definitions.service(service_name)
+    unless services
+      raise RuntimeError.new("service not defined: #{service_name}")
+    end
+    result = ""
+    if @modulepath
+      result << "\n"
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above      
+      result << modulepath.collect { |ele| "module #{ele}" }.join("; ")
+      result << "\n\n"
+    end
+    services.ports.each do |port|
+      result << dump_porttype(port.porttype)
+      result << "\n"
+    end
+    if @modulepath
+      result << "\n\n"
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above      
+      result << modulepath.collect { |ele| "end" }.join("; ")
+      result << "\n"
+    end
+    result
+  end
+
+private
+
+  def dump_porttype(porttype)
+    assigned_method = collect_assigned_method(@definitions, porttype.name, @modulepath)
+    drv_name = mapped_class_basename(porttype.name, @modulepath)
+
+    result = ""
+    result << <<__EOD__
+endpoint_url = ARGV.shift
+obj = #{ drv_name }.new(endpoint_url)
+
+# run ruby with -d to see SOAP wiredumps.
+obj.wiredump_dev = STDERR if $DEBUG
+
+__EOD__
+    element_definitions = @definitions.collect_elements
+    binding = porttype.find_binding
+    if binding
+      binding.operations.each do |op_bind|
+        operation = op_bind.find_operation
+        if operation.nil?
+          warn("operation not found for binding: #{op_bind}")
+          next
+        end
+        name = assigned_method[op_bind.boundid] || operation.name
+        result << dump_method_signature(name, operation, element_definitions)
+        result << dump_input_init(operation.input) << "\n"
+        result << dump_operation(name, operation) << "\n\n"
+      end
+    end
+    result
+  end
+
+  def dump_operation(name, operation)
+    input = operation.input
+    "puts obj.#{ safemethodname(name) }#{ dump_inputparam(input) }"
+  end
+
+  def dump_input_init(input)
+    result = input.find_message.parts.collect { |part|
+      safevarname(part.name)
+    }.join(" = ")
+    if result.empty?
+      ""
+    else
+      result << " = nil"
+    end
+    result
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/complexType.rb

@@ -0,0 +1,174 @@
+# encoding: ASCII-8BIT
+# WSDL4R - SOAP complexType definition for WSDL.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'wsdl/xmlSchema/complexType'
+require 'soap/mapping'
+
+
+module WSDL
+module XMLSchema
+
+
+class ComplexType < Info
+  def compoundtype
+    @compoundtype ||= check_type
+  end
+
+  def check_type
+    if have_any?
+      :TYPE_STRUCT
+    elsif content
+      if attributes.empty? and map_as_array?
+        if name == ::SOAP::Mapping::MapQName
+          :TYPE_MAP
+        else
+          :TYPE_ARRAY
+        end
+      else
+	:TYPE_STRUCT
+      end
+    elsif complexcontent
+      complexcontent.check_type
+    elsif simplecontent
+      :TYPE_SIMPLE
+    elsif !attributes.empty?
+      :TYPE_STRUCT
+    else # empty complexType definition (seen in partner.wsdl of salesforce)
+      :TYPE_EMPTY
+    end
+  end
+
+  def child_type(name = nil)
+    case compoundtype
+    when :TYPE_STRUCT
+      if ele = find_element(name)
+        ele.type
+      elsif ele = find_element_by_name(name.name)
+	ele.type
+      end
+    when :TYPE_ARRAY
+      @contenttype ||= content_arytype
+    when :TYPE_MAP
+      item_ele = find_element_by_name("item") or
+        raise RuntimeError.new("'item' element not found in Map definition.")
+      content = item_ele.local_complextype or
+        raise RuntimeError.new("No complexType definition for 'item'.")
+      if ele = content.find_element(name)
+        ele.type
+      elsif ele = content.find_element_by_name(name.name)
+        ele.type
+      end
+    else
+      raise NotImplementedError.new("Unknown kind of complexType.")
+    end
+  end
+
+  def child_defined_complextype(name)
+    ele = nil
+    case compoundtype
+    when :TYPE_STRUCT, :TYPE_MAP
+      unless ele = find_element(name)
+       	if name.namespace.nil?
+  	  ele = find_element_by_name(name.name)
+   	end
+      end
+    when :TYPE_ARRAY
+      e = elements
+      if e.size == 1
+	ele = e[0]
+      else
+	raise RuntimeError.new("Assert: must not reach.")
+      end
+    else
+      raise RuntimeError.new("Assert: Not implemented.")
+    end
+    unless ele
+      raise RuntimeError.new("Cannot find #{name} as a children of #{@name}.")
+    end
+    ele.local_complextype
+  end
+
+  def find_soapenc_arytype
+    unless compoundtype == :TYPE_ARRAY
+      raise RuntimeError.new("Assert: not for array")
+    end
+    if complexcontent
+      if complexcontent.restriction
+        complexcontent.restriction.attributes.each do |attribute|
+          if attribute.ref == ::SOAP::AttrArrayTypeName
+            return attribute.arytype
+          end
+        end
+      end
+    end
+    nil
+  end
+
+  def find_arytype
+    unless compoundtype == :TYPE_ARRAY
+      raise RuntimeError.new("Assert: not for array")
+    end
+    if arytype = find_soapenc_arytype
+      return arytype
+    end
+    if map_as_array?
+      return element_simpletype(elements[0])
+    end
+    raise RuntimeError.new("Assert: Unknown array definition.")
+  end
+
+  def find_aryelement
+    unless compoundtype == :TYPE_ARRAY
+      raise RuntimeError.new("Assert: not for array")
+    end
+    if map_as_array?
+      return nested_elements[0]
+    end
+    nil # use default item name
+  end
+
+private
+
+  def element_simpletype(element)
+    case element
+    when XMLSchema::Element
+      if element.type
+        element.type 
+      elsif element.local_simpletype
+        element.local_simpletype.base
+      else
+        # element definition
+        nil
+      end
+    when XMLSchema::Any
+      XSD::AnyTypeName
+    else
+      nil
+    end
+  end
+
+  def map_as_array?
+    e = nested_elements
+    e.size == 1 and e[0].map_as_array?
+  end
+
+  def content_arytype
+    if arytype = find_arytype
+      ns = arytype.namespace
+      name = arytype.name.sub(/\[(?:,)*\]$/, '')
+      XSD::QName.new(ns, name)
+    else
+      nil
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/data.rb

@@ -0,0 +1,43 @@
+# encoding: ASCII-8BIT
+# WSDL4R - WSDL SOAP binding data definitions.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/qname'
+require 'wsdl/soap/definitions'
+require 'wsdl/soap/binding'
+require 'wsdl/soap/operation'
+require 'wsdl/soap/body'
+require 'wsdl/soap/element'
+require 'wsdl/soap/header'
+require 'wsdl/soap/headerfault'
+require 'wsdl/soap/fault'
+require 'wsdl/soap/address'
+require 'wsdl/soap/complexType'
+
+
+module WSDL
+module SOAP
+
+
+HeaderFaultName = XSD::QName.new(SOAPBindingNamespace, 'headerfault')
+
+LocationAttrName = XSD::QName.new(nil, 'location')
+StyleAttrName = XSD::QName.new(nil, 'style')
+TransportAttrName = XSD::QName.new(nil, 'transport')
+UseAttrName = XSD::QName.new(nil, 'use')
+PartsAttrName = XSD::QName.new(nil, 'parts')
+PartAttrName = XSD::QName.new(nil, 'part')
+NameAttrName = XSD::QName.new(nil, 'name')
+MessageAttrName = XSD::QName.new(nil, 'message')
+EncodingStyleAttrName = XSD::QName.new(nil, 'encodingStyle')
+NamespaceAttrName = XSD::QName.new(nil, 'namespace')
+SOAPActionAttrName = XSD::QName.new(nil, 'soapAction')
+
+
+end
+end

data/lib/wsdl/soap/definitions.rb

@@ -0,0 +1,201 @@
+# encoding: ASCII-8BIT
+# WSDL4R - WSDL additional definitions for SOAP.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'wsdl/info'
+require 'xsd/namedelements'
+require 'soap/mapping'
+
+
+module WSDL
+
+
+class Definitions < Info
+  def self.soap_rpc_complextypes
+    types = XSD::NamedElements.new
+    types << array_complextype
+    types << fault_complextype
+    types << exception_complextype
+    types
+  end
+
+  def self.array_complextype
+    type = XMLSchema::ComplexType.new(::SOAP::ValueArrayName)
+    type.complexcontent = XMLSchema::ComplexContent.new
+    type.complexcontent.restriction = XMLSchema::ComplexRestriction.new
+    type.complexcontent.restriction.base = ::SOAP::ValueArrayName
+    attr = XMLSchema::Attribute.new
+    attr.ref = ::SOAP::AttrArrayTypeName
+    anyarray = XSD::QName.new(
+      XSD::AnyTypeName.namespace,
+      XSD::AnyTypeName.name + '[]')
+    attr.arytype = anyarray
+    type.complexcontent.restriction.attributes << attr
+    type
+  end
+
+=begin
+<xs:complexType name="Fault" final="extension">
+  <xs:sequence>
+    <xs:element name="faultcode" type="xs:QName" /> 
+    <xs:element name="faultstring" type="xs:string" /> 
+    <xs:element name="faultactor" type="xs:anyURI" minOccurs="0" /> 
+    <xs:element name="detail" type="tns:detail" minOccurs="0" /> 
+  </xs:sequence>
+</xs:complexType>
+=end
+  def self.fault_complextype
+    type = XMLSchema::ComplexType.new(::SOAP::EleFaultName)
+    faultcode = XMLSchema::Element.new(::SOAP::EleFaultCodeName, XSD::XSDQName::Type)
+    faultstring = XMLSchema::Element.new(::SOAP::EleFaultStringName, XSD::XSDString::Type)
+    faultactor = XMLSchema::Element.new(::SOAP::EleFaultActorName, XSD::XSDAnyURI::Type)
+    faultactor.minoccurs = 0
+    detail = XMLSchema::Element.new(::SOAP::EleFaultDetailName, XSD::AnyTypeName)
+    detail.minoccurs = 0
+    type.all_elements = [faultcode, faultstring, faultactor, detail]
+    type.final = 'extension'
+    type
+  end
+
+  def self.exception_complextype
+    type = XMLSchema::ComplexType.new(XSD::QName.new(
+	::SOAP::Mapping::RubyCustomTypeNamespace, 'SOAPException'))
+    excn_name = XMLSchema::Element.new(XSD::QName.new(nil, 'excn_type_name'), XSD::XSDString::Type)
+    cause = XMLSchema::Element.new(XSD::QName.new(nil, 'cause'), XSD::AnyTypeName)
+    backtrace = XMLSchema::Element.new(XSD::QName.new(nil, 'backtrace'), ::SOAP::ValueArrayName)
+    message = XMLSchema::Element.new(XSD::QName.new(nil, 'message'), XSD::XSDString::Type)
+    type.all_elements = [excn_name, cause, backtrace, message]
+    type
+  end
+
+  def soap_rpc_complextypes(binding)
+    types = rpc_operation_complextypes(binding)
+    types + self.class.soap_rpc_complextypes
+  end
+
+  def collect_faulttypes
+    result = []
+    collect_fault_messages.each do |name|
+      faultparts = message(name).parts
+      if faultparts.size != 1
+	raise RuntimeError.new("Expecting fault message \"#{name}\" to have ONE part")
+      end
+      fault_part = faultparts[0]
+      # WS-I Basic Profile Version 1.1 (R2205) requires fault message parts 
+      # to refer to elements rather than types
+      faulttype = fault_part.element
+      if not faulttype
+	warn("Fault message \"#{name}\" part \"#{fault_part.name}\" must specify an \"element\" attribute")
+        faulttype = fault_part.type
+      end
+      if faulttype and result.index(faulttype).nil?
+	result << faulttype
+      end
+    end
+    result
+  end
+
+private
+
+  def get_fault_binding(op_binding, fault_name)
+    op_binding.fault.each do |fault|
+      return fault if fault.name == fault_name
+    end
+    return nil
+  end
+
+  def op_binding_declares_fault(op_binding, fault_name)
+    return get_fault_binding(op_binding, fault_name) != nil
+  end
+
+  def collect_fault_messages
+    result = []
+    porttypes.each do |porttype|
+      port_binding = porttype.find_binding()
+      next unless port_binding
+      porttype.operations.each do |operation|
+        op_binding = port_binding.operations.find { |ele| ele.name == operation.name }
+        next unless op_binding
+	operation.fault.each do |fault|
+          # Make sure the operation fault has a name
+          if not fault.name
+            warn("Operation \"#{operation.name}\": fault must specify a \"name\" attribute")
+            next
+          end
+          # Make sure that portType fault has a corresponding soap:fault
+          # definition in binding section.
+          if not op_binding_declares_fault(op_binding, fault.name)
+            warn("Operation \"#{operation.name}\", fault \"#{fault.name}\": no corresponding wsdl:fault binding found with a matching \"name\" attribute")          
+            next
+          end
+          fault_binding = get_fault_binding(op_binding, fault.name)
+          if fault_binding.soapfault.nil?
+            warn("WARNING: no soap:fault found for wsdl:fault \"#{fault_binding.name}\" in operation \"#{operation.name}\" \n\n")
+            next
+          end
+          if fault_binding.soapfault.name != fault_binding.name
+            warn("WARNING: name of soap:fault \"#{fault_binding.soapfault.name}\" doesn't match the name of wsdl:fault \"#{fault_binding.name}\" in operation \"#{operation.name}\" \n\n")
+            next
+          end
+          # According to WS-I (R2723): if in a wsdl:binding the use attribute
+          # on a contained soapbind:fault element is present, its value MUST 
+          # be "literal".          
+          if fault_binding.soapfault.use and fault_binding.soapfault.use != "literal"
+            warn("Operation \"#{operation.name}\", fault \"#{fault.name}\": soap:fault \"use\" attribute must be \"literal\"")          
+          end
+	  if result.index(fault.message).nil?
+	    result << fault.message
+	  end
+	end
+      end
+    end
+    result
+  end
+
+  def rpc_operation_complextypes(binding)
+    types = XSD::NamedElements.new
+    binding.operations.each do |op_bind|
+      if op_bind_rpc?(op_bind)
+	operation = op_bind.find_operation
+	if op_bind.input
+	  type = XMLSchema::ComplexType.new(op_bind.soapoperation_name)
+	  message = messages[operation.input.message]
+	  type.sequence_elements = elements_from_message(message)
+	  types << type
+	end
+	if op_bind.output
+	  type = XMLSchema::ComplexType.new(operation.outputname)
+	  message = messages[operation.output.message]
+	  type.sequence_elements = elements_from_message(message)
+	  types << type
+	end
+      end
+    end
+    types
+  end
+
+  def op_bind_rpc?(op_bind)
+    op_bind.soapoperation_style == :rpc
+  end
+
+  def elements_from_message(message)
+    message.parts.collect { |part|
+      if part.element
+        collect_elements[part.element]
+      elsif part.name.nil? or part.type.nil?
+	raise RuntimeError.new("part of a message must be an element or typed")
+      else
+        qname = XSD::QName.new(nil, part.name)
+        XMLSchema::Element.new(qname, part.type)
+      end
+    }
+  end
+end
+
+
+end

data/lib/wsdl/soap/driverCreator.rb

@@ -0,0 +1,121 @@
+# encoding: ASCII-8BIT
+# WSDL4R - Creating driver code from WSDL.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'wsdl/info'
+require 'wsdl/soap/mappingRegistryCreator'
+require 'wsdl/soap/methodDefCreator'
+require 'wsdl/soap/classDefCreatorSupport'
+require 'xsd/codegen'
+
+
+module WSDL
+module SOAP
+
+
+class DriverCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+  attr_accessor :drivername_postfix
+
+  def initialize(definitions, name_creator, modulepath = nil)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+    @drivername_postfix = ''
+  end
+
+  def dump(porttype = nil)
+    result = "require 'soap/rpc/driver'\n\n"
+    if @modulepath
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above
+      modulepath.each do |name|
+        result << "module #{name}\n"
+      end
+      result << "\n"
+    end
+    if porttype.nil?
+      @definitions.porttypes.each do |type|
+	result << dump_porttype(type.name)
+	result << "\n"
+      end
+    else
+      result << dump_porttype(porttype)
+    end
+    if @modulepath
+      result << "\n"
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above
+      modulepath.each do |name|
+        result << "end\n"
+      end
+    end
+    result
+  end
+
+private
+
+  def dump_porttype(porttype)
+    drivername = porttype.name + @drivername_postfix
+    qname = XSD::QName.new(porttype.namespace, drivername)
+    class_name = mapped_class_basename(qname, @modulepath)
+    defined_const = {}
+    mdcreator = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const)
+    methoddef = mdcreator.dump(porttype)
+    binding = @definitions.bindings.find { |item| item.type == porttype }
+    if binding.nil? or binding.soapbinding.nil?
+      # not bound or not a SOAP binding
+      return ''
+    end
+    address = @definitions.porttype(porttype).locations[0]
+
+    c = XSD::CodeGen::ClassDef.new(class_name, "::SOAP::RPC::Driver")
+    c.def_const("DefaultEndpointUrl", ndq(address))
+    c.def_code <<-EOD
+Methods = [
+#{methoddef.gsub(/^/, "  ")}
+]
+    EOD
+    wsdl_name = @definitions.name ? @definitions.name.name : 'default'
+    mrname = safeconstname(wsdl_name + 'MappingRegistry')
+    c.def_method("initialize", "endpoint_url = nil") do
+      %Q[endpoint_url ||= DefaultEndpointUrl\n] +
+      %Q[super(endpoint_url, nil)\n] +
+      %Q[self.mapping_registry = #{mrname}::EncodedRegistry\n] +
+      %Q[self.literal_mapping_registry = #{mrname}::LiteralRegistry\n] +
+      %Q[init_methods]
+    end
+    c.def_privatemethod("init_methods") do
+      <<-EOD
+        Methods.each do |definitions|
+          opt = definitions.last
+          if opt[:request_style] == :document
+            add_document_operation(*definitions)
+          else
+            add_rpc_operation(*definitions)
+            qname = definitions[0]
+            name = definitions[2]
+            if qname.name != name and qname.name.capitalize == name.capitalize
+              ::SOAP::Mapping.define_singleton_method(self, qname.name) do |*arg|
+                __send__(name, *arg)
+              end
+            end
+          end
+        end
+      EOD
+    end
+    defined_const.each do |ns, tag|
+      c.def_const(tag, dq(ns))
+    end
+    c.dump
+  end
+end
+
+
+end
+end