In Files

  • wsdl/definitions.rb
  • wsdl/soap/definitions.rb

Class/Module Index [+]

Quicksearch

WSDL::Definitions

Attributes

importedschema[R]
imports[R]
location[RW]
name[R]
targetnamespace[R]

Public Class Methods

array_complextype() click to toggle source 
 
               # File wsdl/soap/definitions.rb, line 26
def self.array_complextype
  type = XMLSchema::ComplexType.new(::SOAP::ValueArrayName)
  type.complexcontent = XMLSchema::ComplexContent.new
  type.complexcontent.base = ::SOAP::ValueArrayName
  attr = XMLSchema::Attribute.new
  attr.ref = ::SOAP::AttrArrayTypeName
  anytype = XSD::AnyTypeName.dup
  anytype.name += '[]'
  attr.arytype = anytype
  type.complexcontent.attributes << attr
  type
end
exception_complextype() click to toggle source 
 
               # File wsdl/soap/definitions.rb, line 62
def self.exception_complextype
  type = XMLSchema::ComplexType.new(XSD::QName.new(
      ::SOAP::Mapping::RubyCustomTypeNamespace, 'SOAPException'))
  excn_name = XMLSchema::Element.new(XSD::QName.new(nil, 'excn_type_name'), XSD::XSDString::Type)
  cause = XMLSchema::Element.new(XSD::QName.new(nil, 'cause'), XSD::AnyTypeName)
  backtrace = XMLSchema::Element.new(XSD::QName.new(nil, 'backtrace'), ::SOAP::ValueArrayName)
  message = XMLSchema::Element.new(XSD::QName.new(nil, 'message'), XSD::XSDString::Type)
  type.all_elements = [excn_name, cause, backtrace, message]
  type
end
fault_complextype() click to toggle source

begin ↑

<xs:complexType name=“Fault” final=“extension”>

<xs:sequence>
  <xs:element name="faultcode" type="xs:QName" /> 
  <xs:element name="faultstring" type="xs:string" /> 
  <xs:element name="faultactor" type="xs:anyURI" minOccurs="0" /> 
  <xs:element name="detail" type="tns:detail" minOccurs="0" /> 
</xs:sequence>

</xs:complexType>

end ↑

 
               # File wsdl/soap/definitions.rb, line 49
def self.fault_complextype
  type = XMLSchema::ComplexType.new(::SOAP::EleFaultName)
  faultcode = XMLSchema::Element.new(::SOAP::EleFaultCodeName, XSD::XSDQName::Type)
  faultstring = XMLSchema::Element.new(::SOAP::EleFaultStringName, XSD::XSDString::Type)
  faultactor = XMLSchema::Element.new(::SOAP::EleFaultActorName, XSD::XSDAnyURI::Type)
  faultactor.minoccurs = 0
  detail = XMLSchema::Element.new(::SOAP::EleFaultDetailName, XSD::AnyTypeName)
  detail.minoccurs = 0
  type.all_elements = [faultcode, faultstring, faultactor, detail]
  type.final = 'extension'
  type
end
new() click to toggle source 
 
               # File wsdl/definitions.rb, line 24
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
parse_element(element) click to toggle source 
 
               # File wsdl/definitions.rb, line 237
def self.parse_element(element)
  if element == DefinitionsName
    Definitions.new
  else
    nil
  end
end
soap_rpc_complextypes() click to toggle source 
 
               # File wsdl/soap/definitions.rb, line 18
def self.soap_rpc_complextypes
  types = XSD::NamedElements.new
  types << array_complextype
  types << fault_complextype
  types << exception_complextype
  types
end

Public Instance Methods

add_type(complextype) click to toggle source

ToDo: simpletype must be accepted…

 
               # File wsdl/definitions.rb, line 106
def add_type(complextype)
  @anontypes << complextype
end
binding(name) click to toggle source 
 
               # File wsdl/definitions.rb, line 162
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
bindings() click to toggle source 
 
               # File wsdl/definitions.rb, line 126
def bindings
  result = @bindings.dup
  @imports.each do |import|
    result.concat(import.content.bindings) if self.class === import.content
  end
  result
end
collect_attributes() click to toggle source 
 
               # File wsdl/definitions.rb, line 53
def collect_attributes
  result = XSD::NamedElements.new
  if @types
    @types.schemas.each do |schema|
      result.concat(schema.collect_attributes)
    end
  end
  @imports.each do |import|
    result.concat(import.content.collect_attributes)
  end
  result
end
collect_complextypes() click to toggle source 
 
               # File wsdl/definitions.rb, line 79
def collect_complextypes
  result = @anontypes.dup
  if @types
    @types.schemas.each do |schema|
      result.concat(schema.collect_complextypes)
    end
  end
  @imports.each do |import|
    result.concat(import.content.collect_complextypes)
  end
  result
end
collect_elements() click to toggle source 
 
               # File wsdl/definitions.rb, line 66
def collect_elements
  result = XSD::NamedElements.new
  if @types
    @types.schemas.each do |schema|
      result.concat(schema.collect_elements)
    end
  end
  @imports.each do |import|
    result.concat(import.content.collect_elements)
  end
  result
end
collect_faulttypes() click to toggle source 
 
               # File wsdl/soap/definitions.rb, line 78
def collect_faulttypes
  result = []
  collect_fault_messages.each do |name|
    faultparts = message(name).parts
    if faultparts.size != 1
      raise RuntimeError.new("expecting fault message to have only 1 part")
    end
    if result.index(faultparts[0].type).nil?
      result << faultparts[0].type
    end
  end
  result
end
collect_simpletypes() click to toggle source 
 
               # File wsdl/definitions.rb, line 92
def collect_simpletypes
  result = XSD::NamedElements.new
  if @types
    @types.schemas.each do |schema|
      result.concat(schema.collect_simpletypes)
    end
  end
  @imports.each do |import|
    result.concat(import.content.collect_simpletypes)
  end
  result
end
inspect() click to toggle source 
 
               # File wsdl/definitions.rb, line 42
def inspect
  sprintf("#<%s:0x%x %s>", self.class.name, __id__, @name || '(unnamed)')
end
message(name) click to toggle source 
 
               # File wsdl/definitions.rb, line 142
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
messages() click to toggle source 
 
               # File wsdl/definitions.rb, line 110
def messages
  result = @messages.dup
  @imports.each do |import|
    result.concat(import.content.messages) if self.class === import.content
  end
  result
end
parse_attr(attr, value) click to toggle source 
 
               # File wsdl/definitions.rb, line 226
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
parse_element(element) click to toggle source 
 
               # File wsdl/definitions.rb, line 192
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
porttype(name) click to toggle source 
 
               # File wsdl/definitions.rb, line 152
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
porttype_binding(name) click to toggle source 
 
               # File wsdl/definitions.rb, line 182
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
porttypes() click to toggle source 
 
               # File wsdl/definitions.rb, line 118
def porttypes
  result = @porttypes.dup
  @imports.each do |import|
    result.concat(import.content.porttypes) if self.class === import.content
  end
  result
end
service(name) click to toggle source 
 
               # File wsdl/definitions.rb, line 172
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
services() click to toggle source 
 
               # File wsdl/definitions.rb, line 134
def services
  result = @services.dup
  @imports.each do |import|
    result.concat(import.content.services) if self.class === import.content
  end
  result
end
soap_rpc_complextypes(binding) click to toggle source 
 
               # File wsdl/soap/definitions.rb, line 73
def soap_rpc_complextypes(binding)
  types = rpc_operation_complextypes(binding)
  types + self.class.soap_rpc_complextypes
end
targetnamespace=(targetnamespace) click to toggle source 
 
               # File wsdl/definitions.rb, line 46
def targetnamespace=(targetnamespace)
  @targetnamespace = targetnamespace
  if @name
    @name = XSD::QName.new(@targetnamespace, @name.name)
  end
end