Class: Neo4j::Wrapper::Rule::Rule

Inherits:
Object
  • Object
show all
Defined in:
lib/neo4j-wrapper/rule/rule.rb

Overview

Holds all defined rules added by the Neo4j::Rule::ClassMethods#rule method.

See Also:

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rule_name, props, &block) ⇒ Rule

Returns a new instance of Rule.



13
14
15
16
17
18
19
20
21
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 13

def initialize(rule_name, props, &block)
  @rule_name = rule_name
  @triggers = props[:triggers]
  @functions = props[:functions]
  @triggers = [@triggers] if @triggers && !@triggers.respond_to?(:each)
  @functions = [@functions] if @functions && !@functions.respond_to?(:each)
  @filter = block
  @bulk_update = bulk_update
end

Instance Attribute Details

#filter ⇒ Object (readonly)

Returns the value of attribute filter.



11
12
13
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 11

def filter
  @filter
end

#functions ⇒ Object (readonly)

Returns the value of attribute functions.



11
12
13
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 11

def functions
  @functions
end

#rule_name ⇒ Object (readonly)

Returns the value of attribute rule_name.



11
12
13
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 11

def rule_name
  @rule_name
end

#triggers ⇒ Object (readonly)

Returns the value of attribute triggers.



11
12
13
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 11

def triggers
  @triggers
end

Class Method Details

.add(clazz, rule_name, props, &block) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 77

def add(clazz, rule_name, props, &block)
  rule_node = rule_node_for(clazz.to_s)
  rule_node.remove_rule(rule_name) # remove any previously inherited rules
  rule = Rule.new(rule_name, props, &block)
  rule_node.add_rule(rule)
  rule
end

.bulk_trigger_rules(classname, class_change, map) ⇒ Object 



123
124
125
126
127
128
129
130
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 123

def bulk_trigger_rules(classname, class_change, map)
  rule_node = rule_node_for(classname)
  return if rule_node.rules.size > 1 # this optimization is not allowed when using more then one rule
  rule_node.classes_changed(class_change)
  if (clazz = rule_node.model_class.superclass) && clazz.include?(Neo4j::NodeMixin)
    bulk_trigger_rules(clazz.name, class_change, map) if clazz.to_s != "Neo4j::Rails::Model"
  end
end

.find_rule_node(node) ⇒ Object 



97
98
99
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 97

def find_rule_node(node)
  @rule_nodes && @rule_nodes.values.find { |rn| rn.rule_node?(node) }
end

.inherit(parent_class, subclass) ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 101

def inherit(parent_class, subclass)
  # copy all the rules
  if rule_node = rule_node_for(parent_class)
    rule_node.inherit(subclass)
  end
end

.rule_names_for(clazz) ⇒ Object 



85
86
87
88
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 85

def rule_names_for(clazz)
  rule_node = rule_node_for(clazz)
  rule_node.rules.map { |rule| rule.rule_name }
end

.rule_node_for(clazz) ⇒ Object 



90
91
92
93
94
95
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 90

def rule_node_for(clazz)
  return nil if clazz.nil?
  @lock.synchronized do
    @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
  end
end

.trigger?(node) ⇒ Boolean

Returns:

  • (Boolean) 


108
109
110
111
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 108

def trigger?(node)
  classname = node[:_classname]
  @rule_nodes && classname && rule_node_for(classname) && !rule_node_for(classname).bulk_update?
end

.trigger_rules(node, *changes) ⇒ Object 



113
114
115
116
117
118
119
120
121
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 113

def trigger_rules(node, *changes)
  classname = node[:_classname]
  return unless classname # there are no rules if there is not a :_classname property
  rule_node = rule_node_for(classname)
  rule_node.execute_rules(node, *changes)

  # recursively add relationships for all the parent classes with rules that also pass for this node
  recursive(node, rule_node.model_class, *changes)
end

Instance Method Details

#bulk_update ⇒ Object 



23
24
25
26
27
28
29
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 23

def bulk_update
  return false if @filter
  return true if @functions.nil?
  # only one function allowed for bulk update
  return false if @functions.size != 1
  @functions.first.class.function_name == :size
end

#bulk_update? ⇒ Boolean

Returns:

  • (Boolean) 


63
64
65
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 63

def bulk_update?
  @bulk_update
end

#execute_filter(node) ⇒ Object 



53
54
55
56
57
58
59
60
61
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 53

def execute_filter(node)
  if @filter.nil?
    true
  elsif @filter.arity != 1
    node.wrapper.instance_eval(&@filter)
  else
    @filter.call(node)
  end
end

#find_function(function_name, function_id) ⇒ Object 



35
36
37
38
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 35

def find_function(function_name, function_id)
  function_id = function_id.to_s
  @functions && @functions.find { |f| f.function_id == function_id && f.class.function_name == function_name }
end

#functions_for(property) ⇒ Object 



49
50
51
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 49

def functions_for(property)
  @functions && @functions.find_all { |f| f.calculate?(property) }
end

#props ⇒ Object

Reconstruct the properties given when created this rule Needed when inheriting a rule and we want to duplicate a rule



42
43
44
45
46
47
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 42

def props
  props = {}
  props[:triggers] = @triggers if @triggers
  props[:functions] = @functions if @functions
  props
end

#to_s ⇒ Object 



31
32
33
 
# File 'lib/neo4j-wrapper/rule/rule.rb', line 31

def to_s
  "Rule #{rule_name} props=#{props.inspect}"
end