* clean up unused codes in MethodDefCreator.

nahi · nahi · commit 3fef3072a486 · 2007-10-30T03:05:34.000Z
git-svn-id: http://dev.ctor.org/svn/soap4r/trunk@2007 23c4dcf6-64ea-0310-84d7-d424c7495ec0
diff --git a/lib/soap/wsdlDriver.rb b/lib/soap/wsdlDriver.rb
@@ -31,10 +31,6 @@ class FactoryError < StandardError; end
 
   def initialize(wsdl)
     @wsdl = import(wsdl)
-    name_creator = WSDL::SOAP::ClassNameCreator.new
-    @modulepath = 'WSDLDriverFactory'
-    @methoddefcreator =
-      WSDL::SOAP::MethodDefCreator.new(@wsdl, name_creator, @modulepath, {})
   end
   
   def inspect
@@ -44,8 +40,10 @@ def inspect
   def create_rpc_driver(servicename = nil, portname = nil)
     port = find_port(servicename, portname)
     drv = SOAP::RPC::Driver.new(port.soap_address.location)
-    init_driver(drv, port)
-    add_operation(drv, port)
+    if binding = port.find_binding
+      init_driver(drv, binding)
+      add_operation(drv, binding)
+    end
     drv
   end
 
@@ -113,20 +111,27 @@ def find_port(servicename = nil, portname = nil)
     port
   end
 
-  def init_driver(drv, port)
+  def init_driver(drv, binding)
     wsdl_elements = @wsdl.collect_elements
     wsdl_types = @wsdl.collect_complextypes + @wsdl.collect_simpletypes
     rpc_decode_typemap = wsdl_types +
-      @wsdl.soap_rpc_complextypes(port.find_binding)
+      @wsdl.soap_rpc_complextypes(binding)
     drv.proxy.mapping_registry =
       Mapping::WSDLEncodedRegistry.new(rpc_decode_typemap)
     drv.proxy.literal_mapping_registry =
       Mapping::WSDLLiteralRegistry.new(wsdl_types, wsdl_elements)
   end
 
-  def add_operation(drv, port)
-    port.find_binding.operations.each do |op_bind|
-      mdef = @methoddefcreator.create_methoddef(op_bind)
+  def add_operation(drv, binding)
+    name_creator = WSDL::SOAP::ClassNameCreator.new
+    modulepath = 'WSDLDriverFactory'
+    methoddefcreator =
+      WSDL::SOAP::MethodDefCreator.new(@wsdl, name_creator, modulepath, {})
+    mdefs = methoddefcreator.create(binding.name)
+    if mdefs.nil?
+      raise FactoryError.new("no method definition found in WSDL")
+    end
+    mdefs.each do |mdef|
       opt = {
         :request_style => mdef.style,
         :response_style => mdef.style,
diff --git a/lib/wsdl/soap/cgiStubCreator.rb b/lib/wsdl/soap/cgiStubCreator.rb
@@ -49,8 +49,7 @@ def dump(service_name)
   def dump_porttype(porttype)
     class_name = mapped_class_name(porttype.name, @modulepath)
     defined_const = {}
-    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
-    methoddef = result[:methoddef]
+    methoddef = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
     wsdl_name = @definitions.name ? @definitions.name.name : 'default'
     mrname = safeconstname(wsdl_name + 'MappingRegistry')
     c1 = XSD::CodeGen::ClassDef.new(class_name)
diff --git a/lib/wsdl/soap/driverCreator.rb b/lib/wsdl/soap/driverCreator.rb
@@ -63,8 +63,7 @@ def dump_porttype(porttype)
     class_name = mapped_class_basename(qname, @modulepath)
     defined_const = {}
     mdcreator = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const)
-    result = mdcreator.dump(porttype)
-    methoddef = result[:methoddef]
+    methoddef = mdcreator.dump(porttype)
     binding = @definitions.bindings.find { |item| item.type == porttype }
     if binding.nil? or binding.soapbinding.nil?
       # not bound or not a SOAP binding
diff --git a/lib/wsdl/soap/methodDefCreator.rb b/lib/wsdl/soap/methodDefCreator.rb
@@ -31,49 +31,44 @@ def initialize(definitions, name_creator, modulepath, defined_const)
     @simpletypes = @definitions.collect_simpletypes
     @complextypes = @definitions.collect_complextypes
     @elements = @definitions.collect_elements
-    @types = []
-    @encoded = false
-    @literal = false
     @defined_const = defined_const
     @assigned_method = {}
   end
 
   def dump(name)
-    @types.clear
-    @encoded = false
-    @literal = false
     methoddef = ""
     porttype = @definitions.porttype(name)
     binding = porttype.find_binding
     if binding
-      binding.operations.each do |op_bind|
-        next unless op_bind # no binding is defined
-        next unless op_bind.soapoperation # not a SOAP operation binding
+      create(binding.name).each do |mdef|
         methoddef << ",\n" unless methoddef.empty?
-        methoddef << dump_method(op_bind).chomp
+        methoddef << dump_method(mdef).chomp
       end
     end
-    result = {
-      :methoddef => methoddef,
-      :types => @types,
-      :encoded => @encoded,
-      :literal => @literal
-    }
-    result
+    methoddef
+  end
+
+  def create(bindingname)
+    binding = @definitions.binding(bindingname)
+    if binding
+      return binding.operations.collect { |op_bind|
+        next unless op_bind.soapoperation # not a SOAP operation binding
+        create_methoddef(op_bind)
+      }
+    end
+    nil
   end
 
+private
+
   def create_methoddef(op_bind)
     op_info = op_bind.operation_info
     name = assign_method_name(op_bind)
     soapaction = op_info.boundid.soapaction
     qname = op_bind.soapoperation_name
-    style = op_info.style
-    inputuse = op_info.inputuse
-    outputuse = op_info.outputuse
     mdef = ::SOAP::RPC::MethodDef.new(name, soapaction, qname)
     op_info.parts.each do |part|
-      if style == :rpc
-        collect_type(part.type)
+      if op_info.style == :rpc
         mapped_class, qname = rpcdefinedtype(part)
       else
         mapped_class, qname = documentdefinedtype(part)
@@ -90,10 +85,7 @@ def create_methoddef(op_bind)
     mdef
   end
 
-private
-
-  def dump_method(op_bind)
-    mdef = create_methoddef(op_bind)
+  def dump_method(mdef)
     style = mdef.style
     inputuse = mdef.inputuse
     outputuse = mdef.outputuse
@@ -111,12 +103,6 @@ def dump_method(op_bind)
     :response_style => #{nsym(style)}, :response_use => #{nsym(outputuse)},
     :faults => #{mdef.faults.inspect} }
 __EOD__
-    if inputuse == :encoded or outputuse == :encoded
-      @encoded = true
-    end
-    if inputuse == :literal or outputuse == :literal
-      @literal = true
-    end
     if style == :rpc
       assign_const(mdef.qname.namespace, 'Ns')
       return <<__EOD__
@@ -183,30 +169,6 @@ def documentdefinedtype(part)
     end
   end
 
-  def collect_type(type)
-    # ignore inline type definition.
-    return if type.nil?
-    return if @types.include?(type)
-    @types << type
-    return unless @complextypes[type]
-    collect_elements_type(@complextypes[type].elements)
-  end
-
-  def collect_elements_type(elements)
-    elements.each do |element|
-      case element
-      when WSDL::XMLSchema::Any
-        # nothing to do
-      when WSDL::XMLSchema::Element
-        collect_type(element.type)
-      when WSDL::XMLSchema::Sequence, WSDL::XMLSchema::Choice
-        collect_elements_type(element.elements)
-      else
-        raise RuntimeError.new("unknown type: #{element}")
-      end
-    end
-  end
-
   def param2str(params)
     params.collect { |param|
       mappingstr = mapping_info2str(param.mapped_class, param.qname)
diff --git a/lib/wsdl/soap/servletStubCreator.rb b/lib/wsdl/soap/servletStubCreator.rb
@@ -49,12 +49,9 @@ def dump(service_name)
   def dump_porttype(porttype)
     class_name = mapped_class_name(porttype.name, @modulepath)
     defined_const = {}
-    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
-    methoddef = result[:methoddef]
-
+    methoddef = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
     wsdl_name = @definitions.name ? @definitions.name.name : 'default'
     mrname = safeconstname(wsdl_name + 'MappingRegistry')
-    
     c1 = XSD::CodeGen::ClassDef.new(class_name)
     c1.def_require("soap/rpc/soaplet")
     c1.def_code <<-EOD
diff --git a/lib/wsdl/soap/standaloneServerStubCreator.rb b/lib/wsdl/soap/standaloneServerStubCreator.rb
@@ -50,12 +50,9 @@ def dump(service_name)
   def dump_porttype(porttype)
     class_name = mapped_class_name(porttype.name, @modulepath)
     defined_const = {}
-    result = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
-    methoddef = result[:methoddef]
-
+    methoddef = MethodDefCreator.new(@definitions, @name_creator, @modulepath, defined_const).dump(porttype.name)
     wsdl_name = @definitions.name ? @definitions.name.name : 'default'
     mrname = safeconstname(wsdl_name + 'MappingRegistry')
-    
     c1 = XSD::CodeGen::ClassDef.new(class_name)
     c1.def_require("soap/rpc/standaloneServer")
     c1.def_code <<-EOD
