neo4j 1.0.0.beta.21-java

data/lib/neo4j/mapping/relationship_mixin.rb

@@ -0,0 +1,120 @@
+module Neo4j::Mapping
+
+  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| @_java_rel.set_property(k.to_s, v) }
+      end
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Instance Methods
+    #
+
+    # Returns the org.neo4j.graphdb.Relationship wrapped object
+    def _java_rel
+      @_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
+      get_type.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_hash :_decl_props
+        c._decl_props ||= {}
+        
+        c.extend ClassMethods::Property
+        c.extend ClassMethods::InitRel
+        c.extend Neo4j::Index::ClassMethods
+
+        def c.inherited(subclass)
+          subclass.rel_indexer subclass
+          super
+        end
+
+        c.rel_indexer c
+      end
+    end
+  end
+end

data/lib/neo4j/model.rb

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

@@ -0,0 +1,95 @@
+# = 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
+
+  class << self
+    
+    # Start Neo4j using the default database.
+    # This is usally not required since the database will be started automatically when it is used.
+    #
+    def start
+      db = default_db
+      db.start unless db.running?
+    end
+
+
+    # sets the default database to use
+    def default_db=(my_db)
+      @db = my_db
+    end
+
+    # Returns default database. Creates a new one if it does not exist, but does not start it.
+    def default_db
+      @db ||= Database.new
+    end
+
+    # Returns a started db instance. Starts it if's not running.
+    def started_db
+      db = default_db
+      db.start unless db.running?
+      db
+    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 reference node, which is a "starting point" in the node space.
+    #
+    # 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)
+      this_db.graph.reference_node
+    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 = default_db)
+      this_db.event_handler
+    end
+    
+    # Ruby to Java type converters
+    def converters
+    	Neo4j::Config[:converters] || {}
+    end
+  end
+end

data/lib/neo4j/node.rb

@@ -0,0 +1,131 @@
+module Neo4j
+
+
+
+  org.neo4j.kernel.impl.core.NodeProxy.class_eval do
+    include Neo4j::Property
+    include Neo4j::NodeRelationship
+    include Neo4j::Equal
+    include Neo4j::Index
+
+    # Delete the node and all its relationship
+    def del
+      rels.each {|r| r.del}
+      delete
+    end
+
+    # returns true if the node exists in the database
+    def exist?
+      Neo4j::Node.exist?(self)
+    end
+
+    # same as _java_node
+    # Used so that we have same method for both relationship and nodes
+    def wrapped_entity
+      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.wrapper(node)
+    def wrapper
+      self.class.wrapper(self)
+    end
+
+    def _java_node
+      self
+    end
+
+    def class
+      Neo4j::Node
+    end
+  end
+
+
+  # A node in the graph with properties and relationships to other entities.
+  # Along with relationships, nodes are the core building blocks of the Neo4j data representation model.
+  # Node has three major groups of operations: operations that deal with relationships, operations that deal with properties and operations that traverse the node space.
+  # The property operations give access to the key-value property pairs.
+  # Property keys are always strings. Valid property value types are the primitives(<tt>String</tt>, <tt>Fixnum</tt>, <tt>Float</tt>, <tt>Boolean</tt>), and arrays of those primitives.
+  #
+  # === Instance Methods form Included Mixins
+  # * Neo4j::Property - methods that deal with properties
+  # * Neo4j::NodeRelationship methods for relationship
+  # * Neo4j::Equal equality operators: <tt>eql?</tt>, <tt>equal</tt>, <tt>==</tt>
+  # * Neo4j::Index lucene index methods, like indexing a node
+  #
+  # === Class Methods from Included Mixins
+  # * Neo4j::Index::ClassMethods lucene index class methods, like find
+  # * Neo4j::Load - methods for loading a node
+  #
+  # See also the Neo4j::NodeMixin (Neo4j::Mapping::NodeMixin) if you want to wrap a node with your own Ruby class.
+  #
+  class Node
+    extend Neo4j::Index::ClassMethods
+    extend Neo4j::Load
+
+    self.node_indexer self
+
+    class << self
+
+      # Returns a new neo4j Node.
+      # The return node is actually an Java obejct of type org.neo4j.graphdb.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
+      #
+      # ==== Parameters
+      # *args :: a hash of properties to initialize the node with or nil
+      #
+      # ==== Returns
+      # org.neo4j.graphdb.Node java object
+      #
+      # ==== Examples
+      #
+      #  Neo4j::Transaction.run do
+      #    Neo4j::Node.new
+      #    Neo4j::Node.new :name => 'foo', :age => 100
+      #  end
+      #
+      #
+      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
+
+      # 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).
+      #
+      # If the node does not exist it will return nil
+      #
+      def load(node_id, db = Neo4j.started_db)
+        node = _load(node_id, db)
+        return nil if node.nil?
+        node.wrapper
+      end
+
+      # Same as load but does not return the node as a wrapped Ruby object.
+      #
+      def _load(node_id, db)
+	return nil if node_id.nil?
+        db.graph.get_node_by_id(node_id.to_i)
+      rescue java.lang.IllegalStateException
+        nil # the node has been deleted
+      rescue org.neo4j.graphdb.NotFoundException
+        nil
+      end
+
+    end
+  end
+end

data/lib/neo4j/node_mixin.rb

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

data/lib/neo4j/node_relationship.rb

@@ -0,0 +1,149 @@
+module Neo4j
+
+
+  module NodeRelationship
+    include ToJava
+
+
+    # Returns the outgoing nodes for this node.
+    #
+    # ==== Returns
+    # a Neo4j::NodeTraverser which can be used to further specify which nodes should be included
+    # in traversal by using the <tt>depth</tt>, <tt>filter</tt> and <tt>prune</tt> methods.
+    #
+    # ==== Examples
+    #   # Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
+    #   me.outgoing(:friends).each {|friend| puts friend[:name]}
+    #
+    #   # Find all my friends and their friends (nodes of depth 1 of type <tt>friends</tt>)
+    #   # me.outgoing(:friends).depth(2).each {|friend| puts friend[:name]}
+    #
+    #   # Find all my friends and include my self in the result
+    #   me.outgoing(:friends).depth(4).include_start_node.each {...}
+    #
+    #   # Find all my friends friends friends, etc. at any depth
+    #   me.outgoing(:friends).depth(:all).each {...}
+    #
+    #   # Find all my friends friends but do not include my friends (only depth == 2)
+    #   me.outgoing(:friends).depth(2).filter{|path| path.length == 2}
+    #
+    #   # Find all my friends but 'cut off' some parts of the traversal path
+    #   me.outgoing(:friends).depth(42).prune(|path| an_expression_using_path_returning_true_false }
+    #
+    #   # Find all my friends and work colleges
+    #   me.outgoing(:friends).outgoing(:work).each {...}
+    #
+    # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt> can be combined.
+    #
+    def outgoing(type)
+      if type
+        NodeTraverser.new(self).outgoing(type)
+      else
+        raise "not implemented yet"
+        NodeTraverser.new(self)
+      end
+    end
+
+
+    # Returns the incoming nodes of given type(s).
+    #
+    # See #outgoing
+    #
+    def incoming(type)
+      if type
+        NodeTraverser.new(self).incoming(type)
+      else
+        raise "not implemented yet"
+        NodeTraverser.new(self)
+      end
+    end
+
+    # Returns both incoming and outgoing nodes of given types(s)
+    #
+    # If a type is not given then it will return all types of relationships.
+    #
+    # See #outgoing
+    #
+    def both(type=nil)
+      if type
+        NodeTraverser.new(self).both(type)
+      else
+        NodeTraverser.new(self) # default is both
+      end
+    end
+
+
+    # Returns an enumeration of relationship objects.
+    # It always returns relationship of depth one.
+    #
+    # See Neo4j::Relationship
+    #
+    # ==== Examples
+    #   # Return both incoming and outgoing relationships
+    #   me.rels(:friends, :work).each {|relationship|...}
+    #
+    #   # Only return outgoing relationship of given type
+    #   me.rels(:friends).outgoing.first.end_node # => my friend node
+    #
+    def rels(*type)
+      RelationshipTraverser.new(self, type, :both)
+    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.
+    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.
+    def _rel(dir, type)
+      get_single_relationship(type_to_java(type), dir_to_java(dir))
+    end
+
+    # Returns the raw java neo4j relationship object.
+    def _rels(dir=:both, *types)
+      if types.size > 1
+        java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
+        get_relationships(java_types)
+      elsif types.size == 1
+        get_relationships(type_to_java(types[0], dir_to_java(dir)))
+      elsif dir == :both
+        get_relationships(dir_to_java(dir))
+      else
+        raise "illegal argument, does not accept #{dir} #{types.join(',')} - only dir=:both for any relationship types"
+      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.
+    #
+    # ==== Parameters
+    # type:: the key and value to be set, default any type
+    # dir:: optional default :both (either, :outgoing, :incoming, :both)
+    #
+    # ==== Returns
+    # true if one or more relationships exists for the given type and dir
+    # otherwise false
+    #
+    def rel? (type=nil, dir=:both)
+      if type
+        hasRelationship(type_to_java(type), dir_to_java(dir))
+      else
+        hasRelationship
+      end
+    end
+
+  end
+
+end