neo4j 1.0.0.beta.23-java → 1.0.0.beta.24-java

data/lib/neo4j/mapping/node_mixin.rb

@@ -29,8 +29,10 @@ module Neo4j::Mapping
   module NodeMixin
     include Neo4j::Index
 
+    include Neo4j::Functions
+
     delegate :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
-             :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both,
+             :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both, :get_property, :set_property,
              :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel, 
              :to => :@_java_node, :allow_nil => true 
 

data/lib/neo4j/mapping/rule.rb

@@ -0,0 +1,155 @@
+module Neo4j::Mapping
+
+
+  # Holds all defined rules and trigger them when an event is received.
+  #
+  # See Neo4j::Mapping::ClassMethods::Rule
+  #
+  class Rule #: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.nil? ? Proc.new { |*| true } : block
+    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.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_nodes        ||= {}
+        @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
+        rule_node          = @rule_nodes[clazz.to_s]
+        rule_node.remove_rule(rule_name) # remove any previously inherited rules
+        rule_node.add_rule(rule_name, props, &block)
+      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)
+        @rule_nodes && @rule_nodes[clazz.to_s]
+      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]
+        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

data/lib/neo4j/mapping/rule_node.rb

@@ -0,0 +1,177 @@
+module Neo4j::Mapping
+
+
+  class RuleNode
+    attr_reader :rules
+
+    def initialize(clazz)
+      @clazz = clazz
+      @rules = []
+    end
+
+    def to_s
+      "RuleNode #{@clazz}, node #{rule_node} #rules: #{@rules.size}"
+    end
+    
+    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_name, props, &block)
+      @rules << (rule = Rule.new(rule_name, props, &block))
+      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 = [property, old_value, new_value]
+      !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
+

data/lib/neo4j/neo4j.rb

@@ -91,9 +91,5 @@ module Neo4j
       this_db.event_handler
     end
     
-    # Ruby to Java type converters
-    def converters
-    	Neo4j::Config[:converters] || {}
-    end
   end
 end

data/lib/neo4j/node.rb

@@ -9,9 +9,19 @@ module Neo4j
     include Neo4j::Index
 
     # Delete the node and all its relationship
+    #
+    # ==== Returns
+    # true :: if the node was deleted
+    # false :: if node was not deleted, maybe it has already been deleted
+    #
     def del
       rels.each {|r| r.del}
-      delete
+      begin
+        delete
+        true
+      rescue
+        false
+      end
     end
 
     # returns true if the node exists in the database
@@ -118,7 +128,7 @@ module Neo4j
       # Same as load but does not return the node as a wrapped Ruby object.
       #
       def _load(node_id, db)
-	return nil if node_id.nil?
+        return nil if node_id.nil?
         db.graph.get_node_by_id(node_id.to_i)
       rescue java.lang.IllegalStateException
         nil # the node has been deleted

data/lib/neo4j/node_relationship.rb

@@ -116,7 +116,7 @@ module Neo4j
         java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
         get_relationships(java_types)
       elsif types.size == 1
-        get_relationships(type_to_java(types[0], dir_to_java(dir)))
+        get_relationships(type_to_java(types[0]), dir_to_java(dir))
       elsif dir == :both
         get_relationships(dir_to_java(dir))
       else

data/lib/neo4j/node_traverser.rb

@@ -71,7 +71,7 @@ module Neo4j
         break if i >= to
       end
       pager.replace res
-      pager.total_entries ||= size  # TODO, this could be very slow to do
+      pager.total_entries ||= count
     end
 
     def <<(other_node)
@@ -118,6 +118,16 @@ module Neo4j
       self
     end
 
+    def functions_method(func, rule_node, rule_name)
+      singelton = class << self; self; end
+      singelton.send(:define_method, func.class.function_name) do |*args|
+        function_id = args.empty? ? "_classname" : args[0]
+        function = rule_node.find_function(rule_name, func.class.function_name, function_id)
+        function.value(rule_node.rule_node, rule_name)
+      end
+      self
+    end
+
     def prune(&block)
       @td = @td.prune(PruneEvaluator.new(block))
       self

data/lib/neo4j/rails/finders.rb

@@ -4,7 +4,7 @@ module Neo4j
       extend ActiveSupport::Concern
 
       included do
-        rule :_all
+        rule :_all, :functions => Neo4j::Functions::Count.new
       end
 
       module ClassMethods

data/lib/neo4j/rails/persistence.rb

@@ -138,6 +138,7 @@ module Neo4j
 
       def update
         write_changed_attributes
+        write_changed_relationships
         clear_changes
         clear_relationships
         true

data/lib/neo4j/rails/relationships/relationships.rb

@@ -3,7 +3,7 @@ module Neo4j
     module Relationships
 
       # TODO, reuse for incoming relationships ?
-      class OutgoingRelationship
+      class OutgoingRelationship #:nodoc:
         include Enumerable
 
         def initialize(from_node, mapper)
@@ -22,17 +22,17 @@ module Neo4j
       end
 
       
-      def write_changed_relationships
+      def write_changed_relationships #:nodoc:
         @relationships.each_value do |mapper|
           mapper.persist
         end
       end
 
-      def valid_relationships?
+      def valid_relationships? #:nodoc:
         !@relationships.values.find {|mapper| !mapper.valid?}
       end
 
-      def _decl_rels_for(type)
+      def _decl_rels_for(type) #:nodoc:
         dsl = super
         if false && persisted?
           dsl
@@ -42,11 +42,14 @@ module Neo4j
       end
 
 
-      def clear_relationships
+      def clear_relationships #:nodoc:
         @relationships = {}
       end
 
 
+      # See, Neo4j::NodeRelationship#outgoing
+      # Creates or traverse relationships in memory without communicating with the neo4j database.
+      #
       def outgoing(rel_type)
         if persisted?
           super