reidiculous-actionwebservice 3.0.3

data/lib/action_web_service/wsdl/soap/element.rb

@@ -0,0 +1,28 @@
+# WSDL4R - XMLSchema element definition for 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 'action_web_service/wsdl/xmlSchema/element'
+
+
+module WSDL
+module XMLSchema
+
+
+class Element < Info
+  def map_as_array?
+    maxoccurs != '1'
+  end
+
+  def attributes
+    @local_complextype.attributes
+  end
+end
+
+
+end
+end

data/lib/action_web_service/wsdl/soap/fault.rb

@@ -0,0 +1,56 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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 'action_web_service/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/action_web_service/wsdl/soap/header.rb

@@ -0,0 +1,86 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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 'action_web_service/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/action_web_service/wsdl/soap/headerfault.rb

@@ -0,0 +1,56 @@
+# WSDL4R - WSDL SOAP body definition.
+# 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 'action_web_service/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/action_web_service/wsdl/soap/mappingRegistryCreator.rb

@@ -0,0 +1,92 @@
+# WSDL4R - Creating MappingRegistry code from WSDL.
+# Copyright (C) 2002, 2003, 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 'action_web_service/wsdl/info'
+require 'action_web_service/wsdl/soap/classDefCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+class MappingRegistryCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions)
+    @definitions = definitions
+    @complextypes = @definitions.collect_complextypes
+    @types = nil
+  end
+
+  def dump(types)
+    @types = types
+    map_cache = []
+    map = ""
+    @types.each do |type|
+      if map_cache.index(type).nil?
+	map_cache << type
+	if type.namespace != XSD::Namespace
+	  if typemap = dump_typemap(type)
+            map << typemap
+          end
+	end
+      end
+   end
+    return map
+  end
+
+private
+
+  def dump_typemap(type)
+    if definedtype = @complextypes[type]
+      case definedtype.compoundtype
+      when :TYPE_STRUCT
+        dump_struct_typemap(definedtype)
+      when :TYPE_ARRAY
+        dump_array_typemap(definedtype)
+      when :TYPE_MAP, :TYPE_EMPTY
+        nil
+      else
+        raise NotImplementedError.new("must not reach here")
+      end
+    end
+  end
+
+  def dump_struct_typemap(definedtype)
+    ele = definedtype.name
+    return <<__EOD__
+MappingRegistry.set(
+  #{create_class_name(ele)},
+  ::SOAP::SOAPStruct,
+  ::SOAP::Mapping::Registry::TypedStructFactory,
+  { :type => #{dqname(ele)} }
+)
+__EOD__
+  end
+
+  def dump_array_typemap(definedtype)
+    ele = definedtype.name
+    arytype = definedtype.find_arytype || XSD::AnyTypeName
+    type = XSD::QName.new(arytype.namespace, arytype.name.sub(/\[(?:,)*\]$/, ''))
+    @types << type
+    return <<__EOD__
+MappingRegistry.set(
+  #{create_class_name(ele)},
+  ::SOAP::SOAPArray,
+  ::SOAP::Mapping::Registry::TypedArrayFactory,
+  { :type => #{dqname(type)} }
+)
+__EOD__
+  end
+end
+
+
+end
+end

data/lib/action_web_service/wsdl/soap/methodDefCreator.rb

@@ -0,0 +1,228 @@
+# WSDL4R - Creating driver code from WSDL.
+# Copyright (C) 2002, 2003, 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 'action_web_service/wsdl/info'
+require 'action_web_service/wsdl/soap/classDefCreatorSupport'
+require 'action_web_service/soap/rpc/element'
+
+
+module WSDL
+module SOAP
+
+
+class MethodDefCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions)
+    @definitions = definitions
+    @simpletypes = @definitions.collect_simpletypes
+    @complextypes = @definitions.collect_complextypes
+    @elements = @definitions.collect_elements
+    @types = []
+  end
+
+  def dump(porttype)
+    @types.clear
+    result = ""
+    operations = @definitions.porttype(porttype).operations
+    binding = @definitions.porttype_binding(porttype)
+    operations.each do |operation|
+      op_bind = binding.operations[operation.name]
+      next unless op_bind # no binding is defined
+      next unless op_bind.soapoperation # not a SOAP operation binding
+      result << ",\n" unless result.empty?
+      result << dump_method(operation, op_bind).chomp
+    end
+    return result, @types
+  end
+
+  def collect_rpcparameter(operation)
+    result = operation.inputparts.collect { |part|
+      collect_type(part.type)
+      param_set(::SOAP::RPC::SOAPMethod::IN, part.name, rpcdefinedtype(part))
+    }
+    outparts = operation.outputparts
+    if outparts.size > 0
+      retval = outparts[0]
+      collect_type(retval.type)
+      result << param_set(::SOAP::RPC::SOAPMethod::RETVAL, retval.name,
+        rpcdefinedtype(retval))
+      cdr(outparts).each { |part|
+	collect_type(part.type)
+	result << param_set(::SOAP::RPC::SOAPMethod::OUT, part.name,
+          rpcdefinedtype(part))
+      }
+    end
+    result
+  end
+
+  def collect_documentparameter(operation)
+    param = []
+    operation.inputparts.each do |input|
+      param << param_set(::SOAP::RPC::SOAPMethod::IN, input.name,
+        documentdefinedtype(input), elementqualified(input))
+    end
+    operation.outputparts.each do |output|
+      param << param_set(::SOAP::RPC::SOAPMethod::OUT, output.name,
+        documentdefinedtype(output), elementqualified(output))
+    end
+    param
+  end
+
+private
+
+  def dump_method(operation, binding)
+    name = safemethodname(operation.name.name)
+    name_as = operation.name.name
+    style = binding.soapoperation_style
+    inputuse = binding.input.soapbody_use
+    outputuse = binding.output.soapbody_use
+    namespace = binding.input.soapbody.namespace
+    if style == :rpc
+      qname = XSD::QName.new(namespace, name_as)
+      paramstr = param2str(collect_rpcparameter(operation))
+    else
+      qname = nil
+      paramstr = param2str(collect_documentparameter(operation))
+    end
+    if paramstr.empty?
+      paramstr = '[]'
+    else
+      paramstr = "[ " << paramstr.split(/\r?\n/).join("\n    ") << " ]"
+    end
+    definitions = <<__EOD__
+#{ndq(binding.soapaction)},
+  #{dq(name)},
+  #{paramstr},
+  { :request_style =>  #{sym(style.id2name)}, :request_use =>  #{sym(inputuse.id2name)},
+    :response_style => #{sym(style.id2name)}, :response_use => #{sym(outputuse.id2name)} }
+__EOD__
+    if style == :rpc
+      return <<__EOD__
+[ #{qname.dump},
+  #{definitions}]
+__EOD__
+    else
+      return <<__EOD__
+[ #{definitions}]
+__EOD__
+    end
+  end
+
+  def rpcdefinedtype(part)
+    if mapped = basetype_mapped_class(part.type)
+      ['::' + mapped.name]
+    elsif definedtype = @simpletypes[part.type]
+      ['::' + basetype_mapped_class(definedtype.base).name]
+    elsif definedtype = @elements[part.element]
+      #['::SOAP::SOAPStruct', part.element.namespace, part.element.name]
+      ['nil', part.element.namespace, part.element.name]
+    elsif definedtype = @complextypes[part.type]
+      case definedtype.compoundtype
+      when :TYPE_STRUCT, :TYPE_EMPTY    # ToDo: empty should be treated as void.
+        type = create_class_name(part.type)
+	[type, part.type.namespace, part.type.name]
+      when :TYPE_MAP
+	[Hash.name, part.type.namespace, part.type.name]
+      when :TYPE_ARRAY
+	arytype = definedtype.find_arytype || XSD::AnyTypeName
+	ns = arytype.namespace
+	name = arytype.name.sub(/\[(?:,)*\]$/, '')
+        type = create_class_name(XSD::QName.new(ns, name))
+	[type + '[]', ns, name]
+      else
+	raise NotImplementedError.new("must not reach here")
+      end
+    else
+      raise RuntimeError.new("part: #{part.name} cannot be resolved")
+    end
+  end
+
+  def documentdefinedtype(part)
+    if mapped = basetype_mapped_class(part.type)
+      ['::' + mapped.name, nil, part.name]
+    elsif definedtype = @simpletypes[part.type]
+      ['::' + basetype_mapped_class(definedtype.base).name, nil, part.name]
+    elsif definedtype = @elements[part.element]
+      ['::SOAP::SOAPElement', part.element.namespace, part.element.name]
+    elsif definedtype = @complextypes[part.type]
+      ['::SOAP::SOAPElement', part.type.namespace, part.type.name]
+    else
+      raise RuntimeError.new("part: #{part.name} cannot be resolved")
+    end
+  end
+
+  def elementqualified(part)
+    if mapped = basetype_mapped_class(part.type)
+      false
+    elsif definedtype = @simpletypes[part.type]
+      false
+    elsif definedtype = @elements[part.element]
+      definedtype.elementform == 'qualified'
+    elsif definedtype = @complextypes[part.type]
+      false
+    else
+      raise RuntimeError.new("part: #{part.name} cannot be resolved")
+    end
+  end
+
+  def param_set(io_type, name, type, ele = nil)
+    [io_type, name, type, ele]
+  end
+
+  def collect_type(type)
+    # ignore inline type definition.
+    return if type.nil?
+    return if @types.include?(type)
+    @types << type
+    return unless @complextypes[type]
+    @complextypes[type].each_element do |element|
+      collect_type(element.type)
+    end
+  end
+
+  def param2str(params)
+    params.collect { |param|
+      io, name, type, ele = param
+      unless ele.nil?
+        "[#{dq(io)}, #{dq(name)}, #{type2str(type)}, #{ele2str(ele)}]"
+      else
+        "[#{dq(io)}, #{dq(name)}, #{type2str(type)}]"
+      end
+    }.join(",\n")
+  end
+
+  def type2str(type)
+    if type.size == 1
+      "[#{dq(type[0])}]" 
+    else
+      "[#{dq(type[0])}, #{ndq(type[1])}, #{dq(type[2])}]" 
+    end
+  end
+
+  def ele2str(ele)
+    qualified = ele
+    if qualified
+      "true"
+    else
+      "false"
+    end
+  end
+
+  def cdr(ary)
+    result = ary.dup
+    result.shift
+    result
+  end
+end
+
+
+end
+end