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



41
42
43
44
45
46
47
 
# File 'lib/active_record_survey/node_map.rb', line 41

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



50
51
52
53
54
55
56
57
58
 
# File 'lib/active_record_survey/node_map.rb', line 50

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) 


61
62
63
64
65
66
67
68
69
 
# File 'lib/active_record_survey/node_map.rb', line 61

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

#mark_self_and_children_for_destruction ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/active_record_survey/node_map.rb', line 71

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