soap4r 1.5.5.20061022

data/lib/wsdl/soap/literalMappingRegistryCreator.rb

@@ -0,0 +1,188 @@
+# WSDL4R - Creating LiteralMappingRegistry code from WSDL.
+# Copyright (C) 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/mappingRegistryCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+class LiteralMappingRegistryCreator
+  include MappingRegistryCreatorSupport
+
+  def initialize(definitions, modulepath)
+    @definitions = definitions
+    @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
+  end
+
+  def dump(varname)
+    @varname = varname
+    result = ''
+    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
+    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
+    result
+  end
+
+private
+
+  def dump_element
+    @elements.collect { |ele|
+      if ele.local_complextype
+        qualified = (ele.elementform == 'qualified')
+        dump_complextypedef(ele.name, ele.local_complextype, qualified)
+      elsif ele.local_simpletype
+        dump_simpletypedef(ele.name, ele.local_simpletype)
+      else
+        nil
+      end
+    }.compact.join("\n")
+  end
+
+  def dump_attribute
+    @attributes.collect { |attr|
+      if attr.local_simpletype
+        dump_simpletypedef(attr.name, attr.local_simpletype)
+      end
+    }.compact.join("\n")
+  end
+
+  def dump_simpletype
+    @simpletypes.collect { |type|
+      dump_simpletypedef(type.name, type)
+    }.compact.join("\n")
+  end
+
+  def dump_complextype
+    @complextypes.collect { |type|
+      dump_complextypedef(type.name, type) unless type.abstract
+    }.compact.join("\n")
+  end
+
+  def dump_complextypedef(qname, typedef, qualified = false)
+    case typedef.compoundtype
+    when :TYPE_STRUCT, :TYPE_EMPTY
+      dump_struct_typemap(qname, typedef, qualified)
+    when :TYPE_ARRAY
+      dump_array_typemap(qname, typedef)
+    when :TYPE_SIMPLE
+      dump_simple_typemap(qname, typedef)
+    when :TYPE_MAP
+      # mapped as a general Hash
+      nil
+    else
+      raise RuntimeError.new(
+        "unknown kind of complexContent: #{typedef.compoundtype}")
+    end
+  end
+
+  def dump_struct_typemap(qname, typedef, qualified = false)
+    var = {}
+    var[:class] = create_class_name(qname, @modulepath)
+    if typedef.name.nil?
+      # local complextype of a element
+      var[:schema_name] = qname.name
+    else
+      # named complextype
+      var[:schema_type] = qname.name
+    end
+    var[:schema_ns] = qname.namespace
+    var[:schema_qualified] = qualified.to_s
+
+    parsed_element = parse_elements(typedef.elements, qname.namespace)
+    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
+    dump_entry(@varname, var)
+  end
+
+  DEFAULT_ITEM_NAME = XSD::QName.new(nil, 'item')
+
+  def dump_array_typemap(qname, typedef)
+    var = {}
+    var[:class] = create_class_name(qname, @modulepath)
+    var[:schema_ns] = qname.namespace
+    if typedef.name.nil?
+      # local complextype of a element
+      var[:schema_name] = qname.name
+    else
+      # named complextype
+      var[:schema_type] = qname.name
+    end
+    child_type = typedef.child_type
+    child_element = typedef.find_aryelement
+    if child_type == XSD::AnyTypeName
+      type = nil
+    elsif child_element and (klass = element_basetype(child_element))
+      type = klass.name
+    elsif child_type
+      type = create_class_name(child_type, @modulepath)
+    else
+      type = nil
+    end
+    if child_element
+      if child_element.map_as_array?
+        type << '[]' if type
+      end
+      child_element_name = child_element.name
+    else
+      child_element_name = DEFAULT_ITEM_NAME
+    end
+    parsed_element = []
+    parsed_element << [child_element_name.name, child_element_name, type]
+    var[:schema_element] = dump_schema_element_definition(parsed_element, 2)
+    dump_entry(@varname, var)
+  end
+
+  def dump_simple_typemap(qname, type_or_element)
+    var = {}
+    var[:class] = create_class_name(qname, @modulepath)
+    var[:schema_ns] = qname.namespace
+    var[:schema_type] = qname.name
+    unless type_or_element.attributes.empty?
+      var[:schema_attribute] = define_attribute(type_or_element.attributes)
+    end
+    dump_entry(@varname, var)
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/mappingRegistryCreator.rb

@@ -0,0 +1,53 @@
+# WSDL4R - Creating MappingRegistry code from WSDL.
+# Copyright (C) 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'
+require 'wsdl/soap/encodedMappingRegistryCreator'
+require 'wsdl/soap/literalMappingRegistryCreator'
+
+
+module WSDL
+module SOAP
+
+
+class MappingRegistryCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions, modulepath = nil)
+    @definitions = definitions
+    @modulepath = modulepath
+  end
+
+  def dump
+    encoded_creator = EncodedMappingRegistryCreator.new(@definitions, @modulepath)
+    literal_creator = LiteralMappingRegistryCreator.new(@definitions, @modulepath)
+    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'
+    methodname = 'define_encoded_mapping'
+    m.def_const(varname, '::SOAP::Mapping::EncodedRegistry.new')
+    m.def_code(encoded_creator.dump(varname))
+    varname = 'LiteralRegistry'
+    methodname = 'define_literal_mapping'
+    m.def_const(varname, '::SOAP::Mapping::LiteralRegistry.new')
+    m.def_code(literal_creator.dump(varname))
+    m.dump
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/mappingRegistryCreatorSupport.rb

@@ -0,0 +1,233 @@
+# WSDL4R - Creating MappingRegistry support.
+# Copyright (C) 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/soap/classDefCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+module MappingRegistryCreatorSupport
+  include ClassDefCreatorSupport
+  include XSD::CodeGen
+
+  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 = definition
+      '[' +
+        (
+          if name
+            varname.dump + ', [' + ndq(type) + ', ' + dqname(name) + ']'
+          else
+            varname.dump + ', ' + ndq(type)
+          end
+        ) + ']'
+    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 parse_elements(elements, base_namespace)
+    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
+        schema_element << [varname, eleqname, type]
+      when XMLSchema::Element
+        if element.type == XSD::AnyTypeName
+          type = nil
+        elsif klass = element_basetype(element)
+          type = klass.name
+        elsif element.type
+          type = create_class_name(element.type, @modulepath)
+        elsif element.ref
+          type = create_class_name(element.ref, @modulepath)
+        else
+          type = nil      # means anyType.
+          # do we define a class for local complexType from it's name?
+          #   type = create_class_name(element.name, @modulepath)
+          # <element>
+          #   <complexType>
+          #     <seq...>
+          #   </complexType>
+          # </element>
+        end
+        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
+        schema_element << [varname, eleqname, type]
+      when WSDL::XMLSchema::Sequence
+        child_schema_element = parse_elements(element.elements, base_namespace)
+        schema_element << child_schema_element
+      when WSDL::XMLSchema::Choice
+        child_schema_element = parse_elements(element.elements, base_namespace)
+        child_schema_element.unshift(:choice)
+        schema_element << child_schema_element
+      else
+        raise RuntimeError.new("unknown type: #{element}")
+      end
+    end
+    schema_element
+  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 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|
+        dqname(name) + ' => ' + ndq(type)
+      }.join(",\n    ") +
+    "\n  }"
+  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
+
+  def dump_entry(regname, var)
+    "#{regname}.register(\n  " +
+      [
+        dump_entry_item(var, :class),
+        dump_entry_item(var, :soap_class),
+        dump_entry_item(var, :schema_ns, true),
+        dump_entry_item(var, :schema_name, true),
+        dump_entry_item(var, :schema_type, true),
+        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, as_string = false)
+    if var.key?(key)
+      if as_string
+        ":#{key} => #{ndq(var[key])}"
+      else
+        ":#{key} => #{var[key]}"
+      end
+    else
+      nil
+    end
+  end
+
+  def dump_simpletypedef(qname, simpletype)
+    if simpletype.restriction
+      dump_simpletypedef_restriction(qname, simpletype)
+    elsif simpletype.list
+      dump_simpletypedef_list(qname, simpletype)
+    else
+      raise RuntimeError.new("unknown kind of simpletype: #{simpletype}")
+    end
+  end
+
+  def dump_simpletypedef_restriction(qname, typedef)
+    restriction = typedef.restriction
+    if restriction.enumeration.empty?
+      # not supported.  minlength?
+      return nil
+    end
+    var = {}
+    var[:class] = create_class_name(qname, @modulepath)
+    var[:schema_ns] = qname.namespace
+    if typedef.name.nil?
+      var[:schema_type] = nil
+    else
+      var[:schema_type] = qname.name
+    end
+    dump_entry(@varname, var)
+  end
+
+  def dump_simpletypedef_list(qname, typedef)
+    nil
+  end
+end
+
+
+end
+end