neo4j 1.0.0.beta.27-java → 1.0.0.beta.28-java

data/lib/neo4j/rule/functions/count.rb

@@ -0,0 +1,37 @@
+module Neo4j
+  module Rule
+    module Functions
+
+      # A function for counting number of nodes of a given class.
+      class Count < Function
+        def initialize
+          @property = '_classname'
+        end
+
+        def calculate?(changed_property)
+          true
+        end
+
+        def delete(rule_name, rule_node, old_value)
+          key = rule_node_property(rule_name)
+          rule_node[key] ||= 0
+          rule_node[key] -= 1
+        end
+
+        def add(rule_name, rule_node, new_value)
+          key = rule_node_property(rule_name)
+          rule_node[key] ||= 0
+          rule_node[key] += 1
+        end
+
+        def update(*)
+          # we are only counting, not interested in property changes
+        end
+
+        def self.function_name
+          :count
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rule/functions/function.rb

@@ -0,0 +1,74 @@
+module Neo4j
+  module Rule
+    module Functions
+
+      # The base class of rule functions.
+      #
+      # You are expected to at least implement two methods:
+      # * update :: update the rule node value of this function
+      # * function_name :: the name of this function, the name of the generated method - A class method !
+      #
+      class Function
+
+        # Initialize the the function with a property which is usually the same as the function identity.
+        # See the #calculate? method how this property is used.
+        #
+        def initialize(property)
+          @property = property.to_s
+        end
+
+        def to_s
+          "Function #{self.class.function_name} function_id: #{function_id}"
+        end
+
+        # Decides if the function should be called are not
+        #
+        def calculate?(changed_property)
+          @property == changed_property
+        end
+
+
+        # The identity of the function.
+        # Used to identify function.
+        #
+        # ==== Example
+        #   Person.sum(:young, :age)
+        #
+        # In the example above the property :age is the used to identify which function will be called
+        # since there could be several sum method. In the example we want use the sum method that uses the :age property.
+        #
+        def function_id
+          @property
+        end
+
+        # The value of the rule
+        def value(rule_node, rule_name)
+          key = rule_node_property(rule_name)
+          rule_node[key] || 0
+        end
+
+        # Called when a node is removed from a rule group
+        # Default is calling update method which is expected to be implemented in a subclass
+        def delete(rule_name, rule_node, old_value)
+          update(rule_name, rule_node, old_value, nil)
+        end
+
+        # Called when a node is added to a rule group
+        # Default is calling update method which is expected to be implemented in a subclass
+        def add(rule_name, rule_node, new_value)
+          update(rule_name, rule_node, nil, new_value)
+        end
+
+        # the name of the property that holds the value of the function
+        def rule_node_property(rule_name)
+          self.class.rule_node_property(self.class.function_name, rule_name, @property)
+        end
+
+        def self.rule_node_property(function_name, rule_name, prop)
+          "_#{function_name}_#{rule_name}_#{prop}"
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/rule/functions/functions.rb

@@ -0,0 +1,3 @@
+require "neo4j/rule/functions/function"
+require "neo4j/rule/functions/count"
+require "neo4j/rule/functions/sum"

data/lib/neo4j/rule/functions/sum.rb

@@ -0,0 +1,29 @@
+module Neo4j
+  module Rule
+    module Functions
+
+      class Sum < Function
+        # Updates the function's value.
+        # Called after the transactions commits and a property has been changed on a node.
+        #
+        # ==== Arguments
+        # * rule_name :: the name of the rule group
+        # * rule_node :: the node which contains the value of this function
+        # * old_value new value :: the changed value of the property (when the transaction commits)
+        def update(rule_name, rule_node, old_value, new_value)
+          key = rule_node_property(rule_name)
+          rule_node[key] ||= 0
+          old_value ||= 0
+          new_value ||= 0
+          rule_node[key] += new_value - old_value
+        end
+
+        def self.function_name
+          :sum
+        end
+      end
+
+
+    end
+  end
+end

data/lib/neo4j/rule/rule.rb

@@ -0,0 +1,5 @@
+require 'neo4j/rule/rule_event_listener'
+require 'neo4j/rule/class_methods'
+require 'neo4j/rule/rule_node'
+
+require 'neo4j/rule/functions/functions'

data/lib/neo4j/rule/rule_event_listener.rb

@@ -0,0 +1,162 @@
+module Neo4j
+  module Rule
+
+
+    # Holds all defined rules and trigger them when an event is received.
+    #
+    # See Neo4j::Rule::ClassMethods
+    #
+    class RuleEventListener #:nodoc:
+
+      attr_reader :rule_name, :filter, :triggers, :functions
+
+      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
+      end
+
+      def to_s
+        "RuleEventListener #{rule_name} props=#{props.inspect}"
+      end
+
+      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
+
+      # Reconstruct the properties given when created this rule
+      # Needed when inheriting a rule and we want to duplicate a rule
+      def props
+        props = {}
+        props[:triggers] = @triggers if @triggers
+        props[:functions] = @functions if @functions
+        props
+      end
+
+      def functions_for(property)
+        @functions && @functions.find_all { |f| f.calculate?(property) }
+      end
+
+      def execute_filter(node)
+        if @filter.nil?
+          true
+        elsif @filter.arity != 1
+          node.wrapper.instance_eval(&@filter)
+        else
+          @filter.call(node)
+        end
+      end
+
+      # ------------------------------------------------------------------------------------------------------------------
+      # Class Methods
+      # ------------------------------------------------------------------------------------------------------------------
+
+      class << self
+        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 = RuleEventListener.new(rule_name, props, &block)
+          rule_node.add_rule(rule)
+          rule
+        end
+
+        def rule_names_for(clazz)
+          rule_node = rule_node_for(clazz)
+          rule_node.rules.map { |rule| rule.rule_name }
+        end
+
+        def rule_node_for(clazz)
+          return nil if clazz.nil?
+          @rule_nodes ||= {}
+          @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
+        end
+
+        def inherit(parent_class, subclass)
+          # copy all the rules
+          if rule_node = rule_node_for(parent_class)
+            rule_node.inherit(subclass)
+          end
+        end
+
+        def delete(clazz)
+          if rule_node = rule_node_for(clazz)
+            rule_node.delete_node
+          end
+        end
+
+        def trigger?(node)
+          classname = node[:_classname]
+          @rule_nodes && classname && rule_node_for(classname)
+        end
+
+        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
+          if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
+            rule_node = rule_node_for(clazz)
+            rule_node && rule_node.execute_rules(node, *changes)
+          end
+        end
+
+
+        # ----------------------------------------------------------------------------------------------------------------
+        # Event handling methods
+        # ----------------------------------------------------------------------------------------------------------------
+
+        def on_relationship_created(rel, *)
+          trigger_start_node = trigger?(rel._start_node)
+          trigger_end_node = trigger?(rel._end_node)
+          trigger_rules(rel._start_node) if trigger_start_node
+          trigger_rules(rel._end_node) if trigger_end_node
+        end
+
+        def on_property_changed(node, *changes)
+          trigger_rules(node, *changes) if trigger?(node)
+        end
+
+        def on_node_deleted(node, old_properties, data)
+          # have we deleted a rule node ?
+          del_rule_node = @rule_nodes && @rule_nodes.values.find { |rn| rn.rule_node?(node) }
+          del_rule_node && del_rule_node.clear_rule_node
+          return if del_rule_node
+
+          # do we have prop_aggregations for this
+          clazz = old_properties['_classname']
+          rule_node = rule_node_for(clazz)
+          return if rule_node.nil?
+
+          id = node.getId
+          rule_node.rules.each do |rule|
+            next if rule.functions.nil?
+            rule_name = rule.rule_name.to_s
+
+            # is the rule node deleted ?
+            deleted_rule_node = data.deletedNodes.find { |n| n == rule_node.rule_node }
+            next if deleted_rule_node
+
+            rule.functions.each do |function|
+              next unless data.deletedRelationships.find do |r|
+                r.getEndNode().getId() == id && r.rel_type == rule_name
+              end
+              previous_value = old_properties[function.function_id]
+              function.delete(rule_name, rule_node.rule_node, previous_value) if previous_value
+            end if rule.functions
+          end
+        end
+
+        def on_neo4j_started(*)
+          @rule_nodes.each_value { |rule_node| rule_node.on_neo4j_started } if @rule_nodes
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j/rule/rule_node.rb

@@ -0,0 +1,182 @@
+module Neo4j
+  module Rule
+
+    # This is the node that has relationships to all nodes of a given class.
+    # For example if the PersonNode has a rule then it will also have one RuleNode
+    # from where it will create relationships to each created node of type PersonNode.
+    # The RuleNode can also be used to hold properties for functions, like sum and count.
+    #
+    class RuleNode
+      attr_reader :rules
+
+      def initialize(clazz)
+        @clazz = clazz
+        @rules = []
+      end
+
+      def to_s
+        "RuleNode #{@clazz}, node #{rule_node} #rules: #{@rules.size}"
+      end
+
+      # returns true if the rule node exist yet in the database
+      def node_exist?
+        !Neo4j.ref_node.rel?(@clazz)
+      end
+
+      def create_node
+        Neo4j::Transaction.run do
+          node = Neo4j::Node.new
+          Neo4j.ref_node.outgoing(@clazz) << node
+          node
+        end
+      end
+
+      def inherit(subclass)
+        @rules.each do |rule|
+          subclass.rule rule.rule_name, rule.props, &rule.filter
+        end
+      end
+
+      def delete_node
+        if Neo4j.ref_node.rel?(@clazz)
+          Neo4j.ref_node.outgoing(@clazz).each { |n| n.del }
+        end
+        clear_rule_node
+      end
+
+      def find_node
+        Neo4j.ref_node.rel?(@clazz.to_s) && Neo4j.ref_node._rel(:outgoing, @clazz.to_s)._end_node
+      end
+
+      def on_neo4j_started
+        # initialize the rule node when neo4j starts
+        @rule_node = find_node || create_node
+      end
+
+      def rule_node
+        @rule_node ||= find_node || create_node
+      end
+
+      def rule_node?(node)
+        @rule_node == node
+      end
+
+      def clear_rule_node
+        @rule_node = nil
+      end
+
+      def rule_names
+        @rules.map { |r| r.rule_name }
+      end
+
+      def find_rule(rule_name)
+        @rules.find { |rule| rule.rule_name == rule_name }
+      end
+
+      def add_rule(rule)
+        @rules << rule
+      end
+
+      def remove_rule(rule_name)
+        r = find_rule(rule_name)
+        r && @rules.delete(r)
+      end
+
+      # Return a traversal object with methods for each rule and function.
+      # E.g. Person.all.old or Person.all.sum(:age)
+      def traversal(rule_name)
+        # define method on the traversal
+        traversal = rule_node.outgoing(rule_name)
+        @rules.each do |rule|
+          traversal.filter_method(rule.rule_name) do |path|
+            path.end_node.rel?(rule.rule_name, :incoming)
+          end
+          rule.functions && rule.functions.each do |func|
+            traversal.functions_method(func, self, rule_name)
+          end
+        end
+        traversal
+      end
+
+      def find_function(rule_name, function_name, function_id)
+        rule = find_rule(rule_name)
+        rule.find_function(function_name, function_id)
+      end
+
+      def execute_rules(node, *changes)
+        @rules.each do |rule|
+          execute_rule(rule, node, *changes)
+          execute_other_rules(rule, node)
+        end
+      end
+
+      def execute_other_rules(rule, node)
+        rule.triggers && rule.triggers.each do |rel_type|
+          node.incoming(rel_type).each { |n| n.trigger_rules }
+        end
+      end
+
+      def execute_rule(rule, node, *changes)
+        if rule.execute_filter(node)
+          if connected?(rule.rule_name, node)
+            # it was already connected - the node is in the same rule group but a property has changed
+            execute_update_functions(rule, *changes)
+          else
+            # the node has changed or is in a new rule group
+            connect(rule.rule_name, node)
+            execute_add_functions(rule, *changes)
+          end
+        else
+          if break_connection(rule.rule_name, node)
+            # the node has been removed from a rule group
+            execute_delete_functions(rule, *changes)
+          end
+        end
+      end
+
+      def execute_update_functions(rule, *changes)
+        if functions = find_functions_for_changes(rule, *changes)
+          functions && functions.each { |f| f.update(rule.rule_name, rule_node, changes[1], changes[2]) }
+        end
+      end
+
+      def execute_add_functions(rule, *changes)
+        if functions = find_functions_for_changes(rule, *changes)
+          functions && functions.each { |f| f.add(rule.rule_name, rule_node, changes[2]) }
+        end
+      end
+
+      def execute_delete_functions(rule, *changes)
+        if functions = find_functions_for_changes(rule, *changes)
+          functions.each { |f| f.delete(rule.rule_name, rule_node, changes[1]) }
+        end
+      end
+
+      def find_functions_for_changes(rule, *changes)
+        !changes.empty? && rule.functions_for(changes[0])
+      end
+
+      # work out if two nodes are connected by a particular relationship
+      # uses the end_node to start with because it's more likely to have less relationships to go through
+      # (just the number of superclasses it has really)
+      def connected?(rule_name, end_node)
+        end_node.incoming(rule_name).find { |n| n == rule_node }
+      end
+
+      def connect(rule_name, end_node)
+        rule_node.outgoing(rule_name) << end_node
+      end
+
+      # sever a direct one-to-one relationship if it exists
+      def break_connection(rule_name, end_node)
+        rel = end_node._rels(:incoming, rule_name).find { |r| r._start_node == rule_node }
+        rel && rel.del
+        !rel.nil?
+      end
+
+    end
+
+
+  end
+
+end