Module: RecursivelyEnumerable

Included in:
Ole::Storage::Dirent
Defined in:
lib/ole/support.rb

Overview

Include this module into a class that defines #each_child. It should maybe use #each instead, but its easier to be more specific, and use an alias.

I don’t want to force the class to cache children (eg where children are loaded on request in pst), because that forces the whole tree to be loaded. So, the methods should only call #each_child once, and breadth first iteration holds its own copy of the children around.

Main methods are #recursive, and #to_tree

Instance Method Summary collapse

Instance Method Details

#each_recursive(mode = :depth_first) {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



113
114
115
116
117
 
# File 'lib/ole/support.rb', line 113

def each_recursive mode=:depth_first, &block
	# we always actually yield ourself (the tree root) before recursing
	yield self
	send "each_recursive_#{mode}", &block
end

#each_recursive_breadth_first(&block) ⇒ Object

don’t think this is actually a proper breadth first recursion. only first level is breadth first.



104
105
106
107
108
109
110
111
 
# File 'lib/ole/support.rb', line 104

def each_recursive_breadth_first(&block)
	children = []
	each_child do |child|
		children << child if child.respond_to? :each_recursive_breadth_first
		yield child
	end
	children.each { |child| child.each_recursive_breadth_first(&block) }
end

#each_recursive_depth_first(&block) ⇒ Object

:nodoc:



93
94
95
96
97
98
99
100
 
# File 'lib/ole/support.rb', line 93

def each_recursive_depth_first(&block)
	each_child do |child|
		yield child
		if child.respond_to? :each_recursive_depth_first
			child.each_recursive_depth_first(&block)
		end
	end
end

#recursive(mode = :depth_first) ⇒ Object

the idea of this function, is to allow use of regular Enumerable methods in a recursive fashion. eg:

# just looks at top level children
root.find { |child| child.some_condition? }
# recurse into all children getting non-folders, breadth first
root.recursive(:breadth_first).select { |child| !child.folder? }
# just get everything
items = root.recursive.to_a



129
130
131
 
# File 'lib/ole/support.rb', line 129

def recursive mode=:depth_first
	to_enum(:each_recursive, mode)
end

#to_tree(io = ''.dup, &inspect) ⇒ Object

streams a “tree” form of the recursively enumerable structure to io, or return a string form instead if io is not specified.

mostly a debugging aid. can specify a different block which will be called to provide the string form for each node.



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/ole/support.rb', line 138

def to_tree io=''.dup, &inspect
	inspect ||= :inspect.to_proc
	io << "- #{inspect[self]}\n"
	recurse = proc do |node, prefix|
		child = nil
		node.each_child do |next_child|
			if child
				io << "#{prefix}|- #{inspect[child]}\n"
				recurse.call child, prefix + '|  '
			end
			child = next_child
		end if node.respond_to?(:each_child)
		if child
			io << "#{prefix}\\- #{inspect[child]}\n"
			recurse.call child, prefix + '   '
		end
	end
	recurse.call self, '  '
	io
end