Class: Moxml::Adapter::Nokogiri

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

Defined Under Namespace

Classes: NokogiriSAXBridge

Class Method Summary collapse

Methods inherited from Base

actual_native, attribute_name, bulk_materialize?, create_cdata, create_comment, create_declaration, create_doctype, create_element, create_entity_reference, create_namespace, create_processing_instruction, create_text, decode_entities, duplicate_node, entity_bearing?, free_document, materialize_fields, patch_node, patches_children?, preprocess_entities, remove_attribute_native, restore_entities, sax_supported?, set_attribute_name, set_attribute_value, wrappers_recyclable?

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) ⇒ Object 



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
 
# File 'lib/moxml/adapter/nokogiri.rb', line 268

def add_child(element, child)
  if element.is_a?(::Nokogiri::XML::Document) &&
      child.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
      child.name == "xml"
    version = declaration_attribute(child, "version") || "1.0"
    encoding = declaration_attribute(child, "encoding")
    standalone = declaration_attribute(child, "standalone")

    attachments.set(element, :xml_decl, {
      version: version,
      encoding: encoding,
      standalone: standalone,
    }.compact)
    return
  end

  if node_type(child) == :doctype
    element.create_internal_subset(
      child.name, child.external_id, child.system_id
    )
  else
    element.add_child(child)
  end
end

.add_next_sibling(node, sibling) ⇒ Object 



297
298
299
 
# File 'lib/moxml/adapter/nokogiri.rb', line 297

def add_next_sibling(node, sibling)
  node.add_next_sibling(sibling)
end

.add_previous_sibling(node, sibling) ⇒ Object 



293
294
295
 
# File 'lib/moxml/adapter/nokogiri.rb', line 293

def add_previous_sibling(node, sibling)
  node.add_previous_sibling(sibling)
end

.adjacent_to_entity_reference?(node) ⇒ Boolean

Returns:

  • (Boolean) 


197
198
199
200
 
# File 'lib/moxml/adapter/nokogiri.rb', line 197

def adjacent_to_entity_reference?(node)
  node.previous_sibling.is_a?(::Nokogiri::XML::EntityReference) ||
    node.next_sibling.is_a?(::Nokogiri::XML::EntityReference)
end

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



399
400
401
402
403
404
405
406
407
408
 
# File 'lib/moxml/adapter/nokogiri.rb', line 399

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

.attachments ⇒ Object 



11
12
13
 
# File 'lib/moxml/adapter/nokogiri.rb', line 11

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

.attribute_element(attr) ⇒ Object 



231
232
233
 
# File 'lib/moxml/adapter/nokogiri.rb', line 231

def attribute_element(attr)
  attr.parent
end

.attributes(element) ⇒ Object 



239
240
241
242
243
244
 
# File 'lib/moxml/adapter/nokogiri.rb', line 239

def attributes(element)
  # attribute_nodes, not attributes.values: the attributes Hash
  # is keyed by local name, so xmi:type and type collide and
  # one is silently dropped (issue #94).
  element.attribute_nodes
end

.cdata_content(node) ⇒ Object 



332
333
334
 
# File 'lib/moxml/adapter/nokogiri.rb', line 332

def cdata_content(node)
  node.content
end

.children(node) ⇒ Object 



193
194
195
 
# File 'lib/moxml/adapter/nokogiri.rb', line 193

def children(node)
  node.children
end

.comment_content(node) ⇒ Object 



340
341
342
 
# File 'lib/moxml/adapter/nokogiri.rb', line 340

def comment_content(node)
  node.content
end

.create_document(_native_doc = nil) ⇒ Object 



77
78
79
 
# File 'lib/moxml/adapter/nokogiri.rb', line 77

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

.create_fragment ⇒ Object 



81
82
83
84
85
86
87
 
# File 'lib/moxml/adapter/nokogiri.rb', line 81

def create_fragment
  # document fragments are weird and should be used with caution:
  # https://github.com/sparklemotion/nokogiri/issues/572
  ::Nokogiri::XML::DocumentFragment.new(
    ::Nokogiri::XML::Document.new,
  )
end

.create_native_cdata(content, owner_doc = nil) ⇒ Object 



97
98
99
 
# File 'lib/moxml/adapter/nokogiri.rb', line 97

def create_native_cdata(content, owner_doc = nil)
  ::Nokogiri::XML::CDATA.new(owner_doc || create_document, content)
end

.create_native_comment(content, owner_doc = nil) ⇒ Object 



101
102
103
 
# File 'lib/moxml/adapter/nokogiri.rb', line 101

def create_native_comment(content, owner_doc = nil)
  ::Nokogiri::XML::Comment.new(owner_doc || create_document, content)
end

.create_native_declaration(version, encoding, standalone) ⇒ Object 



117
118
119
120
121
122
123
 
# File 'lib/moxml/adapter/nokogiri.rb', line 117

def create_native_declaration(version, encoding, standalone)
  ::Nokogiri::XML::ProcessingInstruction.new(
    create_document,
    "xml",
    build_declaration_attrs(version, encoding, standalone),
  )
end

.create_native_doctype(name, external_id, system_id) ⇒ Object 



105
106
107
108
109
 
# File 'lib/moxml/adapter/nokogiri.rb', line 105

def create_native_doctype(name, external_id, system_id)
  create_document.create_internal_subset(
    name, external_id, system_id
  )
end

.create_native_element(name, owner_doc = nil) ⇒ Object 



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

def create_native_element(name, owner_doc = nil)
  ::Nokogiri::XML::Element.new(name, owner_doc || create_document)
end

.create_native_entity_reference(name) ⇒ Object 



125
126
127
 
# File 'lib/moxml/adapter/nokogiri.rb', line 125

def create_native_entity_reference(name)
  ::Nokogiri::XML::EntityReference.new(create_document, name)
end

.create_native_namespace(element, prefix, uri) ⇒ Object 



165
166
167
 
# File 'lib/moxml/adapter/nokogiri.rb', line 165

def create_native_namespace(element, prefix, uri)
  element.add_namespace_definition(prefix, uri)
end

.create_native_processing_instruction(target, content) ⇒ Object 



111
112
113
114
115
 
# File 'lib/moxml/adapter/nokogiri.rb', line 111

def create_native_processing_instruction(target, content)
  ::Nokogiri::XML::ProcessingInstruction.new(
    ::Nokogiri::XML::Document.new, target, content
  )
end

.create_native_text(content, owner_doc = nil) ⇒ Object 



93
94
95
 
# File 'lib/moxml/adapter/nokogiri.rb', line 93

def create_native_text(content, owner_doc = nil)
  ::Nokogiri::XML::Text.new(content, owner_doc || create_document)
end

.declaration_attribute(declaration, attr_name) ⇒ Object 



133
134
135
136
137
138
 
# File 'lib/moxml/adapter/nokogiri.rb', line 133

def declaration_attribute(declaration, attr_name)
  return nil unless declaration.content

  match = declaration.content.match(/#{attr_name}="([^"]*)"/)
  match && match[1]
end

.doctype_external_id(native) ⇒ Object 



377
378
379
 
# File 'lib/moxml/adapter/nokogiri.rb', line 377

def doctype_external_id(native)
  native.external_id
end

.doctype_name(native) ⇒ Object

Doctype accessor methods



373
374
375
 
# File 'lib/moxml/adapter/nokogiri.rb', line 373

def doctype_name(native)
  native.name
end

.doctype_system_id(native) ⇒ Object 



381
382
383
 
# File 'lib/moxml/adapter/nokogiri.rb', line 381

def doctype_system_id(native)
  native.system_id
end

.document(node) ⇒ Object 



219
220
221
 
# File 'lib/moxml/adapter/nokogiri.rb', line 219

def document(node)
  node.document
end

.entity_reference_name(node) ⇒ Object 



129
130
131
 
# File 'lib/moxml/adapter/nokogiri.rb', line 129

def entity_reference_name(node)
  node.name
end

.get_attribute(element, name) ⇒ Object 



246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/moxml/adapter/nokogiri.rb', line 246

def get_attribute(element, name)
  name_s = name.to_s
  if name_s.include?(":")
    prefix, local = name_s.split(":", 2)
    href = element.namespace_definitions
      .find { |ns| ns.prefix == prefix }&.href
    element.attribute_with_ns(local, href)
  else
    element.attribute_with_ns(name_s, nil) ||
      element.attributes[name_s]
  end
end

.get_attribute_value(element, name) ⇒ Object 



259
260
261
262
 
# File 'lib/moxml/adapter/nokogiri.rb', line 259

def get_attribute_value(element, name)
  # get the attribute value by its name including a namespace
  element[name.to_s]
end

.has_declaration?(native_doc, wrapper) ⇒ Boolean

Returns:

  • (Boolean) 


445
446
447
448
449
450
451
 
# File 'lib/moxml/adapter/nokogiri.rb', line 445

def has_declaration?(native_doc, wrapper)
  if attachments.key?(native_doc, :xml_decl)
    !attachments.get(native_doc, :xml_decl).nil?
  else
    wrapper.has_xml_declaration
  end
end

.in_scope_namespaces(element) ⇒ Object 



368
369
370
 
# File 'lib/moxml/adapter/nokogiri.rb', line 368

def in_scope_namespaces(element)
  element.namespace_scopes
end

.inner_text(node) ⇒ Object 



321
322
323
324
325
326
 
# File 'lib/moxml/adapter/nokogiri.rb', line 321

def inner_text(node)
  text_children = node.children.reject do |c|
    c.element? || c.comment?
  end
  text_children.map(&:content).join
end

.line_number(node) ⇒ Object 



227
228
229
 
# File 'lib/moxml/adapter/nokogiri.rb', line 227

def line_number(node)
  node.line
end

.namespace(element) ⇒ Object 



157
158
159
 
# File 'lib/moxml/adapter/nokogiri.rb', line 157

def namespace(element)
  element.namespace
end

.namespace_definitions(node) ⇒ Object 



364
365
366
 
# File 'lib/moxml/adapter/nokogiri.rb', line 364

def namespace_definitions(node)
  node.namespace_definitions
end

.namespace_prefix(namespace) ⇒ Object 



356
357
358
 
# File 'lib/moxml/adapter/nokogiri.rb', line 356

def namespace_prefix(namespace)
  namespace.prefix
end

.namespace_uri(namespace) ⇒ Object 



360
361
362
 
# File 'lib/moxml/adapter/nokogiri.rb', line 360

def namespace_uri(namespace)
  namespace.href
end

.next_sibling(node) ⇒ Object 



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

def next_sibling(node)
  node.next_sibling
end

.node_name(node) ⇒ Object 



185
186
187
 
# File 'lib/moxml/adapter/nokogiri.rb', line 185

def node_name(node)
  node.name
end

.node_type(node) ⇒ Object 



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/moxml/adapter/nokogiri.rb', line 169

def node_type(node)
  case node
  when ::Nokogiri::XML::Element then :element
  when ::Nokogiri::XML::CDATA then :cdata
  when ::Nokogiri::XML::Text then :text
  when ::Nokogiri::XML::Comment then :comment
  when ::Nokogiri::XML::Attr then :attribute
  when ::Nokogiri::XML::Namespace then :namespace
  when ::Nokogiri::XML::ProcessingInstruction then :processing_instruction
  when ::Nokogiri::XML::Document, ::Nokogiri::XML::DocumentFragment then :document
  when ::Nokogiri::XML::DTD then :doctype
  when ::Nokogiri::XML::EntityReference then :entity_reference
  else :unknown
  end
end

.parent(node) ⇒ Object 



207
208
209
 
# File 'lib/moxml/adapter/nokogiri.rb', line 207

def parent(node)
  node.parent
end

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



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/moxml/adapter/nokogiri.rb', line 19

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

  # preprocess_entities always returns UTF-8, so tell Nokogiri to
  # parse as UTF-8 regardless of any original encoding option.
  native_doc = begin
    if options[:fragment]
      ::Nokogiri::XML::DocumentFragment.parse(processed_xml) do |config|
        config.strict.nonet
        config.recover unless options[:strict]
      end
    else
      ::Nokogiri::XML(processed_xml, nil, "UTF-8") do |config|
        config.strict.nonet
        config.recover unless options[:strict]
      end
    end
  rescue ::Nokogiri::XML::SyntaxError => e
    raise Moxml::ParseError.new(e.message, line: e.line,
                                           column: e.column)
  end

  # Use provided context if available, otherwise create new one
  ctx = _context || Context.new(:nokogiri)
  Document.new(native_doc, ctx)
end

.parse_errors(native_doc) ⇒ Object

Nokogiri parses with config.recover unless strict, so recoverable syntax errors land on doc.errors instead of raising (issue #147).



49
50
51
 
# File 'lib/moxml/adapter/nokogiri.rb', line 49

def parse_errors(native_doc)
  native_doc.errors.map(&:message)
end

.previous_sibling(node) ⇒ Object 



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

def previous_sibling(node)
  node.previous_sibling
end

.processing_instruction_content(node) ⇒ Object 



348
349
350
 
# File 'lib/moxml/adapter/nokogiri.rb', line 348

def processing_instruction_content(node)
  node.content
end

.processing_instruction_target(node) ⇒ Object 



161
162
163
 
# File 'lib/moxml/adapter/nokogiri.rb', line 161

def processing_instruction_target(node)
  node.name
end

.remove(node) ⇒ Object 



301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/moxml/adapter/nokogiri.rb', line 301

def remove(node)
  # Special handling for declarations on Nokogiri documents
  if node.is_a?(::Nokogiri::XML::ProcessingInstruction) &&
      node.name == "xml" &&
      node.parent.is_a?(::Nokogiri::XML::Document)
    # Clear document's xml_decl when removing declaration
    attachments.set(node.parent, :xml_decl, nil)
  end

  node.remove
end

.remove_attribute(element, name) ⇒ Object 



264
265
266
 
# File 'lib/moxml/adapter/nokogiri.rb', line 264

def remove_attribute(element, name)
  element.remove_attribute(name.to_s)
end

.remove_declaration(native_doc) ⇒ Object 



453
454
455
 
# File 'lib/moxml/adapter/nokogiri.rb', line 453

def remove_declaration(native_doc)
  attachments.set(native_doc, :xml_decl, nil)
end

.replace(node, new_node) ⇒ Object 



313
314
315
 
# File 'lib/moxml/adapter/nokogiri.rb', line 313

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

.replace_children(node, new_children) ⇒ Object 



202
203
204
205
 
# File 'lib/moxml/adapter/nokogiri.rb', line 202

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

.root(document) ⇒ Object 



223
224
225
 
# File 'lib/moxml/adapter/nokogiri.rb', line 223

def root(document)
  document.is_a?(::Nokogiri::XML::Document) ? document.root : document.children.first
end

.sax_parse(xml, handler) ⇒ void

This method returns an undefined value.

SAX parsing implementation for Nokogiri

Parameters:



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/moxml/adapter/nokogiri.rb', line 58

def sax_parse(xml, handler)
  # Create bridge that translates Nokogiri SAX to Moxml SAX
  bridge = NokogiriSAXBridge.new(handler)

  # Create Nokogiri SAX parser
  parser = ::Nokogiri::XML::SAX::Parser.new(bridge)

  # Parse
  if xml.is_a?(IO) || xml.is_a?(StringIO)
    parser.parse(xml)
  else
    parser.parse(xml.to_s)
  end
rescue ::Nokogiri::XML::SyntaxError => e
  error = Moxml::ParseError.new(e.message, line: e.line,
                                           column: e.column)
  handler.on_error(error)
end

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



410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
 
# File 'lib/moxml/adapter/nokogiri.rb', line 410

def serialize(node, options = {})
  save_options = ::Nokogiri::XML::Node::SaveOptions::AS_XML

  # Don't force expand empty elements if they're really empty
  if options[:expand_empty]
    save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS
  end
  if options[:indent].to_i.positive?
    save_options |= ::Nokogiri::XML::Node::SaveOptions::FORMAT
  end

  custom_decl = nil
  if options[:no_declaration]
    save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
  elsif attachments.key?(node, :xml_decl) && (xml_decl = attachments.get(node, :xml_decl))
    save_options |= ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
    attrs = ["version=\"#{xml_decl[:version]}\""]
    attrs << "encoding=\"#{xml_decl[:encoding]}\"" if xml_decl[:encoding]
    attrs << "standalone=\"#{xml_decl[:standalone]}\"" if xml_decl[:standalone]
    custom_decl = "<?xml #{attrs.join(' ')}?>"
  end

  result = node.to_xml(
    indent: options[:indent],
    encoding: options[:encoding],
    save_with: save_options,
  )

  if custom_decl
    result = "#{custom_decl}\n#{result}"
  end

  result
end

.set_attribute(element, name, value) ⇒ Object 



235
236
237
 
# File 'lib/moxml/adapter/nokogiri.rb', line 235

def set_attribute(element, name, value)
  element[name.to_s] = value.to_s
end

.set_cdata_content(node, content) ⇒ Object 



336
337
338
 
# File 'lib/moxml/adapter/nokogiri.rb', line 336

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

.set_comment_content(node, content) ⇒ Object 



344
345
346
 
# File 'lib/moxml/adapter/nokogiri.rb', line 344

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

.set_declaration_attribute(declaration, attr_name, value) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/moxml/adapter/nokogiri.rb', line 140

def set_declaration_attribute(declaration, attr_name, value)
  attrs = current_declaration_attributes(declaration)
  if value.nil?
    attrs.delete(attr_name)
  else
    attrs[attr_name] = value
  end

  declaration.native_content =
    attrs.map { |k, v| %(#{k}="#{v}") }.join(" ")
end

.set_namespace(element, ns) ⇒ Object 



152
153
154
155
 
# File 'lib/moxml/adapter/nokogiri.rb', line 152

def set_namespace(element, ns)
  element.namespace = ns
  element
end

.set_node_name(node, name) ⇒ Object 



189
190
191
 
# File 'lib/moxml/adapter/nokogiri.rb', line 189

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

.set_processing_instruction_content(node, content) ⇒ Object 



352
353
354
 
# File 'lib/moxml/adapter/nokogiri.rb', line 352

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

.set_root(doc, element) ⇒ Object 



15
16
17
 
# File 'lib/moxml/adapter/nokogiri.rb', line 15

def set_root(doc, element)
  doc.root = element
end

.set_text_content(node, content) ⇒ Object 



328
329
330
 
# File 'lib/moxml/adapter/nokogiri.rb', line 328

def set_text_content(node, content)
  node.native_content = content
end

.text_content(node) ⇒ Object 



317
318
319
 
# File 'lib/moxml/adapter/nokogiri.rb', line 317

def text_content(node)
  node.text.to_s
end

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



385
386
387
388
389
390
391
392
393
394
395
396
397
 
# File 'lib/moxml/adapter/nokogiri.rb', line 385

def xpath(node, expression, namespaces = nil)
  result = node.xpath(expression, namespaces)
  # Adapter contract: Array<native> | scalar (count(),
  # string-length(), boolean functions return scalars).
  result.is_a?(Enumerable) ? result.to_a : result
rescue ::Nokogiri::XML::XPath::SyntaxError => e
  raise Moxml::XPathError.new(
    e.message,
    expression: expression,
    adapter: "Nokogiri",
    node: node,
  )
end