neo4j 1.0.0.beta.27-java → 1.0.0.beta.28-java

data/lib/neo4j/database.rb

@@ -1,3 +1,7 @@
+require 'neo4j/config'
+require 'neo4j/event_handler'
+require 'neo4j/transaction'
+
 module Neo4j
   # Wraps both Java Neo4j GraphDatabaseService and Lucene.
   # You can access the raw java neo4j and lucene db's with the <tt>graph</tt> and <tt>lucene</tt>
@@ -7,7 +11,7 @@ module Neo4j
   # If one tries to start an already started database then a read only instance to neo4j will be used.
   #
   class Database
-    attr_reader :graph, :lucene, :event_handler
+    attr_reader :graph, :lucene, :event_handler, :storage_path
 
     def initialize()
       @event_handler = EventHandler.new
@@ -16,6 +20,7 @@ module Neo4j
     def start #:nodoc:
       return if running?
       @running = true
+      @storage_path = Config.storage_path
 
       begin
         if self.class.locked?
@@ -36,24 +41,24 @@ module Neo4j
     end
 
     def start_readonly_graph_db #:nodoc:
-      Neo4j.logger.info "Starting Neo4j in readonly mode since the #{Neo4j.config.storage_path} is locked"
+      Neo4j.logger.info "Starting Neo4j in readonly mode since the #{@storage_path} is locked"
       Neo4j.load_local_jars
-      @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(Config[:storage_path], Config.to_java_map)
+      @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(@storage_path, Config.to_java_map)
     end
 
     def start_local_graph_db #:nodoc:
-      Neo4j.logger.info "Starting local Neo4j using db #{Neo4j.config.storage_path}"
+      Neo4j.logger.info "Starting local Neo4j using db #{@storage_path}"
       Neo4j.load_local_jars
-      @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(Neo4j.config.storage_path, Config.to_java_map)
+      @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(@storage_path, Config.to_java_map)
       @graph.register_transaction_event_handler(@event_handler)
       @lucene = @graph.index
       @event_handler.neo4j_started(self)
     end
 
     def start_ha_graph_db
-      Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.machine_id']} at #{Neo4j.config['ha.server']} db #{Neo4j.config.storage_path}"
+      Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.machine_id']} at #{Neo4j.config['ha.server']} db #{@storage_path}"
       Neo4j.load_ha_jars # those jars are only needed for the HighlyAvailableGraphDatabase
-      @graph = org.neo4j.kernel.HighlyAvailableGraphDatabase.new(Neo4j.config.storage_path, Neo4j.config.to_java_map)
+      @graph = org.neo4j.kernel.HighlyAvailableGraphDatabase.new(@storage_path, Neo4j.config.to_java_map)
       @graph.register_transaction_event_handler(@event_handler)
       @lucene = @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
       @event_handler.neo4j_started(self)
@@ -69,7 +74,7 @@ module Neo4j
       @graph.isReadOnly
     end
 
-    # check if the database is locked. A neo4j database is locked when there is running.
+    # check if the database is locked. A neo4j database is locked when the database is running.
     def self.locked?
       lock_file = File.join(Neo4j.config.storage_path, 'neostore')
       return false unless File.exist?(lock_file)

data/lib/neo4j/{mapping/class_methods/list.rb → has_list/class_methods.rb}

@@ -1,13 +1,11 @@
-module Neo4j::Mapping
+module Neo4j::HasList
   module ClassMethods
-    module List
       def has_list(name, params = {})
         module_eval(%Q{
                 def #{name}
-                  Neo4j::Mapping::HasList.new(self, '#{name}')
+                  Neo4j::HasList::Mapping.new(self, '#{name}')
                 end}, __FILE__, __LINE__)
       end
-    end
   end
 end
 

data/lib/neo4j/has_list/has_list.rb

@@ -0,0 +1,3 @@
+require 'neo4j/has_list/class_methods'
+require 'neo4j/has_list/mapping'
+

data/lib/neo4j/{mapping/has_list.rb → has_list/mapping.rb}

@@ -1,5 +1,5 @@
 module Neo4j
-  module Mapping
+  module HasList
 
     # Enables creating and traversal of nodes in a list.
     #
@@ -31,7 +31,7 @@ module Neo4j
     #
     #  person.feeds[42] # => a
     #
-    class HasList
+    class Mapping
       include Enumerable
       include ToJava
       include WillPaginate::Finders::Base

data/lib/neo4j/{mapping/class_methods/relationship.rb → has_n/class_methods.rb}

@@ -1,12 +1,11 @@
-module Neo4j::Mapping
-  module ClassMethods
-
-    module Relationship
+module Neo4j
+  module HasN
+    module ClassMethods
       include Neo4j::ToJava
 
       # Specifies a relationship between two node classes.
       # Generates assignment and accessor methods for the given relationship.
-      # Both incoming and outgoing relationships can be declared, see Neo4j::Mapping::DeclRelationshipDsl
+      # Both incoming and outgoing relationships can be declared, see Neo4j::HasN::DeclRelationshipDsl
       #
       # ==== Example
       #
@@ -19,32 +18,63 @@ module Neo4j::Mapping
       #   folder.files << Neo4j::Node.new << Neo4j::Node.new
       #   folder.files.inject {...}
       #
+      #   FolderNode.files #=> 'files' the name of the relationship
+      #
+      # ==== Example has_n(x).to(...)
+      #
+      # You can declare which class it has relationship to.
+      # The generated relationships will be prefixed with the name of that class.
+      #
+      #   class FolderNode
+      #      include Ne4j::NodeMixin
+      #      has_n(:files).to(File)
+      #   end
+      #
+      #   FolderNode.files #=> 'File#files' the name of the relationship
+      #
+      # ==== Example has_n(x).from(class, has_n_name)
+      #
+      # Neo4j.rb can also generate accessor method for traversing and adding relationship on incoming nodes.
+      #
+      #   class FileNode
+      #      include Ne4j::NodeMixin
+      #      has_one(:folder).from(FolderNode, :files)
+      #   end
+      #
+      #
       # ==== Returns
       #
-      # Neo4j::Mapping::DeclRelationshipDsl
+      # * This method returns Neo4j::HasN::DeclRelationshipDsl
+      # * The generated has_n method returns a Neo4j::HasN::Mapping object
       #
       def has_n(rel_type, params = {})
         clazz = self
         module_eval(%Q{
                 def #{rel_type}
                     dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                    Neo4j::Mapping::HasN.new(self, dsl)
+                    Neo4j::HasN::Mapping.new(self, dsl)
                 end}, __FILE__, __LINE__)
 
+        
         module_eval(%Q{
                 def #{rel_type}_rels
                     dsl = _decl_rels_for('#{rel_type}'.to_sym)
                     dsl.all_relationships(self)
                 end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, false, clazz, params)
+        instance_eval(%Q{
+          def #{rel_type}
+            _decl_rels[:#{rel_type}].rel_type.to_s
+          end}, __FILE__, __LINE__)
+
+        _decl_rels[rel_type.to_sym] = DeclRelationshipDsl.new(rel_type, false, clazz, params)
       end
 
 
       # Specifies a relationship between two node classes.
       # Generates assignment and accessor methods for the given relationship
       # Old relationship is deleted when a new relationship is assigned.
-      # Both incoming and outgoing relationships can be declared, see Neo4j::Mapping::DeclRelationshipDsl
+      # Both incoming and outgoing relationships can be declared, see Neo4j::HasN::DeclRelationshipDsl
       #
       # ==== Example
       #
@@ -60,7 +90,7 @@ module Neo4j::Mapping
       #
       # ==== Returns
       #
-      # Neo4j::Mapping::DeclRelationshipDsl
+      # Neo4j::HasN::DeclRelationshipDsl
       #
       def has_one(rel_type, params = {})
         clazz = self
@@ -82,9 +112,9 @@ module Neo4j::Mapping
                   dsl.single_relationship(self)
                end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, clazz, params)
+        _decl_rels[rel_type.to_sym] = DeclRelationshipDsl.new(rel_type, true, clazz, params)
       end
 
     end
   end
-end
+end

data/lib/neo4j/has_n/decl_relationship_dsl.rb

@@ -0,0 +1,216 @@
+module Neo4j
+  module HasN
+
+
+    # A DSL for declared relationships has_n and has_one
+    # This DSL will be used to create accessor methods for relationships.
+    # Instead of using the 'raw' Neo4j::NodeMixin#rels method where one needs to know
+    # the name of relationship and direction one can use the generated accessor methods.
+    #
+    # The DSL can also be used to specify a mapping to a Ruby class for a relationship, see Neo4j::HasN::DeclRelationshipDsl#relationship
+    #
+    # ==== Example
+    #
+    #   class Folder
+    #      include Neo4j::NodeMixin
+    #      property :name
+    #      # Declaring a Many relationship to any other node
+    #      has_n(:files)
+    #    end
+    #
+    #   class File
+    #     include Neo4j::NodeMixin
+    #     # declaring a incoming relationship from Folder's relationship files
+    #     has_one(:folder).from(Folder, :files)
+    #   end
+    #
+    # The following methods will be generated:
+    # <b>Folder#files</b> ::      returns an Enumerable of outgoing nodes for relationship 'files'
+    # <b>Folder#files_rels</b> :: returns an Enumerable of outgoing relationships for relationship 'files'
+    # <b>File#folder</b> ::       for adding one node for the relationship 'files' from the outgoing Folder node
+    # <b>File#folder_rel</b> ::   for accessing relationship 'files' from the outgoing Folder node
+    # <b>File#folder</b> ::       for accessing nodes from relationship 'files' from the outgoing Folder node
+    #
+    class DeclRelationshipDsl
+      include Neo4j::ToJava
+
+      attr_reader :target_class, :direction, :rel_type
+
+      def initialize(method_id, has_one, target_class, params)
+        @direction = :outgoing
+        @method_id = method_id
+        @has_one = has_one
+        @rel_type = method_id
+        @target_class = target_class
+      end
+
+      def to_s
+        "DeclRelationshipDsl #{object_id} dir: #{@direction} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_class} rel_class:#{@relationship}"
+      end
+
+      def has_one?
+        @has_one
+      end
+
+      def each_node(node, direction, raw = false, &block) #:nodoc:
+        type = type_to_java(rel_type)
+        dir = dir_to_java(direction)
+        node._java_node.getRelationships(type, dir).each do |rel|
+          other = raw ? rel.getOtherNode(node) : rel.getOtherNode(node).wrapper
+          block.call other
+        end
+      end
+
+      def incoming? #:nodoc:
+        @direction == :incoming
+      end
+
+      def single_node(node) #:nodoc:
+        rel = single_relationship(node)
+        rel && rel.other_node(node).wrapper
+      end
+
+      def single_relationship(node) #:nodoc:
+        node._java_node.rel(direction, rel_type)
+      end
+
+      def _all_relationships(node) #:nodoc:
+        type = type_to_java(rel_type)
+        dir = dir_to_java(direction)
+        node._java_node.getRelationships(type, dir)
+      end
+
+      def all_relationships(node) #:nodoc:
+        Neo4j::Rels::Traverser.new(node._java_node, [rel_type], direction)
+      end
+
+      def create_relationship_to(node, other) # :nodoc:
+        from, to = incoming? ? [other, node] : [node, other]
+        java_type = type_to_java(rel_type)
+
+        rel = from._java_node.create_relationship_to(to._java_node, java_type)
+        rel[:_classname] = relationship_class.to_s if relationship_class
+        rel.wrapper
+      end
+
+      # Specifies an outgoing relationship.
+      # The name of the outgoing class will be used as a prefix for the relationship used.
+      #
+      # ==== Arguments
+      # clazz:: to which class this relationship goes
+      # relationship:: optional, the relationship to use
+      #
+      # ==== Example
+      #   class FolderNode
+      #     include Neo4j::NodeMixin
+      #     has_n(:files).to(FileNode)
+      #   end
+      #
+      #  folder = FolderNode.new
+      #  # generate a relationship between folder and file of type 'FileNode#files'
+      #  folder.files << FileNode.new
+      #
+      def to(*args)
+        @direction = :outgoing
+
+        if (args.size > 1)
+          raise "only one argument expected - the class of the node this relationship points to, got #{args.inspect}"
+        elsif (Class === args[0])
+          # handle e.g. has_n(:friends).to(class)
+          @target_class = args[0]
+          @rel_type = "#{@target_class}##{@method_id}"
+        else
+          raise "Expected a class for, got #{args[0]}/#{args[0].class}"
+        end
+        self
+      end
+
+      # Specifies an incoming relationship.
+      # Will use the outgoing relationship given by the from class.
+      #
+      # ==== Example, with prefix FileNode
+      #   class FolderNode
+      #     include Neo4j::NodeMixin
+      #     has_n(:files).to(FileNode)
+      #   end
+      #
+      #   class FileNode
+      #     include Neo4j::NodeMixin
+      #     # will only traverse any incoming relationship of type files from node FileNode
+      #     has_one(:folder).from(FileNode, :files)
+      #   end
+      #
+      #   file = FileNode.new
+      #   # create an outgoing relationship of type 'FileNode#files' from folder node to file (FileNode is the prefix).
+      #   file.folder = FolderNode.new
+      #
+      # ==== Example, without prefix
+      #
+      #   class FolderNode
+      #     include Neo4j::NodeMixin
+      #     has_n(:files)
+      #   end
+      #
+      #   class FileNode
+      #     include Neo4j::NodeMixin
+      #     has_one(:folder).from(:files)  # will traverse any incoming relationship of type files
+      #   end
+      #
+      #   file = FileNode.new
+      #   # create an outgoing relationship of type 'FileNode#files' from folder node to file
+      #   file.folder = FolderNode.new
+      #
+      #
+      def from(*args)
+        @direction = :incoming
+
+        if (args.size > 1)
+          # handle specified (prefixed) relationship, e.g. has_n(:known_by).from(clazz, :type)
+          @rel_type = "#{@target_class}##{args[1]}"
+          @target_class = args[0]
+          other_class_dsl = @target_class._decl_rels[args[1]]
+          if other_class_dsl
+            @relationship = other_class_dsl.relationship_class
+          else
+            Neo4j.logger.warn "Unknown outgoing relationship #{args[1]} on #{@target_class}"
+          end
+        elsif (Symbol === args[0])
+          # handle unspecified (unprefixed) relationship, e.g. has_n(:known_by).from(:type)
+          @rel_type = args[0]
+        else
+          raise "Expected a symbol for, got #{args[0]}"
+        end
+        self
+      end
+
+      # Specifies which relationship ruby class to use for the relationship
+      #
+      # ==== Example
+      #
+      #   class OrderLine
+      #     include Neo4j::RelationshipMixin
+      #     property :units
+      #     property :unit_price
+      #   end
+      #
+      #   class Order
+      #     property :total_cost
+      #     property :dispatched
+      #     has_n(:products).to(Product).relationship(OrderLine)
+      #   end
+      #
+      #  order = Order.new
+      #  order.products << Product.new
+      #  order.products_rels.first # => OrderLine
+      #
+      def relationship(rel_class)
+        @relationship = rel_class
+        self
+      end
+
+      def relationship_class # :nodoc:
+        @relationship
+      end
+    end
+  end
+end

data/lib/neo4j/has_n/has_n.rb

@@ -0,0 +1,3 @@
+require 'neo4j/has_n/class_methods'
+require 'neo4j/has_n/decl_relationship_dsl'
+require 'neo4j/has_n/mapping'

data/lib/neo4j/{mapping/has_n.rb → has_n/mapping.rb}

@@ -1,16 +1,20 @@
+require 'neo4j/has_n/class_methods'
+require 'neo4j/has_n/decl_relationship_dsl'
+require 'neo4j/has_n/mapping'
+
 module Neo4j
-  module Mapping
+  module HasN
 
-    # Enables creating and traversal of nodes.
+    # The object created by a has_n or has_one Neo4j::NodeMixin class method which enables creating and traversal of nodes.
     #
-    # Includes the Enumerable Mixin.
+    # Includes the Enumerable and WillPaginate mixins.
     # The Neo4j::Mapping::ClassMethods::Relationship#has_n and Neo4j::Mapping::ClassMethods::Relationship#one
     # methods returns an object of this type.
     #
     # ==== See Also
-    # Neo4j::Mapping::ClassMethods::Relationship
+    # Neo4j::HasN::ClassMethods
     #
-    class HasN
+    class Mapping
       include Enumerable
       include WillPaginate::Finders::Base
       
@@ -23,11 +27,11 @@ module Neo4j
       end
 
       def to_s
-        "HasN [#@direction, id: #{@node.neo_id} type: #{@dsl && @dsl.rel_type} dsl:#{@dsl}]"
+        "HasN::Mapping [#@direction, id: #{@node.neo_id} type: #{@dsl && @dsl.rel_type} dsl:#{@dsl}]"
       end
 
       def size
-        [*self].size
+        self.to_a.size
       end
 
       alias_method :length, :size
@@ -56,6 +60,11 @@ module Neo4j
         @dsl.each_node(@node, @direction, true, &block)
       end
 
+      # Returns an real ruby array.
+      def to_ary
+        self.to_a
+      end
+
       def wp_query(options, pager, args, &block) #:nodoc:
          page     = pager.current_page || 1
          to       = pager.per_page * page