Module

REXML::Node

In:

Represents a node in the tree. Nodes are never encountered except as superclasses of other objects. Nodes have siblings.

Methods

each_recursive find_first_recursive indent index_in_parent next_sibling_node parent? previous_sibling_node to_s

Public Instance methods

each_recursive() {|node| ...}

Visit all subnodes of self recursively

[Source]

42:                 def each_recursive(&block) # :yields: node
43:                         self.elements.each {|node|
44:                                 block.call(node)
45:                                 node.each_recursive(&block)
46:                         }
47:                 end

find_first_recursive() {|node| ...}

Find (and return) first subnode (recursively) for which the block evaluates to true. Returns nil if none was found.

[Source]

51:                 def find_first_recursive(&block) # :yields: node
52:       each_recursive {|node|
53:         return node if block.call(node)
54:       }
55:       return nil
56:     end

indent(to, ind)

[Source]

27:                 def indent to, ind
28:                         if @parent and @parent.context and not @parent.context[:indentstyle].nil? then
29:                                 indentstyle = @parent.context[:indentstyle]
30:                         else
31:                                 indentstyle = '  '
32:                         end
33:                         to << indentstyle*ind unless ind<1
34:                 end

index_in_parent()

Returns the index that self has in its parent’s elements array, so that the following equation holds true:

  node == node.parent.elements[node.index_in_parent]

[Source]

62:     def index_in_parent
63:       parent.index(self)+1
64:     end

next_sibling_node()

@return the next sibling (nil if unset)

[Source]

 8:                 def next_sibling_node
 9:                         return nil if @parent.nil?
10:                         @parent[ @parent.index(self) + 1 ]
11:                 end

parent?()

[Source]

36:                 def parent?
37:                         false;
38:                 end

previous_sibling_node()

@return the previous sibling (nil if unset)

[Source]

14:                 def previous_sibling_node
15:                         return nil if @parent.nil?
16:                         ind = @parent.index(self)
17:                         return nil if ind == 0
18:                         @parent[ ind - 1 ]
19:                 end

to_s(indent=-1)

[Source]

21:                 def to_s indent=-1
22:                         rv = ""
23:                         write rv,indent
24:                         rv
25:                 end

[Validate]

Ruby-Language API Docs and Resources

Methods

Public Instance methods

Search

Ruby API Docs

Links