neo4j 1.0.0.beta.24-java → 1.0.0.beta.25-java

data/lib/generators/neo4j.rb

@@ -2,7 +2,7 @@ require 'rails/generators/named_base'
 require 'rails/generators/active_model'
 
 module Neo4j
-	module Generators
+	module Generators #:nodoc:
 	end
 end
 

data/lib/generators/neo4j/model/model_generator.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'neo4j.rb')
 
-class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base
+class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
 	argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
 	
 	check_class_collision

data/lib/neo4j.rb

@@ -5,11 +5,12 @@ require 'forwardable'
 require 'time'
 require 'date'
 
-require 'neo4j/jars/neo4j-index-1.2-1.2.M04.jar'
-require 'neo4j/jars/neo4j-kernel-1.2-1.2.M04.jar'
-require 'neo4j/jars/neo4j-lucene-index-0.2-1.2.M04.jar'
+require 'neo4j/jars/neo4j-index-1.2-1.2.jar'
+require 'neo4j/jars/neo4j-kernel-1.2-1.2.jar'
+require 'neo4j/jars/neo4j-lucene-index-0.2-1.2.jar'
 require 'neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar'
 require 'neo4j/jars/lucene-core-3.0.2.jar'
+require 'neo4j/jars/neo4j-graph-algo-0.7-1.2'
 
 require 'will_paginate/collection'
 require 'will_paginate/finders/base'
@@ -56,6 +57,7 @@ require 'neo4j/mapping/rule_node'
 require 'neo4j/node_mixin'
 require 'neo4j/relationship_mixin'
 require 'neo4j/mapping/class_methods/rule'
+require 'neo4j/algo'
 
 # rails
 require 'rails/railtie'

data/lib/neo4j/algo.rb

@@ -0,0 +1,290 @@
+module Neo4j
+
+
+  class Algo
+    include Enumerable
+    include ToJava
+
+    class EstimateEvaluator #:nodoc
+      include org.neo4j.graphalgo.EstimateEvaluator
+      include ToJava
+
+      def initialize(&evaluator)
+        @evaluator = evaluator
+      end
+
+      # Implements T getCost(Node node, Node goal)
+      # Estimate the weight of the remaining path from one node to another.
+      def get_cost(node, goal)
+        @evaluator.call(node, goal)
+      end
+    end
+
+    class CostEvaluator #:nodoc
+      include org.neo4j.graphalgo.CostEvaluator
+      include ToJava
+
+      def initialize(&evaluator)
+        @evaluator = evaluator
+      end
+
+      # Implements the Java Method:   T getCost(Relationship relationship, Direction direction)
+      # From the JavaDoc: <pre>
+      # This is the general method for looking up costs for relationships.
+      # This can do anything, like looking up a property or running some small calculation.
+      # Parameters:
+      # relationship -
+      # direction - The direction in which the relationship is being evaluated, either Direction.INCOMING or Direction.OUTGOING.
+      # Returns:
+      # The cost for this edge/relationship
+      # </pre>
+      def get_cost(relationship, direction)
+        @evaluator.call(relationship, dir_from_java(direction))
+      end
+    end
+
+    def initialize(from, to, &factory_proc) #:nodoc:
+      @from          = from
+      @to            = to
+      @factory_proc  = factory_proc
+      @type_and_dirs = []
+
+    end
+
+    def _depth #:nodoc:
+      @depth || java.lang.Integer::MAX_VALUE
+    end
+
+    def _expander #:nodoc:
+      expander = @expander
+      expander ||= @type_and_dirs.empty? ? org.neo4j.kernel.Traversal.expanderForAllTypes() : org.neo4j.kernel.Traversal.expanderForTypes(*@type_and_dirs)
+      expander
+    end
+
+    def _cost_evaluator #:nodoc:
+      raise "Algorithm requeries a cost evalulator, use the cost_evaluator to provide one" unless @cost_evaluator
+      @cost_evaluator
+    end
+
+    def _estimate_evaluator #:nodoc:
+      raise "Algorithm requeries a estimate evaluator, use the estimate_evaluator to provide one" unless @estimate_evaluator
+      @estimate_evaluator
+    end
+
+    # Specifies which outgoing relationship should be traversed for the graph algorithm
+    #
+    # ==== Parameters
+    # * rel :: relationship type (symbol)
+    def outgoing(rel)
+      @type_and_dirs << type_to_java(rel)
+      @type_and_dirs << dir_to_java(:outgoing)
+      self
+    end
+
+    # Specifies which incoming relationship should be traversed for the graph algorithm
+    #
+    # ==== Parameters
+    # * rel :: relationship type (symbol)
+    def incoming(rel)
+      @type_and_dirs << type_to_java(rel)
+      @type_and_dirs << dir_to_java(:incoming)
+      self
+    end
+
+    # Specifies which relationship should be traversed for the graph algorithm
+    #
+    # ==== Example
+    # The following:
+    #
+    #  Neo4j::Algo.shortest_path(@x,@y).expand{|node| node._rels(:outgoing, :friends)}
+    #
+    # Is the same as
+    #  Neo4j::Algo.shortest_path(@x,@y).outgoing(:friends)
+    #
+    # ==== Parameters
+    # * expander_proc :: a proc relationship type (symbol)
+    def expand(&expander_proc)
+      @expander = (RelExpander.create_pair(&expander_proc))
+      self
+    end
+
+    # If only a single path should be returned,
+    # default for some algorithms, like shortest_path
+    def single
+      @single = true
+      self
+    end
+
+    # See #single
+    # Not sure if this method is useful
+    def many
+      @single = false
+    end
+
+    # The depth of the traversal
+    # Notice not all algorithm uses this argument (aStar and dijkstra)
+    def depth(depth)
+      @depth = depth
+      self
+    end
+
+    # Specifies a cost evaluator for the algorithm.
+    # Only available for the aStar and dijkstra algorithms.
+    #
+    # ==== Example
+    #  Neo4j::Algo.dijkstra(@x,@y).cost_evaluator{|rel,*| rel[:weight]}
+    #
+    def cost_evaluator(&cost_evaluator_proc)
+      @cost_evaluator = CostEvaluator.new(&cost_evaluator_proc)
+      self
+    end
+
+    # Specifies an evaluator that returns an (optimistic) estimation of the cost to get from the current node (in the traversal) to the end node.
+    # Only available for the aStar algorithm.
+    #
+    # The provided proc estimate the weight of the remaining path from one node to another.
+    # The proc takes two parameters:
+    # * node :: the node to estimate the weight from.
+    # * goal :: the node to estimate the weight to.
+    #
+    # The proc should return an estimation of the weight of the path from the first node to the second.
+    #
+    # ==== Example
+    #
+    #  Neo4j::Algo.a_star(@x,@y).cost_evaluator{...}.estimate_evaluator{|node,goal| some calucalation retuning a Float}
+    #
+    def estimate_evaluator(&estimate_evaluator_proc)
+      @estimate_evaluator = EstimateEvaluator.new(&estimate_evaluator_proc)
+      self
+    end
+
+    # Specifies that nodes should be returned from as result (this is default)
+    # See also #rels
+    def nodes
+      @path_finder_method = :nodes
+      self
+    end
+
+    # Specifies that relationships should be returned from as result (this is default)
+    # See also #nodes
+    #
+    def rels
+      @path_finder_method = :relationships
+      self
+    end
+
+
+    # So that one can call directly method on the PathFinder result from an executed algorithm.
+    def method_missing(m, *args, &block)
+      execute_algo.send(m, *args)
+    end
+
+    def each(&block) #:nodoc:
+      if @single
+        execute_algo.send(@path_finder_method || :nodes).each &block
+      else
+        execute_algo.each &block
+      end
+    end
+
+    def execute_algo #:nodoc:
+      instance = self.instance_eval(&@factory_proc)
+      if @single
+        instance.find_single_path(@from._java_node, @to._java_node)
+      else
+        instance.find_all_paths(@from._java_node, @to._java_node)
+      end
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all available paths between two nodes.
+    # These returned paths can contain loops (i.e. a node can occur more than once in any returned path).
+    def self.all_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }
+    end
+
+    # See #all_paths, returns the first path found
+    def self.all_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all simple paths between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    def self.all_simple_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }
+    end
+
+    # See #all_simple_paths, returns the first path found
+    def self.all_simple_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all shortest paths (that is paths with as short Path.length() as possible) between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    def self.shortest_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }
+    end
+
+    # See #shortest_paths, returns the first path found
+    def self.shortest_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which uses the Dijkstra algorithm to find the cheapest path between two nodes.
+    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from costEvaluator.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # See http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm for more information.
+    #
+    # Example
+    #
+    #   Neo4j::Algo.dijkstra_path(node_a,node_b).cost_evaluator{|rel,*| rel[:weight]}.rels
+    #
+    def self.dijkstra_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }
+    end
+
+    # See #dijkstra_paths, returns the first path found
+    #
+    def self.dijkstra_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which uses the A* algorithm to find the cheapest path between two nodes.
+    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from lengthEvaluator and estimateEvaluator. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # See http://en.wikipedia.org/wiki/A*_search_algorithm for more information.
+    #
+    # Expacts an cost evaluator and estimate evaluator, see Algo#cost_evaluator and Algo#estimate_evaluator
+    #
+    # Example:
+    #
+    #  Neo4j::Algo.a_star_path(@x,@y).cost_evaluator{|rel,*| rel[:weight]}.estimate_evaluator{|node,goal| returns a float value}
+    #
+    def self.a_star_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }
+    end
+
+    # See #a_star_paths, returns the first path found
+    #
+    def self.a_star_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo can find all paths of a certain length(depth) between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # Expects setting the depth parameter (the lenghto of the path) by the Algo#depth method.
+    #
+    # Example:
+    #
+    #   Neo4j::Algo.with_length_paths(node_a,node_b).depth(2).each {|x| puts "Node #{x}"}
+    #
+    def self.with_length_paths(from,to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }
+    end
+
+    # See #with_length_paths, returns the first path found
+    #
+    def self.with_length_path(from,to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }.single
+    end
+
+  end
+end

data/lib/neo4j/database.rb

@@ -1,15 +1,19 @@
-require 'drb'
-require 'socket'
-
 module Neo4j
-  class Database #:nodoc:
+  # 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>
+  # properties.
+  #
+  # This class is also responsible for checking if there is already a running neo4j database.
+  # 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
 
     def initialize()
       @event_handler = EventHandler.new
     end
 
-    def start
+    def start #:nodoc:
       return if running?
       @running = true
       
@@ -22,26 +26,29 @@ module Neo4j
       at_exit { shutdown }
     end
 
-    def start_readonly_graph_db
+    def start_readonly_graph_db #:nodoc:
       puts "Starting Neo4j in readonly mode since the #{Config[:storage_path]} is locked"
       @graph = org.neo4j.kernel.EmbeddedReadOnlyGraphDatabase.new(Config[:storage_path])
     end
 
-    def start_local_graph_db
+    def start_local_graph_db #:nodoc:
       @graph = org.neo4j.kernel.EmbeddedGraphDatabase.new(Config[:storage_path])
       @graph.register_transaction_event_handler(@event_handler)
       @lucene =  @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
       @event_handler.neo4j_started(self)
     end
 
-    def running?
+    def running? #:nodoc:
       @running
     end
 
+    # Returns true if the neo4j db was started in read only mode.
+    # This can occur if the database was locked (it was already one instance running).
     def read_only?
       @graph.isReadOnly
     end
 
+    # check if the database is locked. A neo4j database is locked when there is running.
     def self.locked?
       lock_file = File.join(::Neo4j::Config[:storage_path], 'neostore')
       return false unless File.exist?(lock_file)
@@ -55,7 +62,7 @@ module Neo4j
       end
     end
     
-    def shutdown
+    def shutdown #:nodoc:
       if @running
         @graph.unregister_transaction_event_handler(@event_handler) unless read_only?
         @event_handler.neo4j_shutdown(self)
@@ -67,19 +74,19 @@ module Neo4j
 
     end
 
-    def begin_tx
+    def begin_tx #:nodoc:
       @graph.begin_tx
     end
 
 
-    def each_node
+    def each_node #:nodoc:
       iter = @graph.all_nodes.iterator
       while (iter.hasNext)
         yield iter.next.wrapper
       end
     end
 
-    def _each_node
+    def _each_node #:nodoc:
       iter = @graph.all_nodes.iterator
       while (iter.hasNext)
         yield iter.next

data/lib/neo4j/mapping/class_methods/relationship.rb

@@ -33,7 +33,7 @@ module Neo4j::Mapping
 
         module_eval(%Q{
                 def #{rel_type}_rels
-                    dsl = #{clazz}._decl_rels[:'#{rel_type.to_s}']
+                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
                     dsl.all_relationships(self)
                 end}, __FILE__, __LINE__)
 

data/lib/neo4j/node.rb

@@ -8,20 +8,20 @@ module Neo4j
     include Neo4j::Equal
     include Neo4j::Index
 
-    # Delete the node and all its relationship
+    # 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.
     #
     # ==== Returns
-    # true :: if the node was deleted
-    # false :: if node was not deleted, maybe it has already been deleted
+    # nil or raise an exception
     #
     def del
       rels.each {|r| r.del}
-      begin
-        delete
-        true
-      rescue
-        false
-      end
+      delete
+      nil
     end
 
     # returns true if the node exists in the database

data/lib/neo4j/node_relationship.rb

@@ -5,6 +5,20 @@ module Neo4j
     include ToJava
 
 
+    # A more powerful alternative of #outgoing, #incoming and #both method.
+    # You can use this method for example to only traverse nodes based on properties on the relationships
+    #
+    # ==== Example
+    #
+    #   some_node.expand { |n| n._rels.find_all { |r| r[:age] > 5 } }.depth(:all).to_a
+    #
+    # The above traverse all relationships with a property of age > 5
+    #
+    def expand(&expander)
+      NodeTraverser.new(self).expander(&expander)
+    end
+
+
     # Returns the outgoing nodes for this node.
     #
     # ==== Returns

data/lib/neo4j/node_traverser.rb

@@ -11,6 +11,34 @@ module Neo4j
     end
   end
 
+  class RelExpander
+    include org.neo4j.graphdb.RelationshipExpander
+
+    attr_accessor :reversed
+
+    def initialize(&block)
+      @block = block
+      @reverse = false
+    end
+
+    def self.create_pair(&block)
+      normal = RelExpander.new(&block)
+      reversed = RelExpander.new(&block)
+      normal.reversed = reversed
+      reversed.reversed = normal
+      reversed.reverse!
+      normal
+    end
+
+    def expand(node)
+      @block.arity == 1 ? @block.call(node) : @block.call(node, @reverse)
+    end
+
+    def reverse!
+      @reverse = true
+    end
+  end
+  
   class FilterPredicate # :nodoc:
     include org.neo4j.helpers.Predicate
     def initialize
@@ -97,6 +125,11 @@ module Neo4j
       self
     end
 
+    def expander(&expander)
+      @td = @td.expand(RelExpander.create_pair(&expander))
+      self
+    end
+
     def outgoing(type)
       @type  = type_to_java(type) if type
       @dir   = dir_to_java(:outgoing)

data/lib/neo4j/rails/attributes.rb

@@ -1,13 +1,13 @@
-# This module handles the getting, setting and updating of attributes or properties
-# in a Railsy way.  This typically means not writing anything to the DB until the
-# object is saved (after validation).
-#
-# Externally, when we talk about properties (e.g. #property?, #property_names, #properties),
-# we mean all of the stored properties for this object include the 'hidden' props
-# with underscores at the beginning such as _neo_id and _classname.  When we talk
-# about attributes, we mean all the properties apart from those hidden ones.
 module Neo4j
   module Rails
+    # This module handles the getting, setting and updating of attributes or properties
+    # in a Railsy way.  This typically means not writing anything to the DB until the
+    # object is saved (after validation).
+    #
+    # Externally, when we talk about properties (e.g. #property?, #property_names, #properties),
+    # we mean all of the stored properties for this object include the 'hidden' props
+    # with underscores at the beginning such as _neo_id and _classname.  When we talk
+    # about attributes, we mean all the properties apart from those hidden ones.
     module Attributes
       extend ActiveSupport::Concern
 

data/lib/neo4j/rails/relationships/mapper.rb

@@ -2,11 +2,14 @@ module Neo4j
   module Rails
     module Relationships
 
-      class Mapper
-        def initialize(rel_type, dsl=nil)
+      class Mapper #:nodoc:
+        attr_reader :dsl
+
+        def initialize(rel_type, dsl, node)
           @rel_type      = rel_type
           @relationships = []
           @dsl           = dsl
+          @node          = node
         end
 
         def rel_type
@@ -17,41 +20,45 @@ module Neo4j
           (@dsl && @dsl.direction) || :outgoing
         end
 
-        def to_s
+        def to_s #:nodoc:
           "#{self.class} #{object_id} dir: #{direction} rel_type: #{@rel_type} wrapped #{@dsl}"
         end
         
         def single_relationship(*)
-          @relationships.first
+          use_persisted_rels? ? @dsl.single_relationship(@node) : @relationships.first
         end
 
-        def each(&block)
-          # TODO direction
-          # TODO DRY
-          @relationships.each do |rel|
-            block.call rel.end_node
+        def all_relationships(*)
+          if use_persisted_rels?
+            @dsl.all_relationships(@node)
+          else
+            @relationships
           end
-          @dsl.each(&block) if @dsl
         end
 
-        def each_node(node, direction, &block) #:nodoc:
-          # TODO direction
-          @relationships.each do |rel|
-            block.call rel.end_node
+        def each_node(node, direction, &block)
+          if use_persisted_rels?
+            @dsl.each_node(node, direction, &block)
+          else
+            # TODO direction
+            @relationships.each do |rel|
+              block.call rel.end_node
+            end
           end
-          @dsl.each_node(node, direction, &block) if @dsl && node.persisted?
+        end
+
+        def use_persisted_rels?
+          @relationships.empty? && @node.persisted?
         end
 
         def del_rel(rel)
-          # TODO, we need to delete this when it is saved
           @relationships.delete(rel)
         end
 
         def create_relationship_to(from, to)
-          #rel_type = (@dsl && @dsl.rel_type) || @rel_type
-          #from, to = (@dsl && @dsl.incoming?) ? [to, from] : [from, to]
           @relationships << Relationship.new(@rel_type, from, to, self)
         end
+        
 
         def single_node(from)
           if !@relationships.empty?

data/lib/neo4j/rails/relationships/relationships.rb

@@ -13,11 +13,15 @@ module Neo4j
 
         def <<(other)
           @mapper.create_relationship_to(@from_node, other)
+          self
+        end
+
+        def size
+          @mapper.dsl.all_relationships(@from_node).size
         end
 
         def each(&block)
-          # TODO Direction
-          @mapper.each &block
+          @mapper.each_node(@from_node, :outgoing, &block)
         end
       end
 
@@ -37,7 +41,7 @@ module Neo4j
         if false && persisted?
           dsl
         else
-          @relationships[type] ||= Mapper.new(type, dsl)
+          @relationships[type] ||= Mapper.new(type, dsl, self)
         end
       end
 
@@ -51,12 +55,8 @@ module Neo4j
       # Creates or traverse relationships in memory without communicating with the neo4j database.
       #
       def outgoing(rel_type)
-        if persisted?
-          super
-        else
-          @relationships[rel_type] ||= Mapper.new(rel_type)
-          OutgoingRelationship.new(self, @relationships[rel_type])
-        end
+        dsl = _decl_rels_for(rel_type)
+        OutgoingRelationship.new(self, dsl)
       end
     end
   end

data/lib/neo4j/relationship.rb

@@ -11,17 +11,13 @@ module Neo4j
 
     # Deletes the relationship between the start and end node
     #
+    # May raise an exception if delete was unsuccessful.
+    #
     # ==== Returns
-    # true :: if the relationship was deleted
-    # false :: if relationship was NOT deleted, maybe it has already been deleted
+    # nil
     #
     def del
-      begin
-        delete
-        true
-      rescue
-        false
-      end
+      delete
     end
 
     def end_node # :nodoc:

data/lib/neo4j/to_java.rb

@@ -5,6 +5,19 @@ module Neo4j
       org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
     end
 
+    def type_from_java(type)
+      type.get_type
+    end
+
+    def dir_from_java(dir)
+      case dir
+        when org.neo4j.graphdb.Direction::OUTGOING then :outgoing
+        when org.neo4j.graphdb.Direction::BOTH     then :both
+        when org.neo4j.graphdb.Direction::INCOMING then :incoming
+        else raise "unknown direction '#{dir} / #{dir.class}'"
+      end
+    end
+
     def dir_to_java(dir)
       case dir
         when :outgoing then org.neo4j.graphdb.Direction::OUTGOING

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.24"
+  VERSION = "1.0.0.beta.25"
 end

data/lib/tmp/neo4j/messages.log

@@ -1,43 +1,43 @@
-Wed Dec 15 10:16:02 CET 2010: Creating new db @ tmp/neo4j/neostore
-Wed Dec 15 10:16:02 CET 2010: Opened [tmp/neo4j/nioneo_logical.log.1] clean empty log, version=0
-Wed Dec 15 10:16:02 CET 2010: Opened [tmp/neo4j/lucene/lucene.log.1] clean empty log, version=0
-Wed Dec 15 10:16:02 CET 2010: Opened [tmp/neo4j/lucene-fulltext/lucene.log.1] clean empty log, version=0
-Wed Dec 15 10:16:02 CET 2010: Opened [/home/andreas/projects/neo4j/lib/tmp/neo4j/index/lucene.log.1] clean empty log, version=0
-Wed Dec 15 10:16:02 CET 2010: Extension org.neo4j.graphdb.index.IndexProvider[lucene] initialized ok
-Wed Dec 15 10:16:02 CET 2010: TM new log: tm_tx_log.1
-Wed Dec 15 10:16:02 CET 2010: --- CONFIGURATION START ---
-Wed Dec 15 10:16:02 CET 2010: Physical mem: 4017MB, Heap size: 483MB
-Wed Dec 15 10:16:02 CET 2010: Kernel version: Neo4j - Graph Database Kernel 1.2-1.2.M04
-Wed Dec 15 10:16:02 CET 2010: Operating System: Linux; version: 2.6.32-26-generic-pae; arch: i386
-Wed Dec 15 10:16:02 CET 2010: VM Name: Java HotSpot(TM) Client VM
-Wed Dec 15 10:16:02 CET 2010: VM Vendor: Sun Microsystems Inc.
-Wed Dec 15 10:16:02 CET 2010: VM Version: 17.1-b03
-Wed Dec 15 10:16:02 CET 2010: Boot Class Path: /usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/resources.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/rt.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/sunrsasign.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/jsse.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/jce.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/charsets.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/classes:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/jruby.jar
-Wed Dec 15 10:16:02 CET 2010: Class Path: :
-Wed Dec 15 10:16:02 CET 2010: Library Path: /usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/i386/client:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/i386:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/../lib/i386:/usr/java/packages/lib/i386:/lib:/usr/lib
-Wed Dec 15 10:16:02 CET 2010: Garbage Collector: Copy: [Eden Space, Survivor Space]
-Wed Dec 15 10:16:02 CET 2010: Garbage Collector: MarkSweepCompact: [Eden Space, Survivor Space, Tenured Gen, Perm Gen, Perm Gen [shared-ro], Perm Gen [shared-rw]]
-Wed Dec 15 10:16:02 CET 2010: VM Arguments: [-Djruby.memory.max=500m, -Djruby.stack.max=1024k, -Xmx500m, -Xss1024k, -Djffi.boot.library.path=/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/i386-Linux:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/ppc-Linux:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/x86_64-Linux, -Xbootclasspath/a:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/jruby.jar, -Djruby.home=/home/andreas/.rvm/rubies/jruby-1.5.5, -Djruby.lib=/home/andreas/.rvm/rubies/jruby-1.5.5/lib, -Djruby.script=jruby, -Djruby.shell=/bin/sh]
-Wed Dec 15 10:16:02 CET 2010: 
-Wed Dec 15 10:16:02 CET 2010: create=true
-Wed Dec 15 10:16:02 CET 2010: dir=tmp/neo4j/lucene-fulltext
-Wed Dec 15 10:16:02 CET 2010: logical_log=tmp/neo4j/nioneo_logical.log
-Wed Dec 15 10:16:02 CET 2010: neo_store=tmp/neo4j/neostore
-Wed Dec 15 10:16:02 CET 2010: neostore.nodestore.db.mapped_memory=20M
-Wed Dec 15 10:16:02 CET 2010: neostore.propertystore.db.arrays.mapped_memory=130M
-Wed Dec 15 10:16:02 CET 2010: neostore.propertystore.db.index.keys.mapped_memory=1M
-Wed Dec 15 10:16:02 CET 2010: neostore.propertystore.db.index.mapped_memory=1M
-Wed Dec 15 10:16:02 CET 2010: neostore.propertystore.db.mapped_memory=90M
-Wed Dec 15 10:16:02 CET 2010: neostore.propertystore.db.strings.mapped_memory=130M
-Wed Dec 15 10:16:02 CET 2010: neostore.relationshipstore.db.mapped_memory=100M
-Wed Dec 15 10:16:02 CET 2010: rebuild_idgenerators_fast=true
-Wed Dec 15 10:16:02 CET 2010: store_dir=tmp/neo4j
-Wed Dec 15 10:16:02 CET 2010: --- CONFIGURATION END ---
-Wed Dec 15 10:16:02 CET 2010: Extension org.neo4j.graphdb.index.IndexProvider[lucene] loaded ok
-Wed Dec 15 10:16:43 CET 2010: Closed log tmp/neo4j/nioneo_logical.log
-Wed Dec 15 10:16:43 CET 2010: NeoStore closed
-Wed Dec 15 10:16:43 CET 2010: Closed log /home/andreas/projects/neo4j/lib/tmp/neo4j/index/lucene.log
-Wed Dec 15 10:16:43 CET 2010: Closed log tmp/neo4j/lucene/lucene.log
-Wed Dec 15 10:16:43 CET 2010: NeoStore closed
-Wed Dec 15 10:16:43 CET 2010: Closed log tmp/neo4j/lucene-fulltext/lucene.log
-Wed Dec 15 10:16:43 CET 2010: TM shutting down
+Thu Dec 30 12:24:53 CET 2010: Creating new db @ tmp/neo4j/neostore
+Thu Dec 30 12:24:54 CET 2010: Opened [tmp/neo4j/nioneo_logical.log.1] clean empty log, version=0
+Thu Dec 30 12:24:54 CET 2010: Opened [tmp/neo4j/lucene/lucene.log.1] clean empty log, version=0
+Thu Dec 30 12:24:54 CET 2010: Opened [tmp/neo4j/lucene-fulltext/lucene.log.1] clean empty log, version=0
+Thu Dec 30 12:24:54 CET 2010: Opened [/home/andreas/projects/neo4j/lib/tmp/neo4j/index/lucene.log.1] clean empty log, version=0
+Thu Dec 30 12:24:54 CET 2010: Extension org.neo4j.graphdb.index.IndexProvider[lucene] initialized ok
+Thu Dec 30 12:24:54 CET 2010: TM new log: tm_tx_log.1
+Thu Dec 30 12:24:54 CET 2010: --- CONFIGURATION START ---
+Thu Dec 30 12:24:54 CET 2010: Physical mem: 4016MB, Heap size: 483MB
+Thu Dec 30 12:24:54 CET 2010: Kernel version: Neo4j - Graph Database Kernel 1.2-1.2.M04
+Thu Dec 30 12:24:54 CET 2010: Operating System: Linux; version: 2.6.35-24-generic-pae; arch: i386
+Thu Dec 30 12:24:54 CET 2010: VM Name: Java HotSpot(TM) Client VM
+Thu Dec 30 12:24:54 CET 2010: VM Vendor: Sun Microsystems Inc.
+Thu Dec 30 12:24:54 CET 2010: VM Version: 17.1-b03
+Thu Dec 30 12:24:54 CET 2010: Boot Class Path: /usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/resources.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/rt.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/sunrsasign.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/jsse.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/jce.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/charsets.jar:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/classes:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/jruby.jar
+Thu Dec 30 12:24:54 CET 2010: Class Path: :
+Thu Dec 30 12:24:54 CET 2010: Library Path: /usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/i386/client:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/lib/i386:/usr/lib/jvm/java-6-sun-1.6.0.22/jre/../lib/i386:/usr/java/packages/lib/i386:/lib:/usr/lib
+Thu Dec 30 12:24:54 CET 2010: Garbage Collector: Copy: [Eden Space, Survivor Space]
+Thu Dec 30 12:24:54 CET 2010: Garbage Collector: MarkSweepCompact: [Eden Space, Survivor Space, Tenured Gen, Perm Gen, Perm Gen [shared-ro], Perm Gen [shared-rw]]
+Thu Dec 30 12:24:54 CET 2010: VM Arguments: [-Djruby.memory.max=500m, -Djruby.stack.max=1024k, -Xmx500m, -Xss1024k, -Djffi.boot.library.path=/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/i386-Linux:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/ppc-Linux:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/native/x86_64-Linux, -Xbootclasspath/a:/home/andreas/.rvm/rubies/jruby-1.5.5/lib/jruby.jar, -Djruby.home=/home/andreas/.rvm/rubies/jruby-1.5.5, -Djruby.lib=/home/andreas/.rvm/rubies/jruby-1.5.5/lib, -Djruby.script=jruby, -Djruby.shell=/bin/sh]
+Thu Dec 30 12:24:54 CET 2010: 
+Thu Dec 30 12:24:54 CET 2010: create=true
+Thu Dec 30 12:24:54 CET 2010: dir=tmp/neo4j/lucene-fulltext
+Thu Dec 30 12:24:54 CET 2010: logical_log=tmp/neo4j/nioneo_logical.log
+Thu Dec 30 12:24:54 CET 2010: neo_store=tmp/neo4j/neostore
+Thu Dec 30 12:24:54 CET 2010: neostore.nodestore.db.mapped_memory=20M
+Thu Dec 30 12:24:54 CET 2010: neostore.propertystore.db.arrays.mapped_memory=130M
+Thu Dec 30 12:24:54 CET 2010: neostore.propertystore.db.index.keys.mapped_memory=1M
+Thu Dec 30 12:24:54 CET 2010: neostore.propertystore.db.index.mapped_memory=1M
+Thu Dec 30 12:24:54 CET 2010: neostore.propertystore.db.mapped_memory=90M
+Thu Dec 30 12:24:54 CET 2010: neostore.propertystore.db.strings.mapped_memory=130M
+Thu Dec 30 12:24:54 CET 2010: neostore.relationshipstore.db.mapped_memory=100M
+Thu Dec 30 12:24:54 CET 2010: rebuild_idgenerators_fast=true
+Thu Dec 30 12:24:54 CET 2010: store_dir=tmp/neo4j
+Thu Dec 30 12:24:54 CET 2010: --- CONFIGURATION END ---
+Thu Dec 30 12:24:54 CET 2010: Extension org.neo4j.graphdb.index.IndexProvider[lucene] loaded ok
+Thu Dec 30 14:15:48 CET 2010: Closed log tmp/neo4j/nioneo_logical.log
+Thu Dec 30 14:15:48 CET 2010: NeoStore closed
+Thu Dec 30 14:15:48 CET 2010: Closed log /home/andreas/projects/neo4j/lib/tmp/neo4j/index/lucene.log
+Thu Dec 30 14:15:48 CET 2010: Closed log tmp/neo4j/lucene/lucene.log
+Thu Dec 30 14:15:48 CET 2010: NeoStore closed
+Thu Dec 30 14:15:48 CET 2010: Closed log tmp/neo4j/lucene-fulltext/lucene.log
+Thu Dec 30 14:15:48 CET 2010: TM shutting down

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 24
-  version: 1.0.0.beta.24
+    - 25
+  version: 1.0.0.beta.25
 platform: java
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 +01:00
+date: 2011-01-05 00:00:00 +01:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -110,6 +110,7 @@ files:
   - lib/tmp/neo4j/neostore.relationshipstore.db
   - lib/tmp/neo4j/neostore.propertystore.db.index.id
   - lib/tmp/neo4j/neostore.propertystore.db.id
+  - lib/tmp/neo4j/index.db
   - lib/tmp/neo4j/neostore.propertystore.db
   - lib/tmp/neo4j/tm_tx_log.1
   - lib/tmp/neo4j/neostore.relationshiptypestore.db
@@ -119,6 +120,9 @@ files:
   - lib/tmp/neo4j/lucene-fulltext/lucene.log.active
   - lib/tmp/neo4j/index/lucene-store.db
   - lib/tmp/neo4j/index/lucene.log.active
+  - lib/tmp/neo4j/index/lucene/node/Network-exact/segments.gen
+  - lib/tmp/neo4j/index/lucene/node/Network-exact/segments_2
+  - lib/tmp/neo4j/index/lucene/node/Network-exact/_0.cfs
   - lib/tmp/neo4j/lucene/lucene-store.db
   - lib/tmp/neo4j/lucene/lucene.log.active
   - lib/neo4j/event_handler.rb
@@ -127,6 +131,7 @@ files:
   - lib/neo4j/node_traverser.rb
   - lib/neo4j/relationship_traverser.rb
   - lib/neo4j/config.rb
+  - lib/neo4j/algo.rb
   - lib/neo4j/transaction.rb
   - lib/neo4j/neo4j.rb
   - lib/neo4j/node.rb
@@ -161,11 +166,12 @@ files:
   - lib/neo4j/rails/mapping/property.rb
   - lib/neo4j/rails/validations/uniqueness.rb
   - lib/neo4j/rails/validations/non_nil.rb
-  - lib/neo4j/jars/neo4j-index-1.2-1.2.M04.jar
-  - lib/neo4j/jars/neo4j-lucene-index-0.2-1.2.M04.jar
+  - lib/neo4j/jars/neo4j-graph-algo-0.7-1.2.jar
+  - lib/neo4j/jars/neo4j-lucene-index-0.2-1.2.jar
   - lib/neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar
   - lib/neo4j/jars/lucene-core-3.0.2.jar
-  - lib/neo4j/jars/neo4j-kernel-1.2-1.2.M04.jar
+  - lib/neo4j/jars/neo4j-kernel-1.2-1.2.jar
+  - lib/neo4j/jars/neo4j-index-1.2-1.2.jar
   - lib/neo4j/mapping/rule.rb
   - lib/neo4j/mapping/decl_relationship_dsl.rb
   - lib/neo4j/mapping/rule_node.rb