neo4j 1.0.0.beta.1

data/lib/neo4j.old/mixins/java_relationship_mixin.rb

@@ -0,0 +1,60 @@
+# This is a mixin that is used to extend the java object org.neo4j.graphdb.Relationship
+#
+module Neo4j::JavaRelationshipMixin
+
+  # Deletes this relationship.
+  #
+  def del
+    Neo4j.event_handler.relationship_deleted(wrapper)
+    type = getType().name()
+
+    delete
+
+    if end_node.class.respond_to?(:indexer)
+      end_node.class.indexer.on_relationship_deleted(end_node, type)
+    elsif end_node.wrapper?
+      end_node.wrapper_class.indexer.on_relationship_deleted(end_node.wrapper, type)
+    end
+  end
+
+  # Returns the end node of this relationship
+  def end_node
+    id = getEndNode.getId
+    Neo4j.load_node(id)
+  end
+
+  # Returns the start node of this relationship
+  def start_node
+    id = getStartNode.getId
+    Neo4j.load_node(id)
+  end
+
+  # A convenience operation that, given a node that is attached to this relationship, returns the other node.
+  # For example if node is a start node, the end node will be returned, and vice versa.
+  # This is a very convenient operation when you're manually traversing the node space by invoking one of the #rels operations on node.
+  #
+  # This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
+  #
+  # ==== Example
+  # For example, to get the node "at the other end" of a relationship, use the following:
+  #   Node endNode = node.rel(:some_rel_type).other_node(node)
+  #
+  def other_node(node)
+    neo_node = node
+    neo_node = node._java_node if node.respond_to?(:_java_node)
+    id = getOtherNode(neo_node).getId
+    Neo4j.load_node(id)
+  end
+
+
+  # Returns the neo relationship type that this relationship is used in.
+  # (see java API org.neo4j.graphdb.Relationship#getType  and org.neo4j.graphdb.RelationshipType)
+  #
+  # ==== Returns
+  # the relationship type (of type Symbol)
+  #
+  def relationship_type
+    get_type.name.to_sym
+  end
+
+end

data/lib/neo4j.old/mixins/migration_mixin.rb

@@ -0,0 +1,157 @@
+module Neo4j
+
+
+  # By including this mixing on a node class one can add migrations to it.
+  # Adds a db_version attribute on the class including this mixin.
+  # 
+  module MigrationMixin
+
+    # Returns the current version of the database of the class including this Mixin.
+    #
+    def db_version
+      Neo4j::Transaction.run {self[:db_version] || 0}
+    end
+
+
+    # Force one or more migrations to occur if not already done yet.
+    # Will check the current db_version with the given 'to_version' and perform
+    # migrations. If the 'to_version' parameter is not given then it will upgrade the
+    # database with all migrations it can find.
+    #
+    # === Parameters
+    # to_version:: the version we want to migrate to, if not given then all migrations will be run
+    # verbose:: if it should print out information of which migration is run
+    #
+    def migrate!(to_version=nil, verbose = false)
+      return if self.class.migrations.nil? || self.class.migrations.empty?
+
+
+      # which version should we go to if to_version was not provided ?
+      to_version ||= self.class.migrations.keys.sort.reverse[0]
+      puts "Migration: Curr ver #{db_version} need upgrade to version #{to_version}" if verbose
+
+      # do we need to migrate ?
+      return if db_version == to_version
+
+      # ok, so we are running some migrations
+      if (db_version < to_version)
+        upgrade( (db_version+1).upto(to_version).collect { |ver| self.class.migrations[ver] }, verbose )
+      else
+        downgrade( db_version.downto(to_version+1).collect { |ver| self.class.migrations[ver] }, verbose )
+      end
+    end
+
+    # Running the up method on the given migrations.
+    #
+    # === Parameters
+    # migrations:: an enumerable of Migration objects
+    def upgrade(migrations, verbose=false)
+      migrations.each do |m|
+        puts "Running upgrade migration #{m.version} - #{m.name}"  if verbose
+        m.up_migrator.execute(self, m.version, &m.up_block)
+      end
+    end
+
+    # Running the down method on the given migrations.
+    #
+    # === Parameters
+    # migrations:: an enumerable of Migration objects
+    def downgrade(migrations, verbose=false)
+      migrations.each do |m|
+        puts "Running downgrade migration #{m.version} - #{m.name}" if verbose
+        m.down_migrator.execute(self, m.version-1, &m.down_block)
+      end
+    end
+
+    def self.included(c) # :nodoc:
+      c.extend Neo4j::MigrationMixin::ClassMethods
+    end
+
+    module ClassMethods
+      attr_accessor :migrations, :migrate_to
+
+      # Specifies a migration to be performed.
+      #
+      # === 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)
+        @migrations ||= {}
+        migration = Migration.new(version, name)
+        migration.instance_eval(&block)
+        @migrations[version] = migration
+      end
+
+      # This is used for lazy migration. It stores the version that we want to upgrade to but does not perform the migrations.
+      # Only when the node is being loaded from the database  (Neo4j::NodeMixin#init_with_node) then
+      # it will check and see if one or more migration is needed to be performed.
+      #
+      def migrate!(to_version=nil)
+        @migrate_to = to_version
+      end
+    end
+
+    # This is the context in which the Migrations DSL are evaluated in.
+    class Migration < Struct.new(:version, :name)
+      attr_reader :up_block, :down_block, :up_migrator, :down_migrator
+
+      # Specifies a code block which is run when the migration is upgraded.
+      #
+      # === Parameters
+      # migrator:: Default Neo4j::MigrationMixin::Migrator - used to execute the block
+      def up(migrator = Migrator, &block)
+        @up_block = block
+        @up_migrator = migrator
+      end
+
+      # Specifies a code block which is run when the migration is upgraded.
+      #
+      # === Parameters
+      # migrator:: Default Neo4j::MigrationMixin::Migrator - used to execute the block
+      def down(migrator = Migrator, &block)
+        @down_block = block
+        @down_migrator = migrator
+      end
+
+      def to_s
+        "Migration version: #{version}, name: #{name}"
+      end
+    end
+
+    # Responsible for running a migration
+    class Migrator
+      class << self
+        # Runs given migration block. If successful it will set the property
+        # ':db_version' on the given context.
+        #
+        # === Parameters
+        # context:: the context on which the block is evaluated in
+        # version:: optional, if given then will set the property db_version on the context
+        def execute(context, version=nil, &block)
+          context.instance_eval &block
+          Neo4j::Transaction.run { context[:db_version] = version} if version
+        end
+      end
+    end
+  end
+
+
+  # Overrides the init method so that it will check if any migration is needed.
+  # Migration might take place when the node is loaded.
+  #
+  module LazyMigrationMixin
+    def init_with_node(java_node) # :nodoc:
+      super # call Neo4j::NodeMixin#init_with_node
+      migrate! self.class.migrate_to # for lazy migrations
+    end
+  end
+end
+

data/lib/neo4j.old/mixins/node_mixin.rb

@@ -0,0 +1,249 @@
+module Neo4j
+
+
+  # Represents a node in the Neo4j space.
+  # 
+  # Is a wrapper around a Java Neo4j::Node (org.neo4j.graphdb.Node)
+  # The following methods are delegated to the Java Neo4j::Node
+  #   []=, [], property?, props, update, neo_id, rels, rel?, to_param
+  #   rel, del, list?, list, lists, print, add_rel, outgoing, incoming,
+  #   next, prev, next=, prev=, head
+  #
+  # Those methods are defined in included mixins
+  # This mixin also include the class method in the
+  #
+  # === Included Mixins
+  # * Neo4j::JavaPropertyMixin - instance methods for properties
+  # * Neo4j::JavaNodeMixin - instance methods
+  # * Neo4j::JavaListMixin - instance methods for list methods
+  # * Neo4j::RelClassMethods - class methods for generating relationship accessors
+  # * Neo4j::PropertyClassMethods - class methods for generating property accessors
+  #
+  module NodeMixin
+    extend Forwardable
+
+    def_delegators :@_java_node, :[]=, :[], :property?, :props, :update, :neo_id, :rels, :rel?, :to_param,
+                   :rel, :del, :list?, :list, :lists, :print, :print_sub, :add_rel, :outgoing, :incoming,
+                   :add_list_item_methods, :next, :prev, :next=, :prev=, :head # used for has_list, defined in Neo4j::JavaListMixin
+
+
+    # --------------------------------------------------------------------------
+    # Initialization methods
+    #
+
+
+    # Initialize the the neo node for this instance.
+    # Will create a new transaction if one is not already running.
+    # 
+    # Does
+    # * sets the neo4j property '_classname' to self.class.to_s
+    # * creates a neo4j node java object (in @_java_node)
+    # * calls init_node if that is defined in the current class.
+    #
+    # If you want to provide your own initialize method you should instead implement the
+    # method init_node method.
+    #
+    # === Example
+    #
+    #   class MyNode
+    #     include Neo4j::NodeMixin
+    #
+    #     def init_node(name, age)
+    #        self[:name] = name
+    #        self[:age] = age
+    #     end
+    #   end
+    #
+    #   node = MyNode('jimmy', 23)
+    #   # or also possible
+    #   node = MyNode :name => 'jimmy', :age => 12
+    #
+    # The init_node is only called when the node is created in the database.
+    # The initialize method is used both for to purposes:
+    # loading an already existing node from the Neo4j database and creating a new node in the database.
+    #
+    def initialize(*args)
+      # was a neo java node provided ?
+      if args.length == 1 && args[0].kind_of?(org.neo4j.graphdb.Node)
+        # yes, it was loaded from the database
+        init_with_node(args[0])
+      elsif self.respond_to?(:init_node)
+        # does the class provide an initialization method ?
+        init_without_node({})
+        init_node(*args)
+      else
+        # no, but maybe it had a hash of properties to initialize it with, create node
+        init_without_node(args[0] || {})
+      end
+      # was a block given in order to initialize the neo4j node ?
+      yield self if block_given?
+      # must call super with no arguments so that chaining of the initialize method works
+      super()
+    end
+
+
+    # Inits this node with the specified java neo node
+    #
+    def init_with_node(java_node) # :nodoc:
+      @_java_node = java_node
+      java_node._wrapper=self
+    end
+
+    # Returns the org.neo4j.graphdb.Node wrapped object
+    def _java_node
+      @_java_node
+    end
+
+    # Creates a new node and initialize with given properties.
+    #
+    def init_without_node(props) # :nodoc:
+      props[:_classname] = self.class.to_s
+      @_java_node = Neo4j.create_node props
+      update_index if props && !props.empty?
+      @_java_node._wrapper = self
+      Neo4j.event_handler.node_created(self)
+    end
+
+
+    # Since we sometimes don't know if we have a java node or a wrapped Ruby node we need this so that we
+    # always can call this method
+    def wrapper # :nodoc:
+      self
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Property methods
+    #
+
+
+    # Creates a struct class containing all properties of this class.
+    # This value object can be used from Ruby on Rails RESTful routing.
+    #
+    # ==== Example
+    #
+    # h = Person.value_object.new
+    # h.name    # => nil
+    # h.name='kalle'
+    # h[:name]   # => 'kalle'
+    #
+    # ==== Returns
+    # a value object struct
+    #
+    def value_object
+      vo = self.class.value_object.new
+      vo._update(props)
+      vo
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Equal and hash methods
+    #
+
+    def equal?(o)
+      eql?(o)
+    end
+
+    def eql?(o)
+      o.kind_of?(NodeMixin) && o._java_node == @_java_node
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+    def hash
+      @_java_node.hashCode
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Update and Delete methods
+    #
+
+
+    # Specifies which relationships should be ignored when trying to cascade delete a node.
+    # If a node does not have any relationships (except those specified here to ignore) it will be cascade deleted
+    #
+    def ignore_incoming_cascade_delete?(relationship) # :nodoc:
+      # ignore relationship with property _cascade_delete_incoming
+      relationship.property?(:_cascade_delete_incoming)
+    end
+
+    # Updates the index for this node.
+    # This method will be automatically called when needed
+    # (a property changed or a relationship was created/deleted)
+    #
+    def update_index # :nodoc:
+      self.class.indexer.index(self)
+    end
+
+    # --------------------------------------------------------------------------
+    # Relationship methods
+    #
+
+    # Returns a Neo4j::Relationships::NodeTraverser object for traversing nodes from and to this node.
+    # The Neo4j::Relationships::NodeTraverser is an Enumerable that returns Neo4j::NodeMixin objects.
+    #
+    # ==== Example
+    #
+    #   person_node.traverse.outgoing(:friends).each { ... }
+    #   person_node.traverse.outgoing(:friends).raw.each { }
+    #
+    # The raw false parameter means that the ruby wrapper object will not be loaded, instead the raw Java Neo4j object will be used,
+    # it might improve the performance.
+    #
+    def traverse(*args)
+      if args.empty?
+        Neo4j::Relationships::NodeTraverser.new(self)
+      else
+        @_java_node.traverse(*args)
+      end
+
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Private methods
+    #
+
+    def _to_java_direction(dir) # :nodoc:
+      case dir
+        when :outgoing
+          org.neo4j.graphdb.Direction::OUTGOING
+        when :incoming
+          org.neo4j.graphdb.Direction::INCOMING
+        when :both
+          org.neo4j.graphdb.Direction::BOTH
+        else
+          raise "Unknown parameter: '#{dir}', only accept :outgoing, :incoming or :both"
+      end
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Hooks
+    #
+
+
+    # Adds class methods from
+    #
+    # * Neo4j::RelClassMethods
+    # * Neo4j::PropertyClassMethods
+    #
+    def self.included(c) # :nodoc:
+      c.instance_eval do
+        # these constants are used in the Neo4j::RelClassMethods and Neo4j::PropertyClassMethods
+        # they are defined here since they should only be defined once -
+        # all subclasses share the same index, declared properties and index_updaters
+        const_set(:ROOT_CLASS, self)
+        const_set(:DECL_RELATIONSHIPS, {})
+        const_set(:PROPERTIES_INFO, {})
+      end unless c.const_defined?(:DECL_RELATIONSHIPS)
+
+      c.extend Neo4j::RelClassMethods
+      c.extend Neo4j::PropertyClassMethods
+    end
+  end
+end