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.



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

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.



397
398
399
 
# File 'lib/hpricot/traverse.rb', line 397

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

#each_child(&block) ⇒ Object

each_child iterates over each child.



491
492
493
494
 
# File 'lib/hpricot/traverse.rb', line 491

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

#each_child_with_index(&block) ⇒ Object

each_child_with_index iterates over each child.



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

def each_child_with_index(&block) # :yields: child_node, index
  children.each_with_index(&block)
  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.



607
608
609
610
611
612
 
# File 'lib/hpricot/traverse.rb', line 607

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.



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/hpricot/traverse.rb', line 584

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|)).



621
622
623
 
# File 'lib/hpricot/traverse.rb', line 621

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.



712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
 
# File 'lib/hpricot/traverse.rb', line 712

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.



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

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.



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

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

#get_element_by_id(id) ⇒ Object 



515
516
517
518
519
520
521
522
 
# File 'lib/hpricot/traverse.rb', line 515

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 



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

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.



479
480
481
482
483
484
485
486
487
488
 
# File 'lib/hpricot/traverse.rb', line 479

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.



467
468
469
470
471
472
473
474
475
 
# File 'lib/hpricot/traverse.rb', line 467

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.



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

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.



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

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.



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

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.



460
461
462
463
 
# File 'lib/hpricot/traverse.rb', line 460

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.



445
446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'lib/hpricot/traverse.rb', line 445

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 



681
682
683
 
# File 'lib/hpricot/traverse.rb', line 681

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