Class: ActiveRecordSurvey::NodeMap

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
lib/active_record_survey/node_map.rb

Instance Method Summary collapse

Instance Method Details

#ancestors_until_node_not_ancestor_of(klass) ⇒ Object

Gets all the ancestor nodes until one is not an ancestor of klass



56
57
58
59
60
61
62
 
# File 'lib/active_record_survey/node_map.rb', line 56

def ancestors_until_node_not_ancestor_of(klass)
	if !self.parent || !self.node.class.ancestors.include?(klass)
		return []
	end

	[self] + self.parent.ancestors_until_node_not_ancestor_of(klass)
end

#as_map(options) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/active_record_survey/node_map.rb', line 20

def as_map(options)
	node_maps = options[:node_maps]

	c = (node_maps.nil?)? self.children : node_maps.select { |i|
		i.parent == self && !i.marked_for_destruction?
	}.sort { |a,b| a.left<=>b.left }

	result = {}
	result.merge!({ :id => self.id, :node_id => ((self.node.respond_to?(:id))? self.node.id : "") }) if !options[:no_ids] && !self.node.nil?
	result.merge!({
		:type => ((!self.node.nil?)? self.node.class.to_s : ""),
		:children => c.collect { |i|
			i.as_map(options)
		}
	})
	

	result
end

#children_until_node_not_ancestor_of(klass) ⇒ Object

Gets all the child nodes until one is not an ancestor of klass



65
66
67
68
69
70
71
72
73
 
# File 'lib/active_record_survey/node_map.rb', line 65

def children_until_node_not_ancestor_of(klass)
	if !self.node.class.ancestors.include?(klass)
		return []
	end

	[self] + self.children.collect { |i|
		i.children_until_node_not_ancestor_of(klass)
	}
end

#has_infinite_loop?(path = []) ⇒ Boolean

Check to see whether there is an infinite loop from this node_map

Returns:

  • (Boolean) 


76
77
78
79
80
81
82
83
84
 
# File 'lib/active_record_survey/node_map.rb', line 76

def has_infinite_loop?(path = [])
	self.survey.node_maps.select { |i| i.parent == self && !i.marked_for_destruction? }.each { |i|
		# Detect infinite loop
		if path.include?(self.node) || i.has_infinite_loop?(path.clone.push(self.node))
			return true
		end
	}
	path.include?(self.node)
end

#is_decendant_of?(node_map) ⇒ Boolean

Whether decendant of a particular node_map

Returns:

  • (Boolean) 


41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/active_record_survey/node_map.rb', line 41

def is_decendant_of?(node_map)
	# Hit ourselves
	if node_map == self
		return true
	end

	# Recurse
	if self.parent
		return self.parent.is_decendant_of?(node_map)
	end

	false
end

#mark_self_and_children_for_destruction ⇒ Object 



86
87
88
89
90
91
92
93
 
# File 'lib/active_record_survey/node_map.rb', line 86

def mark_self_and_children_for_destruction
	removed = [self]
	self.mark_for_destruction
	self.children.each { |i|
		removed.concat(i.mark_self_and_children_for_destruction)
	}
	removed
end

#recursive_clone ⇒ Object

Recursively creates a copy of this entire node_map



11
12
13
14
15
16
17
18
 
# File 'lib/active_record_survey/node_map.rb', line 11

def recursive_clone
	node_map = self.survey.node_maps.build(:survey => self.survey, :node => self.node)
	self.survey.node_maps.select { |i| i.parent == self && !i.marked_for_destruction? }.each { |child_node|
		child_node.survey = self.survey # required due to voodoo - we want to use the same survey with the same object_id
		node_map.children << child_node.recursive_clone
	}
	node_map
end