neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/rails/timestamps.rb

@@ -1,72 +1,74 @@
 module Neo4j
-	module Rails
+  module Rails
     # Handle all the created_at, updated_at, created_on, updated_on type stuff.
-		module Timestamps
-			extend ActiveSupport::Concern
+    module Timestamps
+      extend ActiveSupport::Concern
 
-			TIMESTAMP_PROPERTIES = [ :created_at, :created_on, :updated_at, :updated_on ]
+      TIMESTAMP_PROPERTIES = [:created_at, :created_on, :updated_at, :updated_on]
 
       included do
         before_create :create_timestamp
         before_save :update_timestamp, :if => :new_or_changed?
       end
-			# Set the timestamps for this model if timestamps is set to true in the config
-			# and the model is set up with the correct property name, e.g.:
-			#
-			#   class Trackable < Neo4j::Rails::Model
-			#     property :updated_at, :type => DateTime
-			#   end
-			def update_timestamp
-				#definition provided whenever an :updated_at property is defined
-			end
-
-			# Set the timestamps for this model if timestamps is set to true in the config
-			# and the model is set up with the correct property name, e.g.:
-			#
-			#   class Trackable < Neo4j::Rails::Model
-			#     property :created_at, :type => DateTime
-			#   end
-			def create_timestamp
-				#definition provided whenever an :created_at property is defined
-			end
+      # Set the timestamps for this model if timestamps is set to true in the config
+      # and the model is set up with the correct property name, e.g.:
+      #
+      #   class Trackable < Neo4j::Rails::Model
+      #     property :updated_at, :type => DateTime
+      #   end
+      def update_timestamp
+        #definition provided whenever an :updated_at property is defined
+      end
 
-			# Write the timestamp as a Date, DateTime or Time depending on the property type
-			def write_date_or_timestamp(attribute)
-				value = case self.class._decl_props[attribute][:type].to_s
-				when "DateTime"
-					DateTime.now
-				when "Date"
-					Date.today
-				when "Time"
-					Time.now
-				end
+      # Set the timestamps for this model if timestamps is set to true in the config
+      # and the model is set up with the correct property name, e.g.:
+      #
+      #   class Trackable < Neo4j::Rails::Model
+      #     property :created_at, :type => DateTime
+      #   end
+      def create_timestamp
+        #definition provided whenever an :created_at property is defined
+      end
 
-				send("#{attribute}=", value)
-			end
+      # Write the timestamp as a Date, DateTime or Time depending on the property type
+      def write_date_or_timestamp(attribute)
+        value = case self.class._decl_props[attribute.to_sym][:type].to_s
+                  when "DateTime"
+                    DateTime.now
+                  when "Date"
+                    Date.today
+                  when "Time"
+                    Time.now
+                end
+        send("#{attribute}=", value)
+      end
 
       def new_or_changed?
         self.new? or self.changed?
       end
 
-			module ClassMethods
-				def property_setup(property, options)
-					super
-          define_timestamp_method(:create_timestamp,:created_at) if property == :created_at
-				  define_timestamp_method(:update_timestamp,:updated_at) if property == :updated_at
-					# ensure there's always a type on the timestamp properties
-					if Neo4j::Config[:timestamps] && TIMESTAMP_PROPERTIES.include?(property)
-						_decl_props[property][:type] ||= Time
-					end
-				end
+      module ClassMethods
+        def property_setup(property, options)
+          super
+          define_timestamp_method(:create_timestamp, :created_at) if property == :created_at
+          define_timestamp_method(:update_timestamp, :updated_at) if property == :updated_at
+          # ensure there's always a type on the timestamp properties
+          if Neo4j::Config[:timestamps] && TIMESTAMP_PROPERTIES.include?(property)
+            if _decl_props[property][:converter] == Neo4j::TypeConverters::DefaultConverter
+              _decl_props[property][:type] = Time
+              _decl_props[property][:converter] = Neo4j::TypeConverters.converter(Time)
+            end
+          end
+        end
 
-				def define_timestamp_method(method_name, property)
-					class_eval <<-RUBY, __FILE__, __LINE__
+        def define_timestamp_method(method_name, property)
+          class_eval <<-RUBY, __FILE__, __LINE__
 						def #{method_name}
 							write_date_or_timestamp(:#{property}) if Neo4j::Config[:timestamps]
 						end
           RUBY
-			  end
-			end
-		end
-	end
+        end
+      end
+    end
+  end
 end

data/lib/neo4j/rails/transaction.rb

@@ -38,8 +38,16 @@ module Neo4j
           tx.finish
           Thread.current[:neo4j_transaction] = nil
           Thread.current[:neo4j_transaction_fail] = nil
+        rescue Exception => e
+          if Neo4j::Config[:debug_java] && e.respond_to?(:cause)
+            puts "Java Exception in a transaction, cause: #{e.cause}"
+            e.cause.print_stack_trace
+          end
+          tx.failure unless tx.nil?
+          raise
         end
 
+
         def filter(*, &block)
           run &block
         end
@@ -60,7 +68,7 @@ module Neo4j
             ret
           end
         end
-        
+
         private
         def new
           Thread.current[:neo4j_transaction] = Neo4j::Transaction.new

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -11,7 +11,7 @@ module Neo4j
 
         def setup(klass)
           @attributes.each do |attribute|
-            if klass.index_type_for(attribute) != @validator.index_type
+            if klass.index_type(attribute) != @validator.index_type
               raise index_error_message(klass,attribute,@validator.index_type)
             end
           end

data/lib/neo4j/rails/versioning/versioning.rb

@@ -80,7 +80,7 @@ module Neo4j
       # @param [ Integer ] number The version number to retrieve.
       # Returns nil in case a version is not found.
       def version(number)
-        snapshot = Version.find(:model_classname => _classname, :instance_id => neo_id, :number => number) {|query| query.first.nil? ? nil : query.first.end_node}
+        snapshot = Version.find(:model_classname => _classname, :instance_id => neo_id, :number => number) {|query| query.first.nil? ? nil : query.first.end_node.wrapper}
         snapshot.props.each_pair{|k,v| snapshot.assign(k,Neo4j::TypeConverters.to_ruby(self.class, k, v))} if !snapshot.nil?
         snapshot
       end
@@ -129,7 +129,7 @@ module Neo4j
       end
 
       def each_versionable_relationship
-        rule_relationships = java.util.HashSet.new(Neo4j::Rule::Rule.rule_names_for(_classname))
+        rule_relationships = java.util.HashSet.new(Neo4j::Wrapper::Rule::Rule.rule_names_for(_classname))
         self._java_node.getRelationships().each do |rel|
           yield rel unless rule_relationships.contains(rel.getType().name().to_sym) || rel.getType.name.to_sym == :version
         end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "2.0.0.alpha.5"
+  VERSION = "2.0.0.alpha.6"
 end

data/lib/orm_adapter/adapters/neo4j.rb

@@ -1,51 +1,52 @@
 require 'orm_adapter'
 
 module Neo4j
-	module Rails
-		class Model
-			extend ::OrmAdapter::ToAdapter
-
-			class OrmAdapter < ::OrmAdapter::Base
-				# Do not consider these to be part of the class list
-				def self.except_classes
-					@@except_classes ||= []
-				end
-
-				# Gets a list of the available models for this adapter
-				def self.model_classes
-					::Neo4j::Rails::Model.descendants.to_a.select{|k| !except_classes.include?(k.name)}
-				end
-
-				# get a list of column names for a given class
-				def column_names
-					klass._decl_props.keys
-				end
-
-				# Get an instance by id of the model
-				def get!(id)
-					klass.find!(wrap_key(id))
-				end
-
-				# Get an instance by id of the model
-				def get(id)
-					klass.find(wrap_key(id))
-				end
-
-				# Find the first instance matching conditions
-				def find_first(conditions)
-					klass.first(conditions)
-				end
-
-				# Find all models matching conditions
-				def find_all(conditions)
-					klass.all(conditions)
-				end
-
-				# Create a model using attributes
-				def create!(attributes)
-					klass.create!(attributes)
-				end
-			end
-		end
+  module Rails
+    class Model
+      extend ::OrmAdapter::ToAdapter
+
+      class OrmAdapter < ::OrmAdapter::Base
+        # Do not consider these to be part of the class list
+        def self.except_classes
+          @@except_classes ||= []
+        end
+
+        # Gets a list of the available models for this adapter
+        def self.model_classes
+          ::Neo4j::Rails::Model.descendants.to_a.select { |k| !except_classes.include?(k.name) }
+        end
+
+        # get a list of column names for a given class
+        def column_names
+          klass._decl_props.keys
+        end
+
+        # Get an instance by id of the model
+        def get!(id)
+          klass.find!(wrap_key(id))
+        end
+
+        # Get an instance by id of the model
+        def get(id)
+          klass.find(wrap_key(id))
+        end
+
+        # Find the first instance matching conditions
+        def find_first(conditions)
+          klass.first(conditions)
+        end
+
+        # Find all models matching conditions
+        def find_all(conditions)
+          klass.all(conditions)
+        end
+
+        # Create a model using attributes
+        def create!(attributes)
+          klass.create!(attributes)
+        end
+      end
+    end
   end
 end
+

data/neo4j.gemspec

@@ -32,5 +32,5 @@ It comes included with the Apache Lucene document database.
   s.add_dependency('orm_adapter', ">= 0.0.3")
   s.add_dependency("activemodel", ">= 3.0.0", "< 3.3")
   s.add_dependency("railties", ">= 3.0.0", "< 3.3")
-  s.add_dependency("neo4j-community", "1.7.0.alpha.1")
+  s.add_dependency("neo4j-wrapper", '0.0.5')
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 2.0.0.alpha.5
+  version: 2.0.0.alpha.6
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-27 00:00:00 Z
+date: 2012-04-15 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: orm_adapter
@@ -52,14 +52,14 @@ dependencies:
     type: :runtime
     version_requirements: *id003
   - !ruby/object:Gem::Dependency 
-    name: neo4j-community
+    name: neo4j-wrapper
     prerelease: false
     requirement: &id004 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 1.7.0.alpha.1
+            version: 0.0.5
     type: :runtime
     version_requirements: *id004
 description: |
@@ -93,61 +93,27 @@ files:
   - lib/tasks/upgrade_v2/upgrade_v2.rake
   - lib/tasks/upgrade_v2/lib/upgrade_v2.rb
   - lib/orm_adapter/adapters/neo4j.rb
-  - lib/neo4j/identity_map.rb
-  - lib/neo4j/event_handler.rb
-  - lib/neo4j/model.rb
-  - lib/neo4j/paginated.rb
-  - lib/neo4j/config.rb
-  - lib/neo4j/transaction.rb
-  - lib/neo4j/neo4j.rb
-  - lib/neo4j/node.rb
-  - lib/neo4j/load.rb
-  - lib/neo4j/database.rb
-  - lib/neo4j/relationship_set.rb
+  - lib/neo4j/performance.rb
   - lib/neo4j/version.rb
-  - lib/neo4j/equal.rb
-  - lib/neo4j/relationship.rb
-  - lib/neo4j/to_java.rb
-  - lib/neo4j/algo/algo.rb
-  - lib/neo4j/has_list/mapping.rb
-  - lib/neo4j/has_list/class_methods.rb
-  - lib/neo4j/has_list/has_list.rb
-  - lib/neo4j/property/property.rb
-  - lib/neo4j/property/class_methods.rb
-  - lib/neo4j/traversal/rel_expander.rb
-  - lib/neo4j/traversal/filter_predicate.rb
-  - lib/neo4j/traversal/prune_evaluator.rb
-  - lib/neo4j/traversal/traversal.rb
-  - lib/neo4j/traversal/traverser.rb
-  - lib/neo4j/relationship_mixin/relationship_mixin.rb
-  - lib/neo4j/relationship_mixin/class_methods.rb
-  - lib/neo4j/type_converters/type_converters.rb
-  - lib/neo4j/core_ext/class/inheritable_attributes.rb
-  - lib/neo4j/core_ext/class/rewrite_inheritable_attributes.rb
-  - lib/neo4j/migrations/migrations.rb
-  - lib/neo4j/migrations/lazy_node_mixin.rb
-  - lib/neo4j/migrations/extensions.rb
-  - lib/neo4j/migrations/node_mixin.rb
-  - lib/neo4j/migrations/migration.rb
-  - lib/neo4j/migrations/class_methods.rb
-  - lib/neo4j/migrations/ref_node_wrapper.rb
-  - lib/neo4j/rels/traverser.rb
-  - lib/neo4j/rels/rels.rb
   - lib/neo4j/rails/attributes.rb
   - lib/neo4j/rails/rack_middleware.rb
   - lib/neo4j/rails/model.rb
   - lib/neo4j/rails/validations.rb
+  - lib/neo4j/rails/identity.rb
   - lib/neo4j/rails/persistence.rb
+  - lib/neo4j/rails/node_persistance.rb
   - lib/neo4j/rails/serialization.rb
   - lib/neo4j/rails/railtie.rb
   - lib/neo4j/rails/rails.rb
+  - lib/neo4j/rails/relationship_persistence.rb
   - lib/neo4j/rails/observer.rb
+  - lib/neo4j/rails/nested_attributes.rb
   - lib/neo4j/rails/transaction.rb
   - lib/neo4j/rails/timestamps.rb
   - lib/neo4j/rails/callbacks.rb
+  - lib/neo4j/rails/has_n.rb
   - lib/neo4j/rails/tx_methods.rb
   - lib/neo4j/rails/accept_id.rb
-  - lib/neo4j/rails/rel_persistence.rb
   - lib/neo4j/rails/finders.rb
   - lib/neo4j/rails/relationship.rb
   - lib/neo4j/rails/compositions.rb
@@ -156,34 +122,9 @@ files:
   - lib/neo4j/rails/relationships/relationships.rb
   - lib/neo4j/rails/relationships/storage.rb
   - lib/neo4j/rails/versioning/versioning.rb
-  - lib/neo4j/rails/mapping/property.rb
   - lib/neo4j/rails/validations/associated.rb
   - lib/neo4j/rails/validations/uniqueness.rb
   - lib/neo4j/rails/validations/non_nil.rb
-  - lib/neo4j/index/indexer.rb
-  - lib/neo4j/index/lucene_query.rb
-  - lib/neo4j/index/indexer_registry.rb
-  - lib/neo4j/index/class_methods.rb
-  - lib/neo4j/index/index.rb
-  - lib/neo4j/batch/inserter.rb
-  - lib/neo4j/batch/indexer.rb
-  - lib/neo4j/batch/rule_inserter.rb
-  - lib/neo4j/batch/rule_node.rb
-  - lib/neo4j/batch/batch.rb
-  - lib/neo4j/has_n/decl_relationship_dsl.rb
-  - lib/neo4j/has_n/has_n.rb
-  - lib/neo4j/has_n/mapping.rb
-  - lib/neo4j/has_n/class_methods.rb
-  - lib/neo4j/node_mixin/node_mixin.rb
-  - lib/neo4j/node_mixin/class_methods.rb
-  - lib/neo4j/rule/rule.rb
-  - lib/neo4j/rule/rule_node.rb
-  - lib/neo4j/rule/class_methods.rb
-  - lib/neo4j/rule/event_listener.rb
-  - lib/neo4j/rule/functions/function.rb
-  - lib/neo4j/rule/functions/count.rb
-  - lib/neo4j/rule/functions/sum.rb
-  - lib/neo4j/rule/functions/functions.rb
   - config/locales/en.yml
   - config/neo4j/config.yml
   - README.rdoc

data/lib/neo4j/algo/algo.rb

@@ -1,294 +0,0 @@
-# external neo4j dependencies
-require 'neo4j/to_java'
-
-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 = (Neo4j::Traversal::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
-    # See also #rels
-    def nodes
-      @path_finder_method = :nodes
-      self
-    end
-
-    # Specifies that relationships should be returned from as result
-    # 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 && @path_finder_method
-        execute_algo.send(@path_finder_method).each &block
-      else
-        traversal = execute_algo
-        traversal.each &block if traversal
-      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