Class: Moxml::Adapter::Oga

Inherits:
Base
  • Object
show all
Defined in:
lib/moxml/adapter/oga.rb

Constant Summary

Constants inherited from Base

Base::ENTITY_MARKER, Base::ENTITY_MARKER_RE, Base::ENTITY_NAME_PATTERN, Base::ENTITY_NAME_RE, Base::SERIALIZED_ENTITY_MARKER_RE, Base::STANDARD_ENTITIES

Class Method Summary collapse

Methods inherited from Base

actual_native, create_cdata, create_comment, create_declaration, create_doctype, create_element, create_entity_reference, create_namespace, create_processing_instruction, create_text, duplicate_node, in_scope_namespaces, patch_node, prepare_for_new_document, preprocess_entities, restore_entities, sax_supported?, set_attribute_name, set_attribute_value

Methods included from XmlUtils

#encode_entities, #normalize_xml_value, #validate_comment_content, #validate_declaration_encoding, #validate_declaration_standalone, #validate_declaration_version, #validate_element_name, #validate_entity_reference_name, #validate_pi_target, #validate_prefix, #validate_uri

Class Method Details

.add_child(element, child_or_text) ⇒ Object 



284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/moxml/adapter/oga.rb', line 284

def add_child(element, child_or_text)
  child =
    if child_or_text.is_a?(String)
      create_native_text(child_or_text)
    else
      child_or_text
    end

  if element.is_a?(::Oga::XML::Document) &&
      child.is_a?(::Oga::XML::XmlDeclaration)
    attachments.set(element, :xml_declaration, child)
    return
  end

  # Insert doctype before root element in document
  if element.is_a?(::Oga::XML::Document) && child.is_a?(::Oga::XML::Doctype)
    root_idx = nil
    element.children.each_with_index do |n, i|
      if n.is_a?(::Oga::XML::Element)
        root_idx = i
        break
      end
    end
    if root_idx
      element.children.insert(root_idx, child)
      return
    end
  end

  element.children << child
end

.add_next_sibling(node, sibling) ⇒ Object 



327
328
329
330
331
332
333
334
335
336
 
# File 'lib/moxml/adapter/oga.rb', line 327

def add_next_sibling(node, sibling)
  if node.parent == sibling.parent
    # Oga doesn't manipulate children of the same parent
    dup_sibling = node.node_set.delete(sibling)
    index = node.node_set.index(node) + 1
    node.node_set.insert(index, dup_sibling)
  else
    node.after(sibling)
  end
end

.add_previous_sibling(node, sibling) ⇒ Object 



316
317
318
319
320
321
322
323
324
325
 
# File 'lib/moxml/adapter/oga.rb', line 316

def add_previous_sibling(node, sibling)
  if node.parent == sibling.parent
    # Oga doesn't manipulate children of the same parent
    dup_sibling = node.node_set.delete(sibling)
    index = node.node_set.index(node)
    node.node_set.insert(index, dup_sibling)
  else
    node.before(sibling)
  end
end

.adjacent_to_entity_reference?(node) ⇒ Boolean

Returns:

  • (Boolean) 


211
212
213
 
# File 'lib/moxml/adapter/oga.rb', line 211

def adjacent_to_entity_reference?(node)
  entity_ref?(node.previous) || entity_ref?(node.next)
end

.at_xpath(node, expression, namespaces = nil) ⇒ Object 



455
456
457
458
459
460
461
462
463
464
 
# File 'lib/moxml/adapter/oga.rb', line 455

def at_xpath(node, expression, namespaces = nil)
  node.at_xpath(expression, namespaces: namespaces)
rescue ::Oga::XPath::Error => e
  raise Moxml::XPathError.new(
    e.message,
    expression: expression,
    adapter: "Oga",
    node: node,
  )
end

.attachments ⇒ Object 



12
13
14
 
# File 'lib/moxml/adapter/oga.rb', line 12

def attachments
  @attachments ||= Moxml::NativeAttachment.new
end

.attribute_element(attr) ⇒ Object 



243
244
245
 
# File 'lib/moxml/adapter/oga.rb', line 243

def attribute_element(attr)
  attr.element
end

.attributes(element) ⇒ Object 



247
248
249
250
251
252
253
254
 
# File 'lib/moxml/adapter/oga.rb', line 247

def attributes(element)
  return [] unless element.is_a?(::Oga::XML::Element)

  # remove attributes-namespaces
  element.attributes.reject do |attr|
    attr.name == ::Oga::XML::Element::XMLNS_PREFIX || attr.namespace_name == ::Oga::XML::Element::XMLNS_PREFIX
  end
end

.cdata_content(node) ⇒ Object 



379
380
381
 
# File 'lib/moxml/adapter/oga.rb', line 379

def cdata_content(node)
  node.text
end

.children(node) ⇒ Object 



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
 
# File 'lib/moxml/adapter/oga.rb', line 187

def children(node)
  all_children = []

  if node.is_a?(::Oga::XML::Document)
    all_children += [node.xml_declaration,
                     node.doctype].compact
  end

  return all_children unless node.is_a?(::Oga::XML::Node) || node.is_a?(::Oga::XML::Document)

  child_nodes = node.children.to_a
  # Filter out whitespace-only text nodes at document level only.
  # Document-level whitespace (between <?xml?> and <root>) is
  # formatting, not content, and differs across adapters.
  # Whitespace inside elements (e.g. "FigureA.1" spacing) is
  # meaningful and must be preserved.
  if node.is_a?(::Oga::XML::Document)
    child_nodes = child_nodes.reject do |child|
      child.is_a?(::Oga::XML::Text) && child.text.strip.empty?
    end
  end
  all_children + child_nodes
end

.comment_content(node) ⇒ Object 



387
388
389
 
# File 'lib/moxml/adapter/oga.rb', line 387

def comment_content(node)
  node.text
end

.create_document(_native_doc = nil) ⇒ Object 



62
63
64
 
# File 'lib/moxml/adapter/oga.rb', line 62

def create_document(_native_doc = nil)
  ::Oga::XML::Document.new
end

.create_native_cdata(content, _owner_doc = nil) ⇒ Object 



85
86
87
 
# File 'lib/moxml/adapter/oga.rb', line 85

def create_native_cdata(content, _owner_doc = nil)
  ::Oga::XML::Cdata.new(text: content)
end

.create_native_comment(content, _owner_doc = nil) ⇒ Object 



89
90
91
 
# File 'lib/moxml/adapter/oga.rb', line 89

def create_native_comment(content, _owner_doc = nil)
  ::Oga::XML::Comment.new(text: content)
end

.create_native_declaration(version, encoding, standalone) ⇒ Object 



104
105
106
107
108
109
110
111
 
# File 'lib/moxml/adapter/oga.rb', line 104

def create_native_declaration(version, encoding, standalone)
  attrs = {
    version: version,
    encoding: encoding,
    standalone: standalone,
  }.compact
  ::Moxml::Adapter::CustomizedOga::XmlDeclaration.new(attrs)
end

.create_native_doctype(name, external_id, system_id) ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/moxml/adapter/oga.rb', line 93

def create_native_doctype(name, external_id, system_id)
  ::Oga::XML::Doctype.new(
    name: name, public_id: external_id, system_id: system_id,
    type: external_id ? "PUBLIC" : "SYSTEM"
  )
end

.create_native_element(name, _owner_doc = nil) ⇒ Object 



66
67
68
 
# File 'lib/moxml/adapter/oga.rb', line 66

def create_native_element(name, _owner_doc = nil)
  ::Oga::XML::Element.new(name: name)
end

.create_native_entity_reference(name) ⇒ Object 



74
75
76
77
78
79
 
# File 'lib/moxml/adapter/oga.rb', line 74

def create_native_entity_reference(name)
  text = ::Oga::XML::Text.new
  text.text = "#{self::ENTITY_MARKER}#{name};"
  attachments.set(text, :entity_name, name)
  text
end

.create_native_namespace(element, prefix, uri) ⇒ Object 



129
130
131
132
133
134
135
136
137
138
 
# File 'lib/moxml/adapter/oga.rb', line 129

def create_native_namespace(element, prefix, uri)
  ns = element.available_namespaces[prefix]
  return ns unless ns.nil?

  # Oga creates an attribute and registers a namespace
  set_attribute(element,
                [::Oga::XML::Element::XMLNS_PREFIX, prefix].compact.join(":"), uri)
  element.register_namespace(prefix, uri)
  ::Oga::XML::Namespace.new(name: prefix, uri: uri)
end

.create_native_processing_instruction(target, content) ⇒ Object 



100
101
102
 
# File 'lib/moxml/adapter/oga.rb', line 100

def create_native_processing_instruction(target, content)
  ::Oga::XML::ProcessingInstruction.new(name: target, text: content)
end

.create_native_text(content, _owner_doc = nil) ⇒ Object 



70
71
72
 
# File 'lib/moxml/adapter/oga.rb', line 70

def create_native_text(content, _owner_doc = nil)
  ::Oga::XML::Text.new(text: preprocess_entities(content))
end

.declaration_attribute(declaration, attr_name) ⇒ Object 



113
114
115
116
117
118
119
 
# File 'lib/moxml/adapter/oga.rb', line 113

def declaration_attribute(declaration, attr_name)
  unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
    return
  end

  declaration.public_send(attr_name)
end

.doctype_external_id(native) ⇒ Object 



427
428
429
430
431
432
433
 
# File 'lib/moxml/adapter/oga.rb', line 427

def doctype_external_id(native)
  if native.type == "SYSTEM"
    nil
  else
    native.public_id
  end
end

.doctype_name(native) ⇒ Object

Doctype accessor methods Note: Oga stores SYSTEM identifier in public_id for SYSTEM doctypes. See: Oga::XML::Doctype puts SYSTEM dtd in public_id, system_id is nil.



423
424
425
 
# File 'lib/moxml/adapter/oga.rb', line 423

def doctype_name(native)
  native.name
end

.doctype_system_id(native) ⇒ Object 



435
436
437
438
439
440
441
 
# File 'lib/moxml/adapter/oga.rb', line 435

def doctype_system_id(native)
  if native.type == "SYSTEM"
    native.public_id
  else
    native.system_id
  end
end

.document(node) ⇒ Object 



232
233
234
235
236
237
 
# File 'lib/moxml/adapter/oga.rb', line 232

def document(node)
  current = node
  current = current.parent while parent(current)

  current
end

.entity_ref?(node) ⇒ Boolean

Returns:

  • (Boolean) 


215
216
217
218
 
# File 'lib/moxml/adapter/oga.rb', line 215

def entity_ref?(node)
  node.is_a?(::Oga::XML::Text) &&
    attachments.get(node, :entity_name)
end

.entity_reference_name(node) ⇒ Object 



81
82
83
 
# File 'lib/moxml/adapter/oga.rb', line 81

def entity_reference_name(node)
  attachments.get(node, :entity_name)
end

.get_attribute(element, name) ⇒ Object 



271
272
273
 
# File 'lib/moxml/adapter/oga.rb', line 271

def get_attribute(element, name)
  element.attribute(name.to_s)
end

.get_attribute_value(element, name) ⇒ Object 



275
276
277
 
# File 'lib/moxml/adapter/oga.rb', line 275

def get_attribute_value(element, name)
  element[name.to_s]
end

.has_declaration?(native_doc, _wrapper) ⇒ Boolean

Returns:

  • (Boolean) 


470
471
472
473
474
475
476
477
478
 
# File 'lib/moxml/adapter/oga.rb', line 470

def has_declaration?(native_doc, _wrapper)
  decl = attachments.get(native_doc, :xml_declaration)
  if decl.nil? && !attachments.key?(native_doc, :xml_declaration)
    # No attachment entry - check native doc (for parsed documents)
    native_doc.respond_to?(:xml_declaration) && !native_doc.xml_declaration.nil?
  else
    !decl.nil?
  end
end

.inner_text(node) ⇒ Object 



362
363
364
365
366
367
368
 
# File 'lib/moxml/adapter/oga.rb', line 362

def inner_text(node)
  if node.is_a?(::Oga::XML::Element)
    node.inner_text
  else
    node.text
  end
end

.namespace(element) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
 
# File 'lib/moxml/adapter/oga.rb', line 144

def namespace(element)
  case element
  when ::Oga::XML::Element, ::Oga::XML::Attribute
    element.namespace
  end
rescue NoMethodError
  # Oga attributes fail with NoMethodError:
  # undefined method `available_namespaces' for nil:NilClass
  nil
end

.namespace_definitions(node) ⇒ Object 



414
415
416
417
418
 
# File 'lib/moxml/adapter/oga.rb', line 414

def namespace_definitions(node)
  return [] unless node.is_a?(::Oga::XML::Element)

  node.namespaces.values
end

.namespace_prefix(namespace) ⇒ Object 



403
404
405
406
407
408
 
# File 'lib/moxml/adapter/oga.rb', line 403

def namespace_prefix(namespace)
  # nil for the default namespace
  return if namespace.name == ::Oga::XML::Element::XMLNS_PREFIX

  namespace.name
end

.namespace_uri(namespace) ⇒ Object 



410
411
412
 
# File 'lib/moxml/adapter/oga.rb', line 410

def namespace_uri(namespace)
  namespace.uri
end

.next_sibling(node) ⇒ Object 



224
225
226
 
# File 'lib/moxml/adapter/oga.rb', line 224

def next_sibling(node)
  node.next
end

.node_name(node) ⇒ Object 



179
180
181
 
# File 'lib/moxml/adapter/oga.rb', line 179

def node_name(node)
  node.name
end

.node_type(node) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/moxml/adapter/oga.rb', line 159

def node_type(node)
  case node
  when ::Oga::XML::Element then :element
  when ::Oga::XML::Text
    if attachments.key?(node, :entity_name)
      :entity_reference
    else
      :text
    end
  when ::Oga::XML::Cdata then :cdata
  when ::Oga::XML::Comment then :comment
  when ::Oga::XML::Attribute then :attribute
  when ::Oga::XML::Namespace then :namespace
  when ::Oga::XML::ProcessingInstruction then :processing_instruction
  when ::Oga::XML::Document then :document
  when ::Oga::XML::Doctype then :doctype
  else :unknown
  end
end

.parent(node) ⇒ Object 



220
221
222
 
# File 'lib/moxml/adapter/oga.rb', line 220

def parent(node)
  node.parent if node.is_a?(::Oga::XML::Node)
end

.parse(xml, options = {}, _context = nil) ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/moxml/adapter/oga.rb', line 24

def parse(xml, options = {}, _context = nil)
  processed_xml = preprocess_entities(xml)

  native_doc = begin
    ::Oga.parse_xml(processed_xml, strict: options[:strict])
  rescue LL::ParserError => e
    raise Moxml::ParseError.new(
      e.message,
      source: xml.is_a?(String) ? xml[0..100] : nil,
    )
  end

  ctx = _context || Context.new(:oga)
  DocumentBuilder.new(ctx).build(native_doc)
end

.previous_sibling(node) ⇒ Object 



228
229
230
 
# File 'lib/moxml/adapter/oga.rb', line 228

def previous_sibling(node)
  node.previous
end

.processing_instruction_content(node) ⇒ Object 



395
396
397
 
# File 'lib/moxml/adapter/oga.rb', line 395

def processing_instruction_content(node)
  node.text
end

.processing_instruction_target(node) ⇒ Object 



155
156
157
 
# File 'lib/moxml/adapter/oga.rb', line 155

def processing_instruction_target(node)
  node.name
end

.remove(node) ⇒ Object 



338
339
340
341
342
343
344
345
346
347
 
# File 'lib/moxml/adapter/oga.rb', line 338

def remove(node)
  # Special handling for declarations on Oga documents
  if node.is_a?(::Oga::XML::XmlDeclaration) &&
      node.parent.is_a?(::Oga::XML::Document)
    # Clear declaration state in attachment map
    attachments.set(node.parent, :xml_declaration, nil)
  end

  node.remove
end

.remove_attribute(element, name) ⇒ Object 



279
280
281
282
 
# File 'lib/moxml/adapter/oga.rb', line 279

def remove_attribute(element, name)
  attr = element.attribute(name.to_s)
  element.attributes.delete(attr) if attr
end

.replace(node, new_node) ⇒ Object 



349
350
351
 
# File 'lib/moxml/adapter/oga.rb', line 349

def replace(node, new_node)
  node.replace(new_node)
end

.replace_children(node, new_children) ⇒ Object 



353
354
355
356
 
# File 'lib/moxml/adapter/oga.rb', line 353

def replace_children(node, new_children)
  node.children = []
  new_children.each { |child| add_child(node, child) }
end

.root(document) ⇒ Object 



239
240
241
 
# File 'lib/moxml/adapter/oga.rb', line 239

def root(document)
  document.children.find { |node| node.is_a?(::Oga::XML::Element) }
end

.sax_parse(xml, handler) ⇒ void

This method returns an undefined value.

SAX parsing implementation for Oga

Parameters:



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/moxml/adapter/oga.rb', line 45

def sax_parse(xml, handler)
  bridge = OgaSAXBridge.new(handler)

  xml_string = xml.is_a?(IO) || xml.is_a?(StringIO) ? xml.read : xml.to_s

  # Manually call start_document (Oga doesn't)
  handler.on_start_document

  ::Oga.sax_parse_xml(bridge, xml_string)

  # Manually call end_document (Oga doesn't)
  handler.on_end_document
rescue StandardError => e
  error = Moxml::ParseError.new(e.message)
  handler.on_error(error)
end

.serialize(node, options = {}) ⇒ Object 



466
467
468
 
# File 'lib/moxml/adapter/oga.rb', line 466

def serialize(node, options = {})
  serialize_without_entity_processing(node, options)
end

.set_attribute(element, name, value) ⇒ Object 



256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/moxml/adapter/oga.rb', line 256

def set_attribute(element, name, value)
  namespace_name = nil
  if name.to_s.include?(":")
    namespace_name, name = name.to_s.split(":",
                                           2)
  end

  attr = ::Oga::XML::Attribute.new(
    name: name.to_s,
    namespace_name: namespace_name,
    value: preprocess_entities(value.to_s),
  )
  element.add_attribute(attr)
end

.set_cdata_content(node, content) ⇒ Object 



383
384
385
 
# File 'lib/moxml/adapter/oga.rb', line 383

def set_cdata_content(node, content)
  node.text = content
end

.set_comment_content(node, content) ⇒ Object 



391
392
393
 
# File 'lib/moxml/adapter/oga.rb', line 391

def set_comment_content(node, content)
  node.text = content
end

.set_declaration_attribute(declaration, attr_name, value) ⇒ Object 



121
122
123
124
125
126
127
 
# File 'lib/moxml/adapter/oga.rb', line 121

def set_declaration_attribute(declaration, attr_name, value)
  unless ::Moxml::Declaration::ALLOWED_ATTRIBUTES.include?(attr_name.to_s)
    return
  end

  declaration.public_send("#{attr_name}=", value)
end

.set_namespace(element, ns_or_string) ⇒ Object 



140
141
142
 
# File 'lib/moxml/adapter/oga.rb', line 140

def set_namespace(element, ns_or_string)
  element.namespace_name = ns_or_string.to_s
end

.set_node_name(node, name) ⇒ Object 



183
184
185
 
# File 'lib/moxml/adapter/oga.rb', line 183

def set_node_name(node, name)
  node.name = name
end

.set_processing_instruction_content(node, content) ⇒ Object 



399
400
401
 
# File 'lib/moxml/adapter/oga.rb', line 399

def set_processing_instruction_content(node, content)
  node.text = content
end

.set_root(doc, element) ⇒ Object 



16
17
18
19
20
21
22
 
# File 'lib/moxml/adapter/oga.rb', line 16

def set_root(doc, element)
  # Clear existing root element if any - Oga's NodeSet needs special handling
  # We need to manually remove elements since NodeSet doesn't support clear or delete_if
  elements_to_remove = doc.children.grep(::Oga::XML::Element)
  elements_to_remove.each { |elem| doc.children.delete(elem) }
  doc.children << element
end

.set_text_content(node, content) ⇒ Object 



370
371
372
373
374
375
376
377
 
# File 'lib/moxml/adapter/oga.rb', line 370

def set_text_content(node, content)
  processed = preprocess_entities(content)
  if node.is_a?(::Oga::XML::Element)
    node.inner_text = processed
  else
    node.text = processed
  end
end

.text_content(node) ⇒ Object 



358
359
360
 
# File 'lib/moxml/adapter/oga.rb', line 358

def text_content(node)
  node.text
end

.xpath(node, expression, namespaces = nil) ⇒ Object 



443
444
445
446
447
448
449
450
451
452
453
 
# File 'lib/moxml/adapter/oga.rb', line 443

def xpath(node, expression, namespaces = nil)
  node.xpath(expression, {},
             namespaces: namespaces&.transform_keys(&:to_s)).to_a
rescue ::LL::ParserError => e
  raise Moxml::XPathError.new(
    e.message,
    expression: expression,
    adapter: "Oga",
    node: node,
  )
end