Class: Moxml::Adapter::Nokogiri

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

Defined Under Namespace

Classes: NokogiriSAXBridge

Constant Summary

Constants included from XmlUtils

XmlUtils::VALID_ELEMENT_NAMES

Class Method Summary collapse

Methods inherited from Base

actual_native, attribute_name, attribute_pairs, bulk_materialize?, children_accepts_entity_flag?, create_cdata, create_comment, create_declaration, create_doctype, create_element, create_element_with_attrs, create_entity_reference, create_namespace, create_processing_instruction, create_text, decode_entities, digest, duplicate_node, entity_bearing?, expanded_attr_reads?, expanded_attr_value, free_document, iterparse, iterparse_file, materialize_fields, native_inclusive10, patch_node, patches_children?, plan_structs, preprocess_entities, remove_attribute_native, restore_entities, same_node?, sax_supported?, serialize_generation, set_attribute_name, set_attribute_value, source_position, walk_descendants, wrap_native, 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 



345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
 
# File 'lib/moxml/adapter/nokogiri.rb', line 345

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 



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

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

.add_previous_sibling(node, sibling) ⇒ Object 



370
371
372
 
# File 'lib/moxml/adapter/nokogiri.rb', line 370

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

.adjacent_to_entity_reference?(node) ⇒ Boolean

Returns:

  • (Boolean) 


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

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 



478
479
480
481
482
483
484
485
486
487
 
# File 'lib/moxml/adapter/nokogiri.rb', line 478

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 



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

def attribute_element(attr)
  attr.parent
end

.attributes(element) ⇒ Object 



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

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

.bare_attr_value(element, name) ⇒ Object

Fast bare-name read for Element#[]: the native call plus, only when the parse recorded entity markers, their restoration (the resolver path's other real semantic). The marker flag is constant per document — a WeakMap on the adapter beats the per-read document fetch + attachment hash chain. Raw qualified-name read; the entity-restore decision is the wrapper's (Element#[] rides its generation memo).



45
46
47
 
# File 'lib/moxml/adapter/nokogiri.rb', line 45

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

.bare_get_qname_safe? ⇒ Boolean

Qualified-name reads are clean on this engine (verified by the expanded-name specs); markers restore in-line when the parse recorded them.

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/moxml/adapter/nokogiri.rb', line 22

def bare_get_qname_safe?
  true
end

.bare_set_qname_safe? ⇒ Boolean

Returns:

  • (Boolean) 


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

def bare_set_qname_safe?
  true
end

.cdata_content(node) ⇒ Object 



409
410
411
 
# File 'lib/moxml/adapter/nokogiri.rb', line 409

def cdata_content(node)
  node.content
end

.children(node, **_entity_bearing) ⇒ Object 



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

def children(node, **_entity_bearing)
  node.children
end

.comment_content(node) ⇒ Object 



417
418
419
 
# File 'lib/moxml/adapter/nokogiri.rb', line 417

def comment_content(node)
  node.content
end

.create_document(_native_doc = nil) ⇒ Object 



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

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

.create_fragment ⇒ Object 



138
139
140
141
142
143
144
 
# File 'lib/moxml/adapter/nokogiri.rb', line 138

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 



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

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 



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

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 



174
175
176
177
178
179
180
 
# File 'lib/moxml/adapter/nokogiri.rb', line 174

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 



162
163
164
165
166
 
# File 'lib/moxml/adapter/nokogiri.rb', line 162

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 



146
147
148
 
# File 'lib/moxml/adapter/nokogiri.rb', line 146

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

.create_native_entity_reference(name, _owner_doc = nil) ⇒ Object 



182
183
184
 
# File 'lib/moxml/adapter/nokogiri.rb', line 182

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

.create_native_namespace(element, prefix, uri) ⇒ Object 



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

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

.create_native_processing_instruction(target, content) ⇒ Object 



168
169
170
171
172
 
# File 'lib/moxml/adapter/nokogiri.rb', line 168

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 



150
151
152
 
# File 'lib/moxml/adapter/nokogiri.rb', line 150

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

.declaration_attribute(declaration, attr_name) ⇒ Object 



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

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 



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

def doctype_external_id(native)
  native.external_id
end

.doctype_name(native) ⇒ Object

Doctype accessor methods



450
451
452
 
# File 'lib/moxml/adapter/nokogiri.rb', line 450

def doctype_name(native)
  native.name
end

.doctype_system_id(native) ⇒ Object 



458
459
460
 
# File 'lib/moxml/adapter/nokogiri.rb', line 458

def doctype_system_id(native)
  native.system_id
end

.document(node) ⇒ Object 



284
285
286
 
# File 'lib/moxml/adapter/nokogiri.rb', line 284

def document(node)
  node.document
end

.entity_reference_name(node) ⇒ Object 



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

def entity_reference_name(node)
  node.name
end

.get_attribute(element, name) ⇒ Object 



323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/moxml/adapter/nokogiri.rb', line 323

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 



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

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) 


526
527
528
529
530
531
532
 
# File 'lib/moxml/adapter/nokogiri.rb', line 526

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 



445
446
447
 
# File 'lib/moxml/adapter/nokogiri.rb', line 445

def in_scope_namespaces(element)
  element.namespace_scopes
end

.inner_text(node) ⇒ Object 



398
399
400
401
402
403
 
# File 'lib/moxml/adapter/nokogiri.rb', line 398

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 



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

def line_number(node)
  node.line
end

.namespace(element) ⇒ Object 



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

def namespace(element)
  element.namespace
end

.namespace_definitions(node) ⇒ Object 



441
442
443
 
# File 'lib/moxml/adapter/nokogiri.rb', line 441

def namespace_definitions(node)
  node.namespace_definitions
end

.namespace_prefix(namespace) ⇒ Object 



433
434
435
 
# File 'lib/moxml/adapter/nokogiri.rb', line 433

def namespace_prefix(namespace)
  namespace.prefix
end

.namespace_uri(namespace) ⇒ Object 



437
438
439
 
# File 'lib/moxml/adapter/nokogiri.rb', line 437

def namespace_uri(namespace)
  namespace.href
end

.native_identity_stable? ⇒ Boolean

Returns:

  • (Boolean) 


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

def native_identity_stable?
  true
end

.next_sibling(node) ⇒ Object 



276
277
278
 
# File 'lib/moxml/adapter/nokogiri.rb', line 276

def next_sibling(node)
  node.next_sibling
end

.node_name(node) ⇒ Object 



250
251
252
 
# File 'lib/moxml/adapter/nokogiri.rb', line 250

def node_name(node)
  node.name
end

.node_type(node) ⇒ Object 



234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/moxml/adapter/nokogiri.rb', line 234

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 



272
273
274
 
# File 'lib/moxml/adapter/nokogiri.rb', line 272

def parent(node)
  node.parent
end

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



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
 
# File 'lib/moxml/adapter/nokogiri.rb', line 57

def parse(xml, options = {}, _context = nil)
  processed_xml, entity_markers = Entity.preprocess_with_marker_flag(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]
        config.noblanks if options[:noblanks]
        config.huge
      end
    else
      ::Nokogiri::XML(processed_xml, nil, "UTF-8") do |config|
        config.strict.nonet
        config.recover unless options[:strict]
        config.noblanks if options[:noblanks]
        # XML_PARSE_HUGE: lifts libxml2's arbitrary limits —
        # text nodes > 10MB are silently TRUNCATED at 10MB in
        # recover mode, so large documents lose data without
        # it (users parse >10MB XML).
        config.huge
      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)
  attachments.set(native_doc, :entity_markers, entity_markers)
  Wrappers::Document.new(native_doc, ctx)
end

.parse_diagnostics(native_doc) ⇒ Object

Cross-adapter parity for Document#parse_diagnostics (#271): Nokogiri's doc.errors already carries recover- mode entries; mapped into the same { kind:, message: } shape. Kind is :error — Nokogiri does not classify.



308
309
310
311
312
313
314
 
# File 'lib/moxml/adapter/nokogiri.rb', line 308

def parse_diagnostics(native_doc)
  return [] unless native_doc.respond_to?(:errors)

  native_doc.errors.map do |e|
    { kind: :error, message: e.message.to_s }
  end
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).



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

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

.parse_fragment(xml, _context = nil) ⇒ Object

Nokogiri has a real fragment node type — its children ARE the fragment's top-level nodes.



28
29
30
31
32
33
34
35
 
# File 'lib/moxml/adapter/nokogiri.rb', line 28

def parse_fragment(xml, _context = nil)
  processed = Entity.preprocess_entities(xml)
  ::Nokogiri::XML::DocumentFragment.parse(processed) do |config|
    config.strict.nonet
    config.recover
    config.huge
  end.children.to_a
end

.parse_html(html, _options = {}, _context = nil) ⇒ Object

Tolerant HTML parsing through libxml2's HTML mode: implied html/head/body structure, void elements, lowercased names, the HTML named-entity table. Recovery is inherent — malformed input never raises.



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

def parse_html(html, _options = {}, _context = nil)
  html_string = html.is_a?(IO) || html.is_a?(StringIO) ? html.read : html.to_s
  native_doc = ::Nokogiri::HTML(html_string, &:huge)
  Wrappers::Document.new(native_doc, _context || Context.new(:nokogiri))
end

.plan_rows(native) ⇒ Object

Plan row stream (Moxml::Plan contract): pre-order element rows |name, attrs_pairs, first-text, depth| straight off the libxml2-backed nodes — no wrapper minting.



541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
 
# File 'lib/moxml/adapter/nokogiri.rb', line 541

def plan_rows(native)
  root = native.is_a?(::Nokogiri::XML::Document) ? native.root : native
  return nil unless root

  walk = lambda do |el, depth|
    attrs = []
    el.attribute_nodes.each { |a| attrs << a.name << a.value }
    first_text = nil
    el.children.each { |c| first_text ||= c.content if c.text? }
    yield(el.name, attrs, first_text, depth)
    el.element_children.each { |c| walk.call(c, depth + 1) }
  end
  walk.call(root, 0)
  true
end

.previous_sibling(node) ⇒ Object 



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

def previous_sibling(node)
  node.previous_sibling
end

.processing_instruction_content(node) ⇒ Object 



425
426
427
 
# File 'lib/moxml/adapter/nokogiri.rb', line 425

def processing_instruction_content(node)
  node.content
end

.processing_instruction_target(node) ⇒ Object 



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

def processing_instruction_target(node)
  node.name
end

.remove(node) ⇒ Object 



378
379
380
381
382
383
384
385
386
387
388
 
# File 'lib/moxml/adapter/nokogiri.rb', line 378

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 



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

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

.remove_declaration(native_doc) ⇒ Object 



534
535
536
 
# File 'lib/moxml/adapter/nokogiri.rb', line 534

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

.replace(node, new_node) ⇒ Object 



390
391
392
 
# File 'lib/moxml/adapter/nokogiri.rb', line 390

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

.replace_children(node, new_children) ⇒ Object 



267
268
269
270
 
# File 'lib/moxml/adapter/nokogiri.rb', line 267

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

.root(document) ⇒ Object 



288
289
290
 
# File 'lib/moxml/adapter/nokogiri.rb', line 288

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:



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/moxml/adapter/nokogiri.rb', line 115

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 



489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
 
# File 'lib/moxml/adapter/nokogiri.rb', line 489

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

  serialize_kwargs = {
    indent: options[:indent],
    encoding: options[:encoding],
    save_with: save_options,
  }
  serialize_kwargs[:indent_text] = options[:indent_text] if options[:indent_text]
  result = node.to_xml(**serialize_kwargs)

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

  result
end

.set_attribute(element, name, value) ⇒ Object 



300
301
302
 
# File 'lib/moxml/adapter/nokogiri.rb', line 300

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

.set_cdata_content(node, content) ⇒ Object 



413
414
415
 
# File 'lib/moxml/adapter/nokogiri.rb', line 413

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

.set_comment_content(node, content) ⇒ Object 



421
422
423
 
# File 'lib/moxml/adapter/nokogiri.rb', line 421

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

.set_declaration_attribute(declaration, attr_name, value) ⇒ Object 



197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/moxml/adapter/nokogiri.rb', line 197

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 



209
210
211
212
213
214
215
216
217
218
219
220
 
# File 'lib/moxml/adapter/nokogiri.rb', line 209

def set_namespace(element, ns)
  # Strip any existing name prefix before binding: create_element
  # with a qname ("p:c") leaves name="p:c", and Nokogiri's
  # bare namespace= then serializes p: + p:c → p:p:c (issue
  # #208). Local-name-only + namespace= is the correct shape;
  # consumers that pass the qname get the same result.
  if ns && element.respond_to?(:name=) && element.name.to_s.include?(":")
    element.name = element.name.split(":", 2)[-1]
  end
  element.namespace = ns
  element
end

.set_node_name(node, name) ⇒ Object 



254
255
256
 
# File 'lib/moxml/adapter/nokogiri.rb', line 254

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

.set_processing_instruction_content(node, content) ⇒ Object 



429
430
431
 
# File 'lib/moxml/adapter/nokogiri.rb', line 429

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

.set_root(doc, element) ⇒ Object 



53
54
55
 
# File 'lib/moxml/adapter/nokogiri.rb', line 53

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

.set_text_content(node, content) ⇒ Object 



405
406
407
 
# File 'lib/moxml/adapter/nokogiri.rb', line 405

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

.text_content(node) ⇒ Object 



394
395
396
 
# File 'lib/moxml/adapter/nokogiri.rb', line 394

def text_content(node)
  node.text.to_s
end

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



462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
 
# File 'lib/moxml/adapter/nokogiri.rb', line 462

def xpath(node, expression, namespaces = nil)
  result = node.xpath(expression, namespaces)
  # Adapter contract: Array<native> | LazyNodeSet | scalar
  # (count(), string-length(), boolean functions return
  # scalars). The native node-set passes through lazily —
  # to_a would materialize every result wrapper up front.
  result.is_a?(Enumerable) ? result.extend(Moxml::LazyNodeSet) : result
rescue ::Nokogiri::XML::XPath::SyntaxError => e
  raise Moxml::XPathError.new(
    e.message,
    expression: expression,
    adapter: "Nokogiri",
    node: node,
  )
end