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

data/lib/neo4j/relationship.rb

@@ -1,239 +0,0 @@
-# external neo4j dependencies
-require 'neo4j/property/property'
-require 'neo4j/index/index'
-require 'neo4j/equal'
-require 'neo4j/load'
-require 'neo4j/to_java'
-
-module Neo4j
-
-
-  #
-  # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
-  # You can attach properties to relationships with the API specified in Neo4j::JavaPropertyMixin.
-  #
-  # Relationship are created by invoking the << operator on the rels method on the node as follow:
-  #  node.outgoing(:friends) << other_node << yet_another_node
-  #
-  # or using the Neo4j::Relationship#new method (which does the same thing):
-  #  rel = Neo4j::Relationship.new(:friends, node, other_node)
-  #
-  # The fact that the relationship API gives meaning to start and end nodes implicitly means that all relationships have a direction.
-  # In the example above, rel would be directed from node to otherNode.
-  # A relationship's start node and end node and their relation to outgoing and incoming are defined so that the assertions in the following code are true:
-  #
-  #   a = Neo4j::Node.new
-  #   b = Neo4j::Node.new
-  #   rel = Neo4j::Relationship.new(:some_type, a, b)
-  #   # Now we have: (a) --- REL_TYPE ---> (b)
-  #
-  #    rel.start_node # => a
-  #    rel.end_node   # => b
-  #
-  # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
-  # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-null nodes.
-  #
-  # === Wrapping
-  #
-  # Notice that the Neo4j::Relationship.new does not create a Ruby object. Instead, it returns a Java 
-  # org.neo4j.graphdb.Relationship object which has been modified to feel more rubyish (like Neo4j::Node).
-  #
-  # === See also
-  # * Neo4j::RelationshipMixin if you want to wrap a relationship with your own Ruby class.
-  # * http://api.neo4j.org/1.4/org/neo4j/graphdb/Relationship.html
-  #
-  # === Included Mixins
-  # * Neo4j::Property
-  # * Neo4j::Equal
-  #
-  # (Those mixin are actually not included in the Neo4j::Relationship but instead directly included in the java class org.neo4j.kernel.impl.core.RelationshipProxy)
-  #
-  class Relationship
-    extend Neo4j::Index::ClassMethods
-
-    self.rel_indexer self
-
-    class << self
-      include Neo4j::Load
-      include Neo4j::ToJava
-
-
-      ##
-      # :method: start_node
-      #
-      # Returns the start node of this relationship
-
-
-      ##
-      # :method: end_node
-      #
-      # Returns the end node of this relationship
-
-      ##
-      # :method: other_node
-      #
-      # 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
-      # method on a node. For example, to get the node "at the other end" of a relationship, use the following:
-      #
-      #   end_node = node.rels.first.other_node(node)
-      #
-      # This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
-      #
-      # === Parameters 
-      # 
-      # node :: the node that we don't want to return
-      
-
-      ##
-      # :method: del
-      #
-      # Deletes this relationship. Invoking any methods on this relationship after delete() has returned is invalid and will lead t
-
-      # :method rel_type
-      #
-      # Returns the type of this relationship.
-      # A relationship's type is an immutable attribute that is specified at Relationship creation.
-      # The relationship type is othen used when traversing nodes, example finding all the 
-      # outgoing nodes of relationship type :friends 
-      #  
-      #  node.outgoing(:friends)
-
-      # Returns a org.neo4j.graphdb.Relationship java object (!)
-      # Will trigger a event that the relationship was created.
-      #
-      # === Parameters
-      # type :: the type of relationship
-      # from_node :: the start node of this relationship
-      # end_node  :: the end node of this relationship
-      # props :: optional properties for the created relationship
-      #
-      # === Returns
-      # org.neo4j.graphdb.Relationship java object
-      #
-      # === Examples
-      #
-      #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
-      #
-      def new(type, start_node, end_node, props=nil)
-        java_type = type_to_java(type)
-        rel = start_node._java_node.create_relationship_to(end_node._java_node, java_type)
-        props.each_pair {|k,v| rel[k] = v} if props
-        rel
-      end
-
-      # create is the same as new
-      alias_method :create, :new
-
-      # Loads a relationship or wrapped relationship given a native java relationship or an id.
-      # If there is a Ruby wrapper for the node then it will create a Ruby object that will
-      # wrap the java node (see Neo4j::RelationshipMixin).
-      #
-      # If the relationship does not exist it will return nil
-      #
-      def load(rel_id, db = Neo4j.started_db)
-        rel = _load(rel_id, db)
-        return nil if rel.nil?
-        rel.wrapper
-      end
-
-      # Same as load but does not return the node as a wrapped Ruby object.
-      #
-      def _load(rel_id, db = Neo4j.started_db)
-        return nil if rel_id.nil?
-        rel = db.graph.get_relationship_by_id(rel_id.to_i)
-        rel.hasProperty('_classname')  # since we want a IllegalStateException which is otherwise not triggered
-        rel
-      rescue java.lang.IllegalStateException
-        nil # the node has been deleted
-      rescue org.neo4j.graphdb.NotFoundException
-        nil
-      end
-
-      def extend_java_class(java_clazz)  #:nodoc:
-        java_clazz.class_eval do
-            include Neo4j::Property
-            include Neo4j::Equal
-
-            alias_method :_end_node, :getEndNode
-            alias_method :_start_node, :getStartNode
-            alias_method :_other_node, :getOtherNode
-
-
-            # Deletes the relationship between the start and end node
-            #
-            # May raise an exception if delete was unsuccessful.
-            #
-            # ==== Returns
-            # nil
-            #
-            def del
-              delete
-            end
-
-            def end_node # :nodoc:
-              getEndNode.wrapper
-            end
-
-            def start_node # :nodoc:
-              getStartNode.wrapper
-            end
-
-            def other_node(node) # :nodoc:
-              getOtherNode(node._java_node).wrapper
-            end
-
-
-            # same as _java_rel
-            # Used so that we have same method for both relationship and nodes
-            def wrapped_entity
-              self
-            end
-
-            def _java_rel
-              self
-            end
-
-
-            # Returns true if the relationship exists
-            def exist?
-              Neo4j::Relationship.exist?(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.load_wrapper(node)
-            def wrapper
-              self.class.wrapper(self)
-            end
-
-
-            # Returns the relationship name
-            #
-            # ==== Example
-            #   a = Neo4j::Node.new
-            #   a.outgoing(:friends) << Neo4j::Node.new
-            #   a.rels.first.rel_type # => 'friends'
-            #
-            def rel_type
-              getType().name()
-            end
-
-            def class
-              Neo4j::Relationship
-            end
-
-          end
-
-      end
-
-      Neo4j::Relationship.extend_java_class(org.neo4j.kernel.impl.core.RelationshipProxy)
-
-    end
-
-  end
-
-end
-
-

data/lib/neo4j/relationship_mixin/class_methods.rb

@@ -1,36 +0,0 @@
-module Neo4j
-  module RelationshipMixin
-    module ClassMethods
-      def load_wrapper(rel)
-        wrapped_rel = self.orig_new
-        wrapped_rel.init_on_load(rel)
-        wrapped_rel
-      end
-
-
-      # Creates a relationship between given nodes.
-      #
-      # You can use two callback method to initialize the relationship
-      # init_on_load:: this method is called when the relationship is loaded from the database
-      # init_on_create:: called when the relationship is created, will be provided with the same argument as the new method
-      #
-      # ==== Parameters (when creating a new relationship in db)
-      # type:: the key and value to be set
-      # from_node:: create relationship from this node
-      # to_node:: create relationship to this node
-      # props:: optional hash of properties to initialize the create relationship with
-      #
-      def new(*args)
-        type, from_node, to_node = args
-        rel = Neo4j::Relationship.create(type, from_node, to_node)
-        wrapped_rel = super()
-        Neo4j::IdentityMap.add(rel, wrapped_rel)
-        wrapped_rel.init_on_load(rel)
-        wrapped_rel.init_on_create(*args)
-        wrapped_rel
-      end
-
-      alias_method :create, :new
-    end
-  end
-end

data/lib/neo4j/relationship_mixin/relationship_mixin.rb

@@ -1,142 +0,0 @@
-# external neo4j dependencies
-require 'neo4j/index/index'
-require 'neo4j/property/property'
-
-# internal dependencies
-require 'neo4j/relationship_mixin/class_methods'
-
-
-module Neo4j
-
-  # Use this mixin to wrap Neo4j Relationship Java object.
-  # This mixin is similar to Neo4j::NodeMixin which wraps Neo4j::Node Java objects.
-  #
-  # ==== Instance Methods, Mixins
-  # * Neo4j::Index :: relationships can also be indexed just like nodes
-  # *
-  # ==== Class Methods, Mixins
-  # * Neo4j::Index::ClassMethods :: for declaration for keeping lucene index and neo4j property in sync
-  # * Neo4j::Property::ClassMethods :: for declaration of convenience accessors of property
-  #
-  module RelationshipMixin
-    extend Forwardable
-    include Neo4j::Index
-
-    def_delegators :@_java_rel, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :to_param, :getId,
-                   :equal?, :eql?, :==, :delete, :getStartNode, :getEndNode, :getOtherNode, :exist?
-
-
-
-    # --------------------------------------------------------------------------
-    # Initialization methods
-    #
-
-
-    # Init this node with the specified java neo4j relationship.
-    #
-    def init_on_load(java_rel) # :nodoc:
-      @_java_rel = java_rel
-    end
-
-
-    # Creates a new node and initialize with given properties.
-    #
-    def init_on_create(*args) # :nodoc:
-      type, from_node, to_node, props = args
-      self[:_classname] = self.class.to_s
-      if props.respond_to?(:each_pair)
-        props.each_pair { |k, v| respond_to?("#{k}=") ? self.send("#{k}=", v) : @_java_rel[k] = v }
-      end
-    end
-
-
-    # --------------------------------------------------------------------------
-    # Instance Methods
-    #
-
-    # Returns the org.neo4j.graphdb.Relationship wrapped object
-    def _java_rel
-      @_java_rel
-    end
-
-    def _java_entity
-      @_java_rel
-    end
-
-    # Returns the end node of this relationship
-    def end_node
-      id = getEndNode.getId
-      Neo4j::Node.load(id)
-    end
-
-    # Returns the start node of this relationship
-    def start_node
-      id = getStartNode.getId
-      Neo4j::Node.load(id)
-    end
-
-    # Deletes this relationship
-    def del
-      delete
-    end
-
-    def exist?
-      Neo4j::Relationship.exist?(self)
-    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.respond_to?(:_java_node)? node._java_node : node
-      id = getOtherNode(neo_node).getId
-      Neo4j::Node.load(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
-      @_java_rel.getType.name.to_sym
-    end
-
-    # --------------------------------------------------------------------------
-    # Class Methods
-    #
-
-    class << self
-      def included(c) # :nodoc:
-        c.instance_eval do
-          class << self
-            alias_method :orig_new, :new
-          end
-        end
-        
-        c.class_inheritable_accessor :_decl_props
-        c._decl_props ||= {}
-
-        c.extend ClassMethods
-        c.extend Neo4j::Property::ClassMethods
-        c.extend Neo4j::Index::ClassMethods
-
-        def c.inherited(subclass)
-          subclass.rel_indexer self
-          super
-        end
-
-        c.rel_indexer c
-      end
-    end
-  end
-end

data/lib/neo4j/relationship_set.rb

@@ -1,58 +0,0 @@
-module Neo4j
-  # == Represents a set of relationships.
-  # See Neo4j::EventHandler
-  class RelationshipSet
-    def initialize(size=0)
-      @relationship_type_set = java.util.HashSet.new(size)
-      @relationship_set = java.util.HashSet.new(size)
-      @relationship_map = java.util.HashMap.new(size)
-    end
-
-    # Adds a relationship to the set
-    def add(rel)
-      @relationship_type_set.add(RelationshipSetEntry.new(rel.getEndNode().getId(),rel.rel_type))
-      relationships(rel.getEndNode().getId()) << rel
-      @relationship_set.add(rel.getId)
-    end
-
-    # Returns a collection of relationships where the node with the specified end node id is the end node.
-    def relationships(end_node_id)
-      @relationship_map.get(end_node_id) || add_list(end_node_id)
-    end
-
-    # Returns true if the specified relationship is in the set
-    def contains_rel?(rel)
-      @relationship_set.contains(rel.getId)
-    end
-
-    # Returns true if a relationship with the specified end_node_id and relationship_type is present in the set.
-    def contains?(end_node_id,relationship_type)
-      @relationship_type_set.contains(RelationshipSetEntry.new(end_node_id,relationship_type))
-    end
-
-    protected
-    def add_list(node_id)
-      @relationship_map.put(node_id,[])
-      @relationship_map.get(node_id)
-    end
-  end
-
-  class RelationshipSetEntry
-    attr_accessor :nodeid, :relationship_type
-    def initialize(nodeid,relationship_type)
-      @nodeid,@relationship_type = nodeid.to_s, relationship_type.to_s
-    end
-
-    def ==(o)
-      eql?(o)
-    end
-
-    def eql?(other)
-      @nodeid == other.nodeid && @relationship_type == other.relationship_type
-    end
-
-    def hash
-      3 * @nodeid.hash + @relationship_type.hash
-    end
-  end
-end