neo4j 1.0.0.beta.9 → 1.0.0.beta.10

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

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

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

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