soap4r-sgonyea 1.5.9

data/lib/soap/version.rb

@@ -0,0 +1,9 @@
+# encoding: ASCII-8BIT
+module SOAP
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 5
+    TINY  = 9
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/soap/wsdlDriver.rb

@@ -0,0 +1,165 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP WSDL driver
+# 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/parser'
+require 'wsdl/importer'
+require 'xsd/qname'
+require 'xsd/codegen/gensupport'
+require 'soap/attrproxy'
+require 'soap/mapping/wsdlencodedregistry'
+require 'soap/mapping/wsdlliteralregistry'
+require 'soap/rpc/driver'
+require 'wsdl/soap/methodDefCreator'
+require 'wsdl/soap/classDefCreatorSupport'
+require 'wsdl/soap/classNameCreator'
+
+
+module SOAP
+
+
+class WSDLDriverFactory
+  include WSDL::SOAP::ClassDefCreatorSupport
+
+  class FactoryError < StandardError; end
+
+  attr_reader :wsdl
+
+  def initialize(wsdl)
+    @wsdl = import(wsdl)
+  end
+  
+  def inspect
+    sprintf("#<%s:%s:0x%x\n\n%s>", self.class.name, @wsdl.name, __id__, dump_method_signatures)
+  end
+
+  def create_rpc_driver(servicename = nil, portname = nil)
+    port = find_port(servicename, portname)
+    drv = SOAP::RPC::Driver.new(port.soap_address.location)
+    if binding = port.find_binding
+      init_driver(drv, binding)
+      add_operation(drv, binding)
+    end
+    drv
+  end
+
+  def dump_method_signatures(servicename = nil, portname = nil)
+    targetservice = XSD::QName.new(@wsdl.targetnamespace, servicename) if servicename
+    targetport = XSD::QName.new(@wsdl.targetnamespace, portname) if portname
+    sig = []
+    element_definitions = @wsdl.collect_elements
+    @wsdl.services.each do |service|
+      next if targetservice and service.name != targetservice
+      service.ports.each do |port|
+        next if targetport and port.name != targetport
+        if porttype = port.porttype
+          assigned_method = collect_assigned_method(porttype.name)
+          if binding = port.porttype.find_binding
+            sig << binding.operations.collect { |op_bind|
+              operation = op_bind.find_operation
+              name = assigned_method[op_bind.boundid] || op_bind.name
+              str = "= #{safemethodname(name)}\n\n"
+              str << dump_method_signature(name, operation, element_definitions)
+              str.gsub(/^#/, " ")
+            }.join("\n")
+          end
+        end
+      end
+    end
+    sig.join("\n")
+  end
+
+private
+
+  def collect_assigned_method(porttypename)
+    name_creator = WSDL::SOAP::ClassNameCreator.new
+    methoddefcreator =
+      WSDL::SOAP::MethodDefCreator.new(@wsdl, name_creator, nil, {})
+    methoddefcreator.dump(porttypename)
+    methoddefcreator.assigned_method
+  end
+
+  def find_port(servicename = nil, portname = nil)
+    service = port = nil
+    if servicename
+      service = @wsdl.service(
+        XSD::QName.new(@wsdl.targetnamespace, servicename))
+    else
+      service = @wsdl.services[0]
+    end
+    if service.nil?
+      raise FactoryError.new("service #{servicename} not found in WSDL")
+    end
+    if portname
+      port = service.ports[XSD::QName.new(@wsdl.targetnamespace, portname)]
+      if port.nil?
+        raise FactoryError.new("port #{portname} not found in WSDL")
+      end
+    else
+      port = service.ports.find { |port| !port.soap_address.nil? }
+      if port.nil?
+        raise FactoryError.new("no ports have soap:address")
+      end
+    end
+    if port.soap_address.nil?
+      raise FactoryError.new("soap:address element not found in WSDL")
+    end
+    port
+  end
+
+  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(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, 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,
+        :request_use => mdef.inputuse,
+        :response_use => mdef.outputuse
+      }
+      qname = mdef.qname
+      soapaction = mdef.soapaction
+      name = mdef.name
+      if mdef.style == :rpc
+        drv.add_rpc_operation(qname, soapaction, name, mdef.parameters, opt)
+      else
+        drv.add_document_operation(soapaction, name, mdef.parameters, opt)
+      end
+      orgname = mdef.qname.name
+      if orgname != name and orgname.capitalize == name.capitalize
+        ::SOAP::Mapping.define_singleton_method(drv, orgname) do |*arg|
+          __send__(name, *arg)
+        end
+      end
+    end
+  end
+
+  def import(location)
+    WSDL::Importer.import(location)
+  end
+end
+
+
+end

data/lib/wsdl/binding.rb

@@ -0,0 +1,66 @@
+# encoding: ASCII-8BIT
+# WSDL4R - WSDL binding 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'
+require 'xsd/namedelements'
+
+
+module WSDL
+
+
+class Binding < Info
+  attr_reader :name		# required
+  attr_reader :type		# required
+  attr_reader :operations
+  attr_reader :soapbinding
+
+  def initialize
+    super
+    @name = nil
+    @type = nil
+    @operations = XSD::NamedElements.new
+    @soapbinding = nil
+  end
+
+  def targetnamespace
+    parent.targetnamespace
+  end
+
+  def parse_element(element)
+    case element
+    when OperationName
+      o = OperationBinding.new
+      @operations << o
+      o
+    when SOAPBindingName
+      o = WSDL::SOAP::Binding.new
+      @soapbinding = o
+      o
+    when DocumentationName
+      o = Documentation.new
+      o
+    else
+      nil
+    end
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when NameAttrName
+      @name = XSD::QName.new(targetnamespace, value.source)
+    when TypeAttrName
+      @type = value
+    else
+      nil
+    end
+  end
+end
+
+
+end

data/lib/wsdl/data.rb

@@ -0,0 +1,65 @@
+# encoding: ASCII-8BIT
+# WSDL4R - WSDL data definitions.
+# 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 'xsd/qname'
+require 'wsdl/documentation'
+require 'wsdl/definitions'
+require 'wsdl/types'
+require 'wsdl/message'
+require 'wsdl/part'
+require 'wsdl/portType'
+require 'wsdl/operation'
+require 'wsdl/param'
+require 'wsdl/binding'
+require 'wsdl/operationBinding'
+require 'wsdl/service'
+require 'wsdl/port'
+require 'wsdl/import'
+
+
+module WSDL
+
+
+ArrayTypeAttrName = XSD::QName.new(Namespace, 'arrayType')
+BindingName = XSD::QName.new(Namespace, 'binding')
+DefinitionsName = XSD::QName.new(Namespace, 'definitions')
+DocumentationName = XSD::QName.new(Namespace, 'documentation')
+FaultName = XSD::QName.new(Namespace, 'fault')
+ImportName = XSD::QName.new(Namespace, 'import')
+InputName = XSD::QName.new(Namespace, 'input')
+MessageName = XSD::QName.new(Namespace, 'message')
+OperationName = XSD::QName.new(Namespace, 'operation')
+OutputName = XSD::QName.new(Namespace, 'output')
+PartName = XSD::QName.new(Namespace, 'part')
+PortName = XSD::QName.new(Namespace, 'port')
+PortTypeName = XSD::QName.new(Namespace, 'portType')
+ServiceName = XSD::QName.new(Namespace, 'service')
+TypesName = XSD::QName.new(Namespace, 'types')
+
+SchemaName = XSD::QName.new(XSD::Namespace, 'schema')
+
+SOAPAddressName = XSD::QName.new(SOAPBindingNamespace, 'address')
+SOAPBindingName = XSD::QName.new(SOAPBindingNamespace, 'binding')
+SOAPHeaderName = XSD::QName.new(SOAPBindingNamespace, 'header')
+SOAPBodyName = XSD::QName.new(SOAPBindingNamespace, 'body')
+SOAPFaultName = XSD::QName.new(SOAPBindingNamespace, 'fault')
+SOAPOperationName = XSD::QName.new(SOAPBindingNamespace, 'operation')
+
+BindingAttrName = XSD::QName.new(nil, 'binding')
+ElementAttrName = XSD::QName.new(nil, 'element')
+LocationAttrName = XSD::QName.new(nil, 'location')
+MessageAttrName = XSD::QName.new(nil, 'message')
+NameAttrName = XSD::QName.new(nil, 'name')
+NamespaceAttrName = XSD::QName.new(nil, 'namespace')
+ParameterOrderAttrName = XSD::QName.new(nil, 'parameterOrder')
+TargetNamespaceAttrName = XSD::QName.new(nil, 'targetNamespace')
+TypeAttrName = XSD::QName.new(nil, 'type')
+
+
+end

data/lib/wsdl/definitions.rb

@@ -0,0 +1,237 @@
+# encoding: ASCII-8BIT
+# WSDL4R - WSDL definitions.
+# 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 'xsd/namedelements'
+
+
+module WSDL
+
+
+class Definitions < Info
+  attr_reader :name
+  attr_reader :targetnamespace
+  attr_reader :imports
+
+  attr_accessor :location
+  attr_reader :importedschema
+
+  def initialize
+    super
+    @name = nil
+    @targetnamespace = nil
+    @location = nil
+    @importedschema = {}
+
+    @types = nil
+    @imports = []
+    @messages = XSD::NamedElements.new
+    @porttypes = XSD::NamedElements.new
+    @bindings = XSD::NamedElements.new
+    @services = XSD::NamedElements.new
+
+    @anontypes = XSD::NamedElements.new
+    @root = self
+  end
+
+  def inspect
+    sprintf("#<%s:0x%x %s>", self.class.name, __id__, @name || '(unnamed)')
+  end
+
+  def targetnamespace=(targetnamespace)
+    @targetnamespace = targetnamespace
+    if @name
+      @name = XSD::QName.new(@targetnamespace, @name.name)
+    end
+  end
+
+  def collect_attributes
+    collect_imports(:collect_attributes)
+  end
+
+  def collect_modelgroups
+    collect_imports(:collect_modelgroups)
+  end
+
+  def collect_attributegroups
+    collect_imports(:collect_attributegroups)
+  end
+
+  def collect_elements
+    collect_imports(:collect_elements)
+  end
+
+  def collect_complextypes
+    result = collect_imports(:collect_complextypes)
+    @anontypes.dup.concat(result)
+  end
+
+  def collect_simpletypes
+    collect_imports(:collect_simpletypes)
+  end
+
+  # ToDo: simpletype must be accepted...
+  def add_type(complextype)
+    @anontypes << complextype
+  end
+
+  def messages
+    result = @messages.dup
+    @imports.each do |import|
+      result.concat(import.content.messages) if self.class === import.content
+    end
+    result
+  end
+
+  def porttypes
+    result = @porttypes.dup
+    @imports.each do |import|
+      result.concat(import.content.porttypes) if self.class === import.content
+    end
+    result
+  end
+
+  def bindings
+    result = @bindings.dup
+    @imports.each do |import|
+      result.concat(import.content.bindings) if self.class === import.content
+    end
+    result
+  end
+
+  def services
+    result = @services.dup
+    @imports.each do |import|
+      result.concat(import.content.services) if self.class === import.content
+    end
+    result
+  end
+
+  def message(name)
+    message = @messages[name]
+    return message if message
+    @imports.each do |import|
+      message = import.content.message(name) if self.class === import.content
+      return message if message
+    end
+    nil
+  end
+
+  def porttype(name)
+    porttype = @porttypes[name]
+    return porttype if porttype
+    @imports.each do |import|
+      porttype = import.content.porttype(name) if self.class === import.content
+      return porttype if porttype
+    end
+    nil
+  end
+
+  def binding(name)
+    binding = @bindings[name]
+    return binding if binding
+    @imports.each do |import|
+      binding = import.content.binding(name) if self.class === import.content
+      return binding if binding
+    end
+    nil
+  end
+
+  def service(name)
+    service = @services[name]
+    return service if service
+    @imports.each do |import|
+      service = import.content.service(name) if self.class === import.content
+      return service if service
+    end
+    nil
+  end
+
+  def porttype_binding(name)
+    binding = @bindings.find { |item| item.type == name }
+    return binding if binding
+    @imports.each do |import|
+      binding = import.content.porttype_binding(name) if self.class === import.content
+      return binding if binding
+    end
+    nil
+  end
+
+  def parse_element(element)
+    case element
+    when ImportName
+      o = Import.new
+      @imports << o
+      o
+    when TypesName
+      o = Types.new
+      @types = o
+      o
+    when MessageName
+      o = Message.new
+      @messages << o
+      o
+    when PortTypeName
+      o = PortType.new
+      @porttypes << o
+      o
+    when BindingName
+      o = Binding.new
+      @bindings << o
+      o
+    when ServiceName
+      o = Service.new
+      @services << o
+      o
+    when DocumentationName
+      o = Documentation.new
+      o
+    else
+      nil
+    end
+  end
+
+  def parse_attr(attr, value)
+    case attr
+    when NameAttrName
+      @name = XSD::QName.new(targetnamespace, value.source)
+    when TargetNamespaceAttrName
+      self.targetnamespace = value.source
+    else
+      nil
+    end
+  end
+
+  def self.parse_element(element)
+    if element == DefinitionsName
+      Definitions.new
+    else
+      nil
+    end
+  end
+
+private
+
+  def collect_imports(method)
+    result = XSD::NamedElements.new
+    if @types
+      @types.schemas.each do |schema|
+	result.concat(schema.send(method))
+      end
+    end
+    @imports.each do |import|
+      result.concat(import.content.send(method))
+    end
+    result
+  end
+
+end
+
+
+end