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

data/lib/neo4j.rb

@@ -23,6 +23,11 @@ require 'neo4j/config'
 require 'neo4j/database'
 require 'neo4j/neo4j'
 
+require "neo4j/functions/function"
+require "neo4j/functions/count"
+require "neo4j/functions/sum"
+
+
 require 'neo4j/index/index'
 require 'neo4j/index/class_methods'
 require 'neo4j/index/indexer_registry'
@@ -46,6 +51,8 @@ require 'neo4j/mapping/has_n'
 require 'neo4j/mapping/has_list'
 require 'neo4j/mapping/node_mixin'
 require 'neo4j/mapping/relationship_mixin'
+require 'neo4j/mapping/rule'
+require 'neo4j/mapping/rule_node'
 require 'neo4j/node_mixin'
 require 'neo4j/relationship_mixin'
 require 'neo4j/mapping/class_methods/rule'

data/lib/neo4j/config.rb

@@ -13,7 +13,6 @@ module Neo4j
   # <tt>:storage_path</tt>::   default <tt>tmp/neo4j</tt> where the database is stored
   # <tt>:timestamps</tt>::     default <tt>true</tt> for Rails Neo4j::Model - if timestamps should be used when saving the model
   # <tt>:lucene</tt>::         default hash keys: <tt>:fulltext</tt>, <tt>:exact</tt> configuration how the lucene index is stored
-  # <tt>:converters</tt>::     defines which converters should be used before writing and reading to neo4j, see Neo4j::TypeConverters
   #
   class Config
     # This code is copied from merb-core/config.rb.
@@ -27,12 +26,6 @@ module Neo4j
           :storage_path => 'tmp/neo4j',
           :timestamps => true,
           
-          # TODO: Just pickup all converter classes that are in the Neo4j::TypeConverters module?
-          :converters => { 	Date 			=> Neo4j::TypeConverters::DateConverter, 
-                            DateTime 	=> Neo4j::TypeConverters::DateTimeConverter,
-                            Time 			=> Neo4j::TypeConverters::TimeConverter
-          								},
-          								
           :lucene => {
                   :fulltext =>  {"provider" => "lucene", "type" => "fulltext" },
                   :exact    =>  {"provider" => "lucene", "type" => "exact" }}
@@ -117,10 +110,10 @@ module Neo4j
         @configuration.fetch(key, default)
       end
 
-      # Sets up the configuration
+      # Sets up the configuration to use the default.
       #
       # ==== Returns
-      # The configuration as a hash.
+      # The a new configuration using default values as a hash.
       #
       def setup()
         @configuration = {}

data/lib/neo4j/event_handler.rb

@@ -13,7 +13,57 @@ module Neo4j
   # * <tt>on_property_changed</tt>
   # * <tt>on_rel_property_changed</tt>
   #
-  # === Usage
+  # ==== on_neo4j_started(db)
+  #
+  # Called when the neo4j engine starts.
+  # Notice that the neo4j will be started automatically when the first neo4j operation is performed.
+  # You can also start Neo4j: <tt>Neo4j.start</tt>
+  #
+  # * <tt>db</tt> :: the Neo4j::Database instance
+  #
+  # ==== on_neo4j_shutdown(db)
+  #
+  # Called when the neo4j engine shutdown. You don't need to call <tt>Neo4j.shutdown</tt> since
+  # the it will automatically be shutdown when the application exits (using the at_exit ruby hook).
+  #
+  # * <tt>db</tt> :: the Neo4j::Database instance
+  #
+  # ==== on_node_created(node)
+  #
+  # * <tt>node</tt> :: the node that was created
+  #
+  # ==== on_node_deleted(node, old_props, tx_data)
+  #
+  # * <tt>node</tt> :: the node that was deleted
+  # * <tt>old_props</tt> :: a hash of the old properties this node had
+  # * <tt>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  #
+  # ==== on_relationship_created(rel, tx_data)
+  #
+  # * <tt>rel</tt> :: the relationship that was created
+  # * <tt>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  #
+  # ==== on_relationship_deleted(rel, old_props, tx_data)
+  #
+  # * <tt>rel</tt> :: the relationship that was created
+  # * <tt>old_props</tt> :: a hash of the old properties this relationship had
+  # * <tt>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  #
+  # ==== on_property_changed(node, key, old_value, new_value)
+  #
+  # * <tt>node</tt> :: the node
+  # * <tt>key</tt> :: the name of the property that was changed (String)
+  # * <tt>old_value</tt> :: old value of the property
+  # * <tt>new_value</tt> :: new value of the property
+  #
+  # ==== on_rel_property_changed(rel, key, old_value, new_value)
+  #
+  # * <tt>rel</tt> :: the node that was created
+  # * <tt>key</tt> :: the name of the property that was changed (String)
+  # * <tt>old_value</tt> :: old value of the property
+  # * <tt>new_value</tt> :: new value of the property
+  #
+  # == Usage
   #
   #   class MyListener
   #     def on_node_deleted(node, old_props, tx_data)

data/lib/neo4j/functions/count.rb

@@ -0,0 +1,33 @@
+module Neo4j
+  module Functions
+    class Count < Function
+      def initialize
+        @property = '_classname'
+      end
+
+      def calculate?(changed_property)
+        true
+      end
+
+      def delete(rule_name, rule_node, old_value)
+        key            = rule_node_property(rule_name)
+        rule_node[key] ||= 0
+        rule_node[key] -= 1
+      end
+
+      def add(rule_name, rule_node, new_value)
+        key            = rule_node_property(rule_name)
+        rule_node[key] ||= 0
+        rule_node[key] += 1
+      end
+
+      def update(*)
+        # we are only counting, not interested in property changes
+      end
+
+      def self.function_name
+        :count
+      end
+    end
+  end
+end

data/lib/neo4j/functions/function.rb

@@ -0,0 +1,72 @@
+module Neo4j
+  module Functions
+
+    # The base class of rule functions.
+    #
+    # You are expected to at least implement two methods:
+    # * update :: update the rule node value of this function
+    # * function_name :: the name of this function, the name of the generated method - A class method !
+    #
+    class Function
+
+      # Initialize the the function with a property which is usually the same as the function identity.
+      # See the #calculate? method how this property is used.
+      #
+      def initialize(property)
+        @property = property.to_s
+      end
+
+      def to_s
+        "Function #{self.class.function_name} function_id: #{function_id}"
+      end
+
+      # Decides if the function should be called are not
+      #
+      def calculate?(changed_property)
+        @property == changed_property
+      end
+
+
+      # The identity of the function.
+      # Used to identify function.
+      #
+      # ==== Example
+      #   Person.sum(:young, :age)
+      #
+      # In the example above the property :age is the used to identify which function will be called
+      # since there could be several sum method. In the example we want use the sum method that uses the :age property.
+      #
+      def function_id
+        @property
+      end
+
+      # The value of the rule
+      def value(rule_node, rule_name)
+        key = rule_node_property(rule_name)
+        rule_node[key] || 0
+      end
+
+      # Called when a node is removed from a rule group
+      # Default is calling update method which is expected to be implemented in a subclass
+      def delete(rule_name, rule_node, old_value)
+        update(rule_name, rule_node, old_value, nil)
+      end
+
+      # Called when a node is added to a rule group
+      # Default is calling update method which is expected to be implemented in a subclass
+      def add(rule_name, rule_node, new_value)
+        update(rule_name, rule_node, nil, new_value)
+      end
+
+      # the name of the property that holds the value of the function
+      def rule_node_property(rule_name)
+        self.class.rule_node_property(self.class.function_name, rule_name, @property)
+      end
+
+      def self.rule_node_property(function_name, rule_name, prop)
+        "_#{function_name}_#{rule_name}_#{prop}"
+      end
+
+    end
+  end
+end

data/lib/neo4j/functions/sum.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  module Functions
+
+    class Sum < Function
+      # Updates the function's value.
+      # Called after the transactions commits and a property has been changed on a node.
+      #
+      # ==== Arguments
+      # * rule_name :: the name of the rule group
+      # * rule_node :: the node which contains the value of this function
+      # * old_value new value :: the changed value of the property (when the transaction commits)
+      def update(rule_name, rule_node, old_value, new_value)
+        key            = rule_node_property(rule_name)
+        rule_node[key] ||= 0
+        old_value      ||= 0
+        new_value      ||= 0
+        rule_node[key] += new_value - old_value
+      end
+
+      def self.function_name
+        :sum
+      end
+    end
+
+
+  end
+end

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

@@ -35,7 +35,8 @@ module Neo4j::Mapping
       #     property :since, :type => DateTime  # will be converted into a fixnum
       #   end
       #
-      # You can write your own converter and register it in the Neo4j::Config.
+      # You can write your own converter by writing a class that respond to :convert?, :to_ruby and
+      # :to_java in the Neo4j::TypeConverters module.
       #
       def property(*props)
         if props.size == 2 and props[1].kind_of?(Hash)

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

@@ -1,154 +1,5 @@
 module Neo4j::Mapping
   module ClassMethods
-    # Holds all defined rules and trigger them when an event is received.
-    #
-    # See Rule
-    # 
-    class Rules
-      class << self
-        def add(clazz, field, props, &block)
-          clazz                   = clazz.to_s
-          @rules                  ||= {}
-          # was there no ruls for this class AND is neo4j running ?
-          if !@rules.include?(clazz) && Neo4j.running?
-            # maybe Neo4j was started first and the rules was added later. Create rule nodes now
-            create_rule_node_for(clazz)
-          end
-          @rules[clazz]           ||= {}
-          filter                  = block.nil? ? Proc.new { |*| true } : block
-          @rules[clazz][field]    = filter
-          @triggers               ||= {}
-          @triggers[clazz]        ||= {}
-          trigger                 = props[:trigger].nil? ? [] : props[:trigger]
-          @triggers[clazz][field] = trigger.respond_to?(:each) ? trigger : [trigger]
-        end
-
-        def inherit(parent_class, subclass)
-          # copy all the rules
-          @rules[parent_class.to_s].each_pair do |field, filter|
-            subclass.rule field, &filter
-          end if @rules[parent_class.to_s]
-        end
-
-        def trigger_other_rules(node)
-          clazz = node[:_classname]
-          @rules[clazz].keys.each do |field|
-            rel_types = @triggers[clazz][field]
-            rel_types.each do |rel_type|
-              node.incoming(rel_type).each { |n| n.trigger_rules }
-            end
-          end
-        end
-
-        def fields_for(clazz)
-          clazz = clazz.to_s
-          return [] if @rules.nil? || @rules[clazz].nil?
-          @rules[clazz].keys
-        end
-
-        def delete(clazz)
-          clazz = clazz.to_s
-          # delete the rule node if found
-          if Neo4j.ref_node.rel?(clazz)
-            Neo4j.ref_node.outgoing(clazz).each { |n| n.del }
-          end
-          @rules.delete(clazz) if @rules
-        end
-
-        def on_neo4j_started(*)
-          @rules.each_key { |clazz| create_rule_node_for(clazz) } if @rules
-        end
-
-        def create_rule_node_for(clazz)
-          if !Neo4j.ref_node.rel?(clazz)
-            Neo4j::Transaction.run do
-              node = Neo4j::Node.new
-              Neo4j.ref_node.outgoing(clazz) << node
-              node
-            end
-          end
-        end
-
-        def trigger?(node)
-          @rules && node.property?(:_classname) && @rules.include?(node[:_classname])
-        end
-
-        def rule_for(clazz)
-          if Neo4j.ref_node.rel?(clazz)
-            Neo4j.ref_node._rel(:outgoing, clazz)._end_node
-          else
-            # this should be called if the rule node gets deleted
-            create_rule_node_for(clazz)
-          end
-        end
-
-
-        def on_relationship_created(rel, *)
-          trigger_start_node = trigger?(rel._start_node)
-          trigger_end_node   = trigger?(rel._end_node)
-          # end or start node must be triggered by this event
-          return unless trigger_start_node || trigger_end_node
-          on_property_changed(trigger_start_node ? rel._start_node : rel._end_node)
-        end
-
-
-        def on_property_changed(node, *)
-          trigger_rules(node) if trigger?(node)
-        end
-
-        def trigger_rules(node)
-          trigger_rules_for_class(node, node[:_classname])
-          trigger_other_rules(node)
-        end
-
-        def trigger_rules_for_class(node, clazz)
-          return if @rules[clazz].nil?
-
-          agg_node = rule_for(clazz)
-          @rules[clazz].each_pair do |field, rule|
-            if run_rule(rule, node)
-              # is this node already included ?
-              unless connected?(field, agg_node, node)
-                agg_node.outgoing(field) << node
-              end
-            else
-              # remove old ?
-              break_connection(field, agg_node, node)
-            end
-          end
-
-          # recursively add relationships for all the parent classes with rules that also pass for this node
-          if clazz = eval("#{clazz}.superclass")
-            trigger_rules_for_class(node, clazz.to_s)
-          end
-        end
-
-        # work out if two nodes are connected by a particular relationship
-        # uses the end_node to start with because it's more likely to have less relationships to go through
-        # (just the number of superclasses it has really)
-        def connected?(relationship, start_node, end_node)
-          end_node.incoming(relationship).each do |n|
-            return true if n == start_node
-          end
-          false
-        end
-
-        # sever a direct one-to-one relationship if it exists
-        def break_connection(relationship, start_node, end_node)
-          end_node.rels(relationship).incoming.each do |r|
-            return r.del if r.start_node == start_node
-          end
-        end
-
-        def run_rule(rule, node)
-          if rule.arity != 1
-            node.wrapper.instance_eval(&rule)
-          else
-            rule.call(node)
-          end
-        end
-      end
-    end
 
 
     # Allows you to group nodes by providing a rule.
@@ -196,7 +47,7 @@ module Neo4j::Mapping
     #   class Reader
     #     include Neo4j::NodeMixin
     #     property :age
-    #     rule(:young, :trigger => :readers) { age < 15 }
+    #     rule(:young, :triggers => :readers) { age < 15 }
     #   end
     #
     #   class NewsStory
@@ -218,7 +69,8 @@ module Neo4j::Mapping
     #   end
     #
     # === Thread Safe ?
-    # Not sure...
+    # Yes, since operations are performed in an transaction. However you may get a deadlock exception:
+    # http://docs.neo4j.org/html/snapshot/#_deadlocks
     #
     module Rule
 
@@ -228,8 +80,10 @@ module Neo4j::Mapping
       # Example of usage:
       #   class Person
       #     include Neo4j
+      #     property :age
       #     rule :all
       #     rule :young { self[:age] < 10 }
+      #     rule(:old, :functions => [Sum.new[:age]) { age > 20 }
       #   end
       #
       #   p1 = Person.new :age => 5
@@ -239,35 +93,38 @@ module Neo4j::Mapping
       #   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(name, props = {}, &block)
-        singelton = class << self;
+      def rule(rule_name, props = {}, &block)
+        singleton = class << self;
           self;
         end
 
         # define class methods
-        singelton.send(:define_method, name) do
-          agg_node  = Rules.rule_for(self)
-          raise "no rule node for #{name}  on #{self}" if agg_node.nil?
-          traversal = agg_node.outgoing(name) # TODO possible to cache this object
-          Rules.fields_for(self).each do |filter_name|
-            traversal.filter_method(filter_name) do |path|
-              path.end_node.rel?(filter_name, :incoming)
-            end
-          end
-          traversal
-        end unless respond_to?(name)
+        singleton.send(:define_method, rule_name) do
+          rule_node = Neo4j::Mapping::Rule.rule_node_for(self)
+          rule_node.traversal(rule_name)
+        end unless respond_to?(rule_name)
 
         # define instance methods
-        self.send(:define_method, "#{name}?") do
+        self.send(:define_method, "#{rule_name}?") do
           instance_eval &block
         end
 
-        Rules.add(self, name, props, &block)
+        rule = Neo4j::Mapping::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 = Neo4j::Mapping::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 inherit_rules_from(clazz)
-        Rules.inherit(clazz, self)
+        Neo4j::Mapping::Rule.inherit(clazz, self)
       end
 
       # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
@@ -276,20 +133,20 @@ module Neo4j::Mapping
         singelton = class << self;
           self;
         end
-        Rules.fields_for(self).each do |name|
-          singelton.send(:remove_method, name)
-        end
-        Rules.delete(self)
+        rule_node = Neo4j::Mapping::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.
       def trigger_rules(node)
-        Rules.trigger_rules(node)
+        Neo4j::Mapping::Rule.trigger_rules(node)
       end
 
     end
 
-    Neo4j.unstarted_db.event_handler.add(Rules) unless Neo4j.read_only?
+    Neo4j.unstarted_db.event_handler.add(Neo4j::Mapping::Rule) unless Neo4j.read_only?
   end
 end