soap2r 1.5.8

data/lib/wsdl/soap/fault.rb

@@ -0,0 +1,56 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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'
+
+
+module WSDL
+module SOAP
+
+
+class Fault < Info
+  attr_reader :name	# required
+  attr_reader :use	# required
+  attr_reader :encodingstyle
+  attr_reader :namespace
+
+  def initialize
+    super
+    @name = nil
+    @use = nil
+    @encodingstyle = nil
+    @namespace = nil
+  end
+
+  def targetnamespace
+    parent.targetnamespace
+  end
+
+  def parse_element(element)
+    nil
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when NameAttrName
+      @name = XSD::QName.new(targetnamespace, value.source)
+    when UseAttrName
+      @use = value.source
+    when EncodingStyleAttrName
+      @encodingstyle = value.source
+    when NamespaceAttrName
+      @namespace = value.source
+    else
+      nil
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/header.rb

@@ -0,0 +1,86 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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'
+
+
+module WSDL
+module SOAP
+
+
+class Header < Info
+  attr_reader :headerfault
+
+  attr_reader :message	# required
+  attr_reader :part	# required
+  attr_reader :use	# required
+  attr_reader :encodingstyle
+  attr_reader :namespace
+
+  def initialize
+    super
+    @message = nil
+    @part = nil
+    @use = nil
+    @encodingstyle = nil
+    @namespace = nil
+    @headerfault = nil
+  end
+
+  def targetnamespace
+    parent.targetnamespace
+  end
+
+  def find_message
+    root.message(@message) or raise RuntimeError.new("#{@message} not found")
+  end
+
+  def find_part
+    find_message.parts.each do |part|
+      if part.name == @part
+	return part
+      end
+    end
+    raise RuntimeError.new("#{@part} not found")
+  end
+
+  def parse_element(element)
+    case element
+    when HeaderFaultName
+      o = WSDL::SOAP::HeaderFault.new
+      @headerfault = o
+      o
+    else
+      nil
+    end
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when MessageAttrName
+      if value.namespace.nil?
+        value = XSD::QName.new(targetnamespace, value.source)
+      end
+      @message = value
+    when PartAttrName
+      @part = value.source
+    when UseAttrName
+      @use = value.source
+    when EncodingStyleAttrName
+      @encodingstyle = value.source
+    when NamespaceAttrName
+      @namespace = value.source
+    else
+      nil
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/headerfault.rb

@@ -0,0 +1,56 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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'
+
+
+module WSDL
+module SOAP
+
+
+class HeaderFault < Info
+  attr_reader :message	# required
+  attr_reader :part	# required
+  attr_reader :use	# required
+  attr_reader :encodingstyle
+  attr_reader :namespace
+
+  def initialize
+    super
+    @message = nil
+    @part = nil
+    @use = nil
+    @encodingstyle = nil
+    @namespace = nil
+  end
+
+  def parse_element(element)
+    nil
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when MessageAttrName
+      @message = value
+    when PartAttrName
+      @part = value.source
+    when UseAttrName
+      @use = value.source
+    when EncodingStyleAttrName
+      @encodingstyle = value.source
+    when NamespaceAttrName
+      @namespace = value.source
+    else
+      nil
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/literalMappingRegistryCreator.rb

@@ -0,0 +1,115 @@
+# WSDL4R - Creating LiteralMappingRegistry 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/mappingRegistryCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+class LiteralMappingRegistryCreator
+  include MappingRegistryCreatorSupport
+
+  def initialize(definitions, name_creator, modulepath, defined_const)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+    @elements = definitions.collect_elements
+    @elements.uniq!
+    @attributes = definitions.collect_attributes
+    @attributes.uniq!
+    @simpletypes = definitions.collect_simpletypes
+    @simpletypes.uniq!
+    @complextypes = definitions.collect_complextypes
+    @complextypes.uniq!
+    @varname = nil
+    @defined_const = defined_const
+  end
+
+  def dump(varname)
+    @varname = varname
+    result = ''
+    str = dump_complextype
+    unless str.empty?
+      result << "\n" unless result.empty?
+      result << str
+    end
+    str = dump_simpletype
+    unless str.empty?
+      result << "\n" unless result.empty?
+      result << str
+    end
+    str = dump_element
+    unless str.empty?
+      result << "\n" unless result.empty?
+      result << str
+    end
+    str = dump_attribute
+    unless str.empty?
+      result << "\n" unless result.empty?
+      result << str
+    end
+    result
+  end
+
+private
+
+  def dump_element
+    @elements.collect { |ele|
+      # has the definition different from the complexType of the same name
+      next if ele.type.nil? and @complextypes[ele.name]
+      dump_with_inner {
+        if typedef = ele.local_complextype
+          dump_complextypedef(@modulepath, ele.name, typedef)
+        elsif typedef = ele.local_simpletype
+          dump_simpletypedef(@modulepath, ele.name, typedef)
+        elsif ele.type
+          if typedef = @complextypes[ele.type]
+            dump_complextypedef(@modulepath, ele.type, typedef, ele.name)
+          elsif typedef = @simpletypes[ele.type]
+            dump_simpletypedef(@modulepath, ele.type, typedef, ele.name)
+          end
+        end
+      }
+    }.compact.join("\n")
+  end
+
+  def dump_attribute
+    @attributes.collect { |attr|
+      if attr.local_simpletype
+        dump_with_inner {
+          dump_simpletypedef(@modulepath, attr.name, attr.local_simpletype)
+        }
+      end
+    }.compact.join("\n")
+  end
+
+  def dump_simpletype
+    @simpletypes.collect { |type|
+      dump_with_inner {
+        dump_simpletypedef(@modulepath, type.name, type)
+      }
+    }.compact.join("\n")
+  end
+
+  def dump_complextype
+    @complextypes.collect { |type|
+      unless type.abstract
+        dump_with_inner {
+          dump_complextypedef(@modulepath, type.name, type)
+        }
+      end
+    }.compact.join("\n")
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/mappingRegistryCreator.rb

@@ -0,0 +1,58 @@
+# WSDL4R - Creating MappingRegistry 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'
+require 'wsdl/soap/encodedMappingRegistryCreator'
+require 'wsdl/soap/literalMappingRegistryCreator'
+require 'xsd/codegen/moduledef.rb'
+
+
+module WSDL
+module SOAP
+
+
+class MappingRegistryCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions, name_creator, modulepath = nil)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+  end
+
+  def dump
+    defined_const = {}
+    encoded_creator = EncodedMappingRegistryCreator.new(@definitions, @name_creator, @modulepath, defined_const)
+    literal_creator = LiteralMappingRegistryCreator.new(@definitions, @name_creator, @modulepath, defined_const)
+    wsdl_name = @definitions.name ? @definitions.name.name : 'default'
+    module_name = safeconstname(wsdl_name + 'MappingRegistry')
+    if @modulepath
+      module_name = [@modulepath, module_name].join('::')
+    end
+    m = XSD::CodeGen::ModuleDef.new(module_name)
+    m.def_require("soap/mapping")
+    varname = 'EncodedRegistry'
+    m.def_const(varname, '::SOAP::Mapping::EncodedRegistry.new')
+    m.def_code(encoded_creator.dump(varname))
+    varname = 'LiteralRegistry'
+    m.def_const(varname, '::SOAP::Mapping::LiteralRegistry.new')
+    m.def_code(literal_creator.dump(varname))
+    #
+    defined_const.each do |ns, tag|
+      m.def_const(tag, dq(ns))
+    end
+    m.dump
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/mappingRegistryCreatorSupport.rb

@@ -0,0 +1,376 @@
+# WSDL4R - Creating MappingRegistry support.
+# 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/soap/classDefCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+# requires @defined_const = {}, @dump_with_inner, @modulepath
+module MappingRegistryCreatorSupport
+  include ClassDefCreatorSupport
+  include XSD::CodeGen
+
+  def dump_with_inner
+    @dump_with_inner = []
+    @dump_with_inner.unshift(yield)
+    @dump_with_inner.join("\n")
+  end
+
+  def dump_complextypedef(mpath, qname, typedef, as_element = nil, opt = {})
+    case typedef.compoundtype
+    when :TYPE_STRUCT, :TYPE_EMPTY
+      dump_complex_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_ARRAY
+      dump_array_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_SIMPLE
+      dump_simple_typemap(mpath, qname, typedef, as_element, opt)
+    when :TYPE_MAP
+      # mapped as a general Hash
+      nil
+    else
+      raise RuntimeError.new(
+        "unknown kind of complexContent: #{typedef.compoundtype}")
+    end
+  end
+
+  def dump_array_typemap(mpath, qname, typedef, as_element, opt)
+    if typedef.find_soapenc_arytype
+      if opt[:encoded]
+        dump_encoded_array_typemap(mpath, qname, typedef, as_element, opt)
+      end
+    else
+      dump_literal_array_typemap(mpath, qname, typedef, as_element, opt)
+    end
+  end
+
+  def dump_complex_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    if var[:schema_type] and typedef.base
+      var[:schema_basetype] = typedef.base
+    end
+    parentmodule = var[:class]
+    parsed_element =
+      parse_elements(typedef.elements, qname.namespace, parentmodule, opt)
+    if typedef.choice?
+      parsed_element.unshift(:choice)
+    end
+    var[:schema_element] = dump_schema_element_definition(parsed_element, 2)
+    unless typedef.attributes.empty?
+      var[:schema_attribute] = define_attribute(typedef.attributes)
+    end
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_simple_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    unless typedef.attributes.empty?
+      var[:schema_attribute] = define_attribute(typedef.attributes)
+    end
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_schema_element_definition(definition, indent = 0)
+    return '[]' if definition.empty?
+    sp = ' ' * indent
+    if definition[0] == :choice
+      definition.shift
+      "[ :choice,\n" +
+        dump_schema_element(definition, indent + 2) + "\n" + sp + "]"
+    elsif definition[0].is_a?(::Array)
+      "[\n" +
+        dump_schema_element(definition, indent + 2) + "\n" + sp + "]"
+    else
+      varname, name, type, occurrence = definition
+      '[' + [
+        varname.dump,
+        dump_type(name, type),
+        dump_occurrence(occurrence)
+      ].compact.join(', ') + ']'
+    end
+  end
+
+  def dump_schema_element(schema_element, indent = 0)
+    sp = ' ' * indent
+    delimiter = ",\n" + sp
+    sp + schema_element.collect { |definition|
+      dump_schema_element_definition(definition, indent)
+    }.join(delimiter)
+  end
+
+  def dump_type(name, type)
+    if name
+      assign_const(name.namespace, 'Ns')
+      '[' + ndq(type) + ', ' + dqname(name) + ']'
+    else
+      ndq(type)
+    end
+  end
+
+  def dump_occurrence(occurrence)
+    if occurrence and occurrence != [1, 1] # default
+      minoccurs, maxoccurs = occurrence
+      maxoccurs ||= 'nil'
+      "[#{minoccurs}, #{maxoccurs}]"
+    end
+  end
+
+  def parse_elements(elements, base_namespace, mpath, opt)
+    schema_element = []
+    any = false
+    elements.each do |element|
+      case element
+      when XMLSchema::Any
+        # only 1 <any/> is allowed for now.
+        raise RuntimeError.new("duplicated 'any'") if any
+        any = true
+        varname = 'any' # not used
+        eleqname = XSD::AnyTypeName
+        type = nil
+        occurrence = nil
+        schema_element << [varname, eleqname, type, occurrence]
+      when XMLSchema::Element
+        next if element.ref == SchemaName
+        typebase = @modulepath
+        if element.anonymous_type?
+          child_opt = {
+            :qualified => (element.elementform == 'qualified'),
+            :is_anonymous => true
+          }
+          @dump_with_inner << dump_complextypedef(mpath, element.name, element.local_complextype, nil, child_opt)
+          typebase = mpath
+        end
+        type = create_type_name(typebase, element)
+        name = name_element(element).name
+        varname = safevarname(name)
+        if element.map_as_array?
+          if type
+            type += '[]'
+          else
+            type = '[]'
+          end
+        end
+        # nil means @@schema_ns + varname
+        eleqname = element.name || element.ref
+        if eleqname && varname == name && eleqname.namespace == base_namespace
+          eleqname = nil
+        end
+        occurrence = [element.minoccurs, element.maxoccurs]
+        schema_element << [varname, eleqname, type, occurrence]
+      when WSDL::XMLSchema::Sequence
+        child_schema_element =
+          parse_elements(element.elements, base_namespace, mpath, opt)
+        schema_element << child_schema_element
+      when WSDL::XMLSchema::Choice
+        child_schema_element =
+          parse_elements(element.elements, base_namespace, mpath, opt)
+        if !element.map_as_array?
+          # choice + maxOccurs="unbounded" is treated just as 'all' now.
+          child_schema_element.unshift(:choice)
+        end
+        schema_element << child_schema_element
+      when WSDL::XMLSchema::Group
+        if element.content.nil?
+          warn("no group definition found: #{element}")
+          next
+        end
+        child_schema_element =
+          parse_elements(element.content.elements, base_namespace, mpath, opt)
+        schema_element.concat(child_schema_element)
+      else
+        raise RuntimeError.new("unknown type: #{element}")
+      end
+    end
+    schema_element
+  end
+
+  def define_attribute(attributes)
+    schema_attribute = []
+    attributes.each do |attribute|
+      name = name_attribute(attribute)
+      if klass = attribute_basetype(attribute)
+        type = klass.name
+      else
+        warn("unresolved attribute type #{attribute.type} for #{name}")
+        type = nil
+      end
+      schema_attribute << [name, type]
+    end
+    "{\n    " +
+      schema_attribute.collect { |name, type|
+        assign_const(name.namespace, 'Ns')
+        dqname(name) + ' => ' + ndq(type)
+      }.join(",\n    ") +
+    "\n  }"
+  end
+
+  def dump_entry(regname, var)
+    "#{regname}.register(\n  " +
+      [
+        dump_entry_item(var, :class),
+        dump_entry_item(var, :soap_class),
+        dump_entry_item(var, :schema_name, :qname),
+        dump_entry_item(var, :schema_type, :qname),
+        dump_entry_item(var, :is_anonymous),
+        dump_entry_item(var, :schema_basetype, :qname),
+        dump_entry_item(var, :schema_qualified),
+        dump_entry_item(var, :schema_element),
+        dump_entry_item(var, :schema_attribute)
+      ].compact.join(",\n  ") +
+    "\n)\n"
+  end
+
+  def dump_entry_item(var, key, dump_type = :none)
+    if var.key?(key)
+      case dump_type
+      when :none
+        ":#{key} => #{var[key]}"
+      when :string
+        if @defined_const.key?(var[key])
+          ":#{key} => #{@defined_const[var[key]]}"
+        else
+          ":#{key} => #{ndq(var[key])}"
+        end
+      when :qname
+        qname = var[key]
+        if @defined_const.key?(qname.namespace)
+          ns = @defined_const[qname.namespace]
+        else
+          ns = ndq(qname.namespace)
+        end
+        ":#{key} => XSD::QName.new(#{ns}, #{ndq(qname.name)})"
+      else
+        raise "Unknown dump type: #{dump_type}"
+      end
+    end
+  end
+
+  def dump_simpletypedef(mpath, qname, simpletype, as_element = nil, opt = {})
+    if simpletype.restriction
+      dump_simpletypedef_restriction(mpath, qname, simpletype, as_element, opt)
+    elsif simpletype.list
+      dump_simpletypedef_list(mpath, qname, simpletype, as_element, opt)
+    elsif simpletype.union
+      dump_simpletypedef_union(mpath, qname, simpletype, as_element, opt)
+    else
+      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}")
+    end
+  end
+
+  def dump_simpletypedef_restriction(mpath, qname, typedef, as_element, opt)
+    restriction = typedef.restriction
+    unless restriction.enumeration?
+      # not supported.  minlength?
+      return nil
+    end
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_simpletypedef_list(mpath, qname, typedef, as_element, opt)
+    nil
+  end
+
+  def dump_simpletypedef_union(mpath, qname, typedef, as_element, opt)
+    nil
+  end
+
+  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item')
+
+  def dump_literal_array_typemap(mpath, qname, typedef, as_element, opt)
+    var = {}
+    define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    schema_ns = (var[:schema_name] || var[:schema_type]).namespace
+    parsed_element =
+      parse_elements(typedef.elements, qname.namespace, var[:class], opt)
+    if parsed_element.empty?
+      parsed_element = [create_array_element_definition(typedef, mpath)]
+    end
+    var[:schema_element] = dump_schema_element_definition(parsed_element, 2)
+    assign_const(schema_ns, 'Ns')
+    dump_entry(@varname, var)
+  end
+
+  def dump_encoded_array_typemap(mpath, qname, typedef, as_element, opt)
+    arytype = typedef.find_arytype || XSD::AnyTypeName
+    type = XSD::QName.new(arytype.namespace, arytype.name.sub(/\[(?:,)*\]$/, ''))
+    return <<__EOD__
+#{@varname}.set(
+  #{mapped_class_name(qname, mpath)},
+  ::SOAP::SOAPArray,
+  ::SOAP::Mapping::EncodedRegistry::TypedArrayFactory,
+  { :type => #{dqname(type)} }
+)
+__EOD__
+  end
+
+  # used when "soapenc:arrayType" definition
+  def create_array_element_definition(typedef, mpath)
+    child_type = typedef.child_type
+    child_element = typedef.find_aryelement
+    if child_type == XSD::AnyTypeName
+      type = nil
+    elsif child_element
+      if klass = element_basetype(child_element)
+        type = klass.name
+      else
+        typename = child_element.type || child_element.name
+        type = mapped_class_name(typename, mpath)
+      end
+    elsif child_type
+      type = mapped_class_name(child_type, mpath)
+    else
+      type = nil
+    end
+    occurrence = [0, nil]
+    if child_element and child_element.name
+      if child_element.map_as_array?
+        type << '[]' if type
+        occurrence = [child_element.minoccurs, child_element.maxoccurs]
+      end
+      child_element_name = child_element.name
+    else
+      child_element_name = DEFAULT_ITEM_NAME
+    end
+    [child_element_name.name, child_element_name, type, occurrence]
+  end
+
+  def define_dump_class(var, mpath, qname, typedef, as_element, opt)
+    var[:class] = mapped_class_name(qname, mpath)
+    if as_element
+      var[:schema_name] = as_element
+      schema_ns = as_element.namespace
+    elsif typedef.name.nil?
+      var[:schema_name] = qname
+      schema_ns = qname.namespace
+    else
+      var[:schema_type] = qname
+      schema_ns = qname.namespace
+    end
+    var[:is_anonymous] = opt[:is_anonymous] if opt.key?(:is_anonymous)
+    # true, false, or nil
+    if opt.key?(:qualified)
+      var[:schema_qualified] = opt[:qualified].to_s
+    end
+  end
+end
+
+
+end
+end