Parent

Included Modules

Class Index [+]

Quicksearch

Nokogiri::XML::NodeSet

  

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::Node#css or Nokogiri::XML::Node#xpath

Attributes

document[RW]

The Document this NodeSet is associated with

Public Class Methods

new(document, list = []) click to toggle source

Create a NodeSet with document defaulting to list

    # File lib/nokogiri/xml/node_set.rb, line 14
14:       def initialize document, list = []
15:         @document = document
16:         document.decorate(self)
17:         list.each { |x| self << x }
18:         yield self if block_given?
19:       end

Public Instance Methods

%(path, ns = document.root ? document.root.namespaces : {}) click to toggle source
Alias for: at
&(node_set) click to toggle source

Set Intersection — Returns a new NodeSet containing nodes common to the two NodeSets.

static VALUE intersection(VALUE self, VALUE rb_other)
{
  xmlNodeSetPtr node_set;
  xmlNodeSetPtr other;

  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_other, xmlNodeSet, other);

  return Nokogiri_wrap_xml_node_set(xmlXPathIntersection(node_set, other), rb_iv_get(self, "@document"));
}
+(p1) click to toggle source
Alias for: |
-(node_set) click to toggle source

Difference - returns a new NodeSet that is a copy of this NodeSet, removing each item that also appears in node_set

static VALUE minus(VALUE self, VALUE rb_other)
{
  xmlNodeSetPtr node_set;
  xmlNodeSetPtr other;
  xmlNodeSetPtr new;
  int j ;

  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_other, xmlNodeSet, other);

  new = xmlXPathNodeSetMerge(NULL, node_set);
  for (j = 0 ; j < other->nodeNr ; ++j) {
    xmlXPathNodeSetDel(new, other->nodeTab[j]);
  }

  return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
}
/(*paths) click to toggle source
Alias for: search
<<(p1) click to toggle source
Alias for: push
==(other) click to toggle source
 

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 314
314:       def == other
315:         return false unless other.is_a?(Nokogiri::XML::NodeSet)
316:         return false unless length == other.length
317:         each_with_index do |node, i|
318:           return false unless node == other[i]
319:         end
320:         true
321:       end
>(selector) click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 143
143:       def > selector
144:         ns = document.root.namespaces
145:         xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
146:       end
[index] → Node or nil [start, length] → NodeSet or nil [range] → NodeSet or nil slice(index) → Node or nil slice(start, length) → NodeSet or nil slice(range) → NodeSet or nil click to toggle source

Element reference - returns the node at index, or returns a NodeSet containing nodes starting at start and continuing for length elements, or returns a NodeSet containing nodes specified by range. Negative indices count backward from the end of the node_set (-1 is the last node). Returns nil if the index (or start) are out of range.

static VALUE slice(int argc, VALUE *argv, VALUE self)
{
  VALUE arg ;
  long beg, len ;
  xmlNodeSetPtr node_set;
  Data_Get_Struct(self, xmlNodeSet, node_set);

  if (argc == 2) {
    beg = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    if (beg < 0) {
      beg += node_set->nodeNr ;
    }
    return subseq(self, beg, len);
  }

  if (argc != 1) {
    rb_scan_args(argc, argv, "11", NULL, NULL);
  }
  arg = argv[0];

  if (FIXNUM_P(arg)) {
    return index_at(self, FIX2LONG(arg));
  }
  
  /* if arg is Range */
  switch (rb_range_beg_len(arg, &beg, &len, node_set->nodeNr, 0)) {
  case Qfalse:
    break;
  case Qnil:
    return Qnil;
  default:
    return subseq(self, beg, len);
  }

  return index_at(self, NUM2LONG(arg));
}
Also aliased as: slice
add_class(name) click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 183
183:       def add_class name
184:         each do |el|
185:           classes = el['class'].to_s.split(/\s+/)
186:           el['class'] = classes.push(name).uniq.join " "
187:         end
188:         self
189:       end
after(datum) click to toggle source
 

Insert datum after the last Node in this NodeSet

    # File lib/nokogiri/xml/node_set.rb, line 59
59:       def after datum
60:         last.after datum
61:       end
at(path, ns = document.root ? document.root.namespaces : {}) click to toggle source
 

If path is a string, search this document for path returning the first Node. Otherwise, index in to the array with path.

     # File lib/nokogiri/xml/node_set.rb, line 151
151:       def at path, ns = document.root ? document.root.namespaces : {}
152:         return self[path] if path.is_a?(Numeric)
153:         search(path, ns).first
154:       end
Also aliased as: %
at_css(*rules) click to toggle source

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

     # File lib/nokogiri/xml/node_set.rb, line 171
171:       def at_css *rules
172:         css(*rules).first
173:       end
at_xpath(*paths) click to toggle source

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

     # File lib/nokogiri/xml/node_set.rb, line 162
162:       def at_xpath *paths
163:         xpath(*paths).first
164:       end
attr(key, value = nil, &blk) click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 214
214:       def attr key, value = nil, &blk
215:         unless Hash === key || key && (value || blk)
216:           return first.attribute(key)
217:         end
218: 
219:         hash = key.is_a?(Hash) ? key : { key => value }
220: 
221:         hash.each { |k,v| each { |el| el[k] = v || blk[el] } }
222: 
223:         self
224:       end
Also aliased as: set, attribute
attribute(key, value = nil, &blk) click to toggle source
Alias for: attr
before(datum) click to toggle source
 

Insert datum before the first Node in this NodeSet

    # File lib/nokogiri/xml/node_set.rb, line 53
53:       def before datum
54:         first.before datum
55:       end
children() click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 326
326:       def children
327:         inject(NodeSet.new(document)) { |set, node| set += node.children }
328:       end
css(*paths) click to toggle source
 

Search this NodeSet for css paths

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

     # File lib/nokogiri/xml/node_set.rb, line 96
 96:       def css *paths
 97:         handler = ![
 98:           Hash, String, Symbol
 99:         ].include?(paths.last.class) ? paths.pop : nil
100: 
101:         ns = paths.last.is_a?(Hash) ? paths.pop : nil
102: 
103:         sub_set = NodeSet.new(document)
104: 
105:         each do |node|
106:           doc = node.document
107:           search_ns = ns || doc.root ? doc.root.namespaces : {}
108: 
109:           xpaths = paths.map { |rule|
110:             [
111:               CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => search_ns),
112:               CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => search_ns)
113:             ].join(' | ')
114:           }
115: 
116:           sub_set += node.xpath(*(xpaths + [search_ns, handler].compact))
117:         end
118:         document.decorate(sub_set)
119:         sub_set
120:       end
delete(node) click to toggle source

Delete node from the Nodeset, if it is a member. Returns the deleted node if found, otherwise returns nil.

static VALUE delete(VALUE self, VALUE rb_node)
{
  xmlNodeSetPtr node_set ;
  xmlNodePtr node ;

  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_node, xmlNode, node);

  if (xmlXPathNodeSetContains(node_set, node)) {
    xmlXPathNodeSetDel(node_set, node);
    return rb_node ;
  }

  return Qnil ;
}
dup click to toggle source

Duplicate this node set

static VALUE duplicate(VALUE self)
{
  xmlNodeSetPtr node_set;
  xmlNodeSetPtr dupl;

  Data_Get_Struct(self, xmlNodeSet, node_set);

  dupl = xmlXPathNodeSetMerge(NULL, node_set);

  return Nokogiri_wrap_xml_node_set(dupl, rb_iv_get(self, "@document"));
}
each(&block) click to toggle source
 

Iterate over each node, yielding to block

     # File lib/nokogiri/xml/node_set.rb, line 237
237:       def each(&block)
238:         0.upto(length - 1) do |x|
239:           yield self[x]
240:         end
241:       end
empty?() click to toggle source
 

Is this NodeSet empty?

    # File lib/nokogiri/xml/node_set.rb, line 40
40:       def empty?
41:         length == 0
42:       end
filter(expr) click to toggle source
 

Filter this list for nodes that match expr

     # File lib/nokogiri/xml/node_set.rb, line 177
177:       def filter expr
178:         find_all { |node| node.matches?(expr) }
179:       end
first(n = nil) click to toggle source
 

Get the first element of the NodeSet.

    # File lib/nokogiri/xml/node_set.rb, line 23
23:       def first n = nil
24:         return self[0] unless n
25:         list = []
26:         0.upto(n - 1) do |i|
27:           list << self[i]
28:         end
29:         list
30:       end
include?(node) click to toggle source

Returns true if any member of node set equals node.

static VALUE include_eh(VALUE self, VALUE rb_node)
{
  xmlNodeSetPtr node_set;
  xmlNodePtr node;

  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_node, xmlNode, node);

  return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
}
index(node) click to toggle source
 

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 46
46:       def index(node)
47:         each_with_index { |member, j| return j if member == node }
48:         nil
49:       end
inner_html(*args) click to toggle source
 

Get the inner html of all contained Node objects

     # File lib/nokogiri/xml/node_set.rb, line 252
252:       def inner_html *args
253:         collect{|j| j.inner_html(*args) }.join('')
254:       end
inner_text() click to toggle source
 

Get the inner text of all contained Node objects

     # File lib/nokogiri/xml/node_set.rb, line 245
245:       def inner_text
246:         collect{|j| j.inner_text}.join('')
247:       end
Also aliased as: text
inspect() click to toggle source
 

Return a nicely formated string representation

     # File lib/nokogiri/xml/node_set.rb, line 343
343:       def inspect
344:         "[#{map { |c| c.inspect }.join ', '}]"
345:       end
last() click to toggle source
 

Get the last element of the NodeSet.

    # File lib/nokogiri/xml/node_set.rb, line 34
34:       def last
35:         self[length - 1]
36:       end
length click to toggle source

Get the length of the node set

static VALUE length(VALUE self)
{
  xmlNodeSetPtr node_set;
  Data_Get_Struct(self, xmlNodeSet, node_set);

  if(node_set)
    return INT2NUM(node_set->nodeNr);

  return INT2NUM(0);
}
Also aliased as: size
pop() click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 297
297:       def pop
298:         return nil if length == 0
299:         delete last
300:       end
push(node) click to toggle source

Append node to the NodeSet.

static VALUE push(VALUE self, VALUE rb_node)
{
  xmlNodeSetPtr node_set;
  xmlNodePtr node;

  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_node, xmlNode, node);
  xmlXPathNodeSetAdd(node_set, node);
  return self;
}
Also aliased as: <<
remove() click to toggle source
Alias for: unlink
remove_attr(name) click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 230
230:       def remove_attr name
231:         each { |el| el.delete name }
232:         self
233:       end
remove_class(name = nil) click to toggle source
 

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 195
195:       def remove_class name = nil
196:         each do |el|
197:           if name
198:             classes = el['class'].to_s.split(/\s+/)
199:             if classes.empty?
200:               el.delete 'class'
201:             else
202:               el['class'] = (classes - [name]).uniq.join " "
203:             end
204:           else
205:             el.delete "class"
206:           end
207:         end
208:         self
209:       end
reverse() click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 333
333:       def reverse
334:         node_set = NodeSet.new(document)
335:         (length - 1).downto(0) do |x|
336:           node_set.push self[x]
337:         end
338:         node_set
339:       end
search(*paths) click to toggle source
 

Search this document for paths

For more information see Nokogiri::XML::Node#css and Nokogiri::XML::Node#xpath

    # File lib/nokogiri/xml/node_set.rb, line 71
71:       def search *paths
72:         handler = ![
73:           Hash, String, Symbol
74:         ].include?(paths.last.class) ? paths.pop : nil
75: 
76:         ns = paths.last.is_a?(Hash) ? paths.pop : nil
77: 
78:         sub_set = NodeSet.new(document)
79: 
80:         paths.each do |path|
81:           sub_set += send(
82:             path =~ /^(\.\/|\/)/ ? :xpath : :css,
83:             *(paths + [ns, handler]).compact
84:           )
85:         end
86: 
87:         document.decorate(sub_set)
88:         sub_set
89:       end
Also aliased as: /
set(key, value = nil, &blk) click to toggle source
Alias for: attr
shift() click to toggle source
 

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 305
305:       def shift
306:         return nil if length == 0
307:         delete first
308:       end
size() click to toggle source
Alias for: length
slice(...) click to toggle source
Alias for: []
[index] → Node or nil [start, length] → NodeSet or nil [range] → NodeSet or nil slice(index) → Node or nil slice(start, length) → NodeSet or nil slice(range) → NodeSet or nil click to toggle source

Element reference - returns the node at index, or returns a NodeSet containing nodes starting at start and continuing for length elements, or returns a NodeSet containing nodes specified by range. Negative indices count backward from the end of the node_set (-1 is the last node). Returns nil if the index (or start) are out of range.

static VALUE slice(int argc, VALUE *argv, VALUE self)
{
  VALUE arg ;
  long beg, len ;
  xmlNodeSetPtr node_set;
  Data_Get_Struct(self, xmlNodeSet, node_set);

  if (argc == 2) {
    beg = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    if (beg < 0) {
      beg += node_set->nodeNr ;
    }
    return subseq(self, beg, len);
  }

  if (argc != 1) {
    rb_scan_args(argc, argv, "11", NULL, NULL);
  }
  arg = argv[0];

  if (FIXNUM_P(arg)) {
    return index_at(self, FIX2LONG(arg));
  }
  
  /* if arg is Range */
  switch (rb_range_beg_len(arg, &beg, &len, node_set->nodeNr, 0)) {
  case Qfalse:
    break;
  case Qnil:
    return Qnil;
  default:
    return subseq(self, beg, len);
  }

  return index_at(self, NUM2LONG(arg));
}
text() click to toggle source
Alias for: inner_text
to_a click to toggle source

Return this list as an Array

static VALUE to_array(VALUE self, VALUE rb_node)
{
  xmlNodeSetPtr set;
  VALUE *elts;
  VALUE list;
  int i;

  Data_Get_Struct(self, xmlNodeSet, set);

  elts = calloc((size_t)set->nodeNr, sizeof(VALUE *));
  for(i = 0; i < set->nodeNr; i++) {
    if (XML_NAMESPACE_DECL == set->nodeTab[i]->type) {
      elts[i] = Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(set->nodeTab[i]));
    } else {
      xmlNodePtr node = set->nodeTab[i];

      if(node->_private) {
        if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE)
          elts[i] = DOC_RUBY_OBJECT(node->doc);
        else
          elts[i] = (VALUE)node->_private;
      } else {
        elts[i] = Nokogiri_wrap_xml_node(Qnil, node);
      }
    }
  }

  list = rb_ary_new4((long)set->nodeNr, elts);

  /*free(elts); */

  return list;
}
Also aliased as: to_ary
to_ary() click to toggle source
Alias for: to_a
to_html(*args) click to toggle source
 

Convert this NodeSet to HTML

     # File lib/nokogiri/xml/node_set.rb, line 275
275:       def to_html *args
276:         map { |x| x.to_html(*args) }.join
277:       end
to_s() click to toggle source
 

Convert this NodeSet to a string.

     # File lib/nokogiri/xml/node_set.rb, line 269
269:       def to_s
270:         map { |x| x.to_s }.join
271:       end
to_xhtml(*args) click to toggle source
 

Convert this NodeSet to XHTML

     # File lib/nokogiri/xml/node_set.rb, line 281
281:       def to_xhtml *args
282:         map { |x| x.to_xhtml(*args) }.join
283:       end
to_xml(*args) click to toggle source
 

Convert this NodeSet to XML

     # File lib/nokogiri/xml/node_set.rb, line 287
287:       def to_xml *args
288:         map { |x| x.to_xml(*args) }.join
289:       end
wrap(html, &blk) click to toggle source
 

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

     # File lib/nokogiri/xml/node_set.rb, line 258
258:       def wrap(html, &blk)
259:         each do |j|
260:           new_parent = document.root.parse(html).first
261:           j.add_next_sibling(new_parent)
262:           new_parent.add_child(j)
263:         end
264:         self
265:       end
xpath(*paths) click to toggle source
 

Search this NodeSet for XPath paths

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

     # File lib/nokogiri/xml/node_set.rb, line 126
126:       def xpath *paths
127:         handler = ![
128:           Hash, String, Symbol
129:         ].include?(paths.last.class) ? paths.pop : nil
130: 
131:         ns = paths.last.is_a?(Hash) ? paths.pop : nil
132: 
133:         sub_set = NodeSet.new(document)
134:         each do |node|
135:           sub_set += node.xpath(*(paths + [ns, handler].compact))
136:         end
137:         document.decorate(sub_set)
138:         sub_set
139:       end
|(node_set) click to toggle source

Returns a new set built by merging the set and the elements of the given set.

static VALUE set_union(VALUE self, VALUE rb_other)
{
  xmlNodeSetPtr node_set;
  xmlNodeSetPtr other;
  xmlNodeSetPtr new;

  if(!rb_obj_is_kind_of(rb_other, cNokogiriXmlNodeSet))
    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");

  Data_Get_Struct(self, xmlNodeSet, node_set);
  Data_Get_Struct(rb_other, xmlNodeSet, other);

  new = xmlXPathNodeSetMerge(NULL, node_set);
  new = xmlXPathNodeSetMerge(new, other);

  return Nokogiri_wrap_xml_node_set(new, rb_iv_get(self, "@document"));
}
Also aliased as: +

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.