neo4j 1.2.6-java → 1.3.0-java

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

@@ -66,8 +66,12 @@ module Neo4j
       #   node.rels(:foo) #=> [node2] - incoming and outgoing
       #
       def rels(*rel_types)
-        storage = _create_or_get_storage(rel_types.first)
-        RelsDSL.new(storage)
+        if rel_types.empty?
+          AllRelsDsl.new(@_relationships, _java_node)
+        else
+          storage = _create_or_get_storage(rel_types.first)
+          RelsDSL.new(storage)
+        end
       end
 
       def add_outgoing_rel(rel_type, rel) #:nodoc:

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
@@ -42,6 +91,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.
@@ -98,11 +154,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

@@ -23,6 +23,11 @@ module Neo4j
           "Storage #{object_id} node: #{@node.id} rel_type: #{@rel_type} outgoing #{@outgoing_rels.size} incoming #{@incoming_rels.size}"
         end
 
+        def clear_unpersisted
+          @outgoing_rels.clear
+          @incoming_rels.clear
+        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)}
@@ -37,6 +42,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
@@ -172,7 +181,7 @@ module Neo4j
           end
 
           in_rels.each do |rel|
-            rel.start_node.rm_outgoing_rel(@rel_type.to_sym, rel)
+            rel.start_node.rm_outgoing_rel(@rel_type.to_sym, rel) if rel.start_node
             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/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,6 +10,7 @@ module Neo4j
       include ToJava
       attr_reader :rules
       attr_reader :model_class
+      @@rule_nodes = {}
 
       def initialize(clazz)
         @model_class = eval("#{clazz}")
@@ -27,7 +28,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 +76,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 +85,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 +188,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 +198,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