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, #encode_qname, 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 



180
181
182
183
184
185
186
187
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 180

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 



192
193
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 192

def decode_epilogue
end

#decode_parent(parent, node) ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 195

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 



189
190
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 189

def decode_prologue
end

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



152
153
154
155
156
157
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 152

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 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 159

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

  decode_textbuf(o)
  @textbuf = ''
end

#decode_text(ns, text) ⇒ Object 



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

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
84
85
86
87
88
89
90
91
92
 
# 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 |key, value|
    next if !@generate_explicit_type and key == XSD::AttrTypeName
    # ToDo: check generator.attributeformdefault here
    if key.is_a?(XSD::QName)
      key = encode_qname(attrs, ns, key)
    end
    if value.is_a?(XSD::QName)
      value = encode_qname(attrs, ns, value)
    end
    attrs[key] = value
  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
    if data.text and data.text.is_a?(XSD::QName)
      SOAPGenerator.assign_ns(attrs, ns, data.text.namespace)
    end
    generator.encode_tag(name, attrs)
    if data.text
      if data.text.is_a?(XSD::QName)
        text = ns.name(data.text)
      else
        text = data.text
      end
      generator.encode_rawstring(text)
    end
    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 



94
95
96
97
98
99
 
# File 'lib/soap/encodingstyle/literalHandler.rb', line 94

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