Class: Nokogiri::XML::Node

Inherits:
Object
  • Object
show all
Includes:
Enumerable, PP::Node
Defined in:
lib/nokogiri/xml/node.rb,
lib/nokogiri/ffi/xml/node.rb,
lib/nokogiri/xml/node/save_options.rb,
ext/nokogiri/xml_dtd.c,
ext/nokogiri/xml_attr.c,
ext/nokogiri/xml_node.c,
ext/nokogiri/xml_text.c,
ext/nokogiri/xml_cdata.c,
ext/nokogiri/xml_comment.c,
ext/nokogiri/xml_document.c,
ext/nokogiri/html_document.c,
ext/nokogiri/xml_entity_decl.c,
ext/nokogiri/xml_element_decl.c,
ext/nokogiri/xml_attribute_decl.c,
ext/nokogiri/xml_entity_reference.c,
ext/nokogiri/xml_document_fragment.c,
ext/nokogiri/xml_processing_instruction.c

Overview

Nokogiri::XML::Node is your window to the fun filled world of dealing with XML and HTML tags. A Nokogiri::XML::Node may be treated similarly to a hash with regard to attributes. For example (from irb):

irb(main):004:0> node
=> <a href="#foo" id="link">link</a>
irb(main):005:0> node['href']
=> "#foo"
irb(main):006:0> node.keys
=> ["href", "id"]
irb(main):007:0> node.values
=> ["#foo", "link"]
irb(main):008:0> node['class'] = 'green'
=> "green"
irb(main):009:0> node
=> <a href="#foo" id="link" class="green">link</a>
irb(main):010:0>

See Nokogiri::XML::Node#[] and Nokogiri::XML#[]= for more information.

Nokogiri::XML::Node also has methods that let you move around your tree. For navigating your tree, see:

  • Nokogiri::XML::Node#parent

  • Nokogiri::XML::Node#children

  • Nokogiri::XML::Node#next

  • Nokogiri::XML::Node#previous

You may search this node’s subtree using Node#xpath and Node#css

Defined Under Namespace

Classes: SaveOptions

Constant Summary collapse

ELEMENT_NODE =

Element node type, see Nokogiri::XML::Node#element?

1
ATTRIBUTE_NODE =

Attribute node type

2
TEXT_NODE =

Text node type, see Nokogiri::XML::Node#text?

3
CDATA_SECTION_NODE =

CDATA node type, see Nokogiri::XML::Node#cdata?

4
ENTITY_REF_NODE =

Entity reference node type

5
ENTITY_NODE =

Entity node type

6
PI_NODE =

PI node type

7
COMMENT_NODE =

Comment node type, see Nokogiri::XML::Node#comment?

8
DOCUMENT_NODE =

Document node type, see Nokogiri::XML::Node#xml?

9
DOCUMENT_TYPE_NODE =

Document type node type

10
DOCUMENT_FRAG_NODE =

Document fragment node type

11
NOTATION_NODE =

Notation node type

12
HTML_DOCUMENT_NODE =

HTML document node type, see Nokogiri::XML::Node#html?

13
DTD_NODE =

DTD node type

14
ELEMENT_DECL =

Element declaration type

15
ATTRIBUTE_DECL =

Attribute declaration type

16
ENTITY_DECL =

Entity declaration type

17
NAMESPACE_DECL =

Namespace declaration type

18
XINCLUDE_START =

XInclude start type

19
XINCLUDE_END =

XInclude end type

20
DOCB_DOCUMENT_NODE =

DOCB document node type

21

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from PP::Node

#inspect, #pretty_print

Constructor Details

#initialize(name, document) ⇒ Node

:nodoc:



83
84
85
 
# File 'lib/nokogiri/xml/node.rb', line 83

def initialize name, document # :nodoc:
  # ... Ya.  This is empty on purpose.
end

Instance Attribute Details

#cstruct ⇒ Object

:stopdoc:



6
7
8
 
# File 'lib/nokogiri/ffi/xml/node.rb', line 6

def cstruct
  @cstruct
end

Class Method Details

.new(name, document) ⇒ Object

Create a new node with name sharing GC lifecycle with document



1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
 
# File 'ext/nokogiri/xml_node.c', line 1082

def self.new(name, doc, *rest)
  ptr = LibXML.xmlNewNode(nil, name.to_s)

  node_cstruct = LibXML::XmlNode.new(ptr)
  node_cstruct[:doc] = doc.cstruct[:doc]
  node_cstruct.keep_reference_from_document!

  node = Node.wrap(
    node_cstruct,
    Node == self ? nil : self
  )
  node.send :initialize, name, doc, *rest
  yield node if block_given?
  node
end

.node_properties(cstruct) ⇒ Object 



433
434
435
436
437
438
439
440
441
442
 
# File 'lib/nokogiri/ffi/xml/node.rb', line 433

def node_properties(cstruct)
  attr = []
  prop_cstruct = cstruct[:properties]
  while ! prop_cstruct.null?
    prop = Node.wrap(prop_cstruct)
    attr << prop
    prop_cstruct = prop.cstruct[:next]
  end
  attr
end

.wrap(node_struct, klass = nil) ⇒ Object 



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/nokogiri/ffi/xml/node.rb', line 352

def self.wrap(node_struct, klass=nil)
  if node_struct.is_a?(FFI::Pointer)
    # cast native pointers up into a node cstruct
    return nil if node_struct.null?
    node_struct = LibXML::XmlNode.new(node_struct)
  end

  raise "wrapping a node without a document" unless node_struct.document

  document_struct = node_struct.document
  document_obj = document_struct.nil? ? nil : document_struct.ruby_doc
  if node_struct[:type] == DOCUMENT_NODE || node_struct[:type] == HTML_DOCUMENT_NODE
    return document_obj
  end

  ruby_node = node_struct.ruby_node
  return ruby_node unless ruby_node.nil?

  klasses = case node_struct[:type]
            when ELEMENT_NODE then [XML::Element]
            when TEXT_NODE then [XML::Text]
            when ENTITY_REF_NODE then [XML::EntityReference]
            when ATTRIBUTE_DECL then [XML::AttributeDecl, LibXML::XmlAttribute]
            when ELEMENT_DECL then [XML::ElementDecl, LibXML::XmlElement]
            when COMMENT_NODE then [XML::Comment]
            when DOCUMENT_FRAG_NODE then [XML::DocumentFragment]
            when PI_NODE then [XML::ProcessingInstruction]
            when ATTRIBUTE_NODE then [XML::Attr]
            when ENTITY_DECL then [XML::EntityDecl, LibXML::XmlEntity]
            when CDATA_SECTION_NODE then [XML::CDATA]
            when DTD_NODE then [XML::DTD, LibXML::XmlDtd]
            else [XML::Node]
            end

  if klass
    node = klass.allocate
  else
    node = klasses.first.allocate
  end
  node.cstruct = klasses[1] ? klasses[1].new(node_struct.pointer) : node_struct

  node.cstruct.ruby_node = node

  if document_obj
    node.instance_variable_set(:@document, document_obj)
    cache = document_obj.instance_variable_get(:@node_cache)
    cache << node
    document_obj.decorate(node)
  end

  node
end

Instance Method Details

#<=>(other) ⇒ Object

Compare two Node objects with respect to their Document. Nodes from different documents cannot be compared.



765
766
767
768
769
 
# File 'lib/nokogiri/xml/node.rb', line 765

def <=> other
  return nil unless other.is_a?(Nokogiri::XML::Node)
  return nil unless document == other.document
  compare other
end

#==(other) ⇒ Object

Test to see if this Node is equal to other



604
605
606
607
608
 
# File 'lib/nokogiri/xml/node.rb', line 604

def == other
  return false unless other
  return false unless other.respond_to?(:pointer_id)
  pointer_id == other.pointer_id
end

#>(selector) ⇒ Object

Search this node’s immediate children using CSS selector selector



194
195
196
197
 
# File 'lib/nokogiri/xml/node.rb', line 194

def > selector
  ns = document.root.namespaces
  xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
end

#[](name) ⇒ Object Also known as: get_attribute, attr

Get the attribute value for the attribute name



228
229
230
231
 
# File 'lib/nokogiri/xml/node.rb', line 228

def [] name
  return nil unless key?(name.to_s)
  get(name.to_s)
end

#[]=(property, value) ⇒ Object

Set the property to value



660
661
662
663
 
# File 'ext/nokogiri/xml_node.c', line 660

def []=(property, value)
  LibXML.xmlSetProp(cstruct, property, value)
  value
end

#accept(visitor) ⇒ Object

Accept a visitor. This method calls “visit” on visitor with self.



598
599
600
 
# File 'lib/nokogiri/xml/node.rb', line 598

def accept visitor
  visitor.visit(self)
end

#add_child(node_or_tags) ⇒ Object Also known as: <<

Add node_or_tags as a child of this Node. node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns the new child node.



238
239
240
241
242
243
244
245
 
# File 'lib/nokogiri/xml/node.rb', line 238

def add_child node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node n }
  else
    add_child_node node_or_tags
  end
end

#add_namespace ⇒ Object 



572
 
# File 'lib/nokogiri/xml/node.rb', line 572

alias :add_namespace :add_namespace_definition

#add_namespace_definition(prefix, href) ⇒ Object

Adds a namespace definition with prefix using href



1050
1051
1052
1053
1054
1055
1056
1057
1058
 
# File 'ext/nokogiri/xml_node.c', line 1050

def add_namespace_definition(prefix, href)
  ns = LibXML.xmlNewNs(cstruct, href, prefix)
  if ns.null?
    ns = LibXML.xmlSearchNs(cstruct.document, cstruct,
      prefix.nil? ? nil : prefix.to_s)
  end
  LibXML.xmlSetNs(cstruct, ns) if prefix.nil?
  Namespace.wrap(cstruct.document, ns)
end

#add_next_sibling(node_or_tags) ⇒ Object Also known as: next=

Insert node_or_tags after this Node (as a sibling). node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns the new sibling node.

Also see related method after.



270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'lib/nokogiri/xml/node.rb', line 270

def add_next_sibling node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    if '1.8.6' == RUBY_VERSION
      node_or_tags.reverse.each { |n| add_next_sibling_node n }
    else
      node_or_tags.reverse_each { |n| add_next_sibling_node n }
    end
  else
    add_next_sibling_node node_or_tags
  end
end

#add_previous_sibling(node_or_tags) ⇒ Object Also known as: previous=

Insert node_or_tags before this Node (as a sibling). node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns the new sibling node.

Also see related method before.



254
255
256
257
258
259
260
261
 
# File 'lib/nokogiri/xml/node.rb', line 254

def add_previous_sibling node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_previous_sibling_node n }
  else
    add_previous_sibling_node node_or_tags
  end
end

#after(node_or_tags) ⇒ Object

Insert node_or_tags after this node (as a sibling). node_or_tags can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a string containing markup.

Returns self, to support chaining of calls.

Also see related method add_next_sibling.



302
303
304
305
 
# File 'lib/nokogiri/xml/node.rb', line 302

def after node_or_tags
  add_next_sibling node_or_tags
  self
end

#ancestors(selector = nil) ⇒ Object

Get a list of ancestor Node for this Node. If selector is given, the ancestors must match selector



547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
 
# File 'lib/nokogiri/xml/node.rb', line 547

def ancestors selector = nil
  return NodeSet.new(document) unless respond_to?(:parent)
  return NodeSet.new(document) unless parent

  parents = [parent]

  while parents.last.respond_to?(:parent)
    break unless ctx_parent = parents.last.parent
    parents << ctx_parent
  end

  return NodeSet.new(document, parents) unless selector

  root = parents.last

  NodeSet.new(document, parents.find_all { |parent|
    root.search(selector).include?(parent)
  })
end

#at(path, ns = document.root ? document.root.namespaces : {}) ⇒ Object Also known as: %

Search for the first occurrence of path.

Returns nil if nothing is found, otherwise a Node.



203
204
205
 
# File 'lib/nokogiri/xml/node.rb', line 203

def at path, ns = document.root ? document.root.namespaces : {}
  search(path, ns).first
end

#at_css(*rules) ⇒ Object

Search this node for the first occurrence of CSS rules. Equivalent to css(rules).first See Node#css for more information.



222
223
224
 
# File 'lib/nokogiri/xml/node.rb', line 222

def at_css *rules
  css(*rules).first
end

#at_xpath(*paths) ⇒ Object

Search this node for the first occurrence of XPath paths. Equivalent to xpath(paths).first See Node#xpath for more information.



213
214
215
 
# File 'lib/nokogiri/xml/node.rb', line 213

def at_xpath *paths
  xpath(*paths).first
end

#attribute(name) ⇒ Object

Get the attribute node with name



723
724
725
 
# File 'ext/nokogiri/xml_node.c', line 723

def attribute(name)
  attribute_nodes.find { |x| x.name == name }
end

#attribute_nodes ⇒ Object

returns a list containing the Node attributes.



758
759
760
 
# File 'ext/nokogiri/xml_node.c', line 758

def attribute_nodes
  Node.node_properties cstruct
end

#attribute_with_ns(name, namespace) ⇒ Object

Get the attribute node with name and namespace



740
741
742
743
744
745
 
# File 'ext/nokogiri/xml_node.c', line 740

def attribute_with_ns(name, namespace)
  prop = LibXML.xmlHasNsProp(cstruct, name.to_s,
    namespace.nil? ? NULL : namespace.to_s)
  return prop if prop.null?
  Node.wrap(prop)
end

#attributes ⇒ Object

Returns a hash containing the node’s attributes. The key is the attribute name, the value is a Nokogiri::XML::Attr representing the attribute.



380
381
382
383
384
 
# File 'lib/nokogiri/xml/node.rb', line 380

def attributes
  Hash[*(attribute_nodes.map { |node|
    [node.node_name, node]
  }.flatten)]
end

#before(node_or_tags) ⇒ Object

Insert node_or_tags before this node (as a sibling). node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns self, to support chaining of calls.

Also see related method add_previous_sibling.



290
291
292
293
 
# File 'lib/nokogiri/xml/node.rb', line 290

def before node_or_tags
  add_previous_sibling node_or_tags
  self
end

#blank? ⇒ Boolean

Is this node blank?

Returns:

  • (Boolean) 


404
405
406
 
# File 'ext/nokogiri/xml_node.c', line 404

def blank?
  LibXML.xmlIsBlankNode(cstruct) == 1
end

#cdata? ⇒ Boolean

Returns true if this is a CDATA

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/nokogiri/xml/node.rb', line 480

def cdata?
  type == CDATA_SECTION_NODE
end

#child ⇒ Object

Returns the child node



570
571
572
 
# File 'ext/nokogiri/xml_node.c', line 570

def child
  (val = cstruct[:children]).null? ? nil : Node.wrap(val)
end

#children ⇒ Object

Get the list of children for this node as a NodeSet



497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
 
# File 'ext/nokogiri/xml_node.c', line 497

def children
  return NodeSet.new(nil) if cstruct[:children].null?
  child = Node.wrap(cstruct[:children])

  set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(child.cstruct), self.document)
  return set unless child

  child_ptr = child.cstruct[:next]
  while ! child_ptr.null?
    child = Node.wrap(child_ptr)
    LibXML.xmlXPathNodeSetAddUnique(set.cstruct, child.cstruct)
    child_ptr = child.cstruct[:next]
  end

  return set
end

#clone ⇒ Object 



373
 
# File 'lib/nokogiri/xml/node.rb', line 373

alias :clone          :dup

#comment? ⇒ Boolean

Returns true if this is a Comment

Returns:

  • (Boolean) 


475
476
477
 
# File 'lib/nokogiri/xml/node.rb', line 475

def comment?
  type == COMMENT_NODE
end

#content ⇒ Object

Returns the content for this Node



890
891
892
893
894
895
896
 
# File 'ext/nokogiri/xml_node.c', line 890

def content
  content_ptr = LibXML.xmlNodeGetContent(cstruct)
  return nil if content_ptr.null?
  content = content_ptr.read_string # TODO: encoding?
  LibXML.xmlFree(content_ptr)
  content
end

#content=(string) ⇒ Object

Set the Node’s content to a Text node containing string. The string gets XML escaped, not interpreted as markup.



448
449
450
 
# File 'lib/nokogiri/xml/node.rb', line 448

def content= string
  self.native_content = encode_special_chars(string.to_s)
end

#create_external_subset(name, external_id, system_id) ⇒ Object

Create an external subset



287
288
289
290
291
292
293
294
295
296
 
# File 'ext/nokogiri/xml_node.c', line 287

def create_external_subset name, external_id, system_id
  raise("Document already has an external subset") if external_subset

  doc = cstruct.document
  dtd_ptr = LibXML.xmlNewDtd doc, name, external_id, system_id

  return nil if dtd_ptr.null?

  Node.wrap dtd_ptr
end

#create_internal_subset(name, external_id, system_id) ⇒ Object

Create an internal subset



256
257
258
259
260
261
262
263
264
265
 
# File 'ext/nokogiri/xml_node.c', line 256

def create_internal_subset name, external_id, system_id
  raise("Document already has an internal subset") if internal_subset

  doc = cstruct.document
  dtd_ptr = LibXML.xmlCreateIntSubset doc, name, external_id, system_id

  return nil if dtd_ptr.null?

  Node.wrap dtd_ptr
end

#css(*rules) ⇒ Object

Search this node for CSS rules. rules must be one or more CSS selectors. For example:

node.css('title')
node.css('body h1.bold')
node.css('div + p.green', 'div#one')

Custom CSS pseudo classes may also be defined. To define custom pseudo classes, create a class and implement the custom pseudo class you want defined. The first argument to the method will be the current matching NodeSet. Any other arguments are ones that you pass in. For example:

node.css('title:regex("\w+")', Class.new {
  def regex node_set, regex
    node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
  end
}.new)



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/nokogiri/xml/node.rb', line 176

def css *rules
  # Pop off our custom function handler if it exists
  handler = ![
    Hash, String, Symbol
  ].include?(rules.last.class) ? rules.pop : nil

  ns = rules.last.is_a?(Hash) ? rules.pop :
    (document.root ? document.root.namespaces : {})

  rules = rules.map { |rule|
    CSS.xpath_for(rule, :prefix => ".//", :ns => ns)
  }.flatten.uniq + [ns, handler].compact

  xpath(*rules)
end

#css_path ⇒ Object

Get the path to this node as a CSS expression



538
539
540
541
542
 
# File 'lib/nokogiri/xml/node.rb', line 538

def css_path
  path.split(/\//).map { |part|
    part.length == 0 ? nil : part.gsub(/\[(\d+)\]/, ':nth-of-type(\1)')
  }.compact.join(' > ')
end

#decorate! ⇒ Object

Decorate this node with the decorators set up in this node’s Document



89
90
91
 
# File 'lib/nokogiri/xml/node.rb', line 89

def decorate!
  document.decorate(self)
end

#default_namespace=(url) ⇒ Object

Set the default namespace for this node to url



569
570
571
 
# File 'lib/nokogiri/xml/node.rb', line 569

def default_namespace= url
  add_namespace_definition(nil, url)
end

#description ⇒ Object

Fetch the Nokogiri::HTML::ElementDescription for this node. Returns nil on XML documents and on unknown tags.



507
508
509
510
 
# File 'lib/nokogiri/xml/node.rb', line 507

def description
  return nil if document.xml?
  Nokogiri::HTML::ElementDescription[name]
end

#document ⇒ Object

Get the document for this Node



205
206
207
 
# File 'ext/nokogiri/xml_node.c', line 205

def document
  cstruct.document.ruby_doc
end

#dup ⇒ Object

Copy this node. An optional depth may be passed in, but it defaults to a deep copy. 0 is a shallow copy, 1 is a deep copy.



367
368
369
370
371
 
# File 'ext/nokogiri/xml_node.c', line 367

def dup(deep = 1)
  dup_ptr = LibXML.xmlDocCopyNode(cstruct, cstruct.document, deep)
  return nil if dup_ptr.null?
  Node.wrap(dup_ptr, self.class)
end

#each(&block) ⇒ Object

Iterate over each attribute name and value pair for this Node.



400
401
402
403
404
 
# File 'lib/nokogiri/xml/node.rb', line 400

def each &block
  attribute_nodes.each { |node|
    block.call([node.node_name, node.value])
  }
end

#element? ⇒ Boolean Also known as: elem?

Returns true if this is an Element node

Returns:

  • (Boolean) 


520
521
522
 
# File 'lib/nokogiri/xml/node.rb', line 520

def element?
  type == ELEMENT_NODE
end

#element_children ⇒ Object

Get the list of children for this node as a NodeSet. All nodes will be element nodes.

Example:

@doc.root.element_children.all? { |x| x.element? } # => true



536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
 
# File 'ext/nokogiri/xml_node.c', line 536

def element_children
  child = LibXML.xmlFirstElementChild(cstruct)
  return NodeSet.new(nil) if child.null?
  child = Node.wrap(child)

  set = NodeSet.wrap(LibXML.xmlXPathNodeSetCreate(child.cstruct), self.document)
  return set unless child

  next_sibling = LibXML.xmlNextElementSibling(child.cstruct)
  while ! next_sibling.null?
    child = Node.wrap(next_sibling)
    LibXML.xmlXPathNodeSetAddUnique(set.cstruct, child.cstruct)
    next_sibling = LibXML.xmlNextElementSibling(child.cstruct)
  end

  return set
end

#elements ⇒ Object 



374
 
# File 'lib/nokogiri/xml/node.rb', line 374

alias :elements       :element_children

#encode_special_chars(string) ⇒ Object

Encode any special characters in string



232
233
234
235
236
237
238
 
# File 'ext/nokogiri/xml_node.c', line 232

def encode_special_chars(string)
  char_ptr = LibXML.xmlEncodeSpecialChars(self[:doc], string)
  encoded = char_ptr.read_string
  # TODO: encoding?
  LibXML.xmlFree(char_ptr)
  encoded
end

#external_subset ⇒ Object

Get the external subset



318
319
320
321
322
323
 
# File 'ext/nokogiri/xml_node.c', line 318

def external_subset
  doc = cstruct.document
  return nil if doc[:extSubset].null?

  Node.wrap(doc[:extSubset])
end

#first_element_child ⇒ Object

Returns the first child node of this node that is an element.

Example:

@doc.root.first_element_child.element? # => true



591
592
593
594
 
# File 'ext/nokogiri/xml_node.c', line 591

def first_element_child
  element_child = LibXML.xmlFirstElementChild(cstruct)
  element_child.null? ? nil : Node.wrap(element_child)
end

#fragment(tags) ⇒ Object

Create a DocumentFragment containing tags that is relative to this context node.



422
423
424
425
 
# File 'lib/nokogiri/xml/node.rb', line 422

def fragment tags
  type = document.html? ? Nokogiri::HTML : Nokogiri::XML
  type::DocumentFragment.new(document, tags, self)
end

#fragment? ⇒ Boolean

Returns true if this is a DocumentFragment

Returns:

  • (Boolean) 


500
501
502
 
# File 'lib/nokogiri/xml/node.rb', line 500

def fragment?
  type == DOCUMENT_FRAG_NODE
end

#has_attribute? ⇒ Object 



367
 
# File 'lib/nokogiri/xml/node.rb', line 367

alias :has_attribute? :key?

#html? ⇒ Boolean

Returns true if this is an HTML::Document node

Returns:

  • (Boolean) 


490
491
492
 
# File 'lib/nokogiri/xml/node.rb', line 490

def html?
  type == HTML_DOCUMENT_NODE
end

#inner_html(*args) ⇒ Object

Get the inner_html for this node’s Node#children



533
534
535
 
# File 'lib/nokogiri/xml/node.rb', line 533

def inner_html *args
  children.map { |x| x.to_html(*args) }.join
end

#inner_html=(node_or_tags) ⇒ Object

Set the inner_html for this Node to node_or_tags node_or_tags can be a Nokogiri::XML::Node, a Nokogiri::XML::DocumentFragment, or a string containing markup.

Returns self.



312
313
314
315
316
317
318
319
320
321
 
# File 'lib/nokogiri/xml/node.rb', line 312

def inner_html= node_or_tags
  node_or_tags = coerce(node_or_tags)
  children.unlink
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_child_node n }
  else
    add_child node_or_tags
  end
  self
end

#inner_text ⇒ Object 



366
 
# File 'lib/nokogiri/xml/node.rb', line 366

alias :inner_text     :content

#internal_subset ⇒ Object

Get the internal subset



342
343
344
345
346
347
 
# File 'ext/nokogiri/xml_node.c', line 342

def internal_subset
  doc = cstruct.document
  dtd = LibXML.xmlGetIntSubset(doc)
  return nil if dtd.null?
  Node.wrap(dtd)
end

#key?(attribute) ⇒ Boolean

Returns true if attribute is set

Returns:

  • (Boolean) 


629
630
631
 
# File 'ext/nokogiri/xml_node.c', line 629

def key?(attribute)
  ! (prop = LibXML.xmlHasProp(cstruct, attribute.to_s)).null?
end

#keys ⇒ Object

Get the attribute names for this Node.



394
395
396
 
# File 'lib/nokogiri/xml/node.rb', line 394

def keys
  attribute_nodes.map { |node| node.node_name }
end

#last_element_child ⇒ Object

Returns the last child node of this node that is an element.

Example:

@doc.root.last_element_child.element? # => true



612
613
614
615
 
# File 'ext/nokogiri/xml_node.c', line 612

def last_element_child
  element_child = LibXML.xmlLastElementChild(cstruct)
  element_child.null? ? nil : Node.wrap(element_child)
end

#line ⇒ Object

Returns the line for this Node



1036
1037
1038
 
# File 'ext/nokogiri/xml_node.c', line 1036

def line
  cstruct[:line]
end

#matches?(selector) ⇒ Boolean

Returns true if this Node matches selector

Returns:

  • (Boolean) 


415
416
417
 
# File 'lib/nokogiri/xml/node.rb', line 415

def matches? selector
  ancestors.last.search(selector).include?(self)
end

#name ⇒ Object 



369
 
# File 'lib/nokogiri/xml/node.rb', line 369

alias :name           :node_name

#name= ⇒ Object 



370
 
# File 'lib/nokogiri/xml/node.rb', line 370

alias :name=          :node_name=

#namespace ⇒ Object

returns the Nokogiri::XML::Namespace for the node, if one exists.



779
780
781
 
# File 'ext/nokogiri/xml_node.c', line 779

def namespace
  cstruct[:ns].null? ? nil : Namespace.wrap(cstruct.document, cstruct[:ns])
end

#namespace=(ns) ⇒ Object

Set the namespace for this node to ns



576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'lib/nokogiri/xml/node.rb', line 576

def namespace= ns
  return set_namespace(ns) unless ns

  unless Nokogiri::XML::Namespace === ns
    raise TypeError, "#{ns.class} can't be coerced into Nokogiri::XML::Namespace"
  end
  if ns.document != document
    raise ArgumentError, 'namespace must be declared on the same document'
  end

  set_namespace ns
end

#namespace_definitions ⇒ Object

returns a list of Namespace nodes defined on self



796
797
798
799
800
801
802
803
804
805
806
 
# File 'ext/nokogiri/xml_node.c', line 796

def namespace_definitions
  list = []
  ns_ptr = cstruct[:nsDef]
  return list if ns_ptr.null?
  while ! ns_ptr.null?
    ns = Namespace.wrap(cstruct.document, ns_ptr)
    list << ns
    ns_ptr = ns.cstruct[:next]
  end
  list
end

#namespace_scopes ⇒ Object

returns a list of Namespace nodes in scope for self. this is all namespaces defined in the node, or in any ancestor node.



826
827
828
829
830
831
832
833
834
835
836
837
 
# File 'ext/nokogiri/xml_node.c', line 826

def namespace_scopes
  ns_list = LibXML.xmlGetNsList(self.cstruct[:doc], self.cstruct)
  return [] if ns_list.null?

  list = []
  until (ns_ptr = ns_list.get_pointer(LibXML.pointer_offset(list.length))).null?
    list << Namespace.wrap(cstruct.document, ns_ptr)
  end

  LibXML.xmlFree(ns_list)
  list
end

#namespaced_key?(attribute, namespace) ⇒ Boolean

Returns true if attribute is set with namespace

Returns:

  • (Boolean) 


644
645
646
647
648
 
# File 'ext/nokogiri/xml_node.c', line 644

def namespaced_key?(attribute, namespace)
  prop = LibXML.xmlHasNsProp(cstruct, attribute.to_s,
    namespace.nil? ? nil : namespace.to_s)
  !prop.null?
end

#namespaces ⇒ Object

Get a hash containing the Namespace definitions for this Node



461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/nokogiri/xml/node.rb', line 461

def namespaces
  Hash[*namespace_scopes.map { |nd|
    key = ['xmlns', nd.prefix].compact.join(':')
    if RUBY_VERSION >= '1.9' && document.encoding
      begin
        key.force_encoding document.encoding
      rescue ArgumentError
      end
    end
    [key, nd.href]
  }.flatten]
end

#next ⇒ Object 



352
 
# File 'lib/nokogiri/xml/node.rb', line 352

alias :next           :next_sibling

#next_element ⇒ Object

Returns the next Nokogiri::XML::Element type sibling node.



451
452
453
454
 
# File 'ext/nokogiri/xml_node.c', line 451

def next_element
  sibling_ptr = LibXML.xmlNextElementSibling cstruct
  sibling_ptr.null? ? nil : Node.wrap(sibling_ptr)
end

#next_sibling ⇒ Object

Returns the next sibling node



417
418
419
 
# File 'ext/nokogiri/xml_node.c', line 417

def next_sibling
  cstruct_node_from :next
end

#name ⇒ Object

Returns the name for this Node



949
950
951
 
# File 'ext/nokogiri/xml_node.c', line 949

def node_name
  cstruct[:name] # TODO: encoding?
end

#name=(new_name) ⇒ Object

Set the name for this Node



935
936
937
938
 
# File 'ext/nokogiri/xml_node.c', line 935

def node_name=(string)
  LibXML.xmlNodeSetName(cstruct, string)
  string
end

#node_type ⇒ Object

Get the type for this Node



854
855
856
 
# File 'ext/nokogiri/xml_node.c', line 854

def node_type
  cstruct[:type]
end

#parent ⇒ Object

Get the parent Node for this Node



918
919
920
 
# File 'ext/nokogiri/xml_node.c', line 918

def parent
  cstruct_node_from :parent
end

#parent=(parent_node) ⇒ Object

Set the parent Node for this Node



454
455
456
457
 
# File 'lib/nokogiri/xml/node.rb', line 454

def parent= parent_node
  parent_node.add_child(self)
  parent_node
end

#parse(string_or_io, options = ParseOptions::DEFAULT_XML) {|options| ... } ⇒ Object

Parse string_or_io as a document fragment within the context of this node. Returns a XML::NodeSet containing the nodes parsed from string_or_io.

Yields:

  • (options) 


431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/nokogiri/xml/node.rb', line 431

def parse string_or_io, options = ParseOptions::DEFAULT_XML
  if Fixnum === options
    options = Nokogiri::XML::ParseOptions.new(options)
  end
  # Give the options to the user
  yield options if block_given?

  contents = string_or_io.respond_to?(:read) ?
    string_or_io.read :
    string_or_io

  return Nokogiri::XML::NodeSet.new(document) if contents.empty?
  in_context(contents, options.to_i)
end

#path ⇒ Object

Returns the path associated with this Node



964
965
966
967
968
969
 
# File 'ext/nokogiri/xml_node.c', line 964

def path
  path_ptr = LibXML.xmlGetNodePath(cstruct)
  val = path_ptr.null? ? nil : path_ptr.read_string # TODO: encoding?
  LibXML.xmlFree(path_ptr)
  val
end

#pointer_id ⇒ Object

Get the internal pointer number



218
219
220
 
# File 'ext/nokogiri/xml_node.c', line 218

def pointer_id
  cstruct.pointer
end

#previous ⇒ Object 



353
 
# File 'lib/nokogiri/xml/node.rb', line 353

alias :previous       :previous_sibling

#previous_element ⇒ Object

Returns the previous Nokogiri::XML::Element type sibling node.



468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
# File 'ext/nokogiri/xml_node.c', line 468

def previous_element
  #
  #  note that we don't use xmlPreviousElementSibling here because it's buggy pre-2.7.7.
  #
  sibling_ptr = cstruct[:prev]

  while ! sibling_ptr.null?
    sibling_cstruct = LibXML::XmlNode.new(sibling_ptr)
    break if sibling_cstruct[:type] == ELEMENT_NODE
    sibling_ptr = sibling_cstruct[:prev]
  end

  return sibling_ptr.null? ? nil : Node.wrap(sibling_ptr)
end

#previous_sibling ⇒ Object

Returns the previous sibling node



434
435
436
 
# File 'ext/nokogiri/xml_node.c', line 434

def previous_sibling
  cstruct_node_from :prev
end

#read_only? ⇒ Boolean

Is this a read only node?

Returns:

  • (Boolean) 


514
515
516
517
 
# File 'lib/nokogiri/xml/node.rb', line 514

def read_only?
  # According to gdome2, these are read-only node types
  [NOTATION_NODE, ENTITY_NODE, ENTITY_DECL].include?(type)
end

#remove ⇒ Object 



361
 
# File 'lib/nokogiri/xml/node.rb', line 361

alias :remove         :unlink

#remove_attribute(name) ⇒ Object Also known as: delete

Remove the attribute named name



408
409
410
 
# File 'lib/nokogiri/xml/node.rb', line 408

def remove_attribute name
  attributes[name].remove if key? name
end

#replace(node_or_tags) ⇒ Object

Replace this Node with node_or_tags. node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns the new child node.

Also see related method swap.



330
331
332
333
334
335
336
337
338
 
# File 'lib/nokogiri/xml/node.rb', line 330

def replace node_or_tags
  node_or_tags = coerce(node_or_tags)
  if node_or_tags.is_a?(XML::NodeSet)
    node_or_tags.each { |n| add_previous_sibling n }
    unlink
  else
    replace_node node_or_tags
  end
end

#search(*paths) ⇒ Object Also known as: /

Search this node for paths. paths can be XPath or CSS, and an optional hash of namespaces may be appended. See Node#xpath and Node#css.



97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/nokogiri/xml/node.rb', line 97

def search *paths
  ns = paths.last.is_a?(Hash) ? paths.pop :
    (document.root ? document.root.namespaces : {})
  xpath(*(paths.map { |path|
    path = path.to_s
    path =~ /^(\.\/|\/)/ ? path : CSS.xpath_for(
      path,
      :prefix => ".//",
      :ns     => ns
    )
  }.flatten.uniq) + [ns])
end

#serialize(*args, &block) ⇒ Object

Serialize Node using options. Save options can also be set using a block. See SaveOptions.

These two statements are equivalent:

node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)

or

node.serialize(:encoding => 'UTF-8') do |config|
  config.format.as_xml
end



624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
 
# File 'lib/nokogiri/xml/node.rb', line 624

def serialize *args, &block
  options = args.first.is_a?(Hash) ? args.shift : {
    :encoding   => args[0],
    :save_with  => args[1] || SaveOptions::FORMAT
  }

  encoding = options[:encoding] || document.encoding

  outstring = ""
  if encoding && outstring.respond_to?(:force_encoding)
    outstring.force_encoding(Encoding.find(encoding))
  end
  io = StringIO.new(outstring)
  write_to io, options, &block
  io.string
end

#set_attribute ⇒ Object 



364
 
# File 'lib/nokogiri/xml/node.rb', line 364

alias :set_attribute  :[]=

#swap(node_or_tags) ⇒ Object

Swap this Node for node_or_tags node_or_tags can be a Nokogiri::XML::Node, a ::DocumentFragment, a ::NodeSet, or a string containing markup.

Returns self, to support chaining of calls.

Also see related method replace.



347
348
349
350
 
# File 'lib/nokogiri/xml/node.rb', line 347

def swap node_or_tags
  replace node_or_tags
  self
end

#text ⇒ Object Also known as: to_str 



365
 
# File 'lib/nokogiri/xml/node.rb', line 365

alias :text           :content

#text? ⇒ Boolean

Returns true if this is a Text node

Returns:

  • (Boolean) 


495
496
497
 
# File 'lib/nokogiri/xml/node.rb', line 495

def text?
  type == TEXT_NODE
end

#to_html(options = {}) ⇒ Object

Serialize this Node to HTML

doc.to_html

See Node#write_to for a list of options. For formatted output, use Node#to_xhtml instead.



648
649
650
651
652
653
654
655
656
657
658
 
# File 'lib/nokogiri/xml/node.rb', line 648

def to_html options = {}
  # FIXME: this is a hack around broken libxml versions
  return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

  options[:save_with] ||= SaveOptions::FORMAT |
                          SaveOptions::NO_DECLARATION |
                          SaveOptions::NO_EMPTY_TAGS |
                          SaveOptions::AS_HTML

  serialize(options)
end

#to_s ⇒ Object

Turn this node in to a string. If the document is HTML, this method returns html. If the document is XML, this method returns XML.



528
529
530
 
# File 'lib/nokogiri/xml/node.rb', line 528

def to_s
  document.xml? ? to_xml : to_html
end

#to_xhtml(options = {}) ⇒ Object

Serialize this Node to XHTML using options

doc.to_xhtml(:indent => 5, :encoding => 'UTF-8')

See Node#write_to for a list of options



678
679
680
681
682
683
684
685
686
687
688
 
# File 'lib/nokogiri/xml/node.rb', line 678

def to_xhtml options = {}
  # FIXME: this is a hack around broken libxml versions
  return dump_html if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

  options[:save_with] ||= SaveOptions::FORMAT |
                          SaveOptions::NO_DECLARATION |
                          SaveOptions::NO_EMPTY_TAGS |
                          SaveOptions::AS_XHTML

  serialize(options)
end

#to_xml(options = {}) ⇒ Object

Serialize this Node to XML using options

doc.to_xml(:indent => 5, :encoding => 'UTF-8')

See Node#write_to for a list of options



666
667
668
669
670
 
# File 'lib/nokogiri/xml/node.rb', line 666

def to_xml options = {}
  options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML

  serialize(options)
end

#traverse(&block) ⇒ Object

Yields self and all children to block recursively.



591
592
593
594
 
# File 'lib/nokogiri/xml/node.rb', line 591

def traverse &block
  children.each{|j| j.traverse(&block) }
  block.call(self)
end

#type ⇒ Object 



371
 
# File 'lib/nokogiri/xml/node.rb', line 371

alias :type           :node_type

#unlink ⇒ Object

Unlink this node from its current context.



389
390
391
392
393
 
# File 'ext/nokogiri/xml_node.c', line 389

def unlink
  LibXML.xmlUnlinkNode(cstruct)
  cstruct.keep_reference_from_document!
  self
end

#values ⇒ Object

Get the attribute values for this Node.



388
389
390
 
# File 'lib/nokogiri/xml/node.rb', line 388

def values
  attribute_nodes.map { |node| node.value }
end

#write_html_to(io, options = {}) ⇒ Object

Write Node as HTML to io with options

See Node#write_to for a list of options



725
726
727
728
729
730
731
732
733
734
 
# File 'lib/nokogiri/xml/node.rb', line 725

def write_html_to io, options = {}
  # FIXME: this is a hack around broken libxml versions
  return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

  options[:save_with] ||= SaveOptions::FORMAT |
    SaveOptions::NO_DECLARATION |
    SaveOptions::NO_EMPTY_TAGS |
    SaveOptions::AS_HTML
  write_to io, options
end

#write_to(io, *options) {|config| ... } ⇒ Object

Write Node to io with options. options modify the output of this method. Valid options are:

  • :encoding for changing the encoding

  • :indent_text the indentation text, defaults to one space

  • :indent the number of :indent_text to use, defaults to 2

  • :save_with a combination of SaveOptions constants.

To save with UTF-8 indented twice:

node.write_to(io, :encoding => 'UTF-8', :indent => 2)

To save indented with two dashes:

node.write_to(io, :indent_text => '-', :indent => 2

Yields:

  • (config) 


707
708
709
710
711
712
713
714
715
716
717
718
719
 
# File 'lib/nokogiri/xml/node.rb', line 707

def write_to io, *options
  options       = options.first.is_a?(Hash) ? options.shift : {}
  encoding      = options[:encoding] || options[0]
  save_options  = options[:save_with] || options[1] || SaveOptions::FORMAT
  indent_text   = options[:indent_text] || ' '
  indent_times  = options[:indent] || 2


  config = SaveOptions.new(save_options)
  yield config if block_given?

  native_write_to(io, encoding, indent_text * indent_times, config.options)
end

#write_xhtml_to(io, options = {}) ⇒ Object

Write Node as XHTML to io with options

See Node#write_to for a list of options



740
741
742
743
744
745
746
747
748
749
 
# File 'lib/nokogiri/xml/node.rb', line 740

def write_xhtml_to io, options = {}
  # FIXME: this is a hack around broken libxml versions
  return (io << dump_html) if %w[2 6] === LIBXML_VERSION.split('.')[0..1]

  options[:save_with] ||= SaveOptions::FORMAT |
    SaveOptions::NO_DECLARATION |
    SaveOptions::NO_EMPTY_TAGS |
    SaveOptions::AS_XHTML
  write_to io, options
end

#write_xml_to(io, options = {}) ⇒ Object

Write Node as XML to io with options

doc.write_xml_to io, :encoding => 'UTF-8'

See Node#write_to for a list of options



757
758
759
760
 
# File 'lib/nokogiri/xml/node.rb', line 757

def write_xml_to io, options = {}
  options[:save_with] ||= SaveOptions::FORMAT | SaveOptions::AS_XML
  write_to io, options
end

#xml? ⇒ Boolean

Returns true if this is an XML::Document node

Returns:

  • (Boolean) 


485
486
487
 
# File 'lib/nokogiri/xml/node.rb', line 485

def xml?
  type == DOCUMENT_NODE
end

#xpath(*paths) ⇒ Object

Search this node for XPath paths. paths must be one or more XPath queries. A hash of namespaces may be appended. For example:

node.xpath('.//title')
node.xpath('.//foo:name', { 'foo' => 'http://example.org/' })
node.xpath('.//xmlns:name', node.root.namespaces)

Custom XPath functions may also be defined. To define custom functions create a class and implement the # function you want to define. For example:

node.xpath('.//title[regex(., "\w+")]', Class.new {
  def regex node_set, regex
    node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
  end
}.new)



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/nokogiri/xml/node.rb', line 129

def xpath *paths
  # Pop off our custom function handler if it exists
  handler = ![
    Hash, String, Symbol
  ].include?(paths.last.class) ? paths.pop : nil

  ns = paths.last.is_a?(Hash) ? paths.pop :
    (document.root ? document.root.namespaces : {})

  return NodeSet.new(document) unless document

  sets = paths.map { |path|
    ctx = XPathContext.new(self)
    ctx.register_namespaces(ns)
    ctx.evaluate(path, handler)
  }
  return sets.first if sets.length == 1

  NodeSet.new(document) do |combined|
    sets.each do |set|
      set.each do |node|
        combined << node
      end
    end
  end
end