neo4j 1.0.0.beta.9 → 1.0.0.beta.10

data/lib/neo4j.old/extensions/aggregate/props_aggregator.rb

@@ -1,80 +0,0 @@
-module Neo4j::Aggregate
-  class PropsAggregator
-    def initialize(root_node, agg_id)
-      @root_node = root_node
-      @agg_id = agg_id
-    end
-
-
-    def on(nodes_or_class)
-      if (nodes_or_class.kind_of?(Class) and nodes_or_class.ancestors.include?(Neo4j::NodeMixin))
-        Neo4j.event_handler.add(self)
-        @filter = nodes_or_class
-        @nodes = nodes_or_class
-      elsif (!nodes_or_class.respond_to?(:each))
-        @nodes = [nodes_or_class]
-      else
-        @nodes = nodes_or_class
-      end
-      self
-    end
-
-    def props(*properties)
-      @group_by = properties
-      self
-    end
-
-    # Unregisters this aggregate so that it will not be notified any longer
-    # on Neo4j node events. Used when we create an aggregate that is registered
-    # with the Neo4j even listener by including a filter in the aggregate method
-    #
-    # ==== Example
-    # agg_reg = my_aggregate.aggregate_each(MyNode).group_by(:something)
-    # # add some MyNodes that my_aggregate will aggregate into groups
-    # MyNode.new # etc...
-    # # we now do not want to add more nodes using the aggregate above - unregister it
-    # agg_reg.unregister
-    # # no more nodes will be appended /deleted /modified in the my_aggregate.
-    #
-    def unregister
-      Neo4j.event_handler.remove(self)
-    end
-
-    # called from neo4j event handler
-    # :api: private
-    def on_property_changed(node, prop_key, old_value, new_value) # :nodoc:
-      return if node.class != @filter
-      return unless @group_by.include?(prop_key.to_sym)
-
-      # recreate the aggregate group
-      execute([node])
-    end
-
-
-    def with(prop_key, &proc)
-      @with_proc = proc
-      @prop_key = prop_key
-      self
-    end
-
-    def execute(nodes = @nodes)
-      return unless nodes
-      nodes.each do |node|
-        group_node = node.aggregate_groups(@agg_id)
-        if group_node.nil?
-          group_node = PropGroup.new
-          group_node.group_by = @group_by.join(',')
-          group_node.aggregate = node
-          rel = group_node.rels.outgoing(:aggregate)[node]
-          rel[:aggregate_group] = @agg_id
-          @root_node.groups << group_node
-        end
-        if @with_proc
-          val = group_node.inject(0) {|sum, val| next sum if val.nil?; @with_proc.call(sum, val, 0)}
-          group_node[@prop_key.to_s] = val
-        end
-      end
-      @nodes = nil # prevent it to run twice
-    end
-  end
-end

data/lib/neo4j.old/extensions/aggregate.rb

@@ -1,12 +0,0 @@
-require 'set'
-require 'neo4j/extensions/aggregate/ext/node_mixin'
-require 'neo4j/extensions/rule/node_rule_mixin'
-require 'neo4j/extensions/rule/props_rule_mixin'
-require 'neo4j/extensions/rule/node_rule'
-require 'neo4j/extensions/rule/props_rule'
-require 'neo4j/extensions/rule/rule_enum'
-require 'neo4j/extensions/rule/node_aggregator'
-require 'neo4j/extensions/rule/node_group'
-require 'neo4j/extensions/rule/prop_group'
-require 'neo4j/extensions/rule/property_enum'
-require 'neo4j/extensions/rule/props_aggregator'

data/lib/neo4j.old/extensions/find_path.rb

@@ -1,117 +0,0 @@
-# Extension which finds the shortest path (in terms of number of links) between
-# two nodes. Use something like this:
-#
-#   require 'neo4j/extensions/find_path'
-#   node1.traverse.both(:knows).depth(:all).path_to(node2)
-#   # => [node1, node42, node1234, node256, node2]
-#
-# This extension is still rather experimental. The algorithm is based on the one
-# used in the Neo4j Java IMDB example.
-#
-# Martin Kleppmann, July 2009
-module Neo4j
-  module Relationships
-    class NodeTraverser
-
-      attr_accessor :predecessor_map, :other_traverser, :returnable_evaluator
-      attr_writer :_java_node
-
-      # Finds a path by starting a breadth-first traverser from each end and stopping as soon
-      # as the two meet. Keeps a hash of current_node -> previous_node which allows us to
-      # reconstruct the path that was taken once we meet. Returns an array with all of the
-      # nodes constituting the path from +self+ to +other_node+ (inclusive), or +nil+ if no
-      # path could be found.
-      def path_to(other_node)
-        return [] if other_node._java_node.neo_id == self._java_node.neo_id
-        self.other_traverser = clone
-        self.other_traverser._java_node = other_node._java_node
-        self.other_traverser.other_traverser = self
-        self.other_traverser.prepare_path_search
-        self.other_traverser.swap_directions
-        self.prepare_path_search
-
-        while true # Advance the traversers in alternation
-          break if self.search_for_path
-          break if other_traverser.search_for_path
-        end
-
-        path = returnable_evaluator.found_path
-        if !path && other_traverser.returnable_evaluator.found_path
-          path = other_traverser.returnable_evaluator.found_path.reverse
-        end
-        path
-      end
-
-      # :nodoc:
-      def path_traceback(end_node)
-        # Reconstructs the chain of predecessors leading up to +end_node+. For internal use only.
-        path = []
-        while end_node = predecessor_map[end_node]
-          path.unshift end_node
-        end
-        path
-      end
-
-      # :nodoc:
-      def prepare_path_search
-        self.returnable_evaluator = FindPathEvaluator.new(self, returnable_evaluator)
-        self.predecessor_map = {Neo4j.load_node(_java_node.neo_id) => nil}
-      end
-
-      # :nodoc:
-      def swap_directions
-        @types_and_dirs = @types_and_dirs.map do |item|
-          case item
-          when org.neo4j.graphdb.Direction::INCOMING
-            org.neo4j.graphdb.Direction::OUTGOING
-          when org.neo4j.graphdb.Direction::OUTGOING
-            org.neo4j.graphdb.Direction::INCOMING
-          else
-            item
-          end
-        end
-      end
-
-      # Advances this traverser's path search by one step. Returns +false+ if there is still
-      # more to do and +true+ if finished (irrespective of whether or not a result was found).
-      def search_for_path
-        @path_iterator ||= iterator
-        return true unless @path_iterator.hasNext
-        node = @path_iterator.next
-        !!returnable_evaluator.found_path # !! forces type to boolean
-      end
-    end
-
-
-    class FindPathEvaluator
-      include org.neo4j.graphdb.ReturnableEvaluator
-
-      attr_accessor :traverser, :original_evaluator, :found_path
-
-      def initialize(traverser, original_evaluator)
-        @traverser = traverser
-        @original_evaluator = original_evaluator
-      end
-
-      # Called at each traversal position while searching for a path. Records the current node
-      # and its predecessor (for generating the traceback) and checks whether the two traversers
-      # have met.
-      def isReturnableNode(traversal_position)
-        return false unless original_evaluator.isReturnableNode(traversal_position)
-
-        current  = Neo4j.load_node(traversal_position.current_node.getId)
-        previous = Neo4j.load_node(traversal_position.previous_node.getId) unless traversal_position.previous_node.nil?
-        traverser.predecessor_map[current] = previous
-
-        if traverser.other_traverser.predecessor_map.include? current
-          # Yay, found a path!
-          @found_path = traverser.path_traceback(current)
-          @found_path << current
-          @found_path += traverser.other_traverser.path_traceback(current).reverse
-        end
-
-        true
-      end
-    end
-  end
-end

data/lib/neo4j.old/extensions/graph_algo/all_simple_paths.rb

@@ -1,133 +0,0 @@
-module Neo4j::GraphAlgo
-  require 'neo4j/extensions/graph_algo/neo4j-graph-algo-0.3.jar'
-
-                                                   
-  class ListOfAlternatingNodesAndRelationships #:nodoc:
-    include Enumerable
-
-    def initialize(list)
-      @list = list
-    end
-
-    def each
-      iter = @list.iterator
-      node = true
-      while (iter.hasNext)
-        id = iter.next.getId
-        if (node)
-          yield Neo4j.load_node(id)
-        else
-          yield Neo4j.load_rel(id)
-        end
-        node = !node
-      end
-    end
-  end
-
-  class ListOfNodes #:nodoc:
-    include Enumerable
-
-    def initialize(list)
-      @list = list
-    end
-
-    def size
-      @list.size
-    end
-
-    def each
-      iter = @list.iterator
-      while (iter.hasNext)
-        n = iter.next
-        yield Neo4j.load_node(n.getId)
-      end
-    end
-  end
-
-  # A Wrapper for some of the neo4j graphdb algorithms
-  #
-  # Currently only the AllSimplePaths is wrapped in Ruby.
-  #
-  # === Usage
-  #
-  #   found_nodes = GraphAlgo.all_simple_paths.from(node1).both(:knows).to(node7).depth(4).as_nodes
-  #
-  # === See also
-  # * JavaDoc: http://components.neo4j.org/graph-algo/apidocs/org/neo4j/graphalgo/AllSimplePaths.html
-  # * A complete example: http://github.com/andreasronge/neo4j/tree/master/examples/you_might_know/ 
-  #
-  class AllSimplePaths
-    include Enumerable
-
-    def initialize
-      @types = []
-      @direction = org.neo4j.graphdb.Direction::OUTGOING
-    end
-
-    def each
-      if @as_nodes
-        iter = paths.get_paths_as_nodes.iterator
-        while (iter.has_next) do yield ListOfNodes.new(iter.next) end
-      else
-        iter = paths.get_paths.iterator
-        while (iter.has_next) do yield ListOfAlternatingNodesAndRelationships.new(iter.next) end
-      end
-    end
-
-    def as_nodes
-      @as_nodes = true
-      self
-    end
-
-    def size
-      paths.get_paths_as_nodes.size
-    end
-
-    def paths
-      @paths ||= org.neo4j.graphalgo.AllSimplePaths.new(@from._java_node, @to._java_node, @depth, @direction, @types.to_java(:"org.neo4j.graphdb.RelationshipType"))
-    end
-
-    def from(f)
-      @from = f
-      self
-    end
-
-    def to(t)
-      @to = t
-      self
-    end
-
-    def depth(d)
-      @depth = d
-      self
-    end
-
-    def both(*types)
-      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
-      @direction = org.neo4j.graphdb.Direction::BOTH
-      self
-    end
-
-    def outgoing(*types)
-      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
-      @direction = org.neo4j.graphdb.Direction::OUTGOING
-      self
-    end
-
-    def incoming(*types)
-      types.each { |type| @types << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s) }
-      @direction = org.neo4j.graphdb.Direction::INCOMING
-      self
-    end
-
-  end
-
-  def self.all_simple_paths
-    # org.neo4j.graphdb.Node node1, org.neo4j.graphdb.Node node2, int maximumTotalDepth, org.neo4j.graphdb.Direction relationshipDirection, org.neo4j.graphdb.RelationshipType... relationshipTypes)
-    AllSimplePaths.new
-  end
-
-
-end
-
-

data/lib/neo4j.old/extensions/graph_algo.rb

@@ -1 +0,0 @@
-require 'neo4j/extensions/graph_algo/all_simple_paths'

data/lib/neo4j.old/extensions/reindexer.rb

@@ -1,104 +0,0 @@
-module Neo4j
-
-  module PropertyClassMethods
-      # Traverse all nodes and update the lucene index.
-      # Can be used for example if it's' necessary to change the index on a class
-      #
-      def update_index
-        all.nodes.each do |n|
-          n.update_index
-        end
-      end
-
-      # Returns node instances of this class.
-      #
-      def all
-        index_node = IndexNode.instance
-        index_node.rels.outgoing(self)
-      end
-  end
-  
-  module NodeMixin
-    alias_method :ignore_incoming_cascade_delete_orig?, :ignore_incoming_cascade_delete?
-    def ignore_incoming_cascade_delete? (relationship)
-      # if it's an index node relationship then it should be allowed to cascade delete the node
-      ignore_incoming_cascade_delete_orig?(relationship) || relationship.other_node(self) == IndexNode.instance
-    end
-
-  end
-
-
-  class IndexNode
-    include NodeMixin
-
-    # Connects the given node with the reference node.
-    # The type of the relationship will be the same as the class name of the
-    # specified node unless the optional parameter type is specified.
-    # This method is used internally to keep a reference to all node instances in the node space
-    # (useful for example for reindexing all nodes by traversing the node space).
-    #
-    # ==== Parameters
-    # node<Neo4j::NodeMixin>:: Connect the reference node with this node
-    # type<String>:: Optional, the type of the relationship we want to create
-    #
-    # ==== Returns
-    # nil
-    #
-    # :api: private
-    def connect(node, type = node.class.root_class)
-      rtype = org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
-      @_java_node.createRelationshipTo(node._java_node, rtype)
-      nil
-    end
-
-    def on_node_created(node)
-      # we have to avoid connecting to our self
-      unless self == node
-        node.class.ancestors.grep(Class).each{|p| connect(node, p) if p.respond_to?(:all)}
-      end
-    end
-
-    def self.on_neo_started(neo_instance)
-      if neo_instance.ref_node.rel?(:index_node)
-        # we already have it, put it in instance variable so we do not have to look again
-        @index_node = neo_instance.ref_node.rels.outgoing(:index_node).nodes.first
-      else
-        @index_node = IndexNode.new # cache this so we do not have to look it up always
-        neo_instance.ref_node.rels.outgoing(:index_node) << @index_node
-      end
-      Neo4j.event_handler.add(@index_node)
-    end
-
-    def self.on_neo_stopped(neo_instance)
-      # unregister the instance
-      Neo4j.event_handler.remove(@index_node)
-      @index_node = nil
-    end
-
-    def self.instance
-      Neo4j.start if @index_node.nil?
-      @index_node
-    end
-
-    def self.instance?
-      !@index_node.nil?
-    end
-
-  end
-
-
-  # Add this so it can add it self as listener
-  def self.load_reindexer
-    Neo4j.event_handler.add(IndexNode)
-    # in case we already have started
-    Neo4j::Transaction.run { IndexNode.on_neo_started(Neo4j) } if Neo4j.running?
-  end
-
-  def self.unload_reindexer
-    Neo4j.event_handler.remove(IndexNode)
-    Neo4j.event_handler.remove(IndexNode.instance) if IndexNode.instance?
-  end
-
-
-  load_reindexer
-end