neo4j 1.2.6-java → 2.0.0.alpha.3-java

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

@@ -2,6 +2,55 @@ module Neo4j
   module Rails
     module Relationships
 
+      # This DSL is return when asking for all relationship from and to a node, example node.rels.each{}
+      #
+      class AllRelsDsl
+        include Enumerable
+
+        def initialize(rels_stores, node)
+          @rels_stores = rels_stores
+          @node = node
+        end
+
+        def each
+          @rels_stores.each_value {|storage| storage.relationships(:both).each{|r| yield r}}
+          @node && @node.rels.each {|r| yield r}
+        end
+
+        # simply traverse and count all relationship
+        def size
+          s = 0
+          each { |_| s += 1 }
+          s
+        end
+
+        # Find all relationships between two nodes like this *if* the node is persisted.
+        # Returns an Enumerable. If the node is not persisted it will raise an error.
+        # Notice, only persisted relationships will be returned.
+        def to_other(other)
+          raise('node.rels(...).to_other() not allowed on a node that is not persisted') unless @node
+          @node.rels.to_other(other)
+        end
+
+        def delete_all
+          # since some of the relationships might not be a Neo4j::Rails::Relationship we must create a transaction
+          Neo4j::Transaction.run do
+            each{|r| r.respond_to?(:delete) ? r.delete : r.del}
+          end
+          @rels_stores.clear
+        end
+
+        def destroy_all
+          Neo4j::Transaction.run do
+            each{|r| r.respond_to?(:destroy)? r.destroy : r.del}
+          end
+          @rels_stores.clear
+        end
+
+        alias_method :del, :delete_all
+      end
+
+
       # Instances of this class is returned from the #rels, and generated accessor methods:
       # has_n and has_one.
       # Notice, this class is very similar to the Neo4j::Rails::Relationships::NodesDSL except that
@@ -18,7 +67,6 @@ module Neo4j
       #
       class RelsDSL
         include Enumerable
-        include Neo4j::Paginate
 
         def initialize(storage, dir=:both)
           @storage = storage
@@ -42,6 +90,13 @@ module Neo4j
           rel
         end
 
+        # Find all relationships between two nodes like this *if* the node is persisted.
+        # Returns an Enumerable. If the node is not persisted it will raise an error.
+        # Notice, only persisted relationships will be returned.
+        def to_other(other)
+          @storage.to_other(other)
+        end
+
         # Connects this node with an already existing other node with a new relationship.
         # The relationship can optionally be given a hash of properties
         # Does not save it.
@@ -81,8 +136,8 @@ module Neo4j
           self
         end
 
-        def each(&block)
-          @storage.each_rel(@dir, &block)
+        def each
+          @storage.each_rel(@dir) {|x| yield x}
         end
 
         # Simply counts all relationships
@@ -98,11 +153,13 @@ module Neo4j
         # Destroys all relationships object. Will not destroy the nodes.
         def destroy_all
           each {|n| n.destroy}
+          @storage.clear_unpersisted
         end
 
         # Delete all relationship.
         def delete_all
           each {|n| n.delete}
+          @storage.clear_unpersisted
         end
 
         # Same as Neo4j::Rails::Relationships::NodesDSL#find except that it searches the relationships instead of

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

@@ -20,12 +20,21 @@ module Neo4j
         end
 
         def to_s #:nodoc:
-          "Storage #{object_id} node: #{@node.id} rel_type: #{@rel_type} outgoing #{@outgoing_rels.size} incoming #{@incoming_rels.size}"
+          "Storage #{object_id} node: #{@node.id} rel_type: #{@rel_type} outgoing #{@outgoing_rels.size}/#{@unpersisted_outgoing_rels && @unpersisted_outgoing_rels.size} incoming #{@incoming_rels.size}/#{@unpersisted_incoming_rels && @unpersisted_incoming_rels.size}"
+        end
+
+        def clear_unpersisted
+          @outgoing_rels.clear
+          @incoming_rels.clear
+          @unpersisted_outgoing_rels = nil
+          @unpersisted_incoming_rels = nil
         end
 
         def remove_from_identity_map
           @outgoing_rels.each {|r| Neo4j::IdentityMap.remove(r._java_rel)}
           @incoming_rels.each {|r| Neo4j::IdentityMap.remove(r._java_rel)}
+          @unpersisted_outgoing_rels = nil
+          @unpersisted_incoming_rels = nil
         end
 
         def size(dir)
@@ -37,6 +46,10 @@ module Neo4j
           counter
         end
 
+        def to_other(other)
+          (@node._java_node) ? @node._java_node.rels(@rel_type).to_other(other) : raise('node.rels(...).to_other() not allowed on a node that is not persisted')
+        end
+
         def build(attrs)
           @target_class.new(attrs)
         end
@@ -48,9 +61,9 @@ module Neo4j
         def relationships(dir)
           case dir
             when :outgoing
-              @outgoing_rels
+              @unpersisted_outgoing_rels || @outgoing_rels
             when :incoming
-              @incoming_rels
+              @unpersisted_incoming_rels || @incoming_rels
             when :both
               @incoming_rels + @outgoing_rels
           end
@@ -113,6 +126,11 @@ module Neo4j
           end
         end
 
+        def destroy_single_relationship(dir)
+          rel = single_relationship(dir)
+          rel && rel.destroy && relationships(dir).delete(rel)
+        end
+
         def all_relationships(dir)
           Enumerator.new(self, :each_rel, dir)
         end
@@ -146,6 +164,18 @@ module Neo4j
           @outgoing_rels << rel
         end
 
+        # Makes the given relationship available in callbacks
+        def add_unpersisted_incoming_rel(rel)
+          @unpersisted_incoming_rels ||= []
+          @unpersisted_incoming_rels << rel
+        end
+
+        # Makes the given relationship available in callbacks
+        def add_unpersisted_outgoing_rel(rel)
+          @unpersisted_outgoing_rels ||= []
+          @unpersisted_outgoing_rels << rel
+        end
+
         def rm_incoming_rel(rel)
           @incoming_rels.delete(rel)
         end
@@ -154,6 +184,16 @@ module Neo4j
           @outgoing_rels.delete(rel)
         end
 
+        def rm_unpersisted_incoming_rel(rel)
+          @unpersisted_incoming_rels.delete(rel)
+          @unpersisted_incoming_rels = nil if @unpersisted_incoming_rels.empty?
+        end
+
+        def rm_unpersisted_outgoing_rel(rel)
+          @unpersisted_outgoing_rels.delete(rel)
+          @unpersisted_outgoing_rels = nil if @unpersisted_outgoing_rels.empty?
+        end
+
         def persisted?
           @outgoing_rels.empty? && @incoming_rels.empty?
         end
@@ -165,14 +205,12 @@ module Neo4j
           [@outgoing_rels, @incoming_rels, @persisted_related_nodes, @persisted_node_to_relationships, @persisted_relationships].each{|c| c.clear}
 
           out_rels.each do |rel|
-            rel.end_node.rm_incoming_rel(@rel_type.to_sym, rel) if rel.end_node
             success = rel.persisted? || rel.save
             # don't think this can happen - just in case, TODO
             raise "Can't save outgoing #{rel}, validation errors ? #{rel.errors.inspect}" unless success
           end
 
           in_rels.each do |rel|
-            rel.start_node.rm_outgoing_rel(@rel_type.to_sym, rel)
             success = rel.persisted? || rel.save
             # don't think this can happen - just in case, TODO
             raise "Can't save incoming #{rel}, validation errors ? #{rel.errors.inspect}" unless success

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -54,6 +54,7 @@ module Neo4j
         end
 
         def self.query(model,attribute,value)
+          value = value.gsub("\"", "\\\"") if !value.blank?
           value.blank? ? model.all("*:* -#{attribute}:[* TO *]", :type => :fulltext) : model.all("#{attribute}: \"#{value}\"", :type => :fulltext)
         end
 

data/lib/neo4j/rails/versioning/versioning.rb

@@ -45,6 +45,16 @@ module Neo4j
       class Snapshot
         include Neo4j::NodeMixin
 
+        def assign(key,value)
+          @converted_properties = {} if @converted_properties.nil?
+          @converted_properties[key.to_sym] = value
+        end
+
+        def [](key)
+          return @converted_properties[key] if @converted_properties
+          super(key)
+        end
+
         def incoming(rel_type)
           super "version_#{rel_type.to_s}".to_sym
         end
@@ -70,7 +80,9 @@ module Neo4j
       # @param [ Integer ] number The version number to retrieve.
       # Returns nil in case a version is not found.
       def version(number)
-        Version.find(:model_classname => _classname, :instance_id => neo_id, :number => number) {|query| query.first.nil? ? nil : query.first.end_node}
+        snapshot = Version.find(:model_classname => _classname, :instance_id => neo_id, :number => number) {|query| query.first.nil? ? nil : query.first.end_node}
+        snapshot.props.each_pair{|k,v| snapshot.assign(k,Neo4j::TypeConverters.to_ruby(self.class, k, v))} if !snapshot.nil?
+        snapshot
       end
 
       ##
@@ -83,40 +95,83 @@ module Neo4j
         end
       end
 
+      ##
+      # Reverts this instance to a specified version
+      # @param [ Integer ] version_number The version number to revert to.
+      # Reverting the instance will increment the current version number.
+      def revert_to(version_number)
+        snapshot = version(version_number)
+        self.props.each_pair{|k,v| self[k] = nil if !snapshot.props.has_key?(k)}
+        snapshot.props.each_pair{|k,v| self[k] = v if self.props[k].nil?}
+        Neo4j::Transaction.run do
+          restore_relationships(snapshot)
+          save
+        end
+      end
+
       private
       def revise
         Neo4j::Transaction.run do
-          snapshot = Snapshot.new(self.props.reject{|key, value| key.to_sym == :_classname})
-          version_relationships(snapshot)
+          snapshot = Snapshot.new(converted_properties)
+          each_versionable_relationship{|rel| create_version_relationship(rel,snapshot)}
           delete_old_version if version_max.present? && number_of_versions >= version_max
           Version.new(:version, self, snapshot, :model_classname => _classname, :instance_id => neo_id, :number => current_version)
         end
       end
 
+      def converted_properties
+        properties = self.props.reject{|key, value| key.to_sym == :_classname}
+        properties.inject({}) { |h,(k,v)| h[k] = Neo4j::TypeConverters.to_java(self.class, k, v); h }
+      end
+
       def number_of_versions
         Version.find(:model_classname => _classname, :instance_id => neo_id) {|query| query.size}
       end
 
-      def version_relationships(snapshot)
+      def each_versionable_relationship
+        rule_relationships = java.util.HashSet.new(Neo4j::Rule::Rule.rule_names_for(_classname))
         self._java_node.getRelationships().each do |rel|
-          if (self._java_node == rel.getStartNode())
-            snapshot._java_node.createRelationshipTo(rel.getEndNode(), relationship_type(rel.getType()))
-          else
-            rel.getStartNode().createRelationshipTo(snapshot._java_node, relationship_type(rel.getType()))
-          end
+          yield rel unless rule_relationships.contains(rel.getType().name().to_sym) || rel.getType.name.to_sym == :version
         end
       end
 
+      def create_version_relationship(rel,snapshot)
+        create_relationship(self._java_node,snapshot._java_node, rel, relationship_type(rel.getType()))
+      end
+
       def relationship_type(rel_type)
         org.neo4j.graphdb.DynamicRelationshipType.withName( "version_#{rel_type.name}" )
       end
 
+      def restore_relationship_type(snapshot_rel_type)
+        org.neo4j.graphdb.DynamicRelationshipType.withName( "#{snapshot_rel_type.name.gsub("version_","")}" )
+      end
+
       def delete_old_version
         versions = Version.find(:model_classname => _classname).asc(:number)
         versions.first.del
         versions.close
       end
 
+      def restore_relationships(snapshot)
+        each_versionable_relationship{|rel| rel.del}
+        snapshot._java_node.getRelationships().each do |rel|
+          restore_relationship(rel,snapshot) unless rel.getType.name.to_sym == :version
+        end
+      end
+
+      def restore_relationship(rel,snapshot)
+        create_relationship(snapshot._java_node, self._java_node, rel, restore_relationship_type(rel.getType()))
+      end
+
+      def create_relationship(comparison_node,connection_node,rel, relationship_type)
+        if (comparison_node == rel.getStartNode())
+          connection_node.createRelationshipTo(rel.getEndNode(), relationship_type)
+        else
+          rel.getStartNode().createRelationshipTo(connection_node, relationship_type)
+        end
+      end
+
       module ClassMethods #:nodoc:
 
         # Sets the maximum number of versions to store.

data/lib/neo4j/relationship.rb

@@ -7,79 +7,6 @@ require 'neo4j/to_java'
 
 module Neo4j
 
-  org.neo4j.kernel.impl.core.RelationshipProxy.class_eval do
-    include Neo4j::Property
-    include Neo4j::Equal
-
-    alias_method :_end_node, :getEndNode
-    alias_method :_start_node, :getStartNode
-    alias_method :_other_node, :getOtherNode
-
-
-    # Deletes the relationship between the start and end node
-    #
-    # May raise an exception if delete was unsuccessful.
-    #
-    # ==== Returns
-    # nil
-    #
-    def del
-      delete
-    end
-
-    def end_node # :nodoc:
-      getEndNode.wrapper
-    end
-
-    def start_node # :nodoc:
-      getStartNode.wrapper
-    end
-
-    def other_node(node) # :nodoc:
-      getOtherNode(node._java_node).wrapper
-    end
-
-
-    # same as _java_rel
-    # Used so that we have same method for both relationship and nodes
-    def wrapped_entity
-      self
-    end
-
-    def _java_rel
-      self
-    end
-
-
-    # Returns true if the relationship exists
-    def exist?
-      Neo4j::Relationship.exist?(self)
-    end
-
-    # Loads the Ruby wrapper for this node
-    # If there is no _classname property for this node then it will simply return itself.
-    # Same as Neo4j::Node.load_wrapper(node)
-    def wrapper
-      self.class.wrapper(self)
-    end
-
-
-    # Returns the relationship name
-    #
-    # ==== Example
-    #   a = Neo4j::Node.new
-    #   a.outgoing(:friends) << Neo4j::Node.new
-    #   a.rels.first.rel_type # => 'friends'
-    #
-    def rel_type
-      getType().name()
-    end
-
-    def class
-      Neo4j::Relationship
-    end
-
-  end
 
   #
   # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
@@ -224,6 +151,85 @@ module Neo4j
         nil
       end
 
+      def extend_java_class(java_clazz)  #:nodoc:
+        java_clazz.class_eval do
+            include Neo4j::Property
+            include Neo4j::Equal
+
+            alias_method :_end_node, :getEndNode
+            alias_method :_start_node, :getStartNode
+            alias_method :_other_node, :getOtherNode
+
+
+            # Deletes the relationship between the start and end node
+            #
+            # May raise an exception if delete was unsuccessful.
+            #
+            # ==== Returns
+            # nil
+            #
+            def del
+              delete
+            end
+
+            def end_node # :nodoc:
+              getEndNode.wrapper
+            end
+
+            def start_node # :nodoc:
+              getStartNode.wrapper
+            end
+
+            def other_node(node) # :nodoc:
+              getOtherNode(node._java_node).wrapper
+            end
+
+
+            # same as _java_rel
+            # Used so that we have same method for both relationship and nodes
+            def wrapped_entity
+              self
+            end
+
+            def _java_rel
+              self
+            end
+
+
+            # Returns true if the relationship exists
+            def exist?
+              Neo4j::Relationship.exist?(self)
+            end
+
+            # Loads the Ruby wrapper for this node
+            # If there is no _classname property for this node then it will simply return itself.
+            # Same as Neo4j::Node.load_wrapper(node)
+            def wrapper
+              self.class.wrapper(self)
+            end
+
+
+            # Returns the relationship name
+            #
+            # ==== Example
+            #   a = Neo4j::Node.new
+            #   a.outgoing(:friends) << Neo4j::Node.new
+            #   a.rels.first.rel_type # => 'friends'
+            #
+            def rel_type
+              getType().name()
+            end
+
+            def class
+              Neo4j::Relationship
+            end
+
+          end
+
+      end
+
+      Neo4j::Relationship.extend_java_class(org.neo4j.kernel.impl.core.RelationshipProxy)
+
     end
 
   end

data/lib/neo4j/rule/event_listener.rb

@@ -30,7 +30,7 @@ module Neo4j
 
           id = node.getId
           rule_node.rules.each do |rule|
-            next if rule.functions.nil?
+            next if rule.functions.nil? || rule.bulk_update?
             rule_name = rule.rule_name.to_s
 
             # is the rule node deleted ?
@@ -45,6 +45,12 @@ module Neo4j
           end
         end
 
+        def classes_changed(changed_class_map)
+          changed_class_map.each_pair do |clazz,class_change|
+            Rule.bulk_trigger_rules(clazz,class_change,changed_class_map)
+          end
+        end
+
         def on_neo4j_started(db)
           if not Neo4j::Config[:enable_rules]
             db.event_handler.remove(self)

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

@@ -28,6 +28,12 @@ module Neo4j
           # 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

data/lib/neo4j/rule/rule.rb

@@ -24,6 +24,7 @@ module Neo4j
         @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
@@ -58,6 +59,10 @@ module Neo4j
         end
       end
 
+      def bulk_update?
+        @bulk_update
+      end
+
       # ------------------------------------------------------------------------------------------------------------------
       # Class Methods
       # ------------------------------------------------------------------------------------------------------------------
@@ -74,7 +79,7 @@ module Neo4j
         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 }
@@ -105,7 +110,7 @@ module Neo4j
 
         def trigger?(node)
           classname = node[:_classname]
-          @rule_nodes && classname && rule_node_for(classname)
+          @rule_nodes && classname && rule_node_for(classname) && !rule_node_for(classname).bulk_update?
         end
 
         def trigger_rules(node, *changes)
@@ -118,15 +123,25 @@ module Neo4j
           recursive(node,rule_node.model_class,*changes)
         end
 
-        private 
+        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)
+        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

data/lib/neo4j/rule/rule_node.rb

@@ -10,9 +10,11 @@ module Neo4j
       include ToJava
       attr_reader :rules
       attr_reader :model_class
+      @@rule_nodes = {}
 
       def initialize(clazz)
-        @model_class = eval("#{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
@@ -27,7 +29,21 @@ module Neo4j
       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
@@ -61,11 +77,6 @@ module Neo4j
         ref_node.rel?(@classname.to_s) && ref_node._rel(:outgoing, @classname.to_s)._end_node
       end
 
-      def rule_node
-        clear_rule_node if ref_node_changed?
-        Thread.current[@rule_node_key] ||= find_node || create_node
-      end
-
       def ref_node_changed?
         if ref_node != Thread.current[@ref_node_key]
           Thread.current[@ref_node_key] = ref_node
@@ -75,16 +86,8 @@ module Neo4j
         end
       end
 
-      def rule_node?(node)
-        cached_rule_node == node
-      end
-
-      def cached_rule_node
-        Thread.current[@rule_node_key]
-      end
-
       def clear_rule_node
-        Thread.current[@rule_node_key] = nil
+        @@rule_nodes[key] = nil
       end
 
       def rule_names
@@ -186,7 +189,7 @@ module Neo4j
       end
 
       def connect(rule_name, end_node)
-        rule_node.outgoing(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
@@ -196,9 +199,19 @@ module Neo4j
         !rel.nil?
       end
 
-    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