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

data/lib/neo4j/migrations/migrations.rb

@@ -1,100 +1,6 @@
-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
-
+require 'neo4j/migrations/extensions'
+require 'neo4j/migrations/class_methods'
+require 'neo4j/migrations/migration'
+require 'neo4j/migrations/lazy_node_mixin'
+require 'neo4j/migrations/node_mixin'
+require 'neo4j/migrations/ref_node_wrapper'

data/lib/neo4j/migrations/node_mixin.rb

@@ -0,0 +1,80 @@
+module Neo4j
+  module Migrations
+
+
+    # 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 Neo4j::Migrations::NodeMixin
+    #    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 NodeMixin
+      extend ActiveSupport::Concern
+
+      included do
+        extend Neo4j::Migrations::ClassMethods
+      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::Rule::RuleEventListener.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
+end

data/lib/neo4j/migrations/ref_node_wrapper.rb

@@ -0,0 +1,32 @@
+module Neo4j
+
+  module Migrations
+    # 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 RefNodeWrapper
+      extend ClassMethods
+
+      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
+
+end

data/lib/neo4j/neo4j.rb

@@ -1,3 +1,7 @@
+# external neo4j dependencies
+require 'neo4j/config'
+require 'neo4j/database'
+
 # = Neo4j
 #
 # The Neo4j modules is used to interact with an Neo4j Database instance.
@@ -44,6 +48,13 @@ module Neo4j
       db
     end
 
+    # Returns the current storage path of a running neo4j database.
+    # If the database is not running it returns nil.
+    def storage_path
+      return nil unless db.running?
+      db.storage_path
+    end
+
     # Returns the Neo4j::Config class
     # Same as typing; Neo4j::Config
     def config

data/lib/neo4j/node.rb

@@ -1,52 +1,43 @@
-module Neo4j
-
+# external neo4j dependencies
+require 'neo4j/property/property'
+require 'neo4j/rels/rels'
+require 'neo4j/traversal/traversal'
+require 'neo4j/index/index'
+require 'neo4j/equal'
+require 'neo4j/load'
 
+module Neo4j
 
   org.neo4j.kernel.impl.core.NodeProxy.class_eval do
     include Neo4j::Property
-    include Neo4j::NodeRelationship
+    include Neo4j::Rels
+    include Neo4j::Traversal
     include Neo4j::Equal
     include Neo4j::Index
 
-    # Delete the node and all its relationship.
-    #
-    # It might raise an exception if this method was called without a Transaction,
-    # or if it failed to delete the node (it maybe was already deleted).
-    #
-    # If this method raise an exception you may also get an exception when the transaction finish.
-    #
-    # ==== Returns
-    # nil or raise an exception
-    #
-    def del
+    def del #:nodoc:
       rels.each {|r| r.del}
       delete
       nil
     end
 
-    # returns true if the node exists in the database
-    def exist?
+    def exist?  #:nodoc:
       Neo4j::Node.exist?(self)
     end
 
-    # same as _java_node
-    # Used so that we have same method for both relationship and nodes
-    def wrapped_entity
+    def wrapped_entity  #:nodoc:
       self
     end
     
-    # Loads the Ruby wrapper for this node 
-    # If there is no _classname property for this node then it will simply return itself.
-    # Same as Neo4j::Node.wrapper(node)
-    def wrapper
+    def wrapper  #:nodoc:
       self.class.wrapper(self)
     end
 
-    def _java_node
+    def _java_node  #:nodoc:
       self
     end
 
-    def class
+    def class  #:nodoc:
       Neo4j::Node
     end
   end
@@ -76,6 +67,45 @@ module Neo4j
 
     self.node_indexer self
 
+
+    ##
+    # :method: del
+    # Delete the node and all its relationship.
+    #
+    # It might raise an exception if this method was called without a Transaction,
+    # or if it failed to delete the node (it maybe was already deleted).
+    #
+    # If this method raise an exception you may also get an exception when the transaction finish.
+    # This method is  defined in the  org.neo4j.kernel.impl.core.NodeProxy which is return by Neo4j::Node.new
+    #
+    # ==== Returns
+    # nil or raise an exception
+    #
+
+    ##
+    # :method: exist?
+    # returns true if the node exists in the database
+    # This method is  defined in the  org.neo4j.kernel.impl.core.NodeProxy which is return by Neo4j::Node.new
+
+    ##
+    # :method: wrapped_entity
+    # same as _java_node
+    # Used so that we have same method for both relationship and nodes
+    # This method is  defined in the  org.neo4j.kernel.impl.core.NodeProxy which is return by Neo4j::Node.new
+
+    ##
+    # :method: wrapper
+    # Loads the Ruby wrapper for this node (unless it is already the wrapper).
+    # If there is no _classname property for this node then it will simply return itself.
+    # Same as Neo4j::Node.wrapper(node)
+    # This method is  defined in the  org.neo4j.kernel.impl.core.NodeProxy which is return by Neo4j::Node.new
+
+
+    ##
+    # :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
+    
     class << self
 
       # Returns a new neo4j Node.

data/lib/neo4j/{mapping/class_methods/init_node.rb → node_mixin/class_methods.rb}

@@ -1,6 +1,6 @@
-module Neo4j::Mapping
-  module ClassMethods
-    module InitNode
+module Neo4j
+  module NodeMixin
+    module ClassMethods
 
       def load_wrapper(node)
         wrapped_node = self.orig_new

data/lib/neo4j/{mapping → node_mixin}/node_mixin.rb

@@ -1,7 +1,18 @@
+# external third party dependencies
 require "active_support/core_ext/module/delegation"
 
-module Neo4j::Mapping
+# external neo4j dependencies
+require 'neo4j/index/index'
+require 'neo4j/property/property'
+require 'neo4j/has_n/has_n'
+require 'neo4j/rule/rule'
+require 'neo4j/has_list/has_list'
 
+# internal dependencies
+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.
@@ -11,30 +22,31 @@ module Neo4j::Mapping
   # Mixins:
   # * Neo4j::Index
   # * Neo4j::Property
-  # * Neo4j::NodeRelationship
+  # * Neo4j::Rels
   # * Neo4j::Equal
   # * Neo4j::Index
   #
   # === Class Methods
   #
   # Mixins:
-  # * Neo4j::Mapping::ClassMethods::Root
-  # * Neo4j::Mapping::ClassMethods::Property
-  # * Neo4j::Mapping::ClassMethods::InitNode
-  # * Neo4j::Mapping::ClassMethods::Relationship
-  # * Neo4j::Mapping::ClassMethods::Rule
-  # * Neo4j::Mapping::ClassMethods::List
+  # * Neo4j::NodeMixin::ClassMethods
+  # * Neo4j::Property::ClassMethods
+  # * Neo4j::HasN::ClassMethods
+  # * Neo4j::Rule::ClassMethods
   # * Neo4j::Index::ClassMethods
+  # * Neo4j::HasList::ClassMethods
+  #
+  # This class also includes the class mixin WillPaginate::Finders::Base, see http://github.com/mislav/will_paginate/wiki
   #
   module NodeMixin
     include Neo4j::Index
 
-    include Neo4j::Functions
+    include Neo4j::Rule::Functions
 
     delegate :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
              :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both, :expand, :get_property, :set_property,
              :equal?, :eql?, :==, :exist?, :getRelationships, :getSingleRelationship, :_rels, :rel, :wrapped_entity,
-             :to => :@_java_node, :allow_nil => true 
+             :to => :@_java_node, :allow_nil => true
 
 
     # --------------------------------------------------------------------------
@@ -55,7 +67,7 @@ module Neo4j::Mapping
     def init_on_create(*args) # :nodoc:
       self[:_classname] = self.class.to_s
       if args[0].respond_to?(:each_pair)
-        args[0].each_pair { |k, v| respond_to?("#{k}=")? self.send("#{k}=", v) : @_java_node[k] = v }
+        args[0].each_pair { |k, v| respond_to?("#{k}=") ? self.send("#{k}=", v) : @_java_node[k] = v }
       end
     end
 
@@ -64,6 +76,10 @@ module Neo4j::Mapping
       @_java_node
     end
 
+    # Trigger rules.
+    # You don't normally need to call this method (except in Migration) since
+    # it will be triggered automatically by the Neo4j::Rule::RuleEventListener
+    #
     def trigger_rules
       self.class.trigger_rules(self)
     end
@@ -72,7 +88,8 @@ module Neo4j::Mapping
     def _decl_rels_for(rel_type)
       self.class._decl_rels[rel_type]
     end
-    
+
+    # Returns self. Implements the same method as the Neo4j::Node#wrapper - duck typing.
     def wrapper
       self
     end
@@ -91,11 +108,11 @@ module Neo4j::Mapping
       c.class_inheritable_hash :_decl_rels
       c._decl_rels ||= {}
 
-      c.extend ClassMethods::Property
-      c.extend ClassMethods::InitNode
-      c.extend ClassMethods::Relationship
-      c.extend ClassMethods::Rule
-      c.extend ClassMethods::List
+      c.extend ClassMethods
+      c.extend Neo4j::Property::ClassMethods
+      c.extend Neo4j::HasN::ClassMethods
+      c.extend Neo4j::Rule::ClassMethods
+      c.extend Neo4j::HasList::ClassMethods
       c.extend Neo4j::Index::ClassMethods
       c.extend WillPaginate::Finders::Base
 
@@ -112,4 +129,4 @@ module Neo4j::Mapping
       c.node_indexer c
     end
   end
-end
+end