neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

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

@@ -1,43 +0,0 @@
-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 classes_changed(rule_name, rule_node, class_change)
-          key = rule_node_property(rule_name)
-          rule_node[key] ||= 0
-          rule_node[key] += class_change.net_change
-        end
-
-        def self.function_name
-          :count
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-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

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

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

@@ -1,29 +0,0 @@
-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

@@ -1,150 +0,0 @@
-require 'neo4j/rule/event_listener'
-require 'neo4j/rule/class_methods'
-require 'neo4j/rule/rule_node'
-
-require 'neo4j/rule/functions/functions'
-
-
-module Neo4j
-  module Rule
-
-
-    # Holds all defined rules added by the Neo4j::Rule::ClassMethods#rule method.
-    #
-    # See Neo4j::Rule::ClassMethods
-    #
-    class Rule
-
-      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
-        @bulk_update = !@functions.nil? && @functions.size == 1 && @functions.first.class.function_name == :count && @filter.nil?
-      end
-
-      def to_s
-        "Rule #{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
-
-      def bulk_update?
-        @bulk_update
-      end
-
-      # ------------------------------------------------------------------------------------------------------------------
-      # Class Methods
-      # ------------------------------------------------------------------------------------------------------------------
-
-      @rule_nodes = {}
-
-      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 = Rule.new(rule_name, props, &block)
-          rule_node.add_rule(rule)
-          rule
-        end
-
-        def has_rules?(clazz)
-          !@rule_nodes[clazz.to_s].nil?
-        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[clazz.to_s] ||= RuleNode.new(clazz)
-        end
-
-        def find_rule_node(node)
-          @rule_nodes && @rule_nodes.values.find { |rn| rn.rule_node?(node) }
-        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) && !rule_node_for(classname).bulk_update?
-        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
-          recursive(node,rule_node.model_class,*changes)
-        end
-
-        def bulk_trigger_rules(classname,class_change, map)
-          rule_node = rule_node_for(classname)
-          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 != Neo4j::Rails::Model
-          end
-        end
-
-        private
-
-        def recursive(node,model_class,*changes)
-          if (clazz = model_class.superclass) && clazz.include?(Neo4j::NodeMixin)
-            if clazz != Neo4j::Rails::Model
-              rule_node = rule_node_for(clazz)
-              rule_node && rule_node.execute_rules(node, *changes)
-              recursive(node,clazz,*changes)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neo4j/rule/rule_node.rb

@@ -1,217 +0,0 @@
-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
-      include ToJava
-      attr_reader :rules
-      attr_reader :model_class
-      @@rule_nodes = {}
-
-      def initialize(clazz)
-        classname = clazz.to_s
-        @model_class = classname[0,1] == "#" ? eval(classname) : classname.split('::').inject(Kernel) {|sc, const_name| sc.const_get(const_name)}
-        @classname = clazz
-        @rules = []
-        @rule_node_key = ("rule_" + clazz.to_s).to_sym
-        @ref_node_key = ("rule_ref_for_" + clazz.to_s).to_sym
-      end
-
-      def to_s
-        "RuleNode #{@classname}, node #{rule_node} #rules: #{@rules.size}"
-      end
-
-      # returns true if the rule node exist yet in the database
-      def node_exist?
-        !ref_node.rel?(@classname)
-      end
-
-      def rule_node
-        ref_node._java_node.synchronized do
-          @@rule_nodes[key] ||= find_node || create_node
-        end
-      end
-
-      def rule_node?(node)
-        @@rule_nodes[key] == node
-      end
-
-      def key
-        "#{ref_node}#{@ref_node_key}".to_sym
-      end
-
-      def ref_node
-        if @model_class.respond_to? :ref_node_for_class
-          @model_class.ref_node_for_class
-        else
-          Neo4j.ref_node
-        end
-      end
-
-      def create_node
-        Neo4j::Transaction.run do
-          node = Neo4j::Node.new
-          ref_node.create_relationship_to(node, type_to_java(@classname))
-          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 ref_node.rel?(@classname)
-          ref_node.outgoing(@classname).each { |n| n.del }
-        end
-        clear_rule_node
-      end
-
-      def find_node
-        ref_node.rel?(@classname.to_s) && ref_node._rel(:outgoing, @classname.to_s)._end_node
-      end
-
-      def ref_node_changed?
-        if ref_node != Thread.current[@ref_node_key]
-          Thread.current[@ref_node_key] = ref_node
-          true
-        else
-          false
-        end
-      end
-
-      def clear_rule_node
-        @@rule_nodes[key] = 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._java_node.createRelationshipTo(end_node._java_node, org.neo4j.graphdb.DynamicRelationshipType.withName(rule_name))
-      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
-
-      def bulk_update?
-        @rules.size == 1 && @rules.first.bulk_update?
-      end
-
-      def classes_changed(total)
-        @rules.each do |rule|
-          if rule.bulk_update?
-            rule.functions.first.classes_changed(rule.rule_name, rule_node, total)
-            total.added.each{|node| connect(rule.rule_name, node)}
-            total.deleted.each{|node| break_connection(rule.rule_name, node)}
-          end
-        end
-      end
-    end
-  end
-end