Module: Hpricot::Container::Trav

Includes:
Traverse
Included in:
Doc::Trav, Elem::Trav
Defined in:
lib/hpricot/traverse.rb,
lib/hpricot/modules.rb,
lib/hpricot/traverse.rb,
lib/hpricot/traverse.rb

Overview

:startdoc:

Instance Method Summary collapse

Methods included from Traverse

#after, #at, #before, #bogusetag?, #children_of_type, #clean_path, #comment?, #css_path, #doc?, #doctype?, #elem?, filter, #following, #get_subnode, #html, #index, #inner_html=, #inner_text, #make, #next, #node_position, #nodes_at, #position, #preceding, #previous, #procins?, #search, #swap, #text?, #to_html, #to_original_html, #to_plain_text, #traverse_element, #traverse_text, #xmldecl?, #xpath

Instance Method Details

#classes ⇒ Object

Returns a list of CSS classes to which this element belongs.



518
519
520
 
# File 'lib/hpricot/traverse.rb', line 518

def classes
  get_attribute('class').to_s.strip.split(/\s+/)
end

#containers ⇒ Object

Return all children of this node which can contain other nodes. This is a good way to get all HTML elements which aren’t text, comment, doctype or processing instruction nodes.



404
405
406
 
# File 'lib/hpricot/traverse.rb', line 404

def containers
  children.grep(Container::Trav)
end

#each_child(&block) ⇒ Object

each_child iterates over each child.



498
499
500
501
 
# File 'lib/hpricot/traverse.rb', line 498

def each_child(&block) # :yields: child_node
  children.each(&block) if children
  nil
end

#each_child_with_index(&block) ⇒ Object

each_child_with_index iterates over each child.



504
505
506
507
 
# File 'lib/hpricot/traverse.rb', line 504

def each_child_with_index(&block) # :yields: child_node, index
  children.each_with_index(&block) if children
  nil
end

#each_hyperlink ⇒ Object

each_hyperlink traverses hyperlinks such as HTML href attribute of A element.

It yields Hpricot::Text.

Note that each_hyperlink yields HTML href attribute of BASE element.



614
615
616
617
618
619
 
# File 'lib/hpricot/traverse.rb', line 614

def each_hyperlink # :yields: text
  links = []
  each_hyperlink_attribute {|elem, attr, hyperlink|
    yield hyperlink
  }
end

#each_hyperlink_uri(base_uri = nil) ⇒ Object

each_hyperlink_uri traverses hyperlinks such as HTML href attribute of A element.

It yields Hpricot::Text and URI for each hyperlink.

The URI objects are created with a base URI which is given by HTML BASE element or the argument ((|base_uri|)). each_hyperlink_uri doesn’t yields href of the BASE element.



591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
 
# File 'lib/hpricot/traverse.rb', line 591

def each_hyperlink_uri(base_uri=nil) # :yields: hyperlink, uri
  base_uri = URI.parse(base_uri) if String === base_uri
  links = []
  each_hyperlink_attribute {|elem, attr, hyperlink|
    if %r{\{http://www.w3.org/1999/xhtml\}(?:base)\z}i =~ elem.name
      base_uri = URI.parse(hyperlink.to_s)
    else
      links << hyperlink
    end
  }
  if base_uri
    links.each {|hyperlink| yield hyperlink, base_uri + hyperlink.to_s }
  else
    links.each {|hyperlink| yield hyperlink, URI.parse(hyperlink.to_s) }
  end
end

#each_uri(base_uri = nil) ⇒ Object

each_uri traverses hyperlinks such as HTML href attribute of A element.

It yields URI for each hyperlink.

The URI objects are created with a base URI which is given by HTML BASE element or the argument ((|base_uri|)).



628
629
630
 
# File 'lib/hpricot/traverse.rb', line 628

def each_uri(base_uri=nil) # :yields: URI
  each_hyperlink_uri(base_uri) {|hyperlink, uri| yield uri }
end

#filter(&block) ⇒ Object

filter rebuilds the tree without some components.

node.filter {|descendant_node| predicate } -> node
loc.filter {|descendant_loc| predicate } -> node

filter yields each node except top node. If given block returns false, corresponding node is dropped. If given block returns true, corresponding node is retained and inner nodes are examined.

filter returns an node. It doesn’t return location object even if self is location object.



719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
 
# File 'lib/hpricot/traverse.rb', line 719

def filter(&block)
  subst = {}
  each_child_with_index {|descendant, i|
    if yield descendant
      if descendant.elem?
        subst[i] = descendant.filter(&block)
      else
        subst[i] = descendant
      end
    else
      subst[i] = nil
    end
  }
  to_node.subst_subnode(subst)
end

#find_element(*names) ⇒ Object

find_element searches an element which universal name is specified by the arguments. It returns nil if not found.



512
513
514
515
 
# File 'lib/hpricot/traverse.rb', line 512

def find_element(*names)
  traverse_element(*names) {|e| return e }
  nil
end

#following_siblings ⇒ Object

Find sibling elements which follow the current one. Like the other “sibling” methods, this weeds out text and comment nodes.



435
436
437
438
439
 
# File 'lib/hpricot/traverse.rb', line 435

def following_siblings() 
  sibs = parent.containers 
  si = sibs.index(self) + 1 
  return Elements[*sibs[si...sibs.length]] 
end

#get_element_by_id(id) ⇒ Object 



522
523
524
525
526
527
528
529
 
# File 'lib/hpricot/traverse.rb', line 522

def get_element_by_id(id)
  traverse_all_element do |ele|
      if ele.elem? and eid = ele.get_attribute('id')
          return ele if eid.to_s == id
      end
  end
  nil
end

#get_elements_by_tag_name(*a) ⇒ Object 



531
532
533
534
535
536
537
538
 
# File 'lib/hpricot/traverse.rb', line 531

def get_elements_by_tag_name(*a)
  list = Elements[]
  a.delete("*")
  traverse_element(*a.map { |tag| [tag, "{http://www.w3.org/1999/xhtml}#{tag}"] }.flatten) do |e|
    list << e if e.elem?
  end
  list
end

#insert_after(nodes, ele) ⇒ Object

Insert nodes, an array of HTML elements or a single element, after the node ele, a child of the current node.



486
487
488
489
490
491
492
493
494
495
 
# File 'lib/hpricot/traverse.rb', line 486

def insert_after(nodes, ele)
  case nodes
  when Array
    nodes.reverse_each { |n| insert_after(n, ele) }
  else
    reparent nodes
    idx = children.index(ele)
    children[idx ? idx + 1 : children.length, 0] = nodes
  end
end

#insert_before(nodes, ele) ⇒ Object

Insert nodes, an array of HTML elements or a single element, before the node ele, a child of the current node.



474
475
476
477
478
479
480
481
482
 
# File 'lib/hpricot/traverse.rb', line 474

def insert_before(nodes, ele)
  case nodes
  when Array
    nodes.each { |n| insert_before(n, ele) }
  else
    reparent nodes
    children[children.index(ele) || 0, 0] = nodes
  end
end

#next_sibling ⇒ Object

Returns the container node neighboring this node to the south: just below it. By “container” node, I mean: this method does not find text nodes or comments or cdata or any of that. See Hpricot::Traverse#next_node if you need to hunt out all kinds of nodes.



411
412
413
414
 
# File 'lib/hpricot/traverse.rb', line 411

def next_sibling
  sib = parent.containers
  sib[sib.index(self) + 1] if parent
end

#preceding_siblings ⇒ Object

Find all preceding sibling elements. Like the other “sibling” methods, this weeds out text and comment nodes.



427
428
429
430
431
 
# File 'lib/hpricot/traverse.rb', line 427

def preceding_siblings() 
  sibs = parent.containers 
  si = sibs.index(self) 
  return Elements[*sibs[0...si]] 
end

#previous_sibling ⇒ Object

Returns the container node neighboring this node to the north: just above it. By “container” node, I mean: this method does not find text nodes or comments or cdata or any of that. See Hpricot::Traverse#previous_node if you need to hunt out all kinds of nodes.



419
420
421
422
423
 
# File 'lib/hpricot/traverse.rb', line 419

def previous_sibling
  sib = parent.containers
  x = sib.index(self) - 1
  sib[x] if sib and x >= 0
end

#replace_child(old, new) ⇒ Object

Replace old, a child of the current node, with new node.



467
468
469
470
 
# File 'lib/hpricot/traverse.rb', line 467

def replace_child(old, new)
  reparent new
  children[children.index(old), 1] = [*new]
end

#siblings_at(*pos) ⇒ Object

Puts together an array of neighboring sibling elements based on their proximity to this element.

This method accepts ranges and sets of numbers.

ele.siblings_at(-3..-1, 1..3) # gets three elements before and three after
ele.siblings_at(1, 5, 7) # gets three elements at offsets below the current element
ele.siblings_at(0, 5..6) # the current element and two others

Like the other “sibling” methods, this doesn’t find text and comment nodes. Use nodes_at to include those nodes.



452
453
454
455
456
457
458
459
460
461
462
463
464
 
# File 'lib/hpricot/traverse.rb', line 452

def siblings_at(*pos)
  sib = parent.containers
  i, si = 0, sib.index(self)
  Elements[*
    sib.select do |x|
      sel = case i - si when *pos
              true
            end
      i += 1
      sel
    end
  ]
end

#traverse_text_internal(&block) ⇒ Object 



688
689
690
 
# File 'lib/hpricot/traverse.rb', line 688

def traverse_text_internal(&block)
  each_child {|c| c.traverse_text_internal(&block) }
end