neo4j 1.2.2-java → 1.2.3-java

data/CHANGELOG

@@ -1,3 +1,13 @@
+ == 1.2.3 / 2011-10-01
+* Multitenancy support by namespaced-indices & changeable reference node (Vivek Prahlad, pull 41)
+* Added a Neo4j::Rails::Model#columns which returns all defined properties [#186]
+* Fixed validation associated entities, parent model should be invalid if its nested model(s) is invalid (Vivek Prahlad)
+* Fixed property validation to read value before conversion as per active model conventions (Deepak N)
+* Fixed property_before_type_cast for loaded models (Deepak N)
+* Better support for nested models via ActionView field_for [#185]
+* BUG: fix for null pointer issue after delete_all on Neo4j::Rails::Model#has_n relationships (Vivek Prahlad)
+* BUG: init_on_create was not called when creating a new relationship via the << operator [#183]
+
  == 1.2.2 / 2011-09-15
 * Added compositions support for rails mode (Deepak N)
 * Added support for nested transactions at the Rails model level (Vivek Prahlad)

data/lib/neo4j/has_n/decl_relationship_dsl.rb

@@ -99,9 +99,12 @@ module Neo4j
 
       def create_relationship_to(node, other) # :nodoc:
         from, to = incoming? ? [other, node] : [node, other]
-        rel = from._java_node.create_relationship_to(to._java_node, java_rel_type)
-        rel[:_classname] = relationship_class.to_s if relationship_class
-        rel.wrapper
+
+        if relationship_class
+          relationship_class.new(@rel_type, from._java_node, to._java_node)
+        else
+          from._java_node.create_relationship_to(to._java_node, java_rel_type)
+        end
       end
 
       # Specifies an outgoing relationship.
@@ -232,7 +235,7 @@ module Neo4j
       end
 
       def relationship_class # :nodoc:
-        @relationship
+        @relationship 
       end
     end
   end

data/lib/neo4j/index/indexer.rb

@@ -91,7 +91,7 @@ module Neo4j
 
             field                     = field.to_s
             @via_relationships[field] = rel_dsl
-            via_indexer.index(field, conf_no_via) 
+            via_indexer.index(field, conf_no_via)
           else
             @field_types[field.to_s] = conf[:type] || :exact
           end
@@ -226,7 +226,7 @@ module Neo4j
       # (by Rack).
       #
       # === Example, with a block
-      #   
+      #
       #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
       #
       # ==== Example
@@ -293,11 +293,11 @@ module Neo4j
 
       def index_for_field(field) #:nodoc:
         type           = @field_types[field]
-        @indexes[type] ||= create_index_with(type)
+        create_index_with(type)
       end
 
       def index_for_type(type) #:nodoc:
-        @indexes[type] ||= create_index_with(type)
+        create_index_with(type)
       end
 
       def lucene_config(type) #:nodoc:
@@ -317,12 +317,11 @@ module Neo4j
       end
 
       def index_names
-        default_filename = @indexer_for.to_s.gsub('::', '_')
-        @index_names ||= Hash.new{|hash,index_type| hash[index_type] = "#{default_filename}-#{index_type}"}
+        @index_names ||= Hash.new do |hash,index_type|
+          default_filename = Neo4j.index_prefix + @indexer_for.to_s.gsub('::', '_')
+          hash.fetch(index_type) {"#{default_filename}-#{index_type}"}
+        end
       end
-
     end
-
   end
-
 end

data/lib/neo4j/neo4j.rb

@@ -125,13 +125,38 @@ module Neo4j
       this_db.shutdown if this_db
     end
 
+
+    # Returns the default reference node, which is a "starting point" in the node space.
+    #    
+    def default_ref_node(this_db = self.started_db)
+      this_db.graph.reference_node
+    end
+
     # Returns the reference node, which is a "starting point" in the node space.
+    # In case the ref_node has been assigned via the threadlocal_ref_node method, then that node will be returned instead.
     #
     # Usually, a client attaches relationships to this node that leads into various parts of the node space.
     # For more information about common node space organizational patterns, see the design guide at http://wiki.neo4j.org/content/Design_Guide
     #
     def ref_node(this_db = self.started_db)
-      this_db.graph.reference_node
+      return Thread.current[:local_ref_node] if Thread.current[:local_ref_node]
+      default_ref_node(this_db)
+    end
+
+    # Changes the reference node on a threadlocal basis.
+    # This can be used to achieve multitenancy. All new entities will be attached to the new ref_node,
+    # which effectively partitions the graph, and hence scopes traversals.
+    def threadlocal_ref_node=(reference_node)
+      Thread.current[:local_ref_node] = reference_node.nil? ? nil : reference_node._java_node
+    end
+
+    # Returns a prefix for lucene indices based on the name property of the current reference node.
+    # This allows the index names to be prefixed by the reference node name, and hence scopes lucene indexes
+    # to all entities under the current reference node.
+    def index_prefix
+      return "" if not running?
+      ref_node_name = ref_node[:name]
+      ref_node_name.nil? || ref_node_name.empty? ? "" : ref_node_name + "_"
     end
 
     # Returns a Management JMX Bean.

data/lib/neo4j/rails/attributes.rb

@@ -244,6 +244,7 @@ module Neo4j
 
       # Wrap the setter in a conversion from Ruby to Java
       def write_local_property_with_type_conversion(property, value)
+        self.send("#{property}_before_type_cast=", value) if respond_to?("#{property}_before_type_cast=")
         write_local_property_without_type_conversion(property, Neo4j::TypeConverters.to_java(self.class, property, value))
       end
     end

data/lib/neo4j/rails/mapping/property.rb

@@ -6,18 +6,30 @@ module Neo4j
 
         module ClassMethods
 
+          # Create two new methods: rel_name and rel_name_rels
+          # The first one returns an Neo4j::Rails::Relationships::NodesDSL
+          # the second generate method (with the _rels postfix) returns a
+          # Neo4j::Rails::Relationships::RelsDSL
+          #
+          # See also Neo4j::NodeMixin#has_n which only work with persisted relationships.
+          #
           def has_n(*args)
             options = args.extract_options!
             define_has_n_methods_for(args.first, options)
           end
 
+          # See #has_n
           def has_one(*args)
             options = args.extract_options!
             define_has_one_methods_for(args.first, options)
           end
 
+          # Returns all defined properties
+          def columns
+            self._decl_props.keys
+          end
 
-          def define_has_one_methods_for(rel_type, options)
+          def define_has_one_methods_for(rel_type, options) #:nodoc:
             unless method_defined?(rel_type)
               class_eval <<-RUBY, __FILE__, __LINE__
                 def #{rel_type}
@@ -52,7 +64,7 @@ module Neo4j
             _decl_rels[rel_type.to_sym] = Neo4j::HasN::DeclRelationshipDsl.new(rel_type, true, self)
           end
 
-          def define_has_n_methods_for(rel_type, options)
+          def define_has_n_methods_for(rel_type, options) #:nodoc:
             unless method_defined?(rel_type)
               class_eval <<-RUBY, __FILE__, __LINE__
                 def #{rel_type}
@@ -100,6 +112,7 @@ module Neo4j
             _decl_props[property] = options
             handle_property_options_for(property, options)
             define_property_methods_for(property, options)
+            define_property_before_type_cast_methods_for(property, options)
           end
 
           def handle_property_options_for(property, options)
@@ -129,6 +142,17 @@ module Neo4j
 							RUBY
 						end
 					end
+
+          def define_property_before_type_cast_methods_for(property, options)
+            property_before_type_cast = "#{property}_before_type_cast"
+            class_eval <<-RUBY, __FILE__, __LINE__
+              attr_writer :#{property_before_type_cast}
+
+              def #{property_before_type_cast}
+                instance_variable_defined?(:@#{property_before_type_cast}) ? @#{property_before_type_cast} : self.#{property}
+              end
+            RUBY
+          end
 				end
 			end
 		end

data/lib/neo4j/rails/model.rb

@@ -5,6 +5,21 @@ module Neo4j
     # That means for example that you don't have to care about transactions since they will be
     # automatically be created when needed.
     #
+    # ==== Included Mixins
+    #
+    # * Neo4j::Rails::Persistence :: handles how to save, create and update the model
+    # * Neo4j::Rails::Attributes :: handles how to save and retrieve attributes
+    # * Neo4j::Rails::Mapping::Property :: allows some additional options on the #property class method
+    # * Neo4j::Rails::Serialization :: enable to_xml and to_json
+    # * Neo4j::Rails::Timestamps :: handle created_at, updated_at timestamp properties
+    # * Neo4j::Rails::Validations :: enable validations
+    # * Neo4j::Rails::Callbacks :: enable callbacks
+    # * Neo4j::Rails::Finders :: ActiveRecord style find
+    # * Neo4j::Rails::Relationships :: handles persisted and none persisted relationships.
+    # * Neo4j::Rails::Compositions :: see Neo4j::Rails::Compositions::ClassMethods, similar to http://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html
+    # * ActiveModel::Observing # enable observers, see Rails documentation.
+    # * ActiveModel::Translation - class mixin
+    #
     # ==== Traversals
     # This class only expose a limited set of traversals.
     # If you want to access the raw java node to do traversals use the _java_node.
@@ -19,6 +34,13 @@ module Neo4j
     #
     # The has_n and has_one relationship accessors returns objects of type Neo4j::Rails::Relationships::RelsDSL
     # and Neo4j::Rails::Relationships::NodesDSL which behaves more like the Active Record relationships.
+    # Notice that unlike Neo4j::NodeMixin new relationships are kept in memory until @save@ is called.
+    #
+    # ==== Callbacks
+    #
+    # The following callbacks are supported :validation, :create, :destroy, :save, :update.
+    # It works with before, after and around callbacks, see the Rails documentation.
+    # Notice you can also do callbacks using the Neo4j::Rails::Callbacks module (check the Rails documentation)
     #
     class Model
       include Neo4j::NodeMixin
@@ -69,6 +91,34 @@ module Neo4j
         new? ? self.__id__ == other.__id__ : @_java_node == (other)
       end
 
+      ##
+      # :singleton-method: property
+      #
+      # See Neo4j::Rails::Mapping::Property::ClassMethods#property
+
+      ##
+      # :singleton-method: has_one
+      #
+      # Generates a has_one methods which returns an object of type Neo4j::Rails::Relationships::NodesDSL
+      # and a has_one method postfixed @_rel@ which return a Neo4j::Rails::Relationships::RelsDSL
+      #
+      # See also Neo4j::Rails::Mapping::Property::ClassMethods#has_one
+      #
+
+      ##
+      # :singleton-method: columns
+      #
+      # Returns all defined properties as an array
+
+      ##
+      # :singleton-method: has_n
+      #
+      # Generates a has_n method which returns an object of type Neo4j::Rails::Relationships::NodesDSL
+      # and a has_n method postfixed @_rel@ which return a Neo4j::Rails::Relationships::RelsDSL
+      #
+      # See also Neo4j::Rails::Mapping::Property::ClassMethods#has_n
+      #
+
 
       # --------------------------------------
       # Public Class Methods

data/lib/neo4j/rails/persistence.rb

@@ -2,7 +2,7 @@ module Neo4j
 	module Rails
 		module Persistence
 			extend ActiveSupport::Concern
-			
+
 			included do
 				extend TxMethods
 				tx_methods :destroy, :create, :update, :update_nested_attributes, :delete
@@ -14,7 +14,7 @@ module Neo4j
       def save(*)
       	create_or_update
       end
-      
+
       # Persist the object to the database.  Validations and Callbacks are included
 			# by default but validation can be disabled by passing :validate => false
 			# to #save!.
@@ -25,7 +25,7 @@ module Neo4j
 					raise RecordInvalidError.new(self)
 				end
 			end
-			
+
 			# Updates a single attribute and saves the record.
 			# This is especially useful for boolean flags on existing records. Also note that
 			#
@@ -37,25 +37,25 @@ module Neo4j
 				respond_to?("#{name}=") ? send("#{name}=", value) : self[name] = value
 				save(:validate => false)
 			end
-			
+
 			# Removes the node from Neo4j and freezes the object.
 			def destroy
 				delete
 				freeze
 			end
-			
+
 			# Same as #destroy but doesn't run destroy callbacks and doesn't freeze
 			# the object
 			def delete
 				del unless new_record?
 				set_deleted_properties
 			end
-			
+
 			# Returns true if the object was destroyed.
 			def destroyed?()
         @_deleted || Neo4j::Node._load(id).nil?
       end
-			
+
 			# Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
       # If saving fails because the resource is invalid then false will be returned.
       def update_attributes(attributes)
@@ -68,7 +68,7 @@ module Neo4j
         self.attributes = attributes
         save!
       end
-			
+
       # Reload the object from the DB.
       def reload(options = nil)
         clear_changes
@@ -86,14 +86,14 @@ module Neo4j
       def persisted?
         !new_record? && !destroyed?
       end
-      
+
       # Returns true if the record hasn't been saved to Neo4j yet.
       def new_record?
         _java_node.nil?
       end
-      
+
       alias :new? :new_record?
-      
+
       # Freeze the properties hash.
 			def freeze
 				@properties.freeze; self
@@ -197,12 +197,12 @@ module Neo4j
           write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
         end
       end
-      
+
       def _create_entity(rel_type, attr)
         clazz = self.class._decl_rels[rel_type.to_sym].target_class
         _add_relationship(rel_type, clazz.new(attr))
       end
-      
+
       def _add_relationship(rel_type, node)
         if respond_to?("#{rel_type}=")
           send("#{rel_type}=", node)
@@ -215,6 +215,7 @@ module Neo4j
       end
 
       def _find_node(rel_type, id)
+        return nil if id.nil?
         if respond_to?("#{rel_type}=")
           send("#{rel_type}")
         elsif respond_to?("#{rel_type}")
@@ -224,7 +225,7 @@ module Neo4j
           raise "oops #{rel_type}"
         end
       end
-      
+
       def _has_relationship(rel_type, id)
         !_find_node(rel_type,id).nil?
       end
@@ -234,7 +235,7 @@ module Neo4j
         begin
           # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
           destroy = allow_destroy && attr[:_destroy] && attr[:_destroy] != '0'
-          found = Neo4j::Node.load(attr[:id])
+          found = _find_node(rel_type, attr[:id]) || Neo4j::Node.load(attr[:id])
           if destroy
             found.destroy if found
           else
@@ -242,8 +243,8 @@ module Neo4j
               _create_entity(rel_type, attr) #Create new node from scratch
             else
               #Create relationship to existing node in case it doesn't exist already
-              _add_relationship(rel_type, found) if (not _has_relationship(rel_type,attr[:id])) 
-              found.update_attributes(attr)              
+              _add_relationship(rel_type, found) if (not _has_relationship(rel_type,attr[:id]))
+              found.update_attributes(attr)
             end
           end
         end unless reject_if?(reject_if, attr)

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

@@ -29,13 +29,13 @@ module Neo4j
         #   Person.friends.build(:name => 'kalle')  # creates a Person and Friends class.
         #   Person.knows.build(:name => 'kalle') # creates a Neo4j::Rails::Model and Neo4j::Rails::Relationship class
         #
-        def build(attrs)
+        def build(attrs =  {})
           self << (node = @storage.build(attrs))
           node
         end
 
         # Same as #build except that the relationship and node are saved.
-        def create(attrs)
+        def create(attrs = {})
           self << (node = @storage.create(attrs))
           node.save
           node
@@ -54,6 +54,14 @@ module Neo4j
           self
         end
 
+        def persisted?
+          @storage.persisted?
+        end
+
+        def to_ary
+          all.to_a
+        end
+
         # Specifies the depth of the traversal
         def depth(d)
           adapt_to_traverser.depth(d)

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

@@ -45,7 +45,18 @@ module Neo4j
       end
 
       # See Neo4j::Rels#rels.
+      #
       # Will also allow to access unsaved relationships - like the #outgoing and #incoming method.
+      # It one argument - the relationship type.
+      #
+      # To only find all the persisted relationship, node._java_node.rels
+      #
+      # === Example
+      #
+      #   node.outgoing(:foo) << node2
+      #   node.rels(:foo).outgoing #=> [node2]
+      #   node.rels(:foo).incoming #=> []
+      #   node.rels(:foo) #=> [node2] - incoming and outgoing
       #
       def rels(*rel_types)
         storage = _create_or_get_storage(rel_types.first)

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

@@ -27,14 +27,14 @@ module Neo4j
 
         # Same as Neo4j::Rails::Relationships::NodesDSL#build except that you specify the properties of the
         # relationships and it returns a relationship
-        def build(attrs)
+        def build(attrs = {})
           node = @storage.build(attrs)
           @storage.create_relationship_to(node, @dir)
         end
 
         # Same as Neo4j::Rails::Relationships::NodesDSL#create except that you specify the properties of the
         # relationships and it returns a relationship
-        def create(attrs)
+        def create(attrs = {})
           node = @storage.create(attrs)
           rel = @storage.create_relationship_to(node, @dir)
           node.save

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

@@ -14,6 +14,9 @@ module Neo4j
           @target_class = (dsl && dsl.target_class) || Neo4j::Rails::Model
           @outgoing_rels = []
           @incoming_rels = []
+          @persisted_related_nodes = {}
+          @persisted_relationships = {}
+          @persisted_node_to_relationships = {}
         end
 
         def to_s #:nodoc:
@@ -55,14 +58,19 @@ module Neo4j
         end
 
         def each_rel(dir, &block) #:nodoc:
-          relationships(dir).each { |rel| block.call rel }
-
+          relationships(dir).each { |rel| block.call rel }          
           if @node.persisted?
-            node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
-              block.call rel.wrapper
-            end
+            cache_relationships(dir) if @persisted_relationships[dir].nil?
+            @persisted_relationships[dir].each {|rel| block.call rel unless !rel.exist?}
           end
         end
+        
+        def cache_relationships(dir)
+          @persisted_relationships[dir] ||= []
+          node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+            @persisted_relationships[dir] << rel.wrapper
+          end          
+        end
 
         def each_node(dir, &block)
           relationships(dir).each do |rel|
@@ -72,14 +80,26 @@ module Neo4j
               block.call rel.start_node
             end
           end
-
           if @node.persisted?
-            @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
-              block.call rel.getOtherNode(@node._java_node).wrapper
-            end
+            cache_persisted_nodes_and_relationships(dir) if @persisted_related_nodes[dir].nil?
+            @persisted_related_nodes[dir].each {|node| block.call node unless relationship_deleted?(dir,node)}
           end
         end
 
+        def cache_persisted_nodes_and_relationships(dir)
+          @persisted_related_nodes[dir] ||= []
+          @persisted_node_to_relationships[dir] ||= {}
+          @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+            end_node = rel.getOtherNode(@node._java_node).wrapper
+            @persisted_related_nodes[dir] << end_node
+            @persisted_node_to_relationships[dir][end_node]=rel
+          end
+        end
+
+        def relationship_deleted?(dir,node)
+          @persisted_node_to_relationships[dir][node].nil? || !@persisted_node_to_relationships[dir][node].exist?
+        end
+
         def single_relationship(dir)
           rel = relationships(dir).first
           if rel.nil? && @node.persisted?
@@ -133,12 +153,15 @@ module Neo4j
           @outgoing_rels.delete(rel)
         end
 
+        def persisted?
+          @outgoing_rels.empty? && @incoming_rels.empty?
+        end
+
         def persist
           out_rels = @outgoing_rels.clone
           in_rels = @incoming_rels.clone
 
-          @outgoing_rels.clear
-          @incoming_rels.clear
+          [@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
@@ -154,7 +177,6 @@ module Neo4j
             raise "Can't save incoming #{rel}, validation errors ? #{rel.errors.inspect}" unless success
           end
         end
-
       end
     end
   end

data/lib/neo4j/relationship.rb

@@ -66,7 +66,7 @@ module Neo4j
 
     # Returns the relationship name
     #
-    # ====Example
+    # ==== Example
     #   a = Neo4j::Node.new
     #   a.outgoing(:friends) << Neo4j::Node.new
     #   a.rels.first.rel_type # => 'friends'
@@ -106,7 +106,14 @@ module Neo4j
   # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
   # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-null nodes.
   #
-  # See also the Neo4j::RelationshipMixin if you want to wrap a relationship with your own Ruby class.
+  # === Wrapping
+  #
+  # Notice that the Neo4j::Relationship.new does not create a Ruby object. Instead, it returns a Java 
+  # org.neo4j.graphdb.Relationship object which has been modified to feel more rubyish (like Neo4j::Node).
+  #
+  # === See also
+  # * Neo4j::RelationshipMixin if you want to wrap a relationship with your own Ruby class.
+  # * http://api.neo4j.org/1.4/org/neo4j/graphdb/Relationship.html
   #
   # === Included Mixins
   # * Neo4j::Property
@@ -124,6 +131,48 @@ module Neo4j
       include Neo4j::ToJava
 
 
+      ##
+      # :method: start_node
+      #
+      # Returns the start node of this relationship
+
+
+      ##
+      # :method: end_node
+      #
+      # Returns the start node of this relationship
+
+      ##
+      # :method: other_node
+      #
+      # A convenience operation that, given a node that is attached to this relationship, returns the other node. 
+      # For example if node is a start node, the end node will be returned, and vice versa.
+      # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels
+      # method on a node. For example, to get the node "at the other end" of a relationship, use the following:
+      #
+      #   end_node = node.rels.first.other_node(node)
+      #
+      # This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
+      #
+      # === Parameters 
+      # 
+      # node :: the node that we don't want to return
+      
+
+      ##
+      # :method: del
+      #
+      # Deletes this relationship. Invoking any methods on this relationship after delete() has returned is invalid and will lead t
+
+      # :method rel_type
+      #
+      # Returns the type of this relationship.
+      # A relationship's type is an immutable attribute that is specified at Relationship creation.
+      # The relationship type is othen used when traversing nodes, example finding all the 
+      # outgoing nodes of relationship type :friends 
+      #  
+      #  node.outgoing(:friends)
+
       # Returns a org.neo4j.graphdb.Relationship java object (!)
       # Will trigger a event that the relationship was created.
       #

data/lib/neo4j/rule/class_methods.rb

@@ -79,7 +79,7 @@ module Neo4j
       #
       # Example of usage:
       #   class Person
-      #     include Neo4j
+      #     include Neo4j::NodeMixin
       #     property :age
       #     rule :all
       #     rule :young { self[:age] < 10 }
@@ -123,6 +123,24 @@ module Neo4j
         end
       end
 
+      def ref_node_for_class
+        Neo4j.ref_node #The reference node for a type falls back to the threadlocal ref node by default.
+      end
+
+      # Assigns the reference node for a class via a supplied block.
+      # Example of usage:
+      #   class Person
+      #     include Neo4j::NodeMixin
+      #     ref_node { Neo4j.default_ref_node }
+      #   end
+      #
+      def ref_node(&block)
+        singleton = class << self;
+          self;
+        end
+        singleton.send(:define_method, :ref_node_for_class) { block.call }
+      end
+
       def inherit_rules_from(clazz)
         Rule.inherit(clazz, self)
       end

data/lib/neo4j/rule/rule_node.rb

@@ -11,8 +11,10 @@ module Neo4j
       attr_reader :rules
 
       def initialize(clazz)
+        @type = eval("#{clazz}")
         @clazz = clazz
         @rules = []
+        @rule_node_key = ("rule_" + clazz.to_s).to_sym
       end
 
       def to_s
@@ -21,13 +23,21 @@ module Neo4j
 
       # returns true if the rule node exist yet in the database
       def node_exist?
-        !Neo4j.ref_node.rel?(@clazz)
+        !ref_node.rel?(@clazz)
+      end
+      
+      def ref_node
+        if @type.respond_to? :ref_node_for_class
+          @type.ref_node_for_class
+        else
+          Neo4j.ref_node
+        end
       end
 
       def create_node
         Neo4j::Transaction.run do
           node = Neo4j::Node.new
-          Neo4j.ref_node.create_relationship_to(node, type_to_java(@clazz))
+          ref_node.create_relationship_to(node, type_to_java(@clazz))
           node
         end
       end
@@ -39,31 +49,45 @@ module Neo4j
       end
 
       def delete_node
-        if Neo4j.ref_node.rel?(@clazz)
-          Neo4j.ref_node.outgoing(@clazz).each { |n| n.del }
+        if ref_node.rel?(@clazz)
+          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
+        ref_node.rel?(@clazz.to_s) && 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
+        Thread.current[@rule_node_key] = find_node || create_node
       end
 
       def rule_node
-        @rule_node ||= find_node || create_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[:rule_cached_ref_node]
+          Thread.current[:rule_cached_ref_node] = ref_node
+          true
+        else
+          false
+        end
       end
 
       def rule_node?(node)
-        @rule_node == node
+        cached_rule_node == node
+      end
+
+      def cached_rule_node
+        Thread.current[@rule_node_key]
       end
 
       def clear_rule_node
-        @rule_node = nil
+        Thread.current[@rule_node_key] = nil
       end
 
       def rule_names

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.2.2"
+  VERSION = "1.2.3"
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.2
+  version: 1.2.3
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-15 00:00:00 +02:00
+date: 2011-10-01 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency