A NodeSet contains a list of Nokogiri::XML::Node objects. Typically a NodeSet is return as a result of searching a Document via Nokogiri::XML::Searchable#css or Nokogiri::XML::Searchable#xpath

Methods
#
A
B
C
E
F
I
L
N
P
R
S
T
W
X
Included Modules
Constants
IMPLIED_XPATH_CONTEXTS = [ './/'.freeze, 'self::'.freeze ].freeze # :nodoc:
 

@private

Attributes
[RW] document

The Document this NodeSet is associated with

Class Public methods
new(document, list = [])

Create a NodeSet with document defaulting to list

# File lib/nokogiri/xml/node_set.rb, line 17
def initialize document, list = []
  @document = document
  document.decorate(self)
  list.each { |x| self << x }
  yield self if block_given?
end
Instance Public methods
%(*args)
Alias for: at
==(other)

Equality – Two NodeSets are equal if the contain the same number of elements and if each element is equal to the corresponding element in the other NodeSet

# File lib/nokogiri/xml/node_set.rb, line 283
def == other
  return false unless other.is_a?(Nokogiri::XML::NodeSet)
  return false unless length == other.length
  each_with_index do |node, i|
    return false unless node == other[i]
  end
  true
end
>(selector)

Search this NodeSet's nodes' immediate children using CSS selector selector

# File lib/nokogiri/xml/node_set.rb, line 100
def > selector
  ns = document.root.namespaces
  xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
end
add_class(name)

Append the class attribute name to all Node objects in the NodeSet.

# File lib/nokogiri/xml/node_set.rb, line 134
def add_class name
  each do |el|
    classes = el['class'].to_s.split(/\s+/)
    el['class'] = classes.push(name).uniq.join " "
  end
  self
end
after(datum)

Insert datum after the last Node in this NodeSet

# File lib/nokogiri/xml/node_set.rb, line 60
def after datum
  last.after datum
end
search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]

Search this object for paths, and return only the first result. paths must be one or more XPath or CSS queries.

See Nokogiri::XML::Searchable#search for more information.

Or, if passed an integer, index into the NodeSet:

node_set.at(3) # same as node_set[3]
Also aliased as: %
# File lib/nokogiri/xml/node_set.rb, line 117
def at *args
  if args.length == 1 && args.first.is_a?(Numeric)
    return self[args.first]
  end

  super(*args)
end
attr(key, value = nil, &blk)

Set the attribute key to value or the return value of blk on all Node objects in the NodeSet.

Also aliased as: set, attribute
# File lib/nokogiri/xml/node_set.rb, line 165
def attr key, value = nil, &blk
  unless Hash === key || key && (value || blk)
    return first.attribute(key)
  end

  hash = key.is_a?(Hash) ? key : { key => value }

  hash.each { |k,v| each { |el| el[k] = v || blk[el] } }

  self
end
attribute(key, value = nil, &blk)
Alias for: attr
before(datum)

Insert datum before the first Node in this NodeSet

# File lib/nokogiri/xml/node_set.rb, line 54
def before datum
  first.before datum
end
children()

Returns a new NodeSet containing all the children of all the nodes in the NodeSet

# File lib/nokogiri/xml/node_set.rb, line 295
def children
  node_set = NodeSet.new(document)
  each do |node|
    node.children.each { |n| node_set.push(n) }
  end
  node_set
end
css *rules, [namespace-bindings, custom-pseudo-class]

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

For more information see Nokogiri::XML::Searchable#css

# File lib/nokogiri/xml/node_set.rb, line 74
def css *args
  rules, handler, ns, _ = extract_params(args)
  paths = css_rules_to_xpath(rules, ns)

  inject(NodeSet.new(document)) do |set, node|
    set + xpath_internal(node, paths, handler, ns, nil)
  end
end
each(&block)

Iterate over each node, yielding to block

# File lib/nokogiri/xml/node_set.rb, line 188
def each(&block)
  0.upto(length - 1) do |x|
    yield self[x]
  end
end
empty?()

Is this NodeSet empty?

# File lib/nokogiri/xml/node_set.rb, line 41
def empty?
  length == 0
end
filter(expr)

Filter this list for nodes that match expr

# File lib/nokogiri/xml/node_set.rb, line 128
def filter expr
  find_all { |node| node.matches?(expr) }
end
first(n = nil)

Get the first element of the NodeSet.

# File lib/nokogiri/xml/node_set.rb, line 26
def first n = nil
  return self[0] unless n
  list = []
  n.times { |i| list << self[i] }
  list
end
index(node)

Returns the index of the first node in self that is == to node. Returns nil if no match is found.

# File lib/nokogiri/xml/node_set.rb, line 47
def index(node)
  each_with_index { |member, j| return j if member == node }
  nil
end
inner_html(*args)

Get the inner html of all contained Node objects

# File lib/nokogiri/xml/node_set.rb, line 214
def inner_html *args
  collect{|j| j.inner_html(*args) }.join('')
end
inner_text()

Get the inner text of all contained Node objects

Note: This joins the text of all Node objects in the NodeSet:

doc = Nokogiri::XML('<xml><a><d>foo</d><d>bar</d></a></xml>')
doc.css('d').text # => "foobar"

Instead, if you want to return the text of all nodes in the NodeSet:

doc.css('d').map(&:text) # => ["foo", "bar"]

See Nokogiri::XML::Node#content for more information.

Also aliased as: text
# File lib/nokogiri/xml/node_set.rb, line 207
def inner_text
  collect(&:inner_text).join('')
end
inspect()

Return a nicely formated string representation

# File lib/nokogiri/xml/node_set.rb, line 316
def inspect
  "[#{map(&:inspect).join ', '}]"
end
last()

Get the last element of the NodeSet.

# File lib/nokogiri/xml/node_set.rb, line 35
def last
  self[-1]
end
pop()

Removes the last element from set and returns it, or nil if the set is empty

# File lib/nokogiri/xml/node_set.rb, line 266
def pop
  return nil if length == 0
  delete last
end
remove_attr(name)

Remove the attributed named name from all Node objects in the NodeSet

# File lib/nokogiri/xml/node_set.rb, line 181
def remove_attr name
  each { |el| el.delete name }
  self
end
remove_class(name = nil)

Remove the class attribute name from all Node objects in the NodeSet. If name is nil, remove the class attribute from all Nodes in the NodeSet.

# File lib/nokogiri/xml/node_set.rb, line 146
def remove_class name = nil
  each do |el|
    if name
      classes = el['class'].to_s.split(/\s+/)
      if classes.empty?
        el.delete 'class'
      else
        el['class'] = (classes - [name]).uniq.join " "
      end
    else
      el.delete "class"
    end
  end
  self
end
reverse()

Returns a new NodeSet containing all the nodes in the NodeSet in reverse order

# File lib/nokogiri/xml/node_set.rb, line 306
def reverse
  node_set = NodeSet.new(document)
  (length - 1).downto(0) do |x|
    node_set.push self[x]
  end
  node_set
end
set(key, value = nil, &blk)
Alias for: attr
shift()

Returns the first element of the NodeSet and removes it. Returns nil if the set is empty.

# File lib/nokogiri/xml/node_set.rb, line 274
def shift
  return nil if length == 0
  delete first
end
text()
Alias for: inner_text
to_html(*args)

Convert this NodeSet to HTML

# File lib/nokogiri/xml/node_set.rb, line 237
def to_html *args
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    if !options[:save_with]
      options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
    end
    args.insert(0, options)
  end
  map { |x| x.to_html(*args) }.join
end
to_s()

Convert this NodeSet to a string.

# File lib/nokogiri/xml/node_set.rb, line 231
def to_s
  map(&:to_s).join
end
to_xhtml(*args)

Convert this NodeSet to XHTML

# File lib/nokogiri/xml/node_set.rb, line 250
def to_xhtml *args
  map { |x| x.to_xhtml(*args) }.join
end
to_xml(*args)

Convert this NodeSet to XML

# File lib/nokogiri/xml/node_set.rb, line 256
def to_xml *args
  map { |x| x.to_xml(*args) }.join
end
wrap(html, &blk)

Wrap this NodeSet with html or the results of the builder in blk

# File lib/nokogiri/xml/node_set.rb, line 220
def wrap(html, &blk)
  each do |j|
    new_parent = document.parse(html).first
    j.add_next_sibling(new_parent)
    new_parent.add_child(j)
  end
  self
end
xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]

Search this node set for XPath paths. paths must be one or more XPath queries.

For more information see Nokogiri::XML::Searchable#xpath

# File lib/nokogiri/xml/node_set.rb, line 90
def xpath *args
  paths, handler, ns, binds = extract_params(args)

  inject(NodeSet.new(document)) do |set, node|
    set + xpath_internal(node, paths, handler, ns, binds)
  end
end