neo4j 1.0.0.beta.1

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

@@ -0,0 +1,216 @@
+module Neo4j::Aggregate
+# Used to create a DSL describing how to aggregate an enumeration of nodes
+#
+# :api: public
+  class NodeAggregator
+    attr_accessor :root_dsl
+
+    def initialize(root_node, dsl_nodes_or_filter)
+      @root_node = root_node
+      self.root_dsl = self #if not chained dsl then the root dsl is self
+
+      if dsl_nodes_or_filter.kind_of?(self.class)
+        # we are chaining aggregates
+        @child_dsl = dsl_nodes_or_filter
+        @child_dsl.root_dsl = self # the child has a pointer to the parent
+      elsif dsl_nodes_or_filter.kind_of?(Enumerable)
+        # we are aggregating an enumerable set of nodes
+        @nodes = dsl_nodes_or_filter
+      elsif (dsl_nodes_or_filter.kind_of?(Class) and dsl_nodes_or_filter.ancestors.include?(Neo4j::NodeMixin))
+        # We are listening for events on Neo4j nodes - that will be included in the aggregates
+        @filter = dsl_nodes_or_filter
+        # Register with the Neo4j event handler
+        Neo4j.event_handler.add(self)
+      end
+
+    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(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
+
+    def to_s
+      "Aggregator group_by #{@group_by} filter #{!@filter.nil?} object_id: #{self.object_id} child: #{!@child_dsl.nil?}"
+    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)
+      old_node = node.props
+      old_node[prop_key] = old_value
+      root_dsl.on_prop_added(node, node, old_node)
+      on_prop_deleted(node, node, old_node)
+    end
+
+    # called from neo4j event handler
+    # :api: private
+    def on_node_deleted(node) # :nodoc:
+      return if node.class != @filter
+#      node.print(:incoming, 2)
+      node.rels.incoming(:aggregate).filter{start_node.property? :aggregate_size}.each do |group_rel|
+        group_node = group_rel.start_node
+        group_node.aggregate_size -= 1
+        # should we delete the whole group ?
+        delete_group(group_node) if (group_node.aggregate_size == 0)
+      end
+    end
+
+    def delete_group(group_node) # :nodoc:
+      # get parent aggregates and decrease the aggregate size
+      group_node.rels.incoming.nodes.each do |parent_group|
+        next unless parent_group.respond_to? :aggregate_size
+        parent_group[:aggregate_size] -= 1
+        delete_group(parent_group) if parent_group[:aggregate_size] == 0
+      end
+      group_node.del
+    end
+
+
+    def on_prop_deleted(node, curr_node_values, old_node_values) # :nodoc:
+      old_group_keys = group_key_of(old_node_values)
+      new_group_keys = group_key_of(curr_node_values)
+
+      # keys that are removed
+      removed = old_group_keys - new_group_keys
+
+      removed.each do |key|
+        member_of = [*node.rels.incoming(:aggregate).filter{self[:aggregate_group] == key}]
+        raise "same group key used in several aggregate groups, strange #{member_of.size}" if member_of.size > 1
+        next if member_of.empty?
+        group_node = member_of[0].start_node
+        group_node.aggregate_size -= 1
+        member_of[0].delete
+
+        # should we delete the whole group
+        delete_group(group_node) if (group_node.aggregate_size == 0)
+      end
+
+    end
+
+    def on_prop_added(node, curr_node_values, old_node_values) # :nodoc:
+      old_group_keys = group_key_of(old_node_values)
+      new_group_keys = group_key_of(curr_node_values)
+
+      # keys that are added
+      added = new_group_keys - old_group_keys
+      added.each { |key| root_dsl.create_group_for_key(@root_node, node, key) }
+    end
+
+
+    # Specifies which properties we should group on.
+    # All thos properties can be combined to create a new group.
+    #
+    # :api: public
+    def group_by(*keys)
+      @group_by = keys
+      self
+    end
+
+
+    # Maps the values of the given properties (in group_by or group_by_each).
+    # If this method is not used the group name will be the same as the property value.
+    #
+    # :api: public
+    def map_value(&map_func)
+      @map_func = map_func
+      self
+    end
+
+    # Create a group key for given node
+    # :api: private
+    def group_key_of(node)
+      values = @group_by.map{|key| node[key.to_s]}
+
+      # are there any keys ?
+      return [] if values.to_s.empty?
+
+      # should we map the values ?
+      if !@map_func.nil?
+        raise "Wrong number of argument of map_value function, expected #{values.size} args but it takes #{@map_func.arity} args" if @map_func.arity != values.size
+        values = @map_func.call(*values)
+        values = [values] unless values.kind_of? Enumerable
+      end
+
+
+      # check all values and expand enumerable values
+      group_keys = [*values.inject(Set.new) do |result, value| 
+        if value.respond_to?(:to_a) 
+          result.merge([*value]) 
+        else
+          result << value 
+        end
+      end]
+
+      # if we are not grouping by_each then there will only be one group_key - join it
+      group_keys = [group_keys] unless group_keys.respond_to?(:each)
+      group_keys
+    end
+
+    # Executes the DSL and creates the specified groups.
+    # This method is not necessary to call, since it will automatically be called when needed.
+    #
+    # :api: public
+    def execute(nodes = @nodes)
+      return if nodes.nil?
+
+      # prevent execute to execute again with the same nodes
+      @nodes = nil
+
+      nodes.each { |node| root_dsl.create_groups(@root_node, node) }
+    end
+
+    # :api: private
+    def create_groups(parent, node)
+      group_key_of(node).each { |key| create_group_for_key(parent, node, key) }
+    end
+
+    # :api: private
+    def create_group_for_key(parent, node, key)
+      # find a group node for the given key
+      group_node = parent.rels.outgoing(key).nodes.find{|n| n.kind_of? NodeGroup}
+
+      # if no group key is found create a new one
+      group_node ||= create_group_node(parent, key)
+
+      # check if it is the leaf node or not
+      if (@child_dsl)
+        # this is not the leaf aggregate dsl, let the child node add the node instead
+        @child_dsl.create_groups(group_node, node)
+      else
+        # this IS a leaf aggregate dsl, add node to the group
+        rel_type = node.kind_of?(NodeGroup)? key : :aggregate
+        rel = group_node.add_rel(rel_type, node)
+        rel[:aggregate_group] = key
+        # increase the size counter on this group
+        group_node.aggregate_size += 1
+      end
+    end
+
+    # :api: private
+    def create_group_node(parent, key)
+      new_node = NodeGroup.create(key)
+      rel = parent.add_rel(key, new_node)
+      parent.aggregate_size += 1 # another group was created
+      rel[:aggregate_group] = key
+      new_node
+    end
+
+  end
+
+end

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

@@ -0,0 +1,43 @@
+module Neo4j::Aggregate
+
+# This is the group node. When a new aggregate group is created it will be of this type.
+# Includes the Enumerable mixin in order to iterator over each node member in the group.
+# Overrides [] and []= properties, so that we can access aggregated properties or relationships.
+#
+# :api: private
+  class NodeGroup #:nodoc:
+    include Neo4j::NodeMixin
+    include Enumerable
+
+    property :aggregate_group, :aggregate_size
+
+    def self.create(aggregate_group)
+      new_node = NodeGroup.new
+      new_node.aggregate_group = aggregate_group.kind_of?(Symbol)? aggregate_group.to_s : aggregate_group
+      new_node.aggregate_size = 0
+      new_node
+    end
+
+    def each
+      rels.outgoing.nodes.each { |n| yield n }
+    end
+
+    # :api: private
+    def [](key)
+      value = super(key)
+      return value unless value.nil?
+
+      sub_group = rels.outgoing(key).nodes.first
+      return sub_group unless sub_group.nil?
+
+      # traverse all sub nodes and get their properties
+      PropertyEnum.new(rels.outgoing.nodes, key)
+    end
+
+#    def []=(key, value)
+#      super key, value
+#      self.get_property(key)
+#    end
+  end
+
+end

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

@@ -0,0 +1,30 @@
+module Neo4j::Aggregate
+
+  class PropGroup
+    include Neo4j::NodeMixin
+    include Enumerable
+
+    has_one :aggregate, :cascade_delete => :incoming
+    property :aggregate_group, :aggregate_size, :group_by
+
+    def each
+      group_by.split(',').each do |group|
+        yield aggregate[group]
+      end
+    end
+
+    # :api: private
+    def get_property(key)
+      value = super(key)
+      return value unless value.nil?
+      return nil unless aggregate
+      aggregate[key]
+    end
+
+    def ignore_incoming_cascade_delete? (relationship)
+      super || relationship.start_node.kind_of?(Neo4j::Aggregate::PropsAggregate)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+# Used to aggregate property values.
+#
+# :api: private
+class Neo4j::Aggregate::PropertyEnum #:nodoc:
+  include Enumerable
+
+  def initialize(nodes, property)
+    @nodes = nodes
+    @property = property
+  end
+
+  def each
+    @nodes.each do |n|
+      v = n[@property]
+      if v.kind_of?(Enumerable)
+        v.each {|vv| yield vv}
+      else
+        yield v
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Neo4j::Aggregate
+
+  class PropsAggregate
+    include Neo4j::NodeMixin
+    include Neo4j::Aggregate::PropsAggregateMixin
+  end
+
+end

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

@@ -0,0 +1,31 @@
+module Neo4j::Aggregate
+
+  # Rules properties on one or more nodes.
+  # Can also be used to apply functions (e.g. sum/average) on a set of properties.
+  #
+  module PropsAggregateMixin
+    include Neo4j::NodeMixin
+    include Enumerable
+
+    has_list :groups, :counter => true #, :cascade_delete => :incoming
+
+    def init_node(*args)
+      @aggregate_id = args[0] unless args.empty?
+    end
+    
+    def aggregate_size
+      @aggregator.execute if @aggregator
+      groups.size
+    end
+    
+    def each
+      @aggregator.execute if @aggregator
+      groups.each {|sub_group| sub_group.each {|val| yield val}}
+    end
+
+    def aggregate(agg_id)
+      @aggregator = PropsAggregator.new(self, agg_id.to_s)
+    end
+  end
+
+end

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

@@ -0,0 +1,80 @@
+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/find_path.rb

@@ -0,0 +1,117 @@
+# 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