neo4j 1.2.3-java → 1.2.4-java

data/CHANGELOG

@@ -1,3 +1,9 @@
+ == 1.2.4 / 2011-10-07
+* Support for traversing with Neo4j::Node#eval_paths and setting uniqueness on traversals [#187]
+* Removed unnecessary node creation on database start up (class nodes attached to reference node) (Vivek Prahlad)
+* Safer multitenancy - automatically reset the reference node in thread local context after each request using rack middleware
+* Bugfixes for multitenancy (Deepak N and Vivek Prahlad)
+
  == 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]

data/README.rdoc

@@ -45,7 +45,7 @@ Example of creating a Neo4j::Node
     node.outgoing(:friends).each {|node| puts "name #{node[:name]}"}
   end
 
-==== Neo4j::Mapping::NodeMixin
+==== Neo4j::NodeMixin
 
 Example of mapping a ruby class to a node and delaring properties and relationships and lucene index.
 

data/lib/neo4j/index/indexer.rb

@@ -267,8 +267,9 @@ module Neo4j
       def delete_index_type(type=nil)
         if type
           #raise "can't clear index of type '#{type}' since it does not exist ([#{@field_types.values.join(',')}] exists)" unless index_type?(type)
-          @indexes[type] && @indexes[type].delete
-          @indexes[type] = nil
+          key = index_key(type)
+          @indexes[key] && @indexes[key].delete
+          @indexes[key] = nil
         else
           @indexes.each_value { |index| index.delete }
           @indexes.clear
@@ -293,11 +294,15 @@ module Neo4j
 
       def index_for_field(field) #:nodoc:
         type           = @field_types[field]
-        create_index_with(type)
+        @indexes[index_key(type)] ||= create_index_with(type)
       end
 
       def index_for_type(type) #:nodoc:
-        create_index_with(type)
+        @indexes[index_key(type)] ||= create_index_with(type)
+      end
+
+      def index_key(type)
+        index_names[type] + type.to_s
       end
 
       def lucene_config(type) #:nodoc:
@@ -317,11 +322,20 @@ module Neo4j
       end
 
       def index_names
-        @index_names ||= Hash.new do |hash,index_type|
-          default_filename = Neo4j.index_prefix + @indexer_for.to_s.gsub('::', '_')
+        @index_names ||= Hash.new do |hash, index_type|
+          default_filename = index_prefix + @indexer_for.to_s.gsub('::', '_')
           hash.fetch(index_type) {"#{default_filename}-#{index_type}"}
         end
       end
+
+      protected
+      def index_prefix
+        return "" unless Neo4j.running?
+        return "" unless @indexer_for.respond_to?(:ref_node_for_class)
+        ref_node = @indexer_for.ref_node_for_class
+        ref_node_name = ref_node[:name]
+        ref_node_name.blank? ? "" : ref_node_name + "_"
+      end
     end
   end
 end

data/lib/neo4j/neo4j.rb

@@ -150,15 +150,6 @@ module Neo4j
       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.
     #
     # Notice that this information is also provided by the jconsole Java tool, check http://wiki.neo4j.org/content/Monitoring_and_Deployment

data/lib/neo4j/node.rb

@@ -113,7 +113,93 @@ module Neo4j
     # :method: _java_node
     # Returns the java node/relationship object representing this object unless it is already the java object.
     # This method is  defined in the  org.neo4j.kernel.impl.core.NodeProxy which is return by Neo4j::Node.new
-    
+
+
+    ##
+    # :method: expand
+    # See Neo4j::Traversal#expand
+
+    ##
+    # :method: outgoing
+    # See Neo4j::Traversal#outgoing
+
+
+    ##
+    # :method: incoming
+    # See Neo4j::Traversal#incoming
+
+    ##
+    # :method: both
+    # See Neo4j::Traversal#both
+
+    ##
+    # :method: eval_paths
+    # See Neo4j::Traversal#eval_paths
+
+    ##
+    # :method: unique
+    # See Neo4j::Traversal#unique
+
+    ##
+    # :method: node
+    # See Neo4j::Rels#node or Neo4j::Rels
+
+    ##
+    # :method: _node
+    # See Neo4j::Rels#_node or Neo4j::Rels
+
+    ##
+    # :method: rels
+    # See Neo4j::Rels#rels or Neo4j::Rels
+
+    ##
+    # :method: _rels
+    # See Neo4j::Rels#_rels or Neo4j::Rels
+
+    ##
+    # :method: rel
+    # See Neo4j::Rels#rel
+
+    ##
+    # :method: _rel
+    # See Neo4j::Rels#_rel
+
+    ##
+    # :method: rel?
+    # See Neo4j::Rels#rel?
+
+    ##
+    # :method: props
+    # See Neo4j::Property#props
+
+    ##
+    # :method: neo_id
+    # See Neo4j::Property#neo_id
+
+    ##
+    # :method: attributes
+    # See Neo4j::Property#attributes
+
+    ##
+    # :method: property?
+    # See Neo4j::Property#property?
+
+    ##
+    # :method: update
+    # See Neo4j::Property#update
+
+    ##
+    # :method: []
+    # See Neo4j::Property#[]
+
+    ##
+    # :method: []=
+    # See Neo4j::Property#[]=
+
+    ##
+    # :method: []=
+    # See Neo4j::Property#[]=
+
     class << self
 
       # Returns a new neo4j Node.

data/lib/neo4j/node_mixin/node_mixin.rb

@@ -15,7 +15,7 @@ require 'neo4j/node_mixin/class_methods'
 module Neo4j
   # This Mixin is used to wrap Neo4j Java Nodes in Ruby objects.
   #
-  # It includes a number of mixins and forwards some methods to the raw Java node which in term includes a number of mixins, see below.
+  # It includes a number of mixins and forwards some methods to the raw Java node (Neo4j::Node) which includes the mixins below:
   #
   # === Instance Methods
   #

data/lib/neo4j/rails/finders.rb

@@ -73,7 +73,7 @@ module Neo4j
             when :all, :first
               kind = args.shift
               send(kind, *args)
-            when "0", 0
+            when "0", 0, nil
               nil
             else
               if ((args.first.is_a?(Integer) || args.first.is_a?(String)) && args.first.to_i > 0)
@@ -189,13 +189,17 @@ module Neo4j
         def find_with_ids(*args)
           result = load(*args.map { |p| p.to_i })
           if result.is_a?(Array)
-            result = result.select { |r| r.is_a? self }
+            result = result.select { |r| findable?(r)}
           else
-            result = nil unless result.is_a? self
+            result = nil unless findable?(result)
           end
           result
         end
 
+        def findable?(entity)
+          entity.is_a? self
+        end
+
         def find_with_indexer(*args)
           hits                                     = _indexer.find(*args)
           # We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it

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

@@ -75,6 +75,16 @@ module Neo4j
               RUBY
             end
 
+            unless method_defined?("#{rel_type}=".to_sym)
+              class_eval <<-RUBY, __FILE__, __LINE__
+                def #{rel_type}=(nodes)
+                    self.#{rel_type}_rels.destroy_all
+                    association = self.#{rel_type}
+                    nodes.each { |node| association << node }
+                end
+              RUBY
+            end
+
             unless method_defined?("#{rel_type}_rels".to_sym)
               class_eval <<-RUBY, __FILE__, __LINE__
                 def #{rel_type}_rels

data/lib/neo4j/rails/model.rb

@@ -91,6 +91,68 @@ module Neo4j
         new? ? self.__id__ == other.__id__ : @_java_node == (other)
       end
 
+      def reachable_from_ref_node?
+        Neo4j::Algo.all_path(self.class.ref_node_for_class, self).outgoing(self.class).outgoing(:_all).count > 0
+      end
+
+      ##
+      # :method: outgoing
+      #
+      # Similar to Neo4j::Traversal#outgoing but returns depth one only outgoing relationship
+      # which may not all be persisted.
+      # For only traversing persisted outgoing relationship of any depth or more advanced traversals, use
+      # the wrapped Java node instead.
+      #
+      # ==== Examples
+      #
+      #   person.outgoing(:friends) << other_person
+      #   person.save!
+      #
+      #   person.outgoing(:friends).map{|f| f.outgoing(:knows).to_a}.flatten
+      #
+      # ==== Examples
+      #
+      #   Neo4j::Transaction.run do
+      #     person._java_node.outgoing(:friends) << other_person
+      #   end
+      #
+      #   person._java_node.outgoing(:friends).outgoing(:knows).depth(4)
+      #
+      # Notice you can also declare outgoing relationships with the #has_n and #has_one class method.
+      #
+      # See Neo4j::Rails::Relationships#outgoing
+      # See Neo4j::Traversal#outgoing (when using it from the _java_node)
+
+
+      ##
+      # :method: incoming
+      #
+      # Returns incoming relationship of depth one which may not all be persisted.
+      # See #outgoing
+
+
+      ##
+      # :method: rels
+      #
+      # Returns both incoming and outgoing relationships which may not all be persisted.
+      # If you only want to find persisted relationships: @node._java_node.rels@
+      #
+      # See Neo4j::Rails::Relationships#rels
+      # See Neo4j::Rels#rels or Neo4j::Rels
+      #
+
+      ##
+      # :method: []
+      #
+      # Returns a property of this node, which may or may not have been declared with the class property method.
+      # Similar to Neo4j::Property#[] but can return not persisted properties as well.
+
+      ##
+      # :method: []=
+      #
+      # Sets any property on the node.
+      # Similar to Neo4j::Property#[]= but you must call the #save method to persist the property.
+
       ##
       # :singleton-method: property
       #
@@ -179,6 +241,11 @@ module Neo4j
           end
         end
 
+        # When multitenancy is used, node should be findable only from current ref node.
+        def findable?(entity)
+          entity.is_a? self and entity.reachable_from_ref_node?
+        end
+
         # Set the i18n scope to overwrite ActiveModel.
         #
         # @return [ Symbol ] :neo4j

data/lib/neo4j/rails/persistence.rb

@@ -204,9 +204,9 @@ module Neo4j
       end
 
       def _add_relationship(rel_type, node)
-        if respond_to?("#{rel_type}=")
+        if respond_to?("#{rel_type}_rel")
           send("#{rel_type}=", node)
-        elsif respond_to?("#{rel_type}")
+        elsif respond_to?("#{rel_type}_rels")
           has_n = send("#{rel_type}")
           has_n << node
         else
@@ -216,9 +216,9 @@ module Neo4j
 
       def _find_node(rel_type, id)
         return nil if id.nil?
-        if respond_to?("#{rel_type}=")
+        if respond_to?("#{rel_type}_rel")
           send("#{rel_type}")
-        elsif respond_to?("#{rel_type}")
+        elsif respond_to?("#{rel_type}_rels")
           has_n = send("#{rel_type}")
           has_n.find { |n| n.id == id }
         else
@@ -235,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 = _find_node(rel_type, attr[:id]) || Neo4j::Node.load(attr[:id])
+          found = _find_node(rel_type, attr[:id]) || Model.find(attr[:id])
           if destroy
             found.destroy if found
           else

data/lib/neo4j/rails/{lucene_connection_closer.rb → rack_middleware.rb}

@@ -1,6 +1,8 @@
 module Neo4j
   module Rails
-    class LuceneConnectionCloser  #:nodoc:
+    # close lucene connections
+    # reset the Neo4j.threadlocal_ref_node (Multitenancy)
+    class RackMiddleware  #:nodoc:
       def initialize(app)
         @app = app
       end
@@ -9,6 +11,7 @@ module Neo4j
         @app.call(env)
       ensure
         Neo4j::Rails::Model.close_lucene_connections
+        Neo4j.threadlocal_ref_node = Neo4j.default_ref_node
       end
     end
   end

data/lib/neo4j/rails/rails.rb

@@ -20,6 +20,6 @@ require 'neo4j/rails/relationships/node_dsl'
 require 'neo4j/rails/relationships/rels_dsl'
 require 'neo4j/rails/relationships/relationships'
 require 'neo4j/rails/model'
-require 'neo4j/rails/lucene_connection_closer'
+require 'neo4j/rails/rack_middleware'
 require 'neo4j/rails/rel_persistence'
 require 'neo4j/rails/relationship'

data/lib/neo4j/rails/railtie.rb

@@ -3,7 +3,7 @@ module Neo4j
     config.neo4j = ActiveSupport::OrderedOptions.new
 
     initializer "neo4j.tx" do |app|
-      app.config.middleware.use Neo4j::Rails::LuceneConnectionCloser
+      app.config.middleware.use Neo4j::Rails::RackMiddleware
     end
 
     # Add ActiveModel translations to the I18n load_path

data/lib/neo4j/rule/event_listener.rb

@@ -48,9 +48,7 @@ module Neo4j
         end
 
         def on_neo4j_started(db)
-          if Neo4j::Config[:enable_rules]
-            Rule.on_neo4j_started
-          else
+          if not Neo4j::Config[:enable_rules]
             db.event_handler.remove(self)
           end
         end

data/lib/neo4j/rule/rule.rb

@@ -90,10 +90,6 @@ module Neo4j
           @rule_nodes && @rule_nodes.values.find { |rn| rn.rule_node?(node) }
         end
 
-        def on_neo4j_started
-          @rule_nodes.each_value { |rule_node| rule_node.on_neo4j_started } if @rule_nodes
-        end
-
         def inherit(parent_class, subclass)
           # copy all the rules
           if rule_node = rule_node_for(parent_class)

data/lib/neo4j/rule/rule_node.rb

@@ -15,6 +15,7 @@ module Neo4j
         @clazz = 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
@@ -59,19 +60,14 @@ module Neo4j
         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
-        Thread.current[@rule_node_key] = find_node || create_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[:rule_cached_ref_node]
-          Thread.current[:rule_cached_ref_node] = ref_node
+        if ref_node != Thread.current[@ref_node_key]
+          Thread.current[@ref_node_key] = ref_node
           true
         else
           false

data/lib/neo4j/traversal/traversal.rb

@@ -4,6 +4,11 @@ require 'neo4j/traversal/rel_expander'
 require 'neo4j/traversal/traverser'
 
 module Neo4j
+
+  # Contains methods that are mixin for Neo4j::Node
+  # They all return Neo4j::Traversal::Traverser
+  # See the {Neo4j.rb Guide: Traversing Relationships and Nodes}[http://neo4j.rubyforge.org/guides/traverser.html]
+  #
   module Traversal
     include ToJava
 
@@ -16,6 +21,8 @@ module Neo4j
     #
     # The above traverse all relationships with a property of age > 5
     #
+    # See http://neo4j.rubyforge.org/guides/traverser.html
+    #
     def expand(&expander)
       Traverser.new(self).expander(&expander)
     end
@@ -49,7 +56,9 @@ module Neo4j
     #   # Find all my friends and work colleges
     #   me.outgoing(:friends).outgoing(:work).each {...}
     #
-    # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt> can be combined.
+    # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt>, <tt>eval_paths</tt>, <tt>unique</tt> can be combined.
+    #
+    # See the {Neo4j.rb Guides}[http://neo4j.rubyforge.org/guides/traverser.html]
     #
     def outgoing(type)
       if type
@@ -62,7 +71,7 @@ module Neo4j
 
     # Returns the incoming nodes of given type(s).
     #
-    # See #outgoing
+    # See #outgoing and http://neo4j.rubyforge.org/guides/traverser.html
     #
     def incoming(type)
       if type
@@ -76,7 +85,7 @@ module Neo4j
     #
     # If a type is not given then it will return all types of relationships.
     #
-    # See #outgoing
+    # See #outgoing and http://neo4j.rubyforge.org/guides/traverser.html
     #
     def both(type=nil)
       if type
@@ -86,5 +95,44 @@ module Neo4j
       end
     end
 
+
+    # Traverse using a block. The block is expected to return one of the following values:
+    # * <tt>:exclude_and_continue</tt>
+    # * <tt>:exclude_and_prune</tt>
+    # * <tt>:include_and_continue</tt>
+    # * <tt>:include_and_prune</tt>
+    # This value decides if it should continue to traverse and if it should include the node in the traversal result.
+    # The block will receive a path argument.
+    #
+    # ==== Example
+    #
+    #   @pet0.eval_paths {|path| path.end_node ==  @principal1 ? :include_and_prune : :exclude_and_continue }.unique(:node_path).depth(:all)
+    #
+    # ==== See also
+    #
+    # * How to use - http://neo4j.rubyforge.org/guides/traverser.html
+    # * the path parameter - http://api.neo4j.org/1.4/org/neo4j/graphdb/Path.html
+    # * the #unique method - if paths should be visit more the once, etc...
+    #
+    def eval_paths(&eval_block)
+      Traverser.new(self).eval_paths(&eval_block)
+    end
+
+    # Sets uniqueness of nodes or relationships to visit during a traversals.
+    #
+    # Allowed values
+    # * <tt>:node_global</tt>  A node cannot be traversed more than once (default)
+    # * <tt>:node_path</tt>  For each returned node there 's a unique path from the start node to it.
+    # * <tt>:node_recent</tt>  This is like :node_global, but only guarantees uniqueness among the most recent visited nodes, with a configurable count.
+    # * <tt>:none</tt>  No restriction (the user will have to manage it).
+    # * <tt>:rel_global</tt>  A relationship cannot be traversed more than once, whereas nodes can.
+    # * <tt>:rel_path</tt> :: No restriction (the user will have to manage it).
+    # * <tt>:rel_recent</tt>  Same as for :node_recent, but for relationships.
+    #
+    # See example in #eval_paths
+    # See http://api.neo4j.org/1.4/org/neo4j/kernel/Uniqueness.html and http://neo4j.rubyforge.org/guides/traverser.html
+    def unique(u)
+      Traverser.new(self).unique(u)
+    end
   end
 end

data/lib/neo4j/traversal/traverser.rb

@@ -2,6 +2,32 @@ module Neo4j
 
   module Traversal
 
+    class Evaluator  #:nodoc:
+      include org.neo4j.graphdb.traversal.Evaluator
+      def initialize(&eval_block)
+        @eval_block = eval_block
+      end
+
+      # Implements the Java Interface:
+      #  evaluate(Path path)
+      #  Evaluates a Path and returns an Evaluation containing information about whether or not to include it in the traversal result, i.e return it from the Traverser.
+      def evaluate(path)
+        ret = @eval_block.call(path)
+        case ret
+          when :exclude_and_continue then
+            org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_CONTINUE
+          when :exclude_and_prune then
+            org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_PRUNE
+          when :include_and_continue then
+            org.neo4j.graphdb.traversal.Evaluation::INCLUDE_AND_CONTINUE
+          when :include_and_prune then
+            org.neo4j.graphdb.traversal.Evaluation::INCLUDE_AND_PRUNE
+          else
+            raise "Got #{ret}, only accept :exclude_and_continue,:exclude_and_prune,:include_and_continue and :include_and_prune"
+        end
+      end
+    end
+
     class Traverser
       include Enumerable
       include ToJava
@@ -20,6 +46,39 @@ module Neo4j
         end
       end
 
+      def eval_paths(&eval_path_block)
+        @td = @td.evaluator(Evaluator.new(&eval_path_block))
+        self
+      end
+
+      def unique(u = :node_global)
+        case u
+          when :node_global then
+            # A node cannot be traversed more than once.
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_GLOBAL)
+          when :node_path then
+            # For each returned node there 's a unique path from the start node to it.
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_PATH)
+          when :node_recent then
+            # This is like NODE_GLOBAL, but only guarantees uniqueness among the most recent visited nodes, with a configurable count.
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_RECENT)
+          when :none then
+            # No restriction (the user will have to manage it).
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NONE)
+          when :rel_global then
+            # A relationship cannot be traversed more than once, whereas nodes can.
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_GLOBAL)
+          when :rel_path then
+            # No restriction (the user will have to manage it).
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_PATH)
+          when :rel_recent then
+            # Same as for NODE_RECENT, but for relationships.
+            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_RECENT)
+          else
+            raise "Got option for unique '#{u}' allowed: :node_global, :node_path, :node_recent, :none, :rel_global, :rel_path, :rel_recent"
+        end
+        self
+      end
 
       def to_s
         "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"

data/lib/neo4j/version.rb

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

data/lib/orm_adapter/adapters/neo4j.rb

@@ -4,50 +4,46 @@ module Neo4j
 	module Rails
 		class Model
 			extend ::OrmAdapter::ToAdapter
-  
+
 			class OrmAdapter < ::OrmAdapter::Base
-				NEO4J_REF_NODE_ID = 0
-				
 				# Do not consider these to be part of the class list
 				def self.except_classes
 					@@except_classes ||= []
 				end
-		
+
 				# Gets a list of the available models for this adapter
 				def self.model_classes
 					::Neo4j::Rails::Model.descendants.to_a.select{|k| !except_classes.include?(k.name)}
 				end
-		
+
 				# get a list of column names for a given class
 				def column_names
 					klass._decl_props.keys
 				end
-		
+
 				# Get an instance by id of the model
 				def get!(id)
-					get(id) || raise("Node not found")
+					klass.find!(wrap_key(id))
 				end
-		
+
 				# Get an instance by id of the model
 				def get(id)
-					id = wrap_key(id)
-					return nil if id.to_i == NEO4J_REF_NODE_ID # getting the ref_node in this way is not supported
-					klass.load(id)
+					klass.find(wrap_key(id))
 				end
-		
+
 				# Find the first instance matching conditions
 				def find_first(conditions)
 					klass.first(conditions)
 				end
-		
+
 				# Find all models matching conditions
 				def find_all(conditions)
 					klass.all(conditions)
 				end
-			
+
 				# Create a model using attributes
 				def create!(attributes)
-					klass.create(attributes)
+					klass.create!(attributes)
 				end
 			end
 		end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.3
+  version: 1.2.4
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-01 00:00:00 +02:00
+date: 2011-10-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -121,13 +121,13 @@ files:
   - lib/neo4j/rels/traverser.rb
   - lib/neo4j/rels/rels.rb
   - lib/neo4j/rails/attributes.rb
+  - lib/neo4j/rails/rack_middleware.rb
   - lib/neo4j/rails/model.rb
   - lib/neo4j/rails/validations.rb
   - lib/neo4j/rails/persistence.rb
   - lib/neo4j/rails/serialization.rb
   - lib/neo4j/rails/railtie.rb
   - lib/neo4j/rails/rails.rb
-  - lib/neo4j/rails/lucene_connection_closer.rb
   - lib/neo4j/rails/observer.rb
   - lib/neo4j/rails/transaction.rb
   - lib/neo4j/rails/timestamps.rb