soap4r-spox 1.6.0

data/lib/wsdl/soap/classDefCreatorSupport.rb

@@ -0,0 +1,240 @@
+# WSDL4R - Creating class code support 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 'soap/mapping'
+require 'soap/mapping/typeMap'
+require 'xsd/codegen/gensupport'
+
+
+module WSDL
+module SOAP
+
+
+# requires @defined_const, @simpletypes, @name_creator
+module ClassDefCreatorSupport
+  include XSD::CodeGen::GenSupport
+
+  def mapped_class_name(qname, modulepath)
+    @name_creator.assign_name(qname, modulepath)
+  end
+
+  def mapped_class_basename(qname, modulepath)
+    classname = @name_creator.assign_name(qname, modulepath)
+    classname.sub(/\A.*:/, '')
+  end
+
+  def basetype_mapped_class(name)
+    ::SOAP::TypeMap[name]
+  end
+
+  def dump_method_signature(name, operation, element_definitions)
+    methodname = safemethodname(name)
+    input = operation.input
+    output = operation.output
+    fault = operation.fault
+    signature = "#{methodname}#{dump_inputparam(input)}"
+    str = <<__EOD__
+# SYNOPSIS
+#   #{methodname}#{dump_inputparam(input)}
+#
+# ARGS
+#{dump_inout_type(input, element_definitions).chomp}
+#
+# RETURNS
+#{dump_inout_type(output, element_definitions).chomp}
+#
+__EOD__
+    unless fault.empty?
+      str <<<<__EOD__
+# RAISES
+#{dump_fault_type(fault, element_definitions)}
+#
+__EOD__
+    end
+    str
+  end
+
+  def dq(ele)
+    ele.dump
+  end
+
+  def ndq(ele)
+    ele.nil? ? 'nil' : dq(ele)
+  end
+
+  def sym(ele)
+    ':' + ele.id2name
+  end
+
+  def nsym(ele)
+    ele.nil? ? 'nil' : sym(ele)
+  end
+
+  def dqname(qname)
+    if @defined_const.key?(qname.namespace)
+      qname.dump(@defined_const[qname.namespace])
+    else
+      qname.dump
+    end
+  end
+
+  def assign_const(value, prefix = '')
+    return if value.nil? or @defined_const.key?(value)
+    name = value.scan(/[^:\/]+\/?\z/)[0] || 'C'
+    tag = prefix + safeconstname(name)
+    if @defined_const.value?(tag)
+      idx = 0
+      while true
+        tag = prefix + safeconstname(name + "_#{idx}")
+        break unless @defined_const.value?(tag)
+        idx += 1
+        raise RuntimeError.new("too much similar names") if idx > 100
+      end
+    end
+    @defined_const[value] = tag
+  end
+
+  def create_type_name(modulepath, element)
+    if element.type == XSD::AnyTypeName
+      # nil means anyType.
+      nil
+    elsif simpletype = @simpletypes[element.type]
+      if simpletype.restriction and simpletype.restriction.enumeration?
+        mapped_class_name(element.type, modulepath)
+      else
+        nil
+      end
+    elsif klass = element_basetype(element)
+      klass.name
+    elsif element.type
+      mapped_class_name(element.type, modulepath)
+    elsif element.ref
+      mapped_class_name(element.ref, modulepath)
+    elsif element.anonymous_type?
+      # inner class
+      mapped_class_name(element.name, modulepath)
+    else
+      nil
+    end
+  end
+
+private
+
+  def dump_inout_type(param, element_definitions)
+    if param
+      message = param.find_message
+      params = ""
+      message.parts.each do |part|
+        name = safevarname(part.name)
+        if part.type
+          typename = safeconstname(part.type.name)
+          qname = part.type
+          params << add_at("#   #{name}", "#{typename} - #{qname}\n", 20)
+        elsif part.element
+          ele = element_definitions[part.element]
+          if ele.type
+            typename = safeconstname(ele.type.name)
+            qname = ele.type
+          else
+            typename = safeconstname(ele.name.name)
+            qname = ele.name
+          end
+          params << add_at("#   #{name}", "#{typename} - #{qname}\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
+
+  def dump_fault_type(fault, element_definitions)
+    fault.collect { |ele|
+      dump_inout_type(ele, element_definitions).chomp
+    }.join("\n")
+  end
+
+  def element_basetype(ele)
+    if klass = basetype_class(ele.type)
+      klass
+    elsif ele.local_simpletype
+      basetype_class(ele.local_simpletype.base)
+    else
+      nil
+    end
+  end
+
+  def attribute_basetype(attr)
+    if klass = basetype_class(attr.type)
+      klass
+    elsif attr.local_simpletype
+      basetype_class(attr.local_simpletype.base)
+    else
+      nil
+    end
+  end
+
+  def basetype_class(type)
+    return nil if type.nil?
+    if simpletype = @simpletypes[type]
+      basetype_mapped_class(simpletype.base)
+    else
+      basetype_mapped_class(type)
+    end
+  end
+
+  def name_element(element)
+    return element.name if element.name 
+    return element.ref if element.ref
+    raise RuntimeError.new("cannot define name of #{element}")
+  end
+
+  def name_attribute(attribute)
+    return attribute.name if attribute.name 
+    return attribute.ref if attribute.ref
+    raise RuntimeError.new("cannot define name of #{attribute}")
+  end
+
+  # TODO: run MethodDefCreator just once in 1.6.X.
+  # MethodDefCreator should return parsed struct, not a String.
+  def collect_assigned_method(wsdl, porttypename, modulepath = nil)
+    name_creator = WSDL::SOAP::ClassNameCreator.new
+    methoddefcreator =
+      WSDL::SOAP::MethodDefCreator.new(wsdl, name_creator, modulepath, {})
+    methoddefcreator.dump(porttypename)
+    methoddefcreator.assigned_method
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/classNameCreator.rb

@@ -0,0 +1,54 @@
+# 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,104 @@
+# 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"
+      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"
+      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,173 @@
+# 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