neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/migrations/extensions.rb

@@ -1,58 +0,0 @@
-module Neo4j
-
-  class << self
-    extend Forwardable
-
-    ##
-    # Returns the current version of the database.
-    # This version has been set by running one or more migrations.
-    # The version is stored on the reference node, with property 'db_version'
-    # (It Delegates to the Reference Node)
-    #
-    # ==== See Also
-    # Neo4j::Migrations::RefNodeWrapper#db_version
-    #
-    # :singleton-method: db_version
-
-    ##
-    # Force Neo4j.rb to perform migrations
-    #
-    # ==== See Also
-    #
-    # Neo4j::Migrations::RefNodeWrapper#migrate!
-    #
-    # :singleton-method: migrate!
-
-    ##
-    # Specifies a single migration.
-    # The up and down methods are automatically wrapped in a transaction.
-    #
-    # === Example
-    #
-    #   Neo4j.migration 1, :create_articles do
-    #    up do
-    #      Neo4j.ref_node.rels.outgoing(:colours) << Neo4j.Node.new(:colour => 'red')  << Neo4j.Node.new(:colour => 'blue')
-    #    end
-    #    down do
-    #      Neo4j.ref_node.rels.outgoing(:colours).each {|n| n.del }
-    #    end
-    #  end
-    #
-    # ==== See Also
-    # Neo4j::Migrations::ClassMethods#migration
-    #
-    # :singleton-method: migration
-
-    ##
-    # Returns all migrations that has been defined.
-    #
-    # ==== See Also
-    # Neo4j::Migrations::ClassMethods#migrations
-    #
-    # :singleton-method: migrations
-
-
-    def_delegators :'Neo4j::Migrations::RefNodeWrapper', :db_version, :migrate!, :migrations, :migration
-
-  end
-end

data/lib/neo4j/migrations/lazy_node_mixin.rb

@@ -1,41 +0,0 @@
-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
-      def self.included(base)
-        base.extend Neo4j::Migrations::ClassMethods
-        base.property :_db_version if base.respond_to?(:property)
-      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,112 +0,0 @@
-module Neo4j
-
-  module Migrations
-
-    # 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
-end

data/lib/neo4j/migrations/migrations.rb

@@ -1,6 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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::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
-end

data/lib/neo4j/migrations/ref_node_wrapper.rb

@@ -1,32 +0,0 @@
-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/model.rb

@@ -1,4 +0,0 @@
-module Neo4j
-  # make an alias so that we don't have to write the long name Neo4j::Rails::Model
-  Model = Neo4j::Rails::Model
-end

data/lib/neo4j/neo4j.rb

@@ -1,216 +0,0 @@
-# external neo4j dependencies
-require 'neo4j/config'
-require 'neo4j/database'
-
-# = Neo4j
-#
-# The Neo4j modules is used to interact with an Neo4j Database instance.
-# You can for example start and stop an instance and list all the nodes that exist in the database.
-#
-# === Starting and Stopping Neo4j
-# You don't normally need to start the Neo4j database since it will be automatically started when needed.
-# Before the database is started you should configure where the database is stored, see Neo4j::Config.
-#
-module Neo4j
-
-  # The version of the Neo4j jar files
-  NEO_VERSION = Neo4j::Community::VERSION
-
-  class << self
-    # Start Neo4j using the default database.
-    # This is usally not required since the database will be started automatically when it is used.
-    # If the global variable $NEO4J_SERVER is defined then it will use that as the Java Graph DB. This can
-    # be used if you want to embed neo4j.rb and already got an instance of the Java Neo4j Database service.
-    #
-    # ==== 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.
-    # external_db :: (optionally) use this Java Neo4j instead of creating a new neo4j database service
-    def start(config_file=nil, external_db = $NEO4J_SERVER)
-      return if @db && @db.running?
-
-      Neo4j.config.default_file = config_file if config_file
-      if external_db
-        @db ||= Database.new
-        self.db.start_external_db(external_db)
-      else
-        db.start
-      end
-    end
-
-
-    # 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 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
-
-    def read_only?
-      @db && @db.graph && @db.graph.read_only?
-    end
-
-    # Returns a started db instance. Starts it's not running.
-    # if $NEO4J_SERVER is defined then use that Java Neo4j Database service instead of creating a new one.
-    def started_db
-      start unless db.running?
-      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
-      Neo4j::Config
-    end
-
-    # Executes a Cypher Query
-    # Check the neo4j http://docs.neo4j.org/chunked/milestone/cypher-query-lang.html
-    # Returns an enumerable of hash values.
-    #
-    # === Usage
-    #
-    #  q = Neo4j.query("START n=node({node}) RETURN n", 'node' => @node.neo_id)
-    #  q.first['n'] #=> the @node
-    #  q.columns.first => 'n'
-    #
-    def query(query, params = {})
-      engine = org.neo4j.cypher.javacompat.ExecutionEngine.new(db)
-      engine.execute(query, params)
-    end
-
-
-    # Returns the logger used by neo4j.
-    # If not specified (with Neo4j.logger=) it will use the standard Ruby logger.
-    # You can change standard logger threshold by configuration :logger_level.
-    #
-    # You can also specify which logger class should take care of logging with the
-    # :logger configuration.
-    #
-    # ==== Example
-    #
-    #  Neo4j::Config[:logger] = Logger.new(STDOUT)
-    #  Neo4j::Config[:logger_level] = Logger::ERROR
-    #
-    def logger
-      @logger ||= Neo4j::Config[:logger] || default_logger
-    end
-
-    # Sets which logger should be used.
-    # If this this is not called then the standard Ruby logger will be used.
-    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
-    #
-    # This is typically used for configuring the database, which must sometimes
-    # be done before the database is started
-    # if the database was already started an exception will be raised
-    def unstarted_db
-      @db ||= Database.new
-      raise "database was already started" if @db.running?
-      @db
-    end
-
-    # returns true if the database is running
-    def running?
-      @db && @db.running?
-    end
-
-
-    # Stops this database
-    # There are Ruby hooks that will do this automatically for you.
-    #
-    def shutdown(this_db = @db)
-      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)
-      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 Management JMX Bean.
-    #
-    # Notice that this information is also provided by the jconsole Java tool, check http://wiki.neo4j.org/content/Monitoring_and_Deployment
-    # and http://docs.neo4j.org/chunked/milestone/operations-monitoring.html
-    #
-    # By default it returns the Primitivies JMX Bean that can be used to find number of nodes in use.
-    #
-    # ==== Example Neo4j Primititives
-    #
-    #   Neo4j.management.get_number_of_node_ids_in_use
-    #   Neo4j.management.getNumberOfPropertyIdsInUse
-    #   Neo4j.management.getNumberOfRelationshipIdsInUse
-    #   Neo4j.management.get_number_of_relationship_type_ids_in_use
-    #
-    # ==== Example Neo4j HA Cluster Info
-    #
-    # Neo4j.management(org.neo4j.management.HighAvailability).isMaster
-    #
-    # ==== Arguments
-    #
-    # jmx_clazz :: http://api.neo4j.org/current/org/neo4j/management/package-summary.html
-    # this_db :: default currently runnig instance or a newly started neo4j db instance
-    #
-    def management(jmx_clazz = org.neo4j.jmx.Primitives, this_db = self.started_db)
-      this_db.management(jmx_clazz)
-    end
-
-    # Returns an Enumerable object for all nodes in the database
-    def all_nodes(this_db = self.started_db)
-      Enumerator.new(this_db, :each_node)
-    end
-
-    # Same as #all_nodes but does not return wrapped nodes but instead raw java node objects.
-    def _all_nodes(this_db = self.started_db)
-      Enumerator.new(this_db, :_each_node)
-    end
-
-    # Returns the Neo4j::EventHandler
-    #
-    def event_handler(this_db = db)
-      this_db.event_handler
-    end
-
-  end
-end