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

data/lib/neo4j/rels/rels.rb

@@ -1,110 +0,0 @@
-require 'neo4j/rels/traverser'
-
-
-module Neo4j
-
-  # Contains methods for traversing relationship object of depth one from one node.
-  module Rels
-    include ToJava
-
-    # Returns the only node of a given type and direction that is attached to this node, or nil.
-    # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node.
-    # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an exception.
-
-    # This method reflects that semantics and returns either:
-    #  * nil if there are zero relationships of the given type and direction,
-    #  * the relationship if there's exactly one, or
-    #  * throws an unchecked exception in all other cases.
-    #
-    # This method should be used only in situations with an invariant as described above. In those situations, a "state-checking" method (e.g. #rel?) is not required,
-    # because this method behaves correctly "out of the box."
-    #
-    # Does return the Ruby wrapper object (if it has a '_classname' property) unlike the #_node version of this method
-    #
-    def node(dir, type)
-      n = _node(dir, type)
-      n && n.wrapper
-    end
-
-    # Same as #node but instead returns an unwrapped native java node instead
-    def _node(dir, type)
-      r = _rel(dir, type)
-      r && r._other_node(self._java_node)
-    end
-
-    # Returns an enumeration of relationship objects.
-    # It always returns relationship of depth one.
-    #
-    # See Neo4j::Relationship
-    #
-    # ==== Examples
-    #   # Return both incoming and outgoing relationships
-    #   me.rels(:friends, :work).each {|relationship|...}
-    #
-    #   # Only return outgoing relationship of given type
-    #   me.rels(:friends).outgoing.first.end_node # => my friend node
-    #
-    def rels(*type)
-      Traverser.new(self, type, :both)
-    end
-
-
-    # Returns the only relationship of a given type and direction that is attached to this node, or null.
-    # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or
-    # one relationships of a given type and direction to another node.
-    # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships
-    # exist, it is a fatal error that should generate an unchecked exception. This method reflects that semantics and
-    # returns either:
-    #
-    # * nil if there are zero relationships of the given type and direction,
-    # * the relationship if there's exactly one, or
-    # * raise an exception in all other cases.
-    def rel(dir, type)
-      result = _rel(dir, type)
-      result && result.wrapper
-    end
-
-    # Same as rel but does not return a ruby wrapped object but instead returns the Java object.
-    def _rel(dir, type)
-      get_single_relationship(type_to_java(type), dir_to_java(dir))
-    end
-
-    # Returns the raw java neo4j relationship object.
-    def _rels(dir=:both, *types)
-      if types.size > 1
-        java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
-        get_relationships(java_types)
-      elsif types.size == 1
-        get_relationships(type_to_java(types[0]), dir_to_java(dir))
-      elsif dir == :both
-        get_relationships(dir_to_java(dir))
-      else
-        raise "illegal argument, does not accept #{dir} #{types.join(',')} - only dir=:both for any relationship types"
-      end
-    end
-
-    # Check if the given relationship exists
-    # Returns true if there are one or more relationships from this node to other nodes
-    # with the given relationship.
-    #
-    # ==== Parameters
-    # type:: the key and value to be set, default any type
-    # dir:: optional default :both (either, :outgoing, :incoming, :both)
-    #
-    # ==== Returns
-    # true if one or more relationships exists for the given type and dir
-    # otherwise false
-    #
-    def rel? (type=nil, dir=:both)
-      if type
-        hasRelationship(type_to_java(type), dir_to_java(dir))
-      else
-        hasRelationship
-      end
-    end
-
-  end
-
-end
-
-

data/lib/neo4j/rels/traverser.rb

@@ -1,102 +0,0 @@
-# external neo4j dependencies
-require 'neo4j/to_java'
-
-
-module Neo4j
-  module Rels
-
-    # Traverse relationships of depth one from one node.
-    # This object is returned when using the Neo4j::Rels which is included in the Neo4j::Node class.
-    #
-    class Traverser
-      include Enumerable
-      include ToJava
-
-      def initialize(node, types, dir)
-        @node = node
-        if types.size > 1
-          @types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
-        elsif types.size == 1
-          @type = type_to_java(types[0])
-        end
-        @dir = dir
-      end
-
-      def to_s
-        if @type
-          "#{self.class} [type: #{@type} dir:#{@dir}]"
-        elsif @types
-          "#{self.class} [types: #{@types.join(',')} dir:#{@dir}]"
-        else
-          "#{self.class} [types: ANY dir:#{@dir}]"
-        end
-      end
-
-      def each
-        iter = iterator
-        while (iter.hasNext())
-          rel = iter.next
-          yield rel.wrapper if match_to_other?(rel)
-        end
-      end
-
-      def empty?
-        first == nil
-      end
-
-      def iterator
-        if @types
-          @node.get_relationships(@types).iterator
-        elsif @type
-          @node.get_relationships(@type, dir_to_java(@dir)).iterator
-        else
-          @node.get_relationships(dir_to_java(@dir)).iterator
-        end
-      end
-
-      def match_to_other?(rel)
-        if @to_other.nil?
-          true
-        elsif @dir == :outgoing
-          rel._end_node == @to_other
-        elsif @dir == :incoming
-          rel._start_node == @to_other
-        else
-          rel._start_node == @to_other || rel._end_node == @to_other
-        end
-      end
-
-      def to_other(to_other)
-        @to_other = to_other
-        self
-      end
-
-      def del
-        each { |rel| rel.del }
-      end
-
-      def size
-        [*self].size
-      end
-
-      def both
-        @dir = :both
-        self
-      end
-
-      def incoming
-        raise "Not allowed calling incoming when finding several relationships types" if @types
-        @dir = :incoming
-        self
-      end
-
-      def outgoing
-        raise "Not allowed calling outgoing when finding several relationships types" if @types
-        @dir = :outgoing
-        self
-      end
-
-    end
-
-  end
-end

data/lib/neo4j/rule/class_methods.rb

@@ -1,201 +0,0 @@
-module Neo4j
-  module Rule
-
-
-    # Allows you to group nodes by providing a rule.
-    #
-    # === Example, finding all nodes of a certain class
-    # Just add a rule without a code block, then all nodes of that class will be grouped under the given key (<tt>all</tt>
-    # for the example below).
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     rule :all
-    #   end
-    #
-    # Then you can get all the nodes of type Person (and siblings) by
-    #   Person.all.each {|x| ...}
-    #
-    # === Example, finding all nodes with a given condition on a property
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:old) { age > 10 }
-    #   end
-    #
-    #  Now we can find all nodes with a property <tt>age</tt> above 10.
-    #
-    # === Chain Rules
-    #
-    #   class NewsStory
-    #     include Neo4j::NodeMixin
-    #     has_n :readers
-    #     rule(:featured) { |node| node[:featured] == true }
-    #     rule(:young_readers) { !readers.find{|user| !user.young?}}
-    #   end
-    #
-    # You can combine two rules. Let say you want to find all stories which are featured and has young readers:
-    #   NewsStory.featured.young_readers.each {...}
-    #
-    # === Trigger Other Rules
-    # You can let one rule trigger another rule.
-    # Let say you have readers of some magazine and want to know if the magazine has old or young readers.
-    # So when a reader change from young to old you want to trigger all the magazine that he reads (a but stupid example)
-    #
-    # Example
-    #   class Reader
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:young, :triggers => :readers) { age < 15 }
-    #   end
-    #
-    #   class NewsStory
-    #     include Neo4j::NodeMixin
-    #     has_n :readers
-    #     rule(:young_readers) { !readers.find{|user| !user.young?}}
-    #   end
-    #
-    # === Performance Considerations
-    # If you have many rules and many updates this can be a bit slow.
-    # In order to speed it up somewhat you can use the raw java node object instead by providing an argument in your block.
-    #
-    # Example:
-    #
-    #   class Person
-    #     include Neo4j::NodeMixin
-    #     property :age
-    #     rule(:old) {|node| node[:age] > 10 }
-    #   end
-    #
-    # === Thread Safe ?
-    # Yes, since operations are performed in an transaction. However you may get a deadlock exception:
-    # http://docs.neo4j.org/html/snapshot/#_deadlocks
-    #
-    module ClassMethods
-
-      # Creates an rule node attached to the Neo4j.ref_node
-      # Can be used to rule all instances of a specific Ruby class.
-      #
-      # Example of usage:
-      #   class Person
-      #     include Neo4j::NodeMixin
-      #     property :age
-      #     rule :all
-      #     rule :young { self[:age] < 10 }
-      #     rule(:old, :functions => [Sum.new[:age]) { age > 20 }
-      #   end
-      #
-      #   p1 = Person.new :age => 5
-      #   p2 = Person.new :age => 7
-      #   p3 = Person.new :age => 12
-      #   Neo4j::Transaction.finish
-      #   Person.all    # =>  [p1,p2,p3]
-      #   Person.young  # =>  [p1,p2]
-      #   p1.young?    # => true
-      #   p1.sum(old, :age) # the some of the old people's age
-      #
-      def rule(rule_name, props = {}, &block)
-        singleton = class << self;
-          self;
-        end
-
-        # define class methods
-        singleton.send(:define_method, rule_name) do
-          rule_node = Rule.rule_node_for(self)
-          rule_node.traversal(rule_name)
-        end unless respond_to?(rule_name)
-
-        # define instance methods
-        self.send(:define_method, "#{rule_name}?") do
-          instance_eval &block
-        end
-
-        rule = Rule.add(self, rule_name, props, &block)
-
-        rule.functions && rule.functions.each do |func|
-          singleton.send(:define_method, func.class.function_name) do |r_name, *args|
-            rule_node = Rule.rule_node_for(self)
-            function_id = args.empty? ? "_classname" : args[0]
-            function = rule_node.find_function(r_name, func.class.function_name, function_id)
-            function.value(rule_node.rule_node, r_name)
-          end unless respond_to?(func.class.function_name)
-        end
-      end
-
-      def ref_node_for_class
-        Neo4j.ref_node #The reference node for a type falls back to the threadlocal ref node by default.
-      end
-
-      # Assigns the reference node for a class via a supplied block.
-      # Example of usage:
-      #   class Person
-      #     include Neo4j::NodeMixin
-      #     ref_node { Neo4j.default_ref_node }
-      #   end
-      #
-      def ref_node(&block)
-        singleton = class << self;
-          self;
-        end
-        singleton.send(:define_method, :ref_node_for_class) { block.call }
-      end
-
-      def inherit_rules_from(clazz)
-        Rule.inherit(clazz, self)
-      end
-
-      # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
-      # It also remove all the rule class methods.
-      def delete_rules
-        singelton = class << self;
-          self;
-        end
-        rule_node = Rule.rule_node_for(self)
-
-        rule_node.rule_names.each {|rule_name| singelton.send(:remove_method, rule_name)}
-        rule_node.rules.clear
-      end
-
-      # Force to trigger the rules.
-      # You don't normally need that since it will be done automatically.
-      # This can be useful if you need to trigger rules on already existing nodes in the database.
-      # Can also be called from an migration.
-      #
-      def trigger_rules(node, *changes)
-        Rule.trigger_rules(node, *changes)
-      end
-
-      # Returns a proc that will call add method on the given function
-      # Can be used in migration to trigger rules on already existing nodes.
-      # Parameter function_id is default to '_classname' which means that
-      # the function 'reacts' on changes on the property '_classname'.
-      # That property changes only when a node is created or deleted.
-      # Function using function_id '_classname' is typically used for counting number of nodes of a class.
-      def add_function_for(rule_name, function_name_or_class, function_id = '_classname')
-        function_for(:add, rule_name, function_name_or_class, function_id)
-      end
-
-      # See #add_function_for
-      # Calls the delete method on the function.
-      def delete_function_for(rule_name, function_name_or_class, function_id = '_classname')
-        function_for(:delete, rule_name, function_name_or_class, function_id)
-      end
-
-      # Returns a proc that calls the given method on the given function.
-      def function_for(method, rule_name, function_name_or_class, function_id = '_classname')
-        function_name = function_name_or_class.is_a?(Symbol)? function_name_or_class : function_name_or_class.function_name
-        rule_node = Rule.rule_node_for(self)
-        rule = rule_node.find_rule(rule_name)
-        rule_node_raw = rule_node.rule_node
-
-        function = rule_node.find_function(rule_name, function_name, function_id)
-        lambda do |node|
-          new_value = node[function_id]
-          function.send(method, rule.rule_name, rule_node_raw, new_value)
-        end
-      end
-    end
-
-  end
-end

data/lib/neo4j/rule/event_listener.rb

@@ -1,66 +0,0 @@
-module Neo4j
-  module Rule
-    class EventListener
-      class << self
-        # ----------------------------------------------------------------------------------------------------------------
-        # Event handling methods
-        # ----------------------------------------------------------------------------------------------------------------
-
-        def on_relationship_created(rel, *)
-          trigger_start_node = Rule.trigger?(rel._start_node)
-          trigger_end_node = Rule.trigger?(rel._end_node)
-          Rule.trigger_rules(rel._start_node) if trigger_start_node
-          Rule.trigger_rules(rel._end_node) if trigger_end_node
-        end
-
-        def on_property_changed(node, *changes)
-          Rule.trigger_rules(node, *changes) if Rule.trigger?(node)
-        end
-
-        def on_node_deleted(node, old_properties, deleted_relationship_set, deleted_identity_map)
-          # have we deleted a rule node ?
-          del_rule_node = Rule.find_rule_node(node)
-          del_rule_node && del_rule_node.clear_rule_node
-          return if del_rule_node
-
-          # do we have prop_aggregations for this
-          clazz = old_properties['_classname']
-          rule_node = Rule.rule_node_for(clazz)
-          return if rule_node.nil?
-
-          id = node.getId
-          rule_node.rules.each do |rule|
-            next if rule.functions.nil? || rule.bulk_update?
-            rule_name = rule.rule_name.to_s
-
-            # is the rule node deleted ?
-            deleted_rule_node = deleted_identity_map.get(rule_node.rule_node.neo_id)
-            next if deleted_rule_node
-
-            rule.functions.each do |function|
-              next unless deleted_relationship_set.contains?(id,rule_name)
-              previous_value = old_properties[function.function_id]
-              function.delete(rule_name, rule_node.rule_node, previous_value) if previous_value
-            end if rule.functions
-          end
-        end
-
-        def classes_changed(changed_class_map)
-          changed_class_map.each_pair do |clazz,class_change|
-            Rule.bulk_trigger_rules(clazz,class_change,changed_class_map)
-          end
-        end
-
-        def on_neo4j_started(db)
-          if not Neo4j::Config[:enable_rules]
-            db.event_handler.remove(self)
-          end
-        end
-      end
-
-
-    end
-    Neo4j.unstarted_db.event_handler.add(EventListener) unless Neo4j.read_only?
-
-  end
-end