neo4j 1.0.0.beta.27-java → 1.0.0.beta.28-java

data/lib/neo4j/index/index.rb

@@ -1,3 +1,8 @@
+require 'neo4j/index/class_methods'
+require 'neo4j/index/indexer_registry'
+require 'neo4j/index/indexer'
+require 'neo4j/index/lucene_query'
+
 module Neo4j
 
   module Index

data/lib/neo4j/index/indexer.rb

@@ -1,14 +1,14 @@
 module Neo4j
   module Index
-    class Indexer 
-      attr_reader :indexer_for, :field_types, :via_relationships
+    class Indexer
+      attr_reader :indexer_for, :field_types, :via_relationships, :entity_type, :parent_indexers, :via_relationships
 
       def initialize(clazz, type) #:nodoc:
         # part of the unique name of the index
         @indexer_for       = clazz
 
         # do we want to index nodes or relationships ?
-        @type              = type
+        @entity_type              = type
 
         @indexes           = {} # key = type, value = java neo4j index
         @field_types       = {} # key = field, value = type (e.g. :exact or :fulltext)
@@ -83,9 +83,9 @@ module Neo4j
           rel_dsl = @indexer_for._decl_rels[conf[:via]]
           raise "No relationship defined for '#{conf[:via]}'. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]} <-- error. Define it with a has_one or has_n" unless rel_dsl
           raise "Only incoming relationship are possible to define index on. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]}" unless rel_dsl.incoming?
-          via_indexer = rel_dsl.target_class._indexer
+          via_indexer               = rel_dsl.target_class._indexer
 
-          field = field.to_s
+          field                     = field.to_s
           @via_relationships[field] = rel_dsl
           conf.delete :via # avoid endless recursion
           via_indexer.index(field, conf)
@@ -128,7 +128,7 @@ module Neo4j
           start_node = relationship._start_node
 
           # find the indexer to use
-          indexer   = dsl.target_class._indexer
+          indexer    = dsl.target_class._indexer
 
           # is the relationship created or deleted ?
           if is_created
@@ -141,7 +141,7 @@ module Neo4j
 
       def update_index_on(node, field, old_val, new_val) #:nodoc:
         if @via_relationships.include?(field)
-          dsl = @via_relationships[field]
+          dsl          = @via_relationships[field]
           target_class = dsl.target_class
 
           dsl._all_relationships(node).each do |rel|
@@ -182,22 +182,25 @@ module Neo4j
       # the lucene index in sync. See #index
       #
       def add_index(entity, field, value)
-       	return false unless @field_types.has_key?(field)
+        return false unless @field_types.has_key?(field)
+        value = indexed_value_for(field, value)
+        index = index_for_field(field.to_s)
+        index.add(entity, field, value)
+        @parent_indexers.each { |i| i.add_index(entity, field, value) }
+      end
 
+      def indexed_value_for(field, value)
         # we might need to know what type the properties are when indexing and querying
         @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
 
-        type = @decl_props && @decl_props[field.to_sym] && @decl_props[field.to_sym][:type]
-        if type
-          value = if String != type
-                    org.neo4j.index.impl.lucene.ValueContext.new(value).indexNumeric
-                  else
-                    org.neo4j.index.impl.lucene.ValueContext.new(value)
-                  end
-        end
+        type        = @decl_props && @decl_props[field.to_sym] && @decl_props[field.to_sym][:type]
+        return value unless type
 
-        index_for_field(field.to_s).add(entity, field, value)
-      	@parent_indexers.each { |i| i.add_index(entity, field, value) }
+        if String != type
+          org.neo4j.index.impl.lucene.ValueContext.new(value).indexNumeric
+        else
+          org.neo4j.index.impl.lucene.ValueContext.new(value)
+        end
       end
 
       # Removes an index on the given entity
@@ -236,7 +239,7 @@ module Neo4j
         # we might need to know what type the properties are when indexing and querying
         @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
 
-        index = index_for_type(params[:type] || :exact)
+        index       = index_for_type(params[:type] || :exact)
         if query.is_a?(Hash) && (query.include?(:conditions) || query.include?(:sort))
           params.merge! query.except(:conditions)
           query.delete(:sort)
@@ -285,7 +288,7 @@ module Neo4j
       end
 
       def index_for_field(field) #:nodoc:
-        type = @field_types[field]
+        type           = @field_types[field]
         @indexes[type] ||= create_index_with(type)
       end
 
@@ -300,15 +303,17 @@ module Neo4j
       end
 
       def create_index_with(type) #:nodoc:
-        db=Neo4j.started_db
+        db           = Neo4j.started_db
         index_config = lucene_config(type)
-        if @type == :node
+        if @entity_type == :node
           db.lucene.for_nodes("#{@indexer_for}-#{type}", index_config)
         else
           db.lucene.for_relationships("#{@indexer_for}-#{type}", index_config)
         end
       end
 
+
+
     end
 
   end

data/lib/neo4j/index/lucene_query.rb

@@ -88,6 +88,7 @@ module Neo4j
       # This must be done according to the Neo4j Java Documentation:
       def close
         @hits.close if @hits
+        @hits = nil
       end
 
       # True if there is no search hits.
@@ -110,7 +111,8 @@ module Neo4j
       end
 
       def hits #:nodoc:
-        @hits ||= perform_query
+        close
+        @hits = perform_query
       end
 
       # Performs a range query

data/lib/neo4j/migrations/class_methods.rb

@@ -0,0 +1,102 @@
+module Neo4j
+  module Migrations
+    module ClassMethods
+
+      # Sets the the version we request to migrate to
+      # If not set will migrate to the highest possible migration
+      def migrate_to=(version)
+        @migrate_to = version
+      end
+
+      def migrate_to
+        @migrate_to
+      end
+
+      def latest_migration
+        migrations.keys.sort.reverse[0]
+      end
+
+      # contains all the migrations defined with the #migration DSL method
+      def migrations
+        @migrations ||= {}
+      end
+
+      # Specifies a migration to be performed.
+      # Updates the migrate_to variable so that it will migrate to the latest migration.
+      #
+      # === Example
+      #
+      # In the following example the up and down method will be evaluated in the context of a Person node.
+      #
+      #   Person.migration 1, :my_first_migration do
+      #     up { ... }
+      #     down { ... }
+      #   end
+      #
+      # See the Neo4j::Migrations::Migration which the DSL is evaluated in.
+      #
+      def migration(version, name, &block)
+        migration = Migration.new(version, name)
+        migration.instance_eval(&block)
+        migrations[version] = migration
+        self.migrate_to = latest_migration
+      end
+
+
+      def _migrate!(context, meta_node, version=nil) #:nodoc:
+        # set the version we want to migrate to if provided
+        self.migrate_to = version if version
+
+        # requested to migrate to a version ?
+        return if self.migrate_to.nil?
+
+        # which version are we on now ?
+        current_version = meta_node[:_db_version] || 0
+
+        # do we need to migrate ?
+        return if current_version == self.migrate_to
+
+        # ok, so we are running some migrations
+        if Neo4j::Config['migration_thread']
+          Thread.new { _upgrade_or_downgrade(current_version, context, meta_node) }
+        else
+          _upgrade_or_downgrade(current_version, context, meta_node)
+        end
+      end
+
+      def _upgrade_or_downgrade(current_version, context, meta_node) #:nodoc:
+        if (current_version < self.migrate_to)
+          upgrade((current_version+1).upto(self.migrate_to).collect { |ver| migrations[ver] }, context, meta_node)
+        else
+          downgrade(current_version.downto(self.migrate_to+1).collect { |ver| migrations[ver] }, context, meta_node)
+        end
+
+      end
+
+
+      # Running the up method on the given migrations.
+      #
+      # === Parameters
+      # migrations :: an enumerable of Migration objects
+      def upgrade(migrations, context, meta_node)
+        migrations.each do |m|
+          Neo4j.logger.info "Running upgrade: #{m}"
+          m.execute_up(context, meta_node)
+        end
+      end
+
+      # Running the down method on the given migrations.
+      #
+      # === Parameters
+      # migrations:: an enumerable of Migration objects
+      def downgrade(migrations, context, meta_node)
+        migrations.each do |m|
+          Neo4j.logger.info "Running downgrade: #{m}"
+          m.execute_down(context, meta_node)
+        end
+      end
+
+    end
+  end
+
+end

data/lib/neo4j/migrations/extensions.rb

@@ -9,16 +9,17 @@ module Neo4j
     # The version is stored on the reference node, with property 'db_version'
     # (It Delegates to the Reference Node)
     #
-    # === See Also
-    # Neo4j::MigrationMixin#db_version
+    # ==== See Also
+    # Neo4j::Migrations::RefNodeWrapper#db_version
     #
     # :singleton-method: db_version
 
     ##
     # Force Neo4j.rb to perform migrations
     #
-    # === See Also
-    # Neo4j::MigrationMixin#migrate!
+    # ==== See Also
+    #
+    # Neo4j::Migrations::RefNodeWrapper#migrate!
     #
     # :singleton-method: migrate!
 
@@ -37,21 +38,21 @@ module Neo4j
     #    end
     #  end
     #
-    # === See Also
-    # Neo4j::MigrationMixin::ClassMethods#migration
+    # ==== See Also
+    # Neo4j::Migrations::ClassMethods#migration
     #
     # :singleton-method: migration
 
     ##
     # Returns all migrations that has been defined.
     #
-    # === See Also
-    # Neo4j::MigrationMixin::ClassMethods#migrations
+    # ==== See Also
+    # Neo4j::Migrations::ClassMethods#migrations
     #
     # :singleton-method: migrations
 
 
-    def_delegators :'Neo4j::GlobalMigration', :db_version, :migrate!, :migrations, :migration
+    def_delegators :'Neo4j::Migrations::RefNodeWrapper', :db_version, :migrate!, :migrations, :migration
 
   end
 end

data/lib/neo4j/migrations/lazy_node_mixin.rb

@@ -0,0 +1,50 @@
+module Neo4j
+
+  module Migrations
+
+    # Overrides the init_on_load method so that it will check if any migration is needed.
+    # The init_on_create method is also overridden so that it sets the version to the latest migration number
+    # when a new node is created.
+    #
+    # Migration will take place if needed when the node is loaded.
+    #
+    module LazyNodeMixin
+      extend ActiveSupport::Concern
+
+      included do
+        extend Neo4j::Migrations::ClassMethods
+      end
+
+      module ClassMethods
+        # Remote all migration and set migrate_to = nil
+        # Does not change the version of nodes.
+        def reset_migrations!
+          @migrations = nil
+          @migrate_to = nil
+        end
+      end
+
+      def migrate!
+        self.class._migrate!(self._java_node, self)
+      end
+
+      def init_on_create(*)
+        super
+        # set the db version to the current
+        self[:_db_version] = self.class.migrate_to
+      end
+
+      def init_on_load(*) # :nodoc:
+        super
+        migrate!
+        # this if for Neo4j::Rails::Model which keeps the properties in this variable
+        @properties.clear if instance_variable_defined? :@properties
+      end
+
+      def db_version
+        self[:_db_version]
+      end
+    end
+
+  end
+end

data/lib/neo4j/migrations/migration.rb

@@ -1,109 +1,112 @@
 module Neo4j
 
-  # This is the context in which the Migrations DSL are evaluated in.
-  # This class is also responsible for running the migrations.
-  class Migration
-    attr_reader :up_block, :down_block, :up_migrator, :down_migrator, :version, :name
-
-    def initialize(version, name)
-      @auto_transaction = true
-      @version          = version
-      @name             = name
-    end
+  module Migrations
 
-    # Specifies a code block which is run when the migration is upgraded.
-    #
-    def up(&block)
-      @up_block = block
-    end
+    # This is the context in which the Migrations DSL are evaluated in.
+    # This class is also responsible for running the migrations.
+    class Migration
+      attr_reader :up_block, :down_block, :up_migrator, :down_migrator, :version, :name
 
-    # Specifies a code block which is run when the migration is upgraded.
-    #
-    def down(&block)
-      @down_block = block
-    end
+      def initialize(version, name)
+        @auto_transaction = true
+        @version = version
+        @name = name
+      end
 
-    # Specifies if transaction should automatically be created (default)
-    def auto_transaction(run_with_auto_tx)
-      @auto_transaction = run_with_auto_tx
-    end
+      # Specifies a code block which is run when the migration is upgraded.
+      #
+      def up(&block)
+        @up_block = block
+      end
 
+      # Specifies a code block which is run when the migration is upgraded.
+      #
+      def down(&block)
+        @down_block = block
+      end
 
-    # Specifies which fields should be indexed
-    def add_index(*fields)
-      @add_indexed_field = fields
-    end
+      # Specifies if transaction should automatically be created (default)
+      def auto_transaction(run_with_auto_tx)
+        @auto_transaction = run_with_auto_tx
+      end
 
-    # Specifies which fields indexed should be removed 
-    def rm_index(*fields)
-      @rm_indexed_field = fields
-    end
 
-    # Runs the up migration. If successful it will set the property
-    # ':_db_version' on the given context.
-    #
-    # === Parameters
-    # context:: the context on which the block is evaluated in
-    # meta_node:: the node on which to set the 'db_version' property
-    #
-    def execute_up(context, meta_node)
-
-      if @auto_transaction
-        Neo4j::Transaction.run do
+      # Specifies which fields should be indexed
+      def add_index(*fields)
+        @add_indexed_field = fields
+      end
+
+      # Specifies which fields indexed should be removed
+      def rm_index(*fields)
+        @rm_indexed_field = fields
+      end
+
+      # Runs the up migration. If successful it will set the property
+      # ':_db_version' on the given context.
+      #
+      # === Parameters
+      # context:: the context on which the block is evaluated in
+      # meta_node:: the node on which to set the 'db_version' property
+      #
+      def execute_up(context, meta_node)
+
+        if @auto_transaction
+          Neo4j::Transaction.run do
+            context.instance_eval &@up_block if @up_block
+            add_index_on(context, @add_indexed_field) if @add_indexed_field
+            rm_index_on(context, @rm_indexed_field) if @rm_indexed_field
+            meta_node._java_node[:_db_version] = version # use the raw java node since Neo4j::Rails::Mode wraps it
+          end
+        else
           context.instance_eval &@up_block if @up_block
           add_index_on(context, @add_indexed_field) if @add_indexed_field
-          rm_index_on(context, @rm_indexed_field) if @rm_indexed_field
-          meta_node._java_node[:_db_version] = version # use the raw java node since Neo4j::Rails::Mode wraps it
-        end
-      else
-        context.instance_eval &@up_block if @up_block
-        add_index_on(context, @add_indexed_field) if @add_indexed_field
-        Neo4j::Transaction.run do
-          rm_index_on(context, @rm_indexed_field) if @rm_indexed_field
-          meta_node._java_node[:_db_version] = version # use the raw java node since Neo4j::Rails::Mode wraps it
+          Neo4j::Transaction.run do
+            rm_index_on(context, @rm_indexed_field) if @rm_indexed_field
+            meta_node._java_node[:_db_version] = version # use the raw java node since Neo4j::Rails::Mode wraps it
+          end
         end
       end
-    end
 
-    # Same as #execute_up but executes the down_block instead
-    def execute_down(context, meta_node)
-      if @auto_transaction
-        Neo4j::Transaction.run do
+      # Same as #execute_up but executes the down_block instead
+      def execute_down(context, meta_node)
+        if @auto_transaction
+          Neo4j::Transaction.run do
+            context.instance_eval &@down_block if @down_block
+            add_index_on(context, @rm_indexed_field) if @rm_indexed_field
+            rm_index_on(context, @add_indexed_field) if @add_indexed_field
+            meta_node._java_node[:_db_version] = version - 1
+          end
+        else
           context.instance_eval &@down_block if @down_block
           add_index_on(context, @rm_indexed_field) if @rm_indexed_field
-          rm_index_on(context, @add_indexed_field) if @add_indexed_field
-          meta_node._java_node[:_db_version] = version - 1
-        end
-      else
-        context.instance_eval &@down_block if @down_block
-        add_index_on(context, @rm_indexed_field) if @rm_indexed_field
-        Neo4j::Transaction.run do
-          rm_index_on(context, @add_indexed_field) if @add_indexed_field
-          meta_node._java_node[:_db_version] = version - 1
+          Neo4j::Transaction.run do
+            rm_index_on(context, @add_indexed_field) if @add_indexed_field
+            meta_node._java_node[:_db_version] = version - 1
+          end
         end
       end
-    end
 
-    def add_index_on(context, fields) #:nodoc:
-      context.all.each do |node|
-        fields.each do |field|
-          node.add_index(field)
+      def add_index_on(context, fields) #:nodoc:
+        context.all.each do |node|
+          fields.each do |field|
+            node.add_index(field)
+          end
         end
       end
-    end
 
-    def rm_index_on(context, fields) #:nodoc:
-      context.all.each do |node|
-        fields.each do |field|
-          node.rm_index(field)
+      def rm_index_on(context, fields) #:nodoc:
+        context.all.each do |node|
+          fields.each do |field|
+            node.rm_index(field)
+          end
         end
       end
-    end
 
 
-    def to_s
-      "Migration version: #{version}, name: #{name}"
+      def to_s
+        "Migration version: #{version}, name: #{name}"
+      end
     end
-  end
 
-end
+  end
+end