neo4j 1.0.0.beta.1

data/lib/neo4j/mapping/has_n.rb

@@ -0,0 +1,117 @@
+module Neo4j
+  module Mapping
+
+    # Enables creating and traversal of nodes.
+    # Includes the Enumerable Mixin.
+    #
+    class HasN
+      include Enumerable
+
+      def initialize(node, dsl) # :nodoc:
+        @node = node
+        @direction = dsl.direction
+        # returns the other DSL if it exists otherwise use this DSL for specifing incoming relationships
+        if @direction == :outgoing
+          @dsl = dsl
+        else
+          # which class specifies the incoming DSL ?
+          clazz = dsl.to_class || node.class
+          @dsl = clazz.decl_relationships[dsl.to_type]
+          raise "Unspecified outgoing relationship '#{dsl.to_type}' for incoming relationship '#{dsl.rel_id}' on class #{clazz}" if @dsl.nil?
+        end
+
+        @traverser = Neo4j::NodeTraverser.new(node._java_node, @dsl.namespace_type, @direction)
+      end
+
+
+      # Returns the relationships instead of the nodes.
+      #
+      # ==== Example
+      # # return the relationship objects between the folder and file nodes:
+      # folder.files.rels.each {|x| ...}
+      #
+      def rels
+        Neo4j::RelationshipTraverser.new(@node._java_node, [@dsl.namespace_type], @direction)
+      end
+
+      # Sets the depth of the traversal.
+      # Default is 1 if not specified.
+      #
+      # ==== Example
+      #  morpheus.friends.depth(:all).each { ... }
+      #  morpheus.friends.depth(3).each { ... }
+      #  
+      # ==== Arguments
+      # d<Fixnum,Symbol>:: the depth or :all if traversing to the end of the network.
+      # ==== Return
+      # self
+      # 
+      def depth(d)
+        @traverser.depth(d)
+        self
+      end
+
+      # Required by the Enumerable mixin.
+      def each(&block)
+        @traverser.each(&block)
+      end
+
+
+      # Returns true if there are no node in this type of relationship
+      def empty?
+        @traverser.empty?
+      end
+
+
+      # Creates a relationship instance between this and the other node.
+      def new(other)
+        create_rel(@node, other)
+      end
+
+
+      # Creates a relationship between this and the other node.
+      #
+      # ==== Example
+      # 
+      #   n1 = Node.new # Node has declared having a friend type of relationship
+      #   n2 = Node.new
+      #   n3 = Node.new
+      #
+      #   n1 << n2 << n3
+      #
+      # This is the same as:
+      #
+      #   n1.add_rel(:friends, n2)
+      #   n1.add_rel(:friends, n3)
+      #
+      # ==== Returns
+      # self
+      #
+      def <<(other)
+        create_rel(@node, other)
+        self
+      end
+
+
+      def create_rel(node, other) # :nodoc:
+        # If the are creating an incoming relationship we need to swap incoming and outgoing nodes
+        if @direction == :outgoing
+          from, to = node, other
+        else
+          from, to = other, node
+        end
+
+        rel = from.outgoing(@dsl.namespace_type) << to
+        # rel[_classname] =  @dsl.relationship_class # TODO
+
+        # the from.neo_id is only used for cascade_delete_incoming since that node will be deleted when all the list items has been deleted.
+        # if cascade_delete_outgoing all nodes will be deleted when the root node is deleted
+        # if cascade_delete_incoming then the root node will be deleted when all root nodes' outgoing nodes are deleted
+        rel[@dsl.cascade_delete_prop_name] = node.neo_id if @dsl.cascade_delete?
+        rel
+      end
+
+    end
+
+  end
+end

data/lib/neo4j/mapping/node_mixin.rb

@@ -0,0 +1,70 @@
+module Neo4j::Mapping
+
+  module NodeMixin
+    extend Forwardable
+    include Neo4j::Index
+
+    def_delegators :@_java_node, :[]=, :[], :property?, :props, :attributes, :update, :neo_id, :id, :rels, :rel?, :to_param, :getId,
+                   :rel, :del, :list?, :print, :print_sub, :outgoing, :incoming, :both,
+                   :equal?, :eql?, :==, :exist?
+
+
+    # --------------------------------------------------------------------------
+    # Initialization methods
+    #
+
+
+    # Init this node with the specified java neo node
+    #
+    def init_on_load(java_node) # :nodoc:
+      @_java_node = java_node
+    end
+
+
+    # Creates a new node and initialize with given properties.
+    #
+    def init_on_create(*args) # :nodoc:
+      self[:_classname] = self.class.to_s
+      if args[0].respond_to?(:each_pair)
+         args[0].each_pair { |k, v| @_java_node.set_property(k.to_s, v) }
+      end
+    end
+
+    # Returns the org.neo4j.graphdb.Node wrapped object
+    def _java_node
+      @_java_node
+    end
+
+    def id
+      @_java_node.id
+    end
+
+    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
+        unless c.const_defined?(:DECL_RELATIONSHIPS)
+          const_set(:ROOT_CLASS, self)
+          const_set(:DECL_RELATIONSHIPS, {})
+          const_set(:PROPERTIES_INFO, {})
+        end
+        class << self
+          alias_method :orig_new, :new
+        end
+      end
+      c.extend ClassMethods::Property
+      c.extend ClassMethods::Relationship
+      c.extend ClassMethods::Aggregate
+      c.extend Neo4j::Index::ClassMethods
+      def c.inherited(subclass)
+        subclass.indexer subclass
+        super
+      end
+      c.indexer c
+
+    end
+
+
+  end
+end

data/lib/neo4j/neo4j.rb

@@ -0,0 +1,65 @@
+module Neo4j
+
+  class << self
+
+
+    # Start Neo4j using the default database.
+    # This is not required since the database will be started automatically when it is used.
+    #
+    def start
+      default_db
+    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
+    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 excetion 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
+
+
+    def shutdown(this_db = @db)
+      this_db.shutdown if this_db
+    end
+
+    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
+
+    def event_handler(this_db = default_db)
+      this_db.event_handler
+    end
+  end
+end

data/lib/neo4j/node.rb

@@ -0,0 +1,82 @@
+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
+
+    # provide a hook for ruby class mapping
+    def wrapped_entity
+      self
+    end
+
+    def class
+      Neo4j::Node
+    end
+  end
+
+
+  class Node
+    extend Neo4j::Index::ClassMethods
+
+    self.indexer self
+
+    class << self
+
+
+      # Creates a new node using the default db instance when given no args
+      # Same as Neo4j::Node#create
+      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.set_property(k.to_s, v) } if props
+        node
+      end
+
+      # create is the same as new
+      alias_method :create, :new
+
+      def load(node_id, db = Neo4j.started_db)
+        load_wrapper(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
+
+      def load_wrapper(node)
+        return node unless node.property?(:_classname)
+        to_class(node[:_classname]).load_wrapper(node)
+      end
+
+      def to_class(class_name)
+        class_name.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
+      end
+
+      def exist?(node_or_node_id, db = Neo4j.started_db)
+        id = node_or_node_id.kind_of?(Fixnum) ?  node_or_node_id : node_or_node_id.id
+        load(id, db) != 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,60 @@
+module Neo4j
+
+
+  module NodeRelationship
+    include ToJava
+
+    def outgoing(type=nil)
+      if type
+        NodeTraverser.new(self).outgoing(type)
+      else
+        raise "not implemented yet"
+        NodeTraverser.new(self)
+      end
+    end
+
+    def incoming(type=nil)
+      if type
+        NodeTraverser.new(self).incoming(type)
+      else
+        raise "not implemented yet"
+        NodeTraverser.new(self)
+      end
+    end
+
+    def both(type=nil)
+      if type
+        NodeTraverser.new(self).both(type)
+      else
+        NodeTraverser.new(self) # default is both
+      end
+    end
+
+    def rels(*type)
+      RelationshipTraverser.new(self, type, :both)
+    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

data/lib/neo4j/node_traverser.rb

@@ -0,0 +1,141 @@
+module Neo4j
+
+  class PruneEvaluator  # :nodoc:
+    include org.neo4j.graphdb.traversal.PruneEvaluator
+    def initialize(proc)
+      @proc = proc
+    end
+
+    def prune_after(path)
+      @proc.call(path)
+    end
+  end
+
+  class FilterPredicate # :nodoc:
+    include org.neo4j.helpers.Predicate
+    def initialize
+      @procs = []
+    end
+
+    def add(proc)
+      @procs << proc
+    end
+
+    def include_start_node
+      @include_start_node = true
+    end
+
+    def accept(path)
+      return false if @include_start_node && path.length == 0
+      # find the first filter which returns false
+      # if not found then we will accept this path
+      @procs.find {|p| !p.call(path)}.nil?
+    end
+  end
+
+
+  class NodeTraverser
+    include Enumerable
+    include ToJava
+
+    def initialize(from, type = nil, dir=nil)
+      @from  = from
+      @depth = 1
+      if type.nil? || dir.nil?
+        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first()
+      else
+        @type  = type_to_java(type)
+        @dir   = dir_to_java(dir)
+        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
+      end
+    end
+
+
+
+    def <<(other_node)
+      new(other_node)
+      self
+    end
+
+    def new(other_node)
+      raise "Only allowed to create outgoing relationships, please add it on the other node if you want to create an incoming relationship" unless @dir == org.neo4j.graphdb.Direction::OUTGOING
+      @from.create_relationship_to(other_node, @type)
+    end
+
+    def both(type)
+      @type  = type_to_java(type) if type
+      @dir   = dir_to_java(:both)
+      @td = @td.relationships(type_to_java(type), @dir)
+      self
+    end
+
+    def outgoing(type)
+      @type  = type_to_java(type) if type
+      @dir   = dir_to_java(:outgoing)
+      @td = @td.relationships(type_to_java(type), @dir)
+      self
+    end
+
+    def incoming(type)
+      @type  = type_to_java(type) if type
+      @dir   = dir_to_java(:incoming)
+      @td = @td.relationships(type_to_java(type), @dir)
+      self
+    end
+
+    def filter_method(name, &proc)
+      # add method name
+      singelton = class << self; self; end
+      singelton.send(:define_method, name) {filter &proc}
+      self
+    end
+
+    def prune(&block)
+      @td = @td.prune(PruneEvaluator.new(block))
+      self
+    end
+
+    def filter(&block)
+      # we keep a reference to filter predicate since only one filter is allowed and we might want to modify it
+      @filter_predicate ||= FilterPredicate.new
+      @filter_predicate.add(block)
+      @td = @td.filter(@filter_predicate)
+      self
+    end
+
+    # Sets depth, if :all then it will traverse any depth
+    def depth(d)
+      @depth = d
+      self
+    end
+
+    def include_start_node
+      @include_start_node = true
+      self
+    end
+
+    def size
+      [*self].size
+    end
+
+    def each
+      iter = iterator
+      while (iter.hasNext) do
+        yield Neo4j::Node.load_wrapper(iter.next)
+      end
+    end
+
+    def iterator
+      unless @include_start_node
+        if @filter_predicate
+          @filter_predicate.include_start_node
+        else
+          @td = @td.filter(org.neo4j.kernel.Traversal.return_all_but_start_node)
+        end
+      end
+      @td = @td.prune(org.neo4j.kernel.Traversal.pruneAfterDepth( @depth ) ) unless @depth == :all
+      @td.traverse(@from).nodes.iterator
+    end
+  end
+
+end