Class: SOAP::EncodingStyle::LiteralHandler

Inherits:
Handler show all
Defined in:
lib/soap/encodingstyle/literalHandler.rb

Defined Under Namespace

Classes: SOAPTemporalObject, SOAPUnknown

Constant Summary collapse

Namespace = 
SOAP::LiteralNamespace

Instance Attribute Summary

Attributes inherited from Handler

#charset, #generate_explicit_type

Instance Method Summary collapse

Methods inherited from Handler

#decode_typemap=, each, #encode_epilogue, #encode_prologue, handler, uri

Constructor Details

#initialize(charset = nil) ⇒ LiteralHandler

Returns a new instance of LiteralHandler.



20
21
22
23
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 20

def initialize(charset = nil)
  super(charset)
  @textbuf = ''
end

Instance Method Details

#decode_attrs(ns, attrs) ⇒ Object 



165
166
167
168
169
170
171
172
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 165

def decode_attrs(ns, attrs)
  extraattr = {}
  attrs.each do |key, value|
    qname = ns.parse_local(key)
    extraattr[qname] = value
  end
  extraattr
end

#decode_epilogue ⇒ Object 



177
178
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 177

def decode_epilogue
end

#decode_parent(parent, node) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 180

def decode_parent(parent, node)
  return unless parent.node
  case parent.node
  when SOAPUnknown
    newparent = parent.node.as_element
    node.parent = newparent
    parent.replace_node(newparent)
    decode_parent(parent, node)
  when SOAPElement
    parent.node.add(node)
    node.parent = parent.node
  when SOAPStruct
    parent.node.add(node.elename.name, node)
    node.parent = parent.node
  when SOAPArray
    if node.position
	parent.node[*(decode_arypos(node.position))] = node
	parent.node.sparse = true
    else
	parent.node.add(node)
    end
    node.parent = parent.node
  else
    raise EncodingStyleError.new("illegal parent: #{parent.node}")
  end
end

#decode_prologue ⇒ Object 



174
175
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 174

def decode_prologue
end

#decode_tag(ns, elename, attrs, parent) ⇒ Object 



137
138
139
140
141
142
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 137

def decode_tag(ns, elename, attrs, parent)
  @textbuf = ''
  o = SOAPUnknown.new(self, elename, decode_attrs(ns, attrs))
  o.parent = parent
  o
end

#decode_tag_end(ns, node) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 144

def decode_tag_end(ns, node)
  o = node.node
  if o.is_a?(SOAPUnknown)
    newnode = if /\A\s*\z/ =~ @textbuf
 o.as_element
	else
 o.as_string
	end
    node.replace_node(newnode)
    o = node.node
  end

  decode_textbuf(o)
  @textbuf = ''
end

#decode_text(ns, text) ⇒ Object 



160
161
162
163
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 160

def decode_text(ns, text)
  # @textbuf is set at decode_tag_end.
  @textbuf << text
end

#encode_data(generator, ns, data, parent) ⇒ Object

encode interface.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 29

def encode_data(generator, ns, data, parent)
  attrs = {}
  name = generator.encode_name(ns, data, attrs)
  data.extraattr.each do |k, v|
    # ToDo: check generator.attributeformdefault here
    if k.is_a?(XSD::QName)
      if k.namespace
        SOAPGenerator.assign_ns(attrs, ns, k.namespace)
        k = ns.name(k)
      else
        k = k.name
      end
    end
    attrs[k] = v
  end
  case data
  when SOAPRawString
    generator.encode_tag(name, attrs)
    generator.encode_rawstring(data.to_s)
  when XSD::XSDString
    generator.encode_tag(name, attrs)
    str = data.to_s
    str = XSD::Charset.encoding_to_xml(str, @charset) if @charset
    generator.encode_string(str)
  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
  when SOAPElement
    # passes 2 times for simplifying namespace definition
    data.each do |key, value|
      if value.elename.namespace
        SOAPGenerator.assign_ns(attrs, ns, value.elename.namespace)
      end
    end
    generator.encode_tag(name, attrs)
    generator.encode_rawstring(data.text) if data.text
    data.each do |key, value|
      generator.encode_child(ns, value, data)
    end
  else
    raise EncodingStyleError.new(
      "unknown object:#{data} in this encodingStyle")
  end
end

#encode_data_end(generator, ns, data, parent) ⇒ Object 



85
86
87
88
89
90
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 85

def encode_data_end(generator, ns, data, parent)
  name = generator.encode_name_end(ns, data)
  cr = (data.is_a?(SOAPCompoundtype) or
    (data.is_a?(SOAPElement) and !data.text))
  generator.encode_tag_end(name, cr)
end