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

data/lib/neo4j/migrations/global_migration.rb

@@ -0,0 +1,29 @@
+module Neo4j
+
+  # This node stores the migrations for Neo4j.migrations
+  # Uses the Neo4j.ref_node for keeping the current version of the db.
+  # When the database starts it will check if it needs to run a migration.
+  class GlobalMigration
+    extend Neo4j::Migrations
+
+    class << self
+      def migrate!(version=nil)
+        _migrate!(self, Neo4j.ref_node, version)
+      end
+
+      def db_version
+        Neo4j.ref_node[:_db_version] || 0
+      end
+
+      # Remote all migration and set migrate_to = nil and set the current version to nil
+      def reset_migrations!
+        @migrations = nil
+        @migrate_to = nil
+        Neo4j::Transaction.run do
+          Neo4j.ref_node[:_db_version] = nil
+        end
+      end
+    end
+  end
+
+end

data/lib/neo4j/migrations/lazy_migration_mixin.rb

@@ -0,0 +1,47 @@
+module Neo4j
+
+  # Overrides the init_on_load method so that it will check if any migration is needed.
+  # The init_on_create method is also overriden 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 LazyMigrationMixin
+    extend ActiveSupport::Concern
+
+    included do
+      extend Neo4j::Migrations
+    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

data/lib/neo4j/migrations/migration.rb

@@ -0,0 +1,109 @@
+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
+
+    # 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 if transaction should automatically be created (default)
+    def auto_transaction(run_with_auto_tx)
+      @auto_transaction = run_with_auto_tx
+    end
+
+
+    # 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
+        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
+
+    # 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
+        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
+
+    def add_index_on(context, fields) #:nodoc:
+      context.all.each do |node|
+        fields.each do |field|
+          node.add_index(field)
+        end
+      end
+    end
+
+    def rm_index_on(context, fields) #:nodoc:
+      context.all.each do |node|
+        fields.each do |field|
+          node.rm_index(field)
+        end
+      end
+    end
+
+
+    def to_s
+      "Migration version: #{version}, name: #{name}"
+    end
+  end
+
+end

data/lib/neo4j/migrations/migration_mixin.rb

@@ -0,0 +1,78 @@
+module Neo4j
+
+
+  # By including this mixing on a node class one can add migrations to it.
+  # Each class has a unique db version.
+  #
+  # ==== Example
+  #
+  #  class Person
+  #    include Neo4j::NodeMixin
+  #    include MigrationMixin
+  #    rule :all  # adding the method all to make it possible to find all nodes of this class
+  #  end
+  #
+  #  Person.migration 1, :split_property do
+  #    up do
+  #      all.each_raw do |node|
+  #          node[:given_name] = node[:name].split[0]
+  #          node[:surname]    = node[:name].split[1]
+  #          node[:name]       = nil
+  #        end
+  #    end
+  #
+  #    down do
+  #      all.each_raw do |node|
+  #       node[:name]       = "#{node[:given_name]} #{node[:surname]}"
+  #       node[:surename]   = nil
+  #       node[:given_name] = nil
+  #      end
+  #    end
+  #  end
+  #
+  # Notice that the up and down methods are evaluated in the context of the class (where the all method is defined
+  # if using the rule :all).
+  #
+  module MigrationMixin
+    extend ActiveSupport::Concern
+
+    included do
+      extend Neo4j::Migrations
+    end
+
+    module ClassMethods
+      def migrate!(version=nil)
+        _migrate!(self, migration_meta_node, version)
+      end
+
+      # The node that holds the db version property
+      def migration_meta_node
+        Neo4j::Mapping::Rule.rule_node_for(self).rule_node
+      end
+
+      # Remote all migration and set migrate_to = nil and set the current version to nil
+      def reset_migrations!
+        @migrations = nil
+        @migrate_to = nil
+        Neo4j::Transaction.run do
+          migration_meta_node[:_db_version] = nil
+        end
+      end
+
+      # sets the migration db version for this class on a 'meta' node.
+      def db_version=(version)
+        Neo4j::Transaction.run do
+          migration_meta_node[:_db_version] = version
+        end
+      end
+
+      # returns the current version of the database for this class.
+      def db_version
+        migration_meta_node[:_db_version]
+      end
+    end
+
+  end
+
+
+end

data/lib/neo4j/migrations/migrations.rb

@@ -0,0 +1,100 @@
+module Neo4j
+  module Migrations
+
+    # 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::MigrationMixin::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
+

data/lib/neo4j/neo4j.rb

@@ -10,23 +10,27 @@
 module Neo4j
 
   class << self
-    
     # Start Neo4j using the default database.
     # This is usally not required since the database will be started automatically when it is used.
     #
-    def start
-      db = default_db
+    # ==== Parameters
+    # config_file :: (optionally) if this is nil or not given use the Neo4j::Config, otherwise setup the Neo4j::Config file using the provided YAML configuration file.
+    #
+    def start(config_file=nil)
+      Neo4j.config.default_file = config_file if config_file
       db.start unless db.running?
     end
 
 
-    # sets the default database to use
-    def default_db=(my_db)
+    # Sets the Neo4j::Database instance to use
+    # An Neo4j::Database instance wraps both the Neo4j Database and Lucene Database.
+    def db=(my_db)
       @db = my_db
     end
 
-    # Returns default database. Creates a new one if it does not exist, but does not start it.
-    def default_db
+    # Returns the database holding references to both the Neo4j Graph Database and the Lucene Database.
+    # Creates a new one if it does not exist, but does not start it.
+    def db
       @db ||= Database.new
     end
 
@@ -36,11 +40,31 @@ module Neo4j
     
     # Returns a started db instance. Starts it's not running.
     def started_db
-      db = default_db
       db.start unless db.running?
       db
     end
 
+    # Returns the Neo4j::Config class
+    # Same as typing; Neo4j::Config
+    def config
+      Neo4j::Config
+    end
+
+    def logger
+      @logger ||= Neo4j::Config[:logger] || default_logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def default_logger #:nodoc:
+      require 'logger'
+      logger = Logger.new(STDOUT)
+      logger.sev_threshold = Neo4j::Config[:logger_level] || Logger::INFO
+      logger
+    end
+
 
     # Returns an unstarted db instance
     #
@@ -87,7 +111,7 @@ module Neo4j
 
     # Returns the Neo4j::EventHandler
     #
-    def event_handler(this_db = default_db)
+    def event_handler(this_db = db)
       this_db.event_handler
     end
     

data/lib/neo4j/node_relationship.rb

@@ -53,8 +53,7 @@ module Neo4j
       if type
         NodeTraverser.new(self).outgoing(type)
       else
-        raise "not implemented yet"
-        NodeTraverser.new(self)
+        raise "Not implemented getting all types of outgoing relationship. Specify a relationship type"
       end
     end
 
@@ -67,8 +66,7 @@ module Neo4j
       if type
         NodeTraverser.new(self).incoming(type)
       else
-        raise "not implemented yet"
-        NodeTraverser.new(self)
+        raise "Not implemented getting all types of incoming relationship. Specify a relationship type"
       end
     end