soap4r 1.5.5.20061022

data/lib/wsdl/soap/classDefCreatorSupport.rb

@@ -0,0 +1,131 @@
+# WSDL4R - Creating class code support from WSDL.
+# Copyright (C) 2004  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 'soap/mapping'
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+
+
+module WSDL
+module SOAP
+
+
+module ClassDefCreatorSupport
+  include XSD::CodeGen::GenSupport
+
+  def create_class_name(qname, modulepath = nil)
+    if klass = basetype_mapped_class(qname)
+      ::SOAP::Mapping::DefaultRegistry.find_mapped_obj_class(klass).name
+    else
+      name = safeconstname(qname.name)
+      if modulepath
+        [modulepath, name].join('::')
+      else
+        name
+      end
+    end
+  end
+
+  def basetype_mapped_class(name)
+    ::SOAP::TypeMap[name]
+  end
+
+  def dump_method_signature(operation)
+    name = operation.name
+    input = operation.input
+    output = operation.output
+    fault = operation.fault
+    signature = "#{ name }#{ dump_inputparam(input) }"
+    str = <<__EOD__
+# SYNOPSIS
+#   #{name}#{dump_inputparam(input)}
+#
+# ARGS
+#{dump_inout_type(input).chomp}
+#
+# RETURNS
+#{dump_inout_type(output).chomp}
+#
+__EOD__
+    unless fault.empty?
+      faultstr = (fault.collect { |f| dump_inout_type(f).chomp }).join(', ')
+      str <<<<__EOD__
+# RAISES
+#   #{faultstr}
+#
+__EOD__
+    end
+    str
+  end
+
+  def dq(ele)
+    ele.dump
+  end
+
+  def ndq(ele)
+    ele.nil? ? 'nil' : dq(ele)
+  end
+
+  def sym(ele)
+    ':' + ele
+  end
+
+  def dqname(qname)
+    qname.dump
+  end
+
+private
+
+  def dump_inout_type(param)
+    if param
+      message = param.find_message
+      params = ""
+      message.parts.each do |part|
+        name = safevarname(part.name)
+        if part.type
+          typename = safeconstname(part.type.name)
+          params << add_at("#   #{name}", "#{typename} - #{part.type}\n", 20)
+        elsif part.element
+          typename = safeconstname(part.element.name)
+          params << add_at("#   #{name}", "#{typename} - #{part.element}\n", 20)
+        end
+      end
+      unless params.empty?
+        return params
+      end
+    end
+    "#   N/A\n"
+  end
+
+  def dump_inputparam(input)
+    message = input.find_message
+    params = ""
+    message.parts.each do |part|
+      params << ", " unless params.empty?
+      params << safevarname(part.name)
+    end
+    if params.empty?
+      ""
+    else
+      "(#{ params })"
+    end
+  end
+
+  def add_at(base, str, pos)
+    if base.size >= pos
+      base + ' ' + str
+    else
+      base + ' ' * (pos - base.size) + str
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/clientSkeltonCreator.rb

@@ -0,0 +1,93 @@
+# WSDL4R - Creating client skelton code from WSDL.
+# Copyright (C) 2002, 2003, 2006  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, modulepath = nil)
+    @definitions = definitions
+    @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"
+      result << @modulepath.collect { |ele| "module #{ele}" }.join("; ")
+      result << "\n\n"
+    end
+    services.ports.each do |port|
+      result << dump_porttype(port.porttype.name)
+      result << "\n"
+    end
+    if @modulepath
+      result << "\n\n"
+      result << @modulepath.collect { |ele| "end" }.join("; ")
+      result << "\n"
+    end
+    result
+  end
+
+private
+
+  def dump_porttype(name)
+    drv_name = create_class_name(name)
+
+    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__
+    @definitions.porttype(name).operations.each do |operation|
+      result << dump_method_signature(operation)
+      result << dump_input_init(operation.input) << "\n"
+      result << dump_operation(operation) << "\n\n"
+    end
+    result
+  end
+
+  def dump_operation(operation)
+    name = operation.name
+    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,166 @@
+# WSDL4R - SOAP complexType definition for WSDL.
+# Copyright (C) 2002, 2003  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
+      e = elements
+      if attributes.empty? and e.size == 1 and e[0].maxoccurs != '1'
+        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_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
+    if check_array_content
+      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 check_array_content
+      return 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 check_array_content
+    e = elements
+    e.size == 1 and e[0].maxoccurs != '1'
+    # content and content.elements.size == 1 and
+    #   content.elements[0].maxoccurs != '1'
+  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,42 @@
+# WSDL4R - WSDL SOAP binding data definitions.
+# Copyright (C) 2002, 2003  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,151 @@
+# WSDL4R - WSDL additional definitions for SOAP.
+# Copyright (C) 2002-2005  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 to have only 1 part")
+      end
+      if result.index(faultparts[0].type).nil?
+	result << faultparts[0].type
+      end
+    end
+    result
+  end
+
+private
+
+  def collect_fault_messages
+    result = []
+    porttypes.each do |porttype|
+      porttype.operations.each do |operation|
+	operation.fault.each do |fault|
+	  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