soap4r_es 0.0.1

data/lib/soap/element.rb

@@ -0,0 +1,278 @@
+# encoding: UTF-8
+# SOAP4R - SOAP elements library
+# 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 'soap/baseData'
+
+
+module SOAP
+
+
+###
+## SOAP elements
+#
+module SOAPEnvelopeElement; end
+
+class SOAPFault < SOAPStruct
+  include SOAPEnvelopeElement
+  include SOAPCompoundtype
+
+public
+
+  def faultcode
+    self['faultcode']
+  end
+
+  def faultstring
+    self['faultstring']
+  end
+
+  def faultactor
+    self['faultactor']
+  end
+
+  def detail
+    self['detail']
+  end
+
+  def faultcode=(rhs)
+    self['faultcode'] = rhs
+  end
+
+  def faultstring=(rhs)
+    self['faultstring'] = rhs
+  end
+
+  def faultactor=(rhs)
+    self['faultactor'] = rhs
+  end
+
+  def detail=(rhs)
+    self['detail'] = rhs
+  end
+
+  def initialize(faultcode = nil, faultstring = nil, faultactor = nil, detail = nil)
+    super(EleFaultName)
+    @elename = EleFaultName
+    @encodingstyle = EncodingNamespace
+    if faultcode
+      self.faultcode = faultcode
+      self.faultstring = faultstring
+      self.faultactor = faultactor
+      self.detail = detail
+      self.faultcode.elename = EleFaultCodeName if self.faultcode
+      self.faultstring.elename = EleFaultStringName if self.faultstring
+      self.faultactor.elename = EleFaultActorName if self.faultactor
+      self.detail.elename = EleFaultDetailName if self.detail
+    end
+    faultcode.parent = self if faultcode
+    faultstring.parent = self if faultstring
+    faultactor.parent = self if faultactor
+    detail.parent = self if detail
+  end
+
+  def encode(generator, ns, attrs = {})
+    Generator.assign_ns(attrs, ns, EnvelopeNamespace)
+    Generator.assign_ns(attrs, ns, EncodingNamespace)
+    attrs[ns.name(AttrEncodingStyleName)] = EncodingNamespace
+    name = ns.name(@elename)
+    generator.encode_tag(name, attrs)
+    yield(self.faultcode)
+    yield(self.faultstring)
+    yield(self.faultactor)
+    yield(self.detail) if self.detail
+    generator.encode_tag_end(name, true)
+  end
+end
+
+
+class SOAPBody < SOAPStruct
+  include SOAPEnvelopeElement
+
+  attr_reader :is_fault
+
+  def initialize(data = nil, is_fault = false)
+    super(nil)
+    @elename = EleBodyName
+    @encodingstyle = nil
+    if data
+      if data.respond_to?(:to_xmlpart)
+        data = SOAP::SOAPRawData.new(data)
+      elsif defined?(::REXML) && defined?(::REXML::Element) && data.is_a?(::REXML::Element)
+        data = SOAP::SOAPRawData.new(SOAP::SOAPREXMLElementWrap.new(data))
+      end
+      if data.respond_to?(:elename)
+        add(data.elename.name, data)
+      else
+        data.to_a.each do |datum|
+          add(datum.elename.name, datum)
+        end
+      end
+    end
+    @is_fault = is_fault
+  end
+
+  def encode(generator, ns, attrs = {})
+    name = ns.name(@elename)
+    generator.encode_tag(name, attrs)
+    @data.each do |data|
+      yield(data)
+    end
+    generator.encode_tag_end(name, @data.size > 0)
+  end
+
+  def root_node
+    @data.each do |node|
+      if node.root == 1
+	return node
+      end
+    end
+    # No specified root...
+    @data.each do |node|
+      if node.root != 0
+	return node
+      end
+    end
+    raise Parser::FormatDecodeError.new('no root element')
+  end
+end
+
+
+class SOAPHeaderItem < XSD::NSDBase
+  include SOAPEnvelopeElement
+  include SOAPCompoundtype
+
+public
+
+  attr_accessor :element
+  attr_accessor :mustunderstand
+  attr_accessor :encodingstyle
+  attr_accessor :actor
+
+  def initialize(element, mustunderstand = true, encodingstyle = nil, actor = nil)
+    super()
+    @type = nil
+    @element = element
+    @mustunderstand = mustunderstand
+    @encodingstyle = encodingstyle
+    @actor = actor
+    element.parent = self if element
+    element.qualified = true
+  end
+
+  def encode(generator, ns, attrs = {})
+    attrs.each do |key, value|
+      @element.extraattr[key] = value
+    end
+    # to remove mustUnderstand attribute, set it to nil
+    unless @mustunderstand.nil?
+      @element.extraattr[AttrMustUnderstandName] = (@mustunderstand ? '1' : '0')
+    end
+    if @encodingstyle
+      @element.extraattr[AttrEncodingStyleName] = @encodingstyle
+    end
+    unless @element.encodingstyle
+      @element.encodingstyle = @encodingstyle
+    end
+    if @actor
+      @element.extraattr[AttrActorName] = @actor
+    end
+    yield(@element)
+  end
+end
+
+
+class SOAPHeader < SOAPStruct
+  include SOAPEnvelopeElement
+
+  attr_writer :force_encode
+
+  def initialize
+    super(nil)
+    @elename = EleHeaderName
+    @encodingstyle = nil
+    @force_encode = false
+  end
+
+  def encode(generator, ns, attrs = {})
+    name = ns.name(@elename)
+    generator.encode_tag(name, attrs)
+    @data.each do |data|
+      yield(data)
+    end
+    generator.encode_tag_end(name, @data.size > 0)
+  end
+
+  def add(name, value)
+    actor = value.extraattr[AttrActorName]
+    mu = value.extraattr[AttrMustUnderstandName]
+    encstyle = value.extraattr[AttrEncodingStyleName]
+    mu_value = mu.nil? ? nil : (mu == '1')
+    # to remove mustUnderstand attribute, set it to nil
+    item = SOAPHeaderItem.new(value, mu_value, encstyle, actor)
+    super(name, item)
+  end
+
+  def length
+    @data.length
+  end
+  alias size length
+
+  def encode?
+    @force_encode or length > 0
+  end
+end
+
+
+class SOAPEnvelope < XSD::NSDBase
+  include SOAPEnvelopeElement
+  include SOAPCompoundtype
+
+  attr_reader :header
+  attr_reader :body
+  attr_reader :external_content
+
+  def initialize(header = nil, body = nil)
+    super()
+    @type = nil
+    @elename = EleEnvelopeName
+    @encodingstyle = nil
+    @header = header
+    @body = body
+    @external_content = {}
+    header.parent = self if header
+    body.parent = self if body
+  end
+
+  def header=(header)
+    header.parent = self
+    @header = header
+  end
+
+  def body=(body)
+    body.parent = self
+    @body = body
+  end
+
+  def encode(generator, ns, attrs = {})
+    Generator.assign_ns(attrs, ns, elename.namespace)
+    name = ns.name(@elename)
+    generator.encode_tag(name, attrs)
+    yield(@header) if @header and @header.encode?
+    yield(@body)
+    generator.encode_tag_end(name, true)
+  end
+
+  def to_ary
+    [header, body]
+  end
+end
+
+
+end

data/lib/soap/encodingstyle/aspDotNetHandler.rb

@@ -0,0 +1,208 @@
+# encoding: UTF-8
+# SOAP4R - ASP.NET EncodingStyle handler library
+# 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 'soap/encodingstyle/handler'
+
+
+module SOAP
+module EncodingStyle
+
+
+class ASPDotNetHandler < Handler
+  Namespace = 'http://tempuri.org/ASP.NET'
+  add_handler
+
+  def initialize(charset = nil)
+    super(charset)
+    @textbuf = ''
+    @decode_typemap = nil
+  end
+
+
+  ###
+  ## encode interface.
+  #
+  def encode_data(generator, ns, data, parent)
+    attrs = {}
+    # ASPDotNetHandler is intended to be used for accessing an ASP.NET doc/lit
+    # service as an rpc/encoded service.  in the situation, local elements
+    # should be qualified.  propagate parent's namespace to children.
+    if data.elename.namespace.nil?
+      data.elename =
+        XSD::QName.new(parent.elename.namespace, data.elename.name)
+    end
+    name = generator.encode_name(ns, data, attrs)
+    case data
+    when SOAPRawString
+      generator.encode_tag(name, attrs)
+      generator.encode_rawstring(data.to_s)
+    when XSD::XSDString
+      generator.encode_tag(name, attrs)
+      generator.encode_string(@charset ?
+        XSD::Charset.encoding_to_xml(data.to_s, @charset) : data.to_s)
+    when XSD::XSDAnySimpleType
+      generator.encode_tag(name, attrs)
+      generator.encode_string(data.to_s)
+    when SOAPStruct
+      generator.encode_tag(name, attrs)
+      data.each do |key, value|
+        generator.encode_child(ns, value, data)
+      end
+    when SOAPArray
+      generator.encode_tag(name, attrs)
+      data.traverse do |child, *rank|
+	data.position = nil
+        generator.encode_child(ns, child, data)
+      end
+    else
+      raise EncodingStyleError.new(
+        "unknown object:#{data} in this encodingStyle")
+    end
+  end
+
+  def encode_data_end(generator, ns, data, parent)
+    name = generator.encode_name_end(ns, data)
+    cr = (data.is_a?(SOAPCompoundtype) and data.have_member)
+    generator.encode_tag_end(name, cr)
+  end
+
+
+  ###
+  ## decode interface.
+  #
+  class SOAPTemporalObject
+    attr_accessor :parent
+
+    def initialize
+      @parent = nil
+    end
+  end
+
+  class SOAPUnknown < SOAPTemporalObject
+    def initialize(handler, elename)
+      super()
+      @handler = handler
+      @elename = elename
+    end
+
+    def as_struct
+      o = SOAPStruct.decode(@elename, XSD::AnyTypeName)
+      o.parent = @parent
+      o.type.name = @name
+      @handler.decode_parent(@parent, o)
+      o
+    end
+
+    def as_string
+      o = SOAPString.decode(@elename)
+      o.parent = @parent
+      @handler.decode_parent(@parent, o)
+      o
+    end
+  end
+
+  def decode_tag(ns, elename, attrs, parent)
+    @textbuf = ''
+    o = SOAPUnknown.new(self, elename)
+    o.parent = parent
+    o
+  end
+
+  def decode_tag_end(ns, node)
+    o = node.node
+    if o.is_a?(SOAPUnknown)
+      newnode = o.as_string
+#	if /\A\s*\z/ =~ @textbuf
+#	  o.as_struct
+#	else
+#	  o.as_string
+#	end
+      node.replace_node(newnode)
+      o = node.node
+    end
+
+    decode_textbuf(o)
+    @textbuf = ''
+  end
+
+  def decode_text(ns, text)
+    # @textbuf is set at decode_tag_end.
+    @textbuf << text
+  end
+
+  def decode_prologue
+  end
+
+  def decode_epilogue
+  end
+
+  def decode_parent(parent, node)
+    case parent.node
+    when SOAPUnknown
+      newparent = parent.node.as_struct
+      node.parent = newparent
+      parent.replace_node(newparent)
+      decode_parent(parent, node)
+
+    when SOAPStruct
+      data = parent.node[node.elename.name]
+      case data
+      when nil
+	parent.node.add(node.elename.name, node)
+      when SOAPArray
+	name, type_ns = node.elename.name, node.type.namespace
+	data.add(node)
+	node.elename, node.type.namespace = name, type_ns
+      else
+	parent.node[node.elename.name] = SOAPArray.new
+	name, type_ns = data.elename.name, data.type.namespace
+	parent.node[node.elename.name].add(data)
+	data.elename.name, data.type.namespace = name, type_ns
+	name, type_ns = node.elename.name, node.type.namespace
+	parent.node[node.elename.name].add(node)
+	node.elename.name, node.type.namespace = name, type_ns
+      end
+
+    when SOAPArray
+      if node.position
+	parent.node[*(decode_arypos(node.position))] = node
+	parent.node.sparse = true
+      else
+	parent.node.add(node)
+      end
+
+    when SOAPBasetype
+      raise EncodingStyleError.new("SOAP base type must not have a child")
+
+    else
+      # SOAPUnknown does not have parent.
+      # raise EncodingStyleError.new("illegal parent: #{parent}")
+    end
+  end
+
+private
+
+  def decode_textbuf(node)
+    if node.is_a?(XSD::XSDString)
+      if @charset
+	node.set(XSD::Charset.encoding_from_xml(@textbuf, @charset))
+      else
+	node.set(@textbuf)
+      end
+    else
+      # Nothing to do...
+    end
+  end
+end
+
+ASPDotNetHandler.new
+
+
+end
+end

data/lib/soap/encodingstyle/handler.rb

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+# SOAP4R - EncodingStyle handler library
+# 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 'soap/soap'
+require 'soap/baseData'
+require 'soap/element'
+
+
+module SOAP
+module EncodingStyle
+
+
+class Handler
+  @@handlers = {}
+
+  class EncodingStyleError < Error; end
+
+  class << self
+    def uri
+      self::Namespace
+    end
+
+    def handler(uri)
+      @@handlers[uri]
+    end
+
+    def each
+      @@handlers.each do |key, value|
+	yield(value)
+      end
+    end
+
+  private
+
+    def add_handler
+      @@handlers[self.uri] = self
+    end
+  end
+
+  attr_reader :charset
+  attr_accessor :generate_explicit_type
+  def decode_typemap=(definedtypes)
+    @decode_typemap = definedtypes
+  end
+
+  def initialize(charset)
+    @charset = charset
+    @generate_explicit_type = true
+    @decode_typemap = nil
+  end
+
+  ###
+  ## encode interface.
+  #
+  # Returns a XML instance as a string.
+  def encode_data(generator, ns, data, parent)
+    raise NotImplementError
+  end
+
+  def encode_data_end(generator, ns, data, parent)
+    raise NotImplementError
+  end
+
+  def encode_prologue
+  end
+
+  def encode_epilogue
+  end
+
+  ###
+  ## decode interface.
+  #
+  # Returns SOAP/OM data.
+  def decode_tag(ns, name, attrs, parent)
+    raise NotImplementError
+  end
+
+  def decode_tag_end(ns, name)
+    raise NotImplementError
+  end
+
+  def decode_text(ns, text)
+    raise NotImplementError
+  end
+
+  def decode_prologue
+  end
+
+  def decode_epilogue
+  end
+
+  def encode_attr_key(attrs, ns, qname)
+    if qname.namespace.nil?
+      qname.name
+    else
+      unless ns.assigned_as_tagged?(qname.namespace)
+        Generator.assign_ns!(attrs, ns, qname.namespace)
+      end
+      ns.name_attr(qname)
+    end
+  end
+
+  def encode_qname(attrs, ns, qname)
+    if qname.namespace.nil?
+      qname.name
+    else
+      Generator.assign_ns(attrs, ns, qname.namespace)
+      ns.name(qname)
+    end
+  end
+end
+
+
+end
+end