soap4r-ng 2.0.1

data/lib/wsdl/soap/methodDefCreator.rb

@@ -0,0 +1,200 @@
+# encoding: UTF-8
+# WSDL4R - Creating method definition 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 'soap/rpc/element'
+require 'soap/rpc/methodDef'
+
+
+module WSDL
+module SOAP
+
+
+class MethodDefCreator
+  include ClassDefCreatorSupport
+
+  attr_reader :definitions
+  # TODO: should not export this kind of stateful information.
+  # will be rewwritten in 1.6.1
+  attr_reader :assigned_method
+
+  def initialize(definitions, name_creator, modulepath, defined_const)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+    @simpletypes = @definitions.collect_simpletypes
+    @complextypes = @definitions.collect_complextypes
+    @elements = @definitions.collect_elements
+    @defined_const = defined_const
+    @assigned_method = {}
+  end
+
+  def dump(name)
+    methoddef = ""
+    porttype = @definitions.porttype(name)
+    binding = porttype.find_binding
+    if binding
+      create(binding.name).each do |mdef|
+        methoddef << ",\n" unless methoddef.empty?
+        methoddef << dump_method(mdef).chomp
+      end
+    end
+    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
+    mdef = ::SOAP::RPC::MethodDef.new(name, soapaction, qname)
+    op_info.parts.each do |part|
+      if op_info.style == :rpc
+        mapped_class, qname = rpcdefinedtype(part)
+      else
+        mapped_class, qname = documentdefinedtype(part)
+      end
+      mdef.add_parameter(part.io_type, part.name, qname, mapped_class)
+    end
+    op_info.faults.each do |name, faultinfo|
+      faultclass = mapped_class_name(name, @modulepath)
+      mdef.faults[faultclass] = faultinfo
+    end
+    mdef.style = op_info.style
+    mdef.inputuse = op_info.inputuse
+    mdef.outputuse = op_info.outputuse
+    mdef
+  end
+
+  def dump_method(mdef)
+    style = mdef.style
+    inputuse = mdef.inputuse
+    outputuse = mdef.outputuse
+    paramstr = param2str(mdef.parameters)
+    if paramstr.empty?
+      paramstr = '[]'
+    else
+      paramstr = "[ " << paramstr.split(/\r?\n/).join("\n    ") << " ]"
+    end
+    definitions = <<__EOD__
+#{ndq(mdef.soapaction)},
+  #{dq(mdef.name)},
+  #{paramstr},
+  { :request_style =>  #{nsym(style)}, :request_use =>  #{nsym(inputuse)},
+    :response_style => #{nsym(style)}, :response_use => #{nsym(outputuse)},
+    :faults => #{mdef.faults.inspect} }
+__EOD__
+    if style == :rpc
+      assign_const(mdef.qname.namespace, 'Ns')
+      return <<__EOD__
+[ #{dqname(mdef.qname)},
+  #{definitions}]
+__EOD__
+    else
+      return <<__EOD__
+[ #{definitions}]
+__EOD__
+    end
+  end
+
+  def assign_method_name(op_bind)
+    method_name = safemethodname(op_bind.name)
+    i = 1 # starts from _2
+    while @assigned_method.value?(method_name)
+      i += 1
+      method_name = safemethodname("#{op_bind.name}_#{i}")
+    end
+    @assigned_method[op_bind.boundid] = method_name
+    method_name
+  end
+
+  def rpcdefinedtype(part)
+    if mapped = basetype_mapped_class(part.type)
+      return ['::' + mapped.name, nil]
+    elsif definedtype = @simpletypes[part.type]
+      return [nil, definedtype.name]
+    elsif definedtype = @elements[part.element]
+      return [nil, part.element]
+    elsif definedtype = @complextypes[part.type]
+      case definedtype.compoundtype
+      when :TYPE_STRUCT, :TYPE_EMPTY, :TYPE_ARRAY, :TYPE_SIMPLE
+        type = mapped_class_name(part.type, @modulepath)
+	return [type, part.type]
+      when :TYPE_MAP
+	return [Hash.name, part.type]
+      else
+	raise NotImplementedError.new("must not reach here: #{definedtype.compoundtype}")
+      end
+    elsif part.type == XSD::AnyTypeName
+      return [nil, nil]
+    else
+      raise RuntimeError.new("part: #{part.name} cannot be resolved")
+    end
+  end
+
+  def documentdefinedtype(part)
+    if mapped = basetype_mapped_class(part.type)
+      return ['::' + mapped.name, XSD::QName.new(nil, part.name)]
+    elsif definedtype = @simpletypes[part.type]
+      if definedtype.base
+        return ['::' + basetype_mapped_class(definedtype.base).name, XSD::QName.new(nil, part.name)]
+      else
+        raise RuntimeError.new("unsupported simpleType: #{definedtype}")
+      end
+    elsif definedtype = @elements[part.element]
+      return ['::SOAP::SOAPElement', part.element]
+    elsif definedtype = @complextypes[part.type]
+      return ['::SOAP::SOAPElement', part.type]
+    else
+      raise RuntimeError.new("part: #{part.name} cannot be resolved")
+    end
+  end
+
+  def param2str(params)
+    params.collect { |param|
+      mappingstr = mapping_info2str(param.mapped_class, param.qname)
+      "[:#{param.io_type.id2name}, #{dq(param.name)}, #{mappingstr}]"
+    }.join(",\n")
+  end
+
+  def mapping_info2str(mapped_class, qname)
+    if qname.nil?
+      "[#{ndq(mapped_class)}]" 
+    else
+      "[#{ndq(mapped_class)}, #{ndq(qname.namespace)}, #{dq(qname.name)}]" 
+    end
+  end
+
+  def ele2str(ele)
+    qualified = ele
+    if qualified
+      "true"
+    else
+      "false"
+    end
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/operation.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+# WSDL4R - WSDL SOAP operation 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 Operation < Info
+  class ParamInfo
+    attr_reader :style
+    attr_reader :op_name
+    attr_reader :optype_name
+    attr_reader :encodingstyle
+    attr_reader :headerparts
+    attr_reader :bodyparts
+    attr_reader :faultpart
+    attr_reader :soapaction
+    
+    def initialize(style, use, encodingstyle, op_name, optype_name,
+        headerparts, bodyparts, faultpart, soapaction)
+      @style = style
+      @use = use
+      @encodingstyle = encodingstyle
+      @op_name = op_name
+      @optype_name = optype_name
+      @headerparts = headerparts
+      @bodyparts = bodyparts
+      @faultpart = faultpart
+      @soapaction = soapaction
+    end
+  end
+
+  attr_reader :soapaction
+  attr_reader :style
+
+  def initialize
+    super
+    @soapaction = nil
+    @style = nil
+  end
+
+  def parse_element(element)
+    nil
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when StyleAttrName
+      if ["document", "rpc"].include?(value.source)
+	@style = value.source.intern
+      else
+	raise Parser::AttributeConstraintError.new(
+          "Unexpected value #{ value }.")
+      end
+    when SOAPActionAttrName
+      @soapaction = value.source
+    else
+      nil
+    end
+  end
+
+  def operation_style
+    return @style if @style
+    if parent_binding.soapbinding
+      return parent_binding.soapbinding.style
+    end
+    nil
+  end
+
+private
+
+  def parent_binding
+    parent.parent
+  end
+
+  def create_param_info(name_info, param)
+    op_style = operation_style()
+    op_use = param.soapbody_use
+    op_encodingstyle = param.soapbody_encodingstyle
+    op_name = name_info.op_name
+    optype_name = name_info.optype_name
+    soapheader = param.soapheader
+    headerparts = soapheader.collect { |item| item.find_part }
+    soapbody = param.soapbody
+    if soapbody.namespace
+      op_name = XSD::QName.new(soapbody.namespace, op_name.name)
+    end
+    if soapbody.parts
+      target = soapbody.parts.split(/\s+/)
+      bodyparts = name_info.parts.find_all { |part|
+	target.include?(part.name)
+      }
+    else
+      bodyparts = name_info.parts
+    end
+    faultpart = nil
+    ParamInfo.new(op_style, op_use, op_encodingstyle, op_name, optype_name,
+      headerparts, bodyparts, faultpart, parent.soapaction)
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/servantSkeltonCreator.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+# WSDL4R - Creating servant 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'
+require 'xsd/codegen'
+
+
+module WSDL
+module SOAP
+
+
+class ServantSkeltonCreator
+  include ClassDefCreatorSupport
+  include XSD::CodeGen::GenSupport
+
+  attr_reader :definitions
+
+  def initialize(definitions, name_creator, modulepath = nil)
+    @definitions = definitions
+    @name_creator = name_creator
+    @modulepath = modulepath
+  end
+
+  def dump(porttype = nil)
+    result = ""
+    if @modulepath
+      result << "\n"
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above      
+      result << modulepath.collect { |ele| "module #{ele}" }.join("; ")
+      result << "\n\n"
+    end
+    if porttype.nil?
+      @definitions.porttypes.each do |porttype|
+	result << dump_porttype(porttype)
+	result << "\n"
+      end
+    else
+      result << dump_porttype(porttype)
+    end
+    if @modulepath
+      result << "\n\n"
+      modulepath = @modulepath.respond_to?(:lines) ? @modulepath.lines : @modulepath # RubyJedi: compatible with Ruby 1.8.6 and above      
+      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)
+    class_name = mapped_class_basename(porttype.name, @modulepath)
+    c = XSD::CodeGen::ClassDef.new(class_name)
+    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
+        methodname = safemethodname(name)
+        input = operation.input
+        params = input.find_message.parts.collect { |part|
+          safevarname(part.name)
+        }
+        m = XSD::CodeGen::MethodDef.new(methodname, params) do <<-EOD
+              p [#{params.join(", ")}]
+              raise NotImplementedError.new
+            EOD
+          end
+        m.comment = dump_method_signature(methodname, operation, element_definitions)
+        c.add_method(m)
+      end
+    end
+    c.dump
+  end
+end
+
+
+end
+end

data/lib/wsdl/soap/servletStubCreator.rb

@@ -0,0 +1,105 @@
+# encoding: UTF-8
+# WSDL4R - Creating servlet stub 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/mappingRegistryCreator'
+require 'wsdl/soap/methodDefCreator'
+require 'wsdl/soap/classDefCreatorSupport'
+
+
+module WSDL
+module SOAP
+
+
+class ServletStubCreator
+  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)
+    warn("- Servlet stub can have only 1 port for now.  So creating stub for the first port and rests are ignored.")
+    services = @definitions.service(service_name)
+    unless services
+      raise RuntimeError.new("service not defined: #{service_name}")
+    end
+    ports = services.ports
+    if ports.empty?
+      raise RuntimeError.new("ports not found for #{service_name}")
+    end
+    port = ports[0]
+    if port.porttype.nil?
+      raise RuntimeError.new("porttype not found for #{port}")
+    end
+    dump_porttype(port.porttype)
+  end
+
+private
+
+  def dump_porttype(porttype)
+    class_name = mapped_class_name(porttype.name, @modulepath)
+    defined_const = {}
+    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
+Methods = [
+#{methoddef.gsub(/^/, "  ")}
+]
+    EOD
+    defined_const.each do |ns, tag|
+      c1.def_const(tag, dq(ns))
+    end
+    c2 = XSD::CodeGen::ClassDef.new(class_name + "Servlet",
+      "::SOAP::RPC::SOAPlet")
+    c2.def_method("initialize", "router = nil") do
+      <<-EOD
+        super(router)
+        servant = #{class_name}.new
+        #{class_name}::Methods.each do |definitions|
+          opt = definitions.last
+          if opt[:request_style] == :document
+            @router.add_document_operation(servant, *definitions)
+          else
+            @router.add_rpc_operation(servant, *definitions)
+          end
+        end
+        @router.mapping_registry = #{mrname}::EncodedRegistry
+        @router.literal_mapping_registry = #{mrname}::LiteralRegistry
+      EOD
+    end
+    c1.dump + "\n" + c2.dump + format(<<-EOD)
+
+      if $0 == __FILE__
+        require 'webrick'
+        server = WEBrick::HTTPServer.new(
+          :BindAddress => "0.0.0.0",
+          :Port => 10080,
+          :DocumentRoot => "."
+        )
+        server.mount("/", #{c2.name}.new)
+        trap(:INT) do
+          server.shutdown
+        end
+        server.start
+      end
+    EOD
+  end
+end
+
+
+end
+end