neo4j-core 0.0.1-java

data/lib/neo4j-core/node/class_methods.rb

@@ -0,0 +1,77 @@
+module Neo4j
+  module Core
+    module Node
+      module ClassMethods
+        # Returns a new neo4j Node.
+        # The return node is actually an Java object of type Java::OrgNeo4jGraphdb::Node java object
+        # which has been extended (see the included mixins for Neo4j::Node).
+        #
+        #
+        # The created node will have a unique id - Neo4j::Property#neo_id
+        #
+        # @param [Hash, Array] args either an hash of properties or an array where the first item is the database to be used and the second item is the properties
+        # @return [Java::OrgNeo4jGraphdb::Node] the java node which implements the Neo4j::Node mixins
+        #
+        # @example using default database
+        #
+        #  Neo4j::Transaction.run do
+        #    Neo4j::Node.new
+        #    Neo4j::Node.new :name => 'foo', :age => 100
+        #  end
+        #
+        # @example using a different database
+        #
+        #   Neo4j::Node.new({:name => 'foo', :age => 100}, my_db)
+        def new(*args)
+          # the first argument can be an hash of properties to set
+          props = args[0].respond_to?(:each_pair) && args[0]
+
+          # a db instance can be given, is the first argument if that was not a hash, or otherwise the second
+          db = (!props && args[0]) || args[1] || Neo4j.started_db
+
+          node = db.graph.create_node
+          props.each_pair { |k, v| node[k]= v } if props
+          node
+        end
+
+        # create is the same as new
+        alias_method :create, :new
+
+
+        # Same as load but does not return the node as a wrapped Ruby object.
+        #
+        def _load(node_id, db = Neo4j.started_db)
+          return nil if node_id.nil?
+          db.graph.get_node_by_id(node_id.to_i)
+        rescue Java::OrgNeo4jGraphdb.NotFoundException
+          nil
+        end
+
+
+        # Checks if the given entity node or entity id (Neo4j::Node#neo_id) exists in the database.
+        # @return [true, false] if exist
+        def exist?(entity_or_entity_id, db = Neo4j.started_db)
+          id = entity_or_entity_id.kind_of?(Fixnum) ? entity_or_entity_id : entity_or_entity_id.id
+          node = _load(id, db)
+          return false unless node
+          node.has_property?('a')
+          true
+        rescue java.lang.IllegalStateException
+          nil # the node has been deleted
+        end
+
+        # Loads a node or wrapped node given a native java node 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::NodeMixin).
+        # To implement a wrapper you must implement a wrapper class method in the Neo4j::Node or Neo4j::Relationship.
+        #
+        # @return [Object, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
+        def load(node_id, db = Neo4j.started_db)
+          node = _load(node_id, db)
+          node && node.wrapper
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j-core/node/node.rb

@@ -0,0 +1,47 @@
+module Neo4j
+
+  module Core
+    module Node
+
+      # 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  Java::OrgNeo4jKernel::impl.core.NodeProxy which is return by Neo4j::Node.new
+      #
+      # @return nil or raise an exception
+      def del
+        _rels.each { |r| r.del }
+        delete
+        nil
+      end
+
+      # This method can be used to access the none wrapped neo4j node/relationship java object.
+      # Notice that this method is defined in the  Java::OrgNeo4jKernel::impl.core.NodeProxy or RelationshipProxy which is return by Neo4j::Node.new
+      # @return the java node/relationship object representing this object unless it is already the java object.
+      def _java_node
+        self
+      end
+
+      # Same as Neo4j::Node#exist? or Neo4j::Relationship#exist?
+      # @return [true, false] if the node exists in the database
+      def exist?
+        Neo4j::Node.exist?(self)
+      end
+
+      # Tries to load the wrapper object for this node by calling the class #wrapper method.
+      # This allows you to create a custom Ruby wrapper class around the Neo4j::Node.
+      # This is for example done in the <tt>neo4j<//t> ruby gem <tt>Neo4j::NodeMixin</tt>
+      # @return a wrapper object or self
+      def wrapper
+        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
+      end
+
+      def class
+        Neo4j::Node
+      end
+    end
+  end
+end

data/lib/neo4j-core/property/property.rb

@@ -0,0 +1,94 @@
+module Neo4j
+  module Core
+    module Property
+
+      # @return [Hash] all properties plus the id of the node with the key <tt>_neo_id</tt>
+      def props
+        ret = {"_neo_id" => neo_id}
+        iter = get_property_keys.iterator
+        while (iter.hasNext) do
+          key = iter.next
+          ret[key] = get_property(key)
+        end
+        ret
+      end
+
+      # Ids are garbage collected over time so they are only guaranteed to be unique during a specific time span:
+      # if the node is deleted, it's likely that a new node at some point will get the old id. Note:
+      # this makes node ids brittle as public APIs.
+      # @return [Fixnum] the unique id of this node.
+      def neo_id
+        getId
+      end
+
+      # @param [#to_s] the property we want to check if it exist.
+      # @return [true false] true if the given key exist as a property.
+      def property?(key)
+        has_property?(key.to_s)
+      end
+
+      # Updates this node/relationship's properties by using the provided struct/hash.
+      # If the option <code>{:strict => true}</code> is given, any properties present on
+      # the node but not present in the hash will be removed from the node.
+      #
+      # @param [Hash, :each_pair] struct_or_hash the key and value to be set
+      # @param [Hash] options further options defining the context of the update
+      # @option options [Boolean] :strict any properties present on the node but not present in the hash will be removed from the node if true
+      # @return self
+      def update(struct_or_hash, options={})
+        strict = options[:strict]
+        keys_to_delete = props.keys - %w(_neo_id _classname) if strict
+        struct_or_hash.each_pair do |key, value|
+          next if key.to_s[0..0] == '_'
+          # do not allow special properties to be mass assigned
+          keys_to_delete.delete(key.to_s) if strict
+          self[key] = value
+        end
+        keys_to_delete.each { |key| remove_property(key) } if strict
+        self
+      end
+
+
+      # @return the value of the given key or nil if the property does not exist.
+      def [](key)
+        return unless property?(key)
+        val = get_property(key.to_s)
+        val.class.superclass == ArrayJavaProxy ? val.to_a : val
+      end
+
+      # Sets the property of this node.
+      # Property keys are always strings. Valid property value types are the primitives(<tt>String</tt>, <tt>Fixnum</tt>, <tt>Float</tt>, <tt>FalseClass</tt>, <tt>TrueClass</tt>) or array of those primitives.
+      #
+      # ==== Gotchas
+      # * Values in the array must be of the same type.
+      # * You can *not* delete or add one item in the array (e.g. person.phones.delete('123')) but instead you must create a new array instead.
+      #
+      # @param [String, Symbol] key of the property to set
+      # @param [String,Fixnum,Float,true,false, Array] value to set
+      def []=(key, value)
+        k = key.to_s
+        if value.nil?
+          remove_property(k)
+        elsif (Array === value)
+          case value[0]
+            when NilClass
+              set_property(k, [].to_java(:string))
+            when String
+              set_property(k, value.to_java(:string))
+            when Float
+              set_property(k, value.to_java(:double))
+            when FalseClass, TrueClass
+              set_property(k, value.to_java(:boolean))
+            when Fixnum
+              set_property(k, value.to_java(:long))
+            else
+              raise "Not allowed to store array with value #{value[0]} type #{value[0].class}"
+          end
+        else
+          set_property(k, value)
+        end
+      end
+
+    end
+  end
+end

data/lib/neo4j-core/relationship/class_methods.rb

@@ -0,0 +1,80 @@
+module Neo4j
+  module Core
+    module Relationship
+      module ClassMethods
+
+        # Returns a Java::OrgNeo4jGraphdb::Relationship java object which include the Neo4j::Relationship mixins.
+        # Will trigger a event that the relationship was created.
+        #
+        # @param [String, Symbol] type of relationship
+        # @param [#_java_node] from_node the start node of this relationship
+        # @param [#_java_node] end_node the end node of this relationship
+        # @param [Hash] props optional properties for the created relationship
+        #
+        # @return [Neo4j::Relationship] which is really a Java::OrgNeo4jGraphdb::Relationship java object including the Neo4j::Relationship mixins
+        #
+        # @example
+        #
+        #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
+        #
+        def new(type, start_node, end_node, props=nil)
+          java_type = ToJava.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).
+        # Notice that it can load the node even if it has been deleted in the same transaction, see #exist?
+        #
+        # @see #_load
+        # @see #exist?
+        # @return the wrapper for the relationship or 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.
+        # @see #load
+        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)
+          # TODO
+          rel
+        rescue Java::OrgNeo4jGraphdb::NotFoundException
+          nil
+        end
+
+        # Checks if the given node or entity id (Neo4j::Relationship#neo_id) exists in the database.
+        # @return [true, false] if exist
+        def exist?(entity_or_entity_id, db = Neo4j.started_db)
+          id = entity_or_entity_id.kind_of?(Fixnum) ? entity_or_entity_id : entity_or_entity_id.id
+          entity = _load(id, db)
+          return false unless entity
+          entity.hasProperty('_classname') # since we want a IllegalStateException which is otherwise not triggered
+          true
+        rescue java.lang.IllegalStateException
+          nil # the node has been deleted
+        end
+
+        # Loads a relationship or wrapped relationship given a native java relationship or an id.
+        # If there is a Ruby wrapper for the relationship then it will create a Ruby object that will
+        # wrap the java node (see Neo4j::RelationshipMixin).
+        # To implement a wrapper you must implement a wrapper class method in the Neo4j::Node or Neo4j::Relationship.
+        #
+        # @return [Object, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
+        def load(node_id, db = Neo4j.started_db)
+          node = _load(node_id, db)
+          node && node.wrapper
+        end
+      end
+    end
+  end
+end

data/lib/neo4j-core/relationship/relationship.rb

@@ -0,0 +1,97 @@
+module Neo4j
+  module Core
+    module Relationship
+
+      # Same as Java::OrgNeo4jGraphdb::Relationship#getEndNode
+      def _end_node
+        get_end_node
+      end
+
+      # Same as Java::OrgNeo4jGraphdb::Relationship#getStartNode
+      def _start_node
+        get_start_node
+      end
+
+      # Same as Java::OrgNeo4jGraphdb::Relationship#getOtherNode
+      def _other_node(node)
+        get_other_node(node)
+      end
+
+      # Deletes the relationship between the start and end node
+      # May raise an exception if delete was unsuccessful.
+      #
+      # @return [nil]
+      def del
+        delete
+      end
+
+      # Same as Java::OrgNeo4jGraphdb::Relationship#getEndNode but returns the wrapper for it (if it exist)
+      # @see Neo4j::Node#wrapper
+      def end_node
+        _end_node.wrapper
+      end
+
+      # Same as Java::OrgNeo4jGraphdb::Relationship#getStartNode but returns the wrapper for it (if it exist)
+      # @see Neo4j::Node#wrapper
+      def start_node
+        _start_node.wrapper
+      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
+      # method on a node. For example, to get the node "at the other end" of a relationship, use the following:
+      #
+      # @example
+      #   end_node = node.rels.first.other_node(node)
+      #
+      # @raise This operation will throw a runtime exception if node is neither this relationship's start node nor its end node.
+      #
+      # @param [Neo4j::Node] node the node that we don't want to return
+      # @return [Neo4j::Node] the other node wrapper
+      def other_node(node)
+        _other_node(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
+
+      # @return self
+      def _java_rel
+        self
+      end
+
+      # @return [true, false] if the relationship exists
+      def exist?
+        Neo4j::Relationship.exist?(self)
+      end
+
+      # Loads the wrapper using the #wrapper class method if it exists, otherwise return self.
+      def wrapper
+        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
+      end
+
+
+      # Returns the relationship name
+      #
+      # @example
+      #   a = Neo4j::Node.new
+      #   a.outgoing(:friends) << Neo4j::Node.new
+      #   a.rels.first.rel_type # => 'friends'
+      # @return [String] the type of the relationship
+      def rel_type
+        getType().name()
+      end
+
+      def class
+        Neo4j::Relationship
+      end
+
+
+    end
+  end
+end

data/lib/neo4j-core/relationship_set.rb

@@ -0,0 +1,61 @@
+module Neo4j
+  module Core
+    # == 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
+end

data/lib/neo4j-core/rels/rels.rb

@@ -0,0 +1,147 @@
+module Neo4j
+  module Core
+    # Contains methods for traversing relationship object of depth one from one node.
+    module Rels
+      # Returns the only node of a given type and direction that is attached to this node, or nil.
+      # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node.
+      # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an exception.
+
+      # This method reflects that semantics and returns either:
+      # * nil if there are zero relationships of the given type and direction,
+      # * the relationship if there's exactly one, or
+      # * throws an unchecked exception in all other cases.
+      #
+      # This method should be used only in situations with an invariant as described above. In those situations, a "state-checking" method (e.g. #rel?) is not required,
+      # because this method behaves correctly "out of the box."
+      #
+      # @param (see #rel)
+      # @see Neo4j::Core::Node#wrapper #wrapper - The method used to wrap the node in a Ruby object if the node was found
+      def node(dir, type)
+        n = _node(dir, type)
+        n && n.wrapper
+      end
+
+      # Same as #node but instead returns an unwrapped native java node.
+      # @param (see #rel)
+      def _node(dir, type)
+        r = _rel(dir, type)
+        r && r._other_node(self._java_node)
+      end
+
+      # Works like #rels method but instead returns the nodes.
+      # @param (see #rels)
+      # @see #rels
+      # @return [Enumerable<Neo4j::Node>]
+      def _nodes(dir, *types)
+        r = _rels(dir, *types)
+        case dir
+          when :outgoing then
+            Neo4j::Core::LazyMap.new(r, &:_end_node)
+          when :incoming then
+            Neo4j::Core::LazyMap.new(r, &:_start_node)
+          when :both then
+            Neo4j::Core::LazyMap.new(r) { |x| x._other_node(self) }
+        end
+      end
+
+      # Works like #rels method but instead returns the nodes.
+      # It does try to load a Ruby wrapper around each node
+      # @param (see #rels)
+      # @see Neo4j::Core::Node#wrapper #wrapper - The method used wrap to the node in a Ruby object if the node was found
+      # @return [Enumerable] an Enumeration of either Neo4j::Node objects or wrapped Neo4j::Node objects
+      # @notice it's possible that the same node is returned more then once because of several relationship reaching to the same node, see #outgoing for alternative
+      def nodes(dir, *types)
+        Neo4j::Core::LazyMap.new(_nodes(dir, *types), &:wrapper)
+      end
+
+
+      # Returns an enumeration of relationship objects using the builder DSL pattern.
+      # It always returns relationships of depth one.
+      #
+      # @param [:both, :incoming, :outgoing] dir the direction of the relationship
+      # @param [String, Symbol] types the requested relationship types we want look for, if none it gets relationships of any type
+      # @return [Neo4j::Core::Rels::Traverser] an object which included the Ruby Enumerable mixin
+      #
+      # @example Return both incoming and outgoing relationships
+      #   me.rels(:both, :friends, :work).each {|relationship|...}
+      #
+      # @example Only return outgoing relationship of given type
+      #   me.rels(:outgoing, :friends).first.end_node # => my friend node
+      #
+      # @example All the relationships between me and another node of given dir & type
+      #   me.rels(:outgoing, :friends).to_other(node)
+      #
+      # @example Delete all relationships between me and another node of given dir & type
+      #   me.rels(:outgoing, :friends).to_other(node).del
+      #
+      # @see Neo4j::Core::Node#wrapper #wrapper - The method used wrap to the node in a Ruby object if the node was found
+      # @see Neo4j::Relationship#rel_type
+      # @raise an exception if the first parameter is not <tt>:both</tt>, <tt>;outgoing</tt> or <tt>:incoming</tt>
+      def rels(dir=:both, *types)
+        raise "Illegal argument, first argument must be :both, :incoming or :outgoing, got #{dir.inspect}" unless [:incoming, :outgoing, :both].include?(dir)
+        Neo4j::Core::Rels::Traverser.new(self, types, dir)
+      end
+
+
+      # Returns the only relationship of a given type and direction that is attached to this node, or null.
+      # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or
+      # one relationships of a given type and direction to another node.
+      # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships
+      # exist, it is a fatal error that should generate an unchecked exception. This method reflects that semantics and
+      # returns either:
+      #
+      # * nil if there are zero relationships of the given type and direction,
+      # * the relationship if there's exactly one, or
+      # * raise an exception in all other cases.
+      # @param [:both, :incoming, :outgoing] dir the direction of the relationship
+      # @param [Symbol, String] type the type of relationship, see Neo4j::Core::Relationship#rel_type
+      # @return [Neo4j::Relationship, nil, Object] the Relationship or wrapper for the Relationship or nil
+      # @see Neo4j::Core::Relationship#rel_type
+      # @see Neo4j::Core::Node#wrapper #wrapper - The method used to wrap the node in a Ruby object if the node was found
+      def rel(dir, type)
+        result = _rel(dir, type)
+        result && result.wrapper
+      end
+
+      # Same as rel but does not return a ruby wrapped object but instead returns the Java object.
+      # @param (see #rel)
+      # @return [Neo4j::Relationship, nil]
+      # @see #rel
+      def _rel(dir, type)
+        get_single_relationship(ToJava.type_to_java(type), ToJava.dir_to_java(dir))
+      end
+
+      # Finds relationship starting from this node given a direction and/or relationship type(s).
+      # @param (see #rels)
+      # @return [Enumerable] of Neo4j::Relationship objects
+      def _rels(dir=:both, *types)
+        if types.size > 1
+          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types))
+        elsif types.size == 1
+          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir))
+        else
+          get_relationships(ToJava.dir_to_java(dir))
+        end
+      end
+
+      # Check if the given relationship exists
+      # Returns true if there are one or more relationships from this node to other nodes
+      # with the given relationship.
+      #
+      # @param [:both, :incoming, :outgoing] dir  optional default :both (either, :outgoing, :incoming, :both)
+      # @param [String,Symbol] type the key and value to be set, default any type
+      # @return [Boolean] true if one or more relationships exists for the given type and dir otherwise false
+      def rel?(dir=:both, type=nil)
+        if type
+          has_relationship(ToJava.type_to_java(type), ToJava.dir_to_java(dir))
+        else
+          has_relationship(ToJava.dir_to_java(dir))
+        end
+      end
+
+    end
+
+  end
+
+
+end