class Nokogiri::XML::NodeSet

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

def ==(other)

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

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

def add_class(name)

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

NodeSet.
Add the class attribute +name+ to all Node objects in the
##

def add_class(name)
  each do |el|
    el.add_class(name)
  end
  self
end

def after(datum)

Insert +datum+ after the last Node in this NodeSet
##

def after(datum)
  last.after(datum)
end

def append_class(name)

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

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

def append_class(name)
  each do |el|
    el.append_class(name)
  end
  self
end

def at(*args)

node_set.at(3) # same as node_set[3]

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

See Searchable#search for more information.

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

call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
##

def at(*args)
  if args.length == 1 && args.first.is_a?(Numeric)
    return self[args.first]
  end
  super(*args)
end

def attr(key, value = nil, &block)

node_set.attr("class") { |node| node.name }

for that node:
the NodeSet and the return value used as the attribute value
If +block+ is passed, it will be called on each Node object in

node_set.attr("href", "https://www.nokogiri.org")

for all nodes:
If +value+ is passed, it will be used as the attribute value

node_set.attr("href" => "https://www.nokogiri.org", "class" => "member")

key/value pair:
If +key+ is a Hash then attributes will be set for each

must be passed.
If +key+ is an attribute name, then either +value+ or +block+

called as a setter, +#attr+ returns the NodeSet.
attribute name, or a Hash of attribute names and values. When
To set an attribute on each node, +key+ can either be an

Note that an empty NodeSet will return nil when +#attr+ is called as a getter.

node_set.attr("href") # => "https://www.nokogiri.org"

To get an attribute from the first Node in a NodeSet:

attribute from the first Node in the NodeSet.
Set attributes on each Node in the NodeSet, or get an
##

def attr(key, value = nil, &block)
  unless key.is_a?(Hash) || (key && (value || block))
    return first&.attribute(key)
  end
  hash = key.is_a?(Hash) ? key : { key => value }
  hash.each do |k, v|
    each do |node|
      node[k] = v || yield(node)
    end
  end
  self
end

def before(datum)

Insert +datum+ before the first Node in this NodeSet
##

def before(datum)
  first.before(datum)
end

def children

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

def children
  node_set = NodeSet.new(document)
  each do |node|
    node.children.each { |n| node_set.push(n) }
  end
  node_set
end

def css(*args)

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

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

call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
##

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

def deconstruct

Since v1.14.0

Returns the members of this NodeSet as an array, to use in pattern matching.

:call-seq: deconstruct() → Array

def deconstruct
  to_a
end

def each

Iterate over each node, yielding to +block+
##

def each
  return to_enum unless block_given?
  0.upto(length - 1) do |x|
    yield self[x]
  end
  self
end

def empty?

Is this NodeSet empty?
##

def empty?
  length == 0
end

def filter(expr)

Filter this list for nodes that match +expr+
##

def filter(expr)
  find_all { |node| node.matches?(expr) }
end

def first(n = nil)

Get the first element of the NodeSet.
##

def first(n = nil)
  return self[0] unless n
  list = []
  [n, length].min.times { |i| list << self[i] }
  list
end

def index(node = nil)

Returns the index of the first node in self that is == to +node+ or meets the given block. Returns nil if no match is found.
##

def index(node = nil)
  if node
    warn("given block not used") if block_given?
    each_with_index { |member, j| return j if member == node }
  elsif block_given?
    each_with_index { |member, j| return j if yield(member) }
  end
  nil
end

def initialize(document, list = [])

Create a NodeSet with +document+ defaulting to +list+

def initialize(document, list = [])
  @document = document
  document.decorate(self)
  list.each { |x| self << x }
  yield self if block_given?
end

def inner_html(*args)

Get the inner html of all contained Node objects
##

def inner_html(*args)
  collect { |j| j.inner_html(*args) }.join("")
end

def inner_text

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

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

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

doc.css('d').text # => "foobar"
doc = Nokogiri::XML('foobar')

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

Get the inner text of all contained Node objects
##

def inner_text
  collect(&:inner_text).join("")
end

def inspect

Return a nicely formated string representation
##

def inspect
  "[#{map(&:inspect).join(", ")}]"
end

def last

Get the last element of the NodeSet.
##

def last
  self[-1]
end

def pop

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

def pop
  return if length == 0
  delete(last)
end

def remove_attr(name)

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

def remove_attr(name)
  each { |el| el.delete(name) }
  self
end

def remove_class(name = nil)

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

NodeSet.
Remove the class attribute +name+ from all Node objects in the
##

def remove_class(name = nil)
  each do |el|
    el.remove_class(name)
  end
  self
end

def reverse

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

def reverse
  node_set = NodeSet.new(document)
  (length - 1).downto(0) do |x|
    node_set.push(self[x])
  end
  node_set
end

def shift

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

def shift
  return if length == 0
  delete(first)
end

def to_html(*args)

Convert this NodeSet to HTML
##

def to_html(*args)
  if Nokogiri.jruby?
    options = args.first.is_a?(Hash) ? args.shift : {}
    options[:save_with] ||= Node::SaveOptions::DEFAULT_HTML
    args.insert(0, options)
  end
  if empty?
    encoding = (args.first.is_a?(Hash) ? args.first[:encoding] : nil)
    encoding ||= document.encoding
    encoding.nil? ? "" : "".encode(encoding)
  else
    map { |x| x.to_html(*args) }.join
  end
end

def to_s

Convert this NodeSet to a string.
##

def to_s
  map(&:to_s).join
end

def to_xhtml(*args)

Convert this NodeSet to XHTML
##

def to_xhtml(*args)
  map { |x| x.to_xhtml(*args) }.join
end

def to_xml(*args)

Convert this NodeSet to XML
##

def to_xml(*args)
  map { |x| x.to_xml(*args) }.join
end

def wrap(node_or_tags)

#
#

# =>
doc.to_html
doc.css("a").wrap(doc.create_element("div"))
HTML

d
c
b
a

doc = Nokogiri::HTML5(<<~HTML)

having to reparse the wrapper markup for each node.
💡 Note that this is faster than the equivalent call passing a +String+ because it avoids

*Example* with a +Node+ argument

#
#

# =>
doc.to_html
doc.css("a").wrap("

")
HTML

d
c
b
a

doc = Nokogiri::HTML5(<<~HTML)

*Example* with a +String+ argument:

Also see Node#wrap

use by passing a +Node+ instead.
NodeSet. You can avoid this overhead in cases where you know exactly the wrapper you wish to
⚠ Note that if a +String+ is passed, the markup will be parsed once per node in the

[Returns] +self+, to support chaining.

An element that is `#dup`ed and used as the wrapper.
- *node* (Nokogiri::XML::Node)
node is used as the wrapper.
associated document is used. If the parsed fragment has multiple roots, the first root
node's parent, if it exists, is used as the context node for parsing; otherwise the
Markup that is parsed, once per member of the NodeSet, and used as the wrapper. Each
- *markup* (String)
[Parameters]

Wrap each member of this NodeSet with the node parsed from +markup+ or a dup of the +node+.

wrap(node) -> self
wrap(markup) -> self
:call-seq:

def wrap(node_or_tags)
  map { |node| node.wrap(node_or_tags) }
  self
end

def xpath(*args)

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

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

call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
##

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

Modules

Classes