neo4j 1.0.0.beta.28-java → 1.0.0.beta.29-java

data/CONTRIBUTORS

@@ -2,6 +2,7 @@ Maintainer:
   Andreas Ronge <andreas dot ronge at gmail dot com>
 
 Contributors:
+* Stephan Hagemann
 * Bobby Calderwood
 * Ben Jackson
 * Dwight van Tuyl

data/bin/neo4j-shell

@@ -1,107 +1,5 @@
-#!/bin/sh
-# ----------------------------------------------------------------------------
-#  Copyright 2001-2006 The Apache Software Foundation.
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-# ----------------------------------------------------------------------------
+#!/usr/bin/env ruby
 
-#   Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
-#   reserved.
-
-BASEDIR=`dirname $0`/..
-BASEDIR=`(cd "$BASEDIR"; pwd)`
-
-
-
-# OS specific support.  $var _must_ be set to either true or false.
-cygwin=false;
-darwin=false;
-case "`uname`" in
-  CYGWIN*) cygwin=true ;;
-  Darwin*) darwin=true
-           if [ -z "$JAVA_VERSION" ] ; then
-             JAVA_VERSION="CurrentJDK"
-           else
-             echo "Using Java version: $JAVA_VERSION"
-           fi
-           if [ -z "$JAVA_HOME" ] ; then
-             JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/${JAVA_VERSION}/Home
-           fi
-           ;;
-esac
-
-if [ -z "$JAVA_HOME" ] ; then
-  if [ -r /etc/gentoo-release ] ; then
-    JAVA_HOME=`java-config --jre-home`
-  fi
-fi
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched
-if $cygwin ; then
-  [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-  [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"`
-fi
-
-# If a specific java binary isn't specified search for the standard 'java' binary
-if [ -z "$JAVACMD" ] ; then
-  if [ -n "$JAVA_HOME"  ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-      # IBM's JDK on AIX uses strange locations for the executables
-      JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-      JAVACMD="$JAVA_HOME/bin/java"
-    fi
-  else
-    JAVACMD=`which java`
-  fi
-fi
-
-if [ ! -x "$JAVACMD" ] ; then
-  echo "Error: JAVA_HOME is not defined correctly."
-  echo "  We cannot execute $JAVACMD"
-  exit 1
-fi
-
-if [ -z "$REPO" ]
-then
-  REPO="$BASEDIR"/lib/neo4j/jars
-fi
-
-LIBRARY_JARS=""
-for jar in $(find $REPO -iname "*.jar")
-do
-  LIBRARY_JARS=${LIBRARY_JARS}:$jar
-done
-
-CLASSPATH=$CLASSPATH_PREFIX${LIBRARY_JARS}
-
-EXTRA_JVM_ARGUMENTS=""
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin; then
-  [ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --windows "$CLASSPATH"`
-  [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"`
-  [ -n "$HOME" ] && HOME=`cygpath --path --windows "$HOME"`
-  [ -n "$BASEDIR" ] && BASEDIR=`cygpath --path --windows "$BASEDIR"`
-  [ -n "$REPO" ] && REPO=`cygpath --path --windows "$REPO"`
-fi
-
-exec "$JAVACMD" $JAVA_OPTS \
-  $EXTRA_JVM_ARGUMENTS \
-  -classpath "$CLASSPATH" \
-  -Dapp.name="neo4j-shell" \
-  -Dapp.pid="$$" \
-  -Dapp.repo="$REPO" \
-  -Dbasedir="$BASEDIR" \
-  org.neo4j.shell.StartClient \
-  "$@"
+require 'neo4j'
+Neo4j.load_shell_jars
+org.neo4j.shell.StartClient.main(ARGV)

data/lib/neo4j.rb

@@ -15,6 +15,7 @@ require 'neo4j/jars/core/geronimo-jta_1.1_spec-1.1.1.jar'
 require 'neo4j/jars/core/lucene-core-3.0.3.jar'
 require 'neo4j/jars/core/neo4j-lucene-index-0.5-1.3.M01.jar'
 require 'neo4j/jars/core/neo4j-kernel-1.3-1.3.M01.jar'
+require 'neo4j/jars/ha/neo4j-management-1.3-1.3.M01.jar'
 
 module Neo4j
 
@@ -24,11 +25,13 @@ module Neo4j
     require 'neo4j/jars/core/neo4j-index-1.3-1.3.M01.jar'
   end
 
+  def self.load_shell_jars
+    require 'neo4j/jars/ha/neo4j-shell-1.3-1.3.M01.jar'
+  end
+  
   def self.load_ha_jars
     require 'neo4j/jars/ha/log4j-1.2.16.jar'
     require 'neo4j/jars/ha/neo4j-ha-0.6-1.3.M01.jar'
-    require 'neo4j/jars/ha/neo4j-management-1.3-1.3.M01.jar'
-    require 'neo4j/jars/ha/neo4j-shell-1.3-1.3.M01.jar'
     require 'neo4j/jars/ha/netty-3.2.1.Final.jar'
     require 'neo4j/jars/ha/org.apache.servicemix.bundles.jline-0.9.94_1.jar'
     require 'neo4j/jars/ha/org.apache.servicemix.bundles.lucene-3.0.1_2.jar'

data/lib/neo4j/batch/batch.rb

@@ -1,2 +1,4 @@
 require 'neo4j/batch/inserter'
 require 'neo4j/batch/indexer'
+require 'neo4j/batch/rule_inserter'
+require 'neo4j/batch/rule_node'

data/lib/neo4j/batch/inserter.rb

@@ -23,6 +23,7 @@ module Neo4j
         raise "Not allowed to start batch inserter while Neo4j is already running at storage location #{storage_path}" if Neo4j.storage_path == storage_path
         @batch_inserter  = org.neo4j.kernel.impl.batchinsert.BatchInserterImpl.new(storage_path, config)
         Indexer.index_provider  = org.neo4j.index.impl.lucene.LuceneBatchInserterIndexProvider.new(@batch_inserter)
+        @rule_inserter = RuleInserter.new(self)
       end
 
       def running?
@@ -33,7 +34,8 @@ module Neo4j
       def shutdown
         @batch_inserter && @batch_inserter.shutdown
         @batch_inserter = nil
-
+        @rule_inserter = nil
+        
         Indexer.index_provider
         Indexer.index_provider && Indexer.index_provider.shutdown
         Indexer.index_provider = nil
@@ -48,6 +50,7 @@ module Neo4j
 
         node = @batch_inserter.create_node(props)
         props && _index(node, props, clazz)
+        @rule_inserter.node_added(node, props)
         node
       end
 

data/lib/neo4j/batch/rule_inserter.rb

@@ -0,0 +1,24 @@
+module Neo4j
+  module Batch
+    class RuleInserter #:nodoc:
+      def initialize(inserter)
+        @inserter = inserter
+      end
+
+      def node_added(node, props)
+        classname = props && props['_classname']
+        classname && create_rules(node, props, classname)
+      end
+
+
+      def create_rules(node, props, classname)
+        rule_node = RuleNode.rule_node_for(classname, @inserter)
+        rule_node && rule_node.execute_rules(@inserter, node, props)
+
+        if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
+          create_rules(node, props, clazz.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/batch/rule_node.rb

@@ -0,0 +1,72 @@
+module Neo4j
+  module Batch
+    class RuleNode #:nodoc:
+      attr_reader :node
+      delegate :rules, :to => :@wrapped_rule_node
+
+      def initialize(wrapped_rule_node, node)
+        @wrapped_rule_node = wrapped_rule_node
+        @node              = node
+      end
+
+      def execute_rules(inserter, node, props)
+        rules.each do |rule|
+          if execute_filter(rule, props)
+            inserter.create_rel(rule.rule_name, @node, node)
+            execute_add_functions(inserter, rule, props)
+          end
+        end
+      end
+
+      def execute_add_functions(inserter, rule, props)
+        rule_props = nil
+        executed_functions = []
+        props.keys.each do |key|
+          functions = rule.functions_for(key)
+          next unless functions
+          functions -= executed_functions
+          rule_props ||= clone_node_props(inserter) #inserter.node_props(@node)
+          functions.each { |f| executed_functions << f; f.add(rule.rule_name, rule_props, props[key]) }
+        end
+        rule_props && inserter.set_node_props(@node, rule_props)
+      end
+
+      def clone_node_props(inserter)
+        hash = {}
+        props = inserter.node_props(@node)  # need to clone this since we can't modify it
+        props.each_pair{|k,v| hash[k]=v}
+        hash
+      end
+      
+      def execute_filter(rule, props)
+        if rule.filter.nil?
+          true
+        elsif rule.filter.arity != 1
+          classname = props['_classname'] || 'Neo4j::Node'
+          clazz     = Neo4j::Node.to_class(classname)
+          wrapper   = clazz.load_wrapper(ActiveSupport::HashWithIndifferentAccess.new(props))
+          wrapper.instance_eval(&rule.filter)
+        else
+          rule.filter.call(ActiveSupport::HashWithIndifferentAccess.new(props))
+        end
+      end
+
+      class << self
+        def rule_node_for(classname, inserter)
+          return nil unless Neo4j::Rule::Rule.has_rules?(classname)
+          wrapped_rule_node      = Neo4j::Rule::Rule.rule_node_for(classname)
+          @rule_nodes            ||= {}
+          @rule_nodes[classname] ||= RuleNode.new(wrapped_rule_node, create_node(classname, inserter))
+        end
+
+        def create_node(classname, inserter)
+          rule_node = inserter.create_node
+          inserter.create_rel(classname, inserter.ref_node, rule_node)
+          rule_node
+        end
+      end
+
+
+    end
+  end
+end

data/lib/neo4j/database.rb

@@ -22,6 +22,12 @@ module Neo4j
       @running = true
       @storage_path = Config.storage_path
 
+
+      if Config[:enable_remote_shell]
+        Neo4j.logger.info("Enable remote shell at port #{Config[:enable_remote_shell]}")
+        Neo4j.load_shell_jars
+      end
+
       begin
         if self.class.locked?
           start_readonly_graph_db
@@ -96,10 +102,17 @@ module Neo4j
         @graph   = nil
         @lucene  = nil
         @running = false
+        @neo4j_manager = nil
       end
 
     end
 
+
+    def management(jmx_clazz) #:nodoc:
+      @neo4j_manager ||= org.neo4j.management.Neo4jManager.new(@graph.get_management_bean(org.neo4j.management.Kernel.java_class))
+      @neo4j_manager.getBean(jmx_clazz.java_class)
+    end
+
     def begin_tx #:nodoc:
       @graph.begin_tx
     end

data/lib/neo4j/migrations/node_mixin.rb

@@ -48,7 +48,7 @@ module Neo4j
 
         # The node that holds the db version property
         def migration_meta_node
-          Neo4j::Rule::RuleEventListener.rule_node_for(self).rule_node
+          Neo4j::Rule::Rule.rule_node_for(self).rule_node
         end
 
         # Remote all migration and set migrate_to = nil and set the current version to nil

data/lib/neo4j/neo4j.rb

@@ -110,6 +110,33 @@ module Neo4j
       this_db.graph.reference_node
     end
 
+    # Returns a Management JMX Bean.
+    #
+    # Notice that this information is also provided by the jconsole Java tool, check http://wiki.neo4j.org/content/Monitoring_and_Deployment
+    # and http://docs.neo4j.org/chunked/milestone/operations-monitoring.html
+    #
+    # By default it returns the Primitivies JMX Bean that can be used to find number of nodes in use.
+    #
+    # ==== Example Neo4j Primititives
+    #
+    #   Neo4j.management.get_number_of_node_ids_in_use
+    #   Neo4j.management.getNumberOfPropertyIdsInUse
+    #   Neo4j.management.getNumberOfRelationshipIdsInUse
+    #   Neo4j.management.get_number_of_relationship_type_ids_in_use
+    #
+    # ==== Example Neo4j HA Cluster Info
+    #
+    # Neo4j.management(org.neo4j.management.HighAvailability).isMaster
+    #
+    # ==== Arguments
+    #
+    # jmx_clazz :: http://api.neo4j.org/current/org/neo4j/management/package-summary.html
+    # this_db :: default currently runnig instance or a newly started neo4j db instance
+    #
+    def management(jmx_clazz = org.neo4j.management.Primitives, this_db = self.started_db)
+      this_db.management(jmx_clazz)
+    end
+
     # Returns an Enumerable object for all nodes in the database
     def all_nodes(this_db = self.started_db)
       Enumerator.new(this_db, :each_node)

data/lib/neo4j/node_mixin/node_mixin.rb

@@ -78,7 +78,7 @@ module Neo4j
 
     # Trigger rules.
     # You don't normally need to call this method (except in Migration) since
-    # it will be triggered automatically by the Neo4j::Rule::RuleEventListener
+    # it will be triggered automatically by the Neo4j::Rule::Rule
     #
     def trigger_rules
       self.class.trigger_rules(self)

data/lib/neo4j/property/property.rb

@@ -64,7 +64,7 @@ module Neo4j
           self[key] = value
         end
       end
-      keys_to_delete.each { |key| delete_property(key) } if strict
+      keys_to_delete.each { |key| remove_property(key) } if strict
       self
     end
 

data/lib/neo4j/rails/attributes.rb

@@ -57,7 +57,101 @@ module Neo4j
       # Mass-assign attributes.  Stops any protected attributes from being assigned.
       def attributes=(attributes, guard_protected_attributes = true)
         attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
-        attributes.each { |k, v| respond_to?("#{k}=") ? send("#{k}=", v) : self[k] = v }
+
+        multi_parameter_attributes = []
+        attributes.each do |k, v|
+          if k.to_s.include?("(")
+            multi_parameter_attributes << [ k, v ]
+          else
+            respond_to?("#{k}=") ? send("#{k}=", v) : self[k] = v
+          end
+        end
+
+        assign_multiparameter_attributes(multi_parameter_attributes)
+      end
+
+      # Instantiates objects for all attribute classes that needs more than one constructor parameter. This is done
+      # by calling new on the column type or aggregation type (through composed_of) object with these parameters.
+      # So having the pairs written_on(1) = "2004", written_on(2) = "6", written_on(3) = "24", will instantiate
+      # written_on (a date type) with Date.new("2004", "6", "24"). You can also specify a typecast character in the
+      # parentheses to have the parameters typecasted before they're used in the constructor. Use i for Fixnum,
+      # f for Float, s for String, and a for Array. If all the values for a given attribute are empty, the
+      # attribute will be set to nil.
+      def assign_multiparameter_attributes(pairs)
+        execute_callstack_for_multiparameter_attributes(
+          extract_callstack_for_multiparameter_attributes(pairs)
+        )
+      end
+
+      def execute_callstack_for_multiparameter_attributes(callstack)
+        errors = []
+        callstack.each do |name, values_with_empty_parameters|
+          begin
+            # (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+            klass = self.class._decl_props[name.to_sym][:type]
+            raise "Not a multiparameter attribute, missing :type on property #{name} for #{self.class}" unless klass
+
+            # in order to allow a date to be set without a year, we must keep the empty values.
+            values = values_with_empty_parameters.reject { |v| v.nil? }
+
+            if values.empty?
+              send(name + "=", nil)
+            else
+
+              value = if Time == klass
+                instantiate_time_object(name, values)
+              elsif Date == klass
+                begin
+                  values = values_with_empty_parameters.collect do |v| v.nil? ? 1 : v end
+                  Date.new(*values)
+                rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
+                  instantiate_time_object(name, values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
+                end
+              else
+                klass.new(*values)
+              end
+
+              send(name + "=", value)
+            end
+          rescue Exception => ex
+            raise "error on assignment #{values.inspect} to #{name}, ex: #{ex}"
+          end
+        end
+        unless errors.empty?
+          raise MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
+      end
+
+      def instantiate_time_object(name, values)
+#        if self.class.send(:create_time_zone_conversion_attribute?, name, column_for_attribute(name))
+#          Time.zone.local(*values)
+#        else
+          Time.time_with_datetime_fallback(self.class.default_timezone, *values)
+#        end
+      end
+
+      def extract_callstack_for_multiparameter_attributes(pairs)
+        attributes = { }
+
+        for pair in pairs
+          multiparameter_name, value = pair
+          attribute_name = multiparameter_name.split("(").first
+          attributes[attribute_name] = [] unless attributes.include?(attribute_name)
+
+          parameter_value = value.empty? ? nil : type_cast_attribute_value(multiparameter_name, value)
+          attributes[attribute_name] << [ find_parameter_position(multiparameter_name), parameter_value ]
+        end
+
+        attributes.each { |name, values| attributes[name] = values.sort_by{ |v| v.first }.collect { |v| v.last } }
+      end
+
+
+      def type_cast_attribute_value(multiparameter_name, value)
+        multiparameter_name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+      end
+
+      def find_parameter_position(multiparameter_name)
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first
       end
 
       # Tracks the current changes and clears the changed attributes hash.  Called

data/lib/neo4j/rails/model.rb

@@ -2,10 +2,10 @@ module Neo4j
   module Rails
     class Model
       include Neo4j::NodeMixin
-      
+
       # Initialize a Node with a set of properties (or empty if nothing is passed)
       def initialize(attributes = {})
-      	reset_attributes
+        reset_attributes
         clear_relationships
         self.attributes = attributes if attributes.is_a?(Hash)
       end
@@ -39,9 +39,10 @@ module Neo4j
       end
 
       def ==(other)
-      	new? ? self.__id__ == other.__id__ : @_java_node == (other)
+        new? ? self.__id__ == other.__id__ : @_java_node == (other)
       end
-      
+
+
       # --------------------------------------
       # Public Class Methods
       # --------------------------------------
@@ -49,11 +50,22 @@ module Neo4j
         # NodeMixin overwrites the #new class method but it saves it as orig_new
         # Here, we just get it back to normal
         alias :new :orig_new
-        
+
         def transaction(&block)
           Neo4j::Rails::Transaction.run do |tx|
             block.call(tx)
-          end 
+          end
+        end
+
+        ##
+        # Determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling
+        # dates and times from the database. This is set to :local by default.
+        def default_timezone
+          @default_timezone || :local
+        end
+
+        def default_timezone=(zone)
+          @default_timezone = zone
         end
 
         def accepts_nested_attributes_for(*attr_names)
@@ -87,19 +99,19 @@ module Neo4j
         end
       end
     end
-    
+
     Model.class_eval do
-    	extend ActiveModel::Translation
-      
-      include Persistence				# handles how to save, create and update the model
-      include Attributes				# handles how to save and retrieve attributes
-      include Mapping::Property	# allows some additional options on the #property class method
-      include Serialization			# enable to_xml and to_json
-      include Timestamps				# handle created_at, updated_at timestamp properties
-      include Validations				# enable validations
-      include Callbacks					# enable callbacks
-      include Finders						# ActiveRecord style find
-      include Relationships     # for none persisted relationships
+      extend ActiveModel::Translation
+
+      include Persistence # handles how to save, create and update the model
+      include Attributes # handles how to save and retrieve attributes
+      include Mapping::Property # allows some additional options on the #property class method
+      include Serialization # enable to_xml and to_json
+      include Timestamps # handle created_at, updated_at timestamp properties
+      include Validations # enable validations
+      include Callbacks # enable callbacks
+      include Finders # ActiveRecord style find
+      include Relationships # for none persisted relationships
     end
   end
 end

data/lib/neo4j/rule/class_methods.rb

@@ -102,7 +102,7 @@ module Neo4j
 
         # define class methods
         singleton.send(:define_method, rule_name) do
-          rule_node = RuleEventListener.rule_node_for(self)
+          rule_node = Rule.rule_node_for(self)
           rule_node.traversal(rule_name)
         end unless respond_to?(rule_name)
 
@@ -111,11 +111,11 @@ module Neo4j
           instance_eval &block
         end
 
-        rule = RuleEventListener.add(self, rule_name, props, &block)
+        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 = RuleEventListener.rule_node_for(self)
+            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)
@@ -124,7 +124,7 @@ module Neo4j
       end
 
       def inherit_rules_from(clazz)
-        RuleEventListener.inherit(clazz, self)
+        Rule.inherit(clazz, self)
       end
 
       # This is typically used for RSpecs to clean up rule nodes created by the #rule method.
@@ -133,7 +133,7 @@ module Neo4j
         singelton = class << self;
           self;
         end
-        rule_node = RuleEventListener.rule_node_for(self)
+        rule_node = Rule.rule_node_for(self)
 
         rule_node.rule_names.each {|rule_name| singelton.send(:remove_method, rule_name)}
         rule_node.rules.clear
@@ -145,7 +145,7 @@ module Neo4j
       # Can also be called from an migration.
       #
       def trigger_rules(node, *changes)
-        RuleEventListener.trigger_rules(node, *changes)
+        Rule.trigger_rules(node, *changes)
       end
 
       # Returns a proc that will call add method on the given function
@@ -167,7 +167,7 @@ module Neo4j
       # 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 = RuleEventListener.rule_node_for(self)
+        rule_node = Rule.rule_node_for(self)
         rule = rule_node.find_rule(rule_name)
         rule_node_raw = rule_node.rule_node
 
@@ -179,6 +179,5 @@ module Neo4j
       end
     end
 
-    Neo4j.unstarted_db.event_handler.add(RuleEventListener) unless Neo4j.read_only?
   end
 end

data/lib/neo4j/rule/event_listener.rb

@@ -0,0 +1,60 @@
+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, data)
+          # 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_name         = rule.rule_name.to_s
+
+            # is the rule node deleted ?
+            deleted_rule_node = data.deletedNodes.find { |n| n == rule_node.rule_node }
+            next if deleted_rule_node
+
+            rule.functions.each do |function|
+              next unless data.deletedRelationships.find do |r|
+                r.getEndNode().getId() == id && r.rel_type == rule_name
+              end
+              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 on_neo4j_started(*)
+          Rule.on_neo4j_started
+        end
+      end
+
+
+    end
+    Neo4j.unstarted_db.event_handler.add(EventListener) unless Neo4j.read_only?
+
+  end
+end

data/lib/neo4j/rule/rule.rb

@@ -1,5 +1,130 @@
-require 'neo4j/rule/rule_event_listener'
+require 'neo4j/rule/event_listener'
 require 'neo4j/rule/class_methods'
 require 'neo4j/rule/rule_node'
 
-require 'neo4j/rule/functions/functions'
+require 'neo4j/rule/functions/functions'
+
+
+module Neo4j
+  module Rule
+
+
+    # Holds all defined rules added by the Neo4j::Rule::ClassMethods#rule method.
+    #
+    # See Neo4j::Rule::ClassMethods
+    #
+    class Rule
+
+      attr_reader :rule_name, :filter, :triggers, :functions
+
+      def initialize(rule_name, props, &block)
+        @rule_name = rule_name
+        @triggers  = props[:triggers]
+        @functions = props[:functions]
+        @triggers = [@triggers] if @triggers && !@triggers.respond_to?(:each)
+        @functions = [@functions] if @functions && !@functions.respond_to?(:each)
+        @filter = block
+      end
+
+      def to_s
+        "Rule #{rule_name} props=#{props.inspect}"
+      end
+
+      def find_function(function_name, function_id)
+        function_id = function_id.to_s
+        @functions && @functions.find { |f| f.function_id == function_id && f.class.function_name == function_name }
+      end
+
+      # Reconstruct the properties given when created this rule
+      # Needed when inheriting a rule and we want to duplicate a rule
+      def props
+        props = {}
+        props[:triggers] = @triggers if @triggers
+        props[:functions] = @functions if @functions
+        props
+      end
+
+      def functions_for(property)
+        @functions && @functions.find_all { |f| f.calculate?(property) }
+      end
+
+      def execute_filter(node)
+        if @filter.nil?
+          true
+        elsif @filter.arity != 1
+          node.wrapper.instance_eval(&@filter)
+        else
+          @filter.call(node)
+        end
+      end
+
+      # ------------------------------------------------------------------------------------------------------------------
+      # Class Methods
+      # ------------------------------------------------------------------------------------------------------------------
+
+      class << self
+        def add(clazz, rule_name, props, &block)
+          rule_node = rule_node_for(clazz.to_s)
+          rule_node.remove_rule(rule_name) # remove any previously inherited rules
+          rule = Rule.new(rule_name, props, &block)
+          rule_node.add_rule(rule)
+          rule
+        end
+
+        def has_rules?(clazz)
+          !@rule_nodes[clazz.to_s].nil?
+        end
+        
+        def rule_names_for(clazz)
+          rule_node = rule_node_for(clazz)
+          rule_node.rules.map { |rule| rule.rule_name }
+        end
+
+        def rule_node_for(clazz)
+          return nil if clazz.nil?
+          @rule_nodes             ||= {}
+          @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
+        end
+
+        def find_rule_node(node)
+          @rule_nodes && @rule_nodes.values.find { |rn| rn.rule_node?(node) }
+        end
+
+        def on_neo4j_started
+          @rule_nodes.each_value { |rule_node| rule_node.on_neo4j_started } if @rule_nodes
+        end
+
+        def inherit(parent_class, subclass)
+          # copy all the rules
+          if rule_node = rule_node_for(parent_class)
+            rule_node.inherit(subclass)
+          end
+        end
+
+        def delete(clazz)
+          if rule_node = rule_node_for(clazz)
+            rule_node.delete_node
+          end
+        end
+
+        def trigger?(node)
+          classname = node[:_classname]
+          @rule_nodes && classname && rule_node_for(classname)
+        end
+
+        def trigger_rules(node, *changes)
+          classname = node[:_classname]
+          return unless classname # there are no rules if there is not a :_classname property
+          rule_node = rule_node_for(classname)
+          rule_node.execute_rules(node, *changes)
+
+          # recursively add relationships for all the parent classes with rules that also pass for this node
+          if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
+            rule_node = rule_node_for(clazz)
+            rule_node && rule_node.execute_rules(node, *changes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/type_converters/type_converters.rb

@@ -65,7 +65,7 @@ module Neo4j
 
         def to_ruby(value)
           return nil if value.nil?
-          Time.at(value).utc
+          Time.at(value).utc.to_date
         end
       end
     end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.28"
+  VERSION = "1.0.0.beta.29"
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 1.0.0.beta.28
+  version: 1.0.0.beta.29
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-02 00:00:00 +01:00
+date: 2011-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -154,6 +154,8 @@ files:
   - 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
@@ -164,7 +166,7 @@ files:
   - lib/neo4j/rule/rule.rb
   - lib/neo4j/rule/rule_node.rb
   - lib/neo4j/rule/class_methods.rb
-  - lib/neo4j/rule/rule_event_listener.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

data/lib/neo4j/rule/rule_event_listener.rb

@@ -1,162 +0,0 @@
-module Neo4j
-  module Rule
-
-
-    # Holds all defined rules and trigger them when an event is received.
-    #
-    # See Neo4j::Rule::ClassMethods
-    #
-    class RuleEventListener #:nodoc:
-
-      attr_reader :rule_name, :filter, :triggers, :functions
-
-      def initialize(rule_name, props, &block)
-        @rule_name = rule_name
-        @triggers = props[:triggers]
-        @functions = props[:functions]
-        @triggers = [@triggers] if @triggers && !@triggers.respond_to?(:each)
-        @functions = [@functions] if @functions && !@functions.respond_to?(:each)
-        @filter = block
-      end
-
-      def to_s
-        "RuleEventListener #{rule_name} props=#{props.inspect}"
-      end
-
-      def find_function(function_name, function_id)
-        function_id = function_id.to_s
-        @functions && @functions.find { |f| f.function_id == function_id && f.class.function_name == function_name }
-      end
-
-      # Reconstruct the properties given when created this rule
-      # Needed when inheriting a rule and we want to duplicate a rule
-      def props
-        props = {}
-        props[:triggers] = @triggers if @triggers
-        props[:functions] = @functions if @functions
-        props
-      end
-
-      def functions_for(property)
-        @functions && @functions.find_all { |f| f.calculate?(property) }
-      end
-
-      def execute_filter(node)
-        if @filter.nil?
-          true
-        elsif @filter.arity != 1
-          node.wrapper.instance_eval(&@filter)
-        else
-          @filter.call(node)
-        end
-      end
-
-      # ------------------------------------------------------------------------------------------------------------------
-      # Class Methods
-      # ------------------------------------------------------------------------------------------------------------------
-
-      class << self
-        def add(clazz, rule_name, props, &block)
-          rule_node = rule_node_for(clazz.to_s)
-          rule_node.remove_rule(rule_name) # remove any previously inherited rules
-          rule = RuleEventListener.new(rule_name, props, &block)
-          rule_node.add_rule(rule)
-          rule
-        end
-
-        def rule_names_for(clazz)
-          rule_node = rule_node_for(clazz)
-          rule_node.rules.map { |rule| rule.rule_name }
-        end
-
-        def rule_node_for(clazz)
-          return nil if clazz.nil?
-          @rule_nodes ||= {}
-          @rule_nodes[clazz.to_s] ||= RuleNode.new(clazz)
-        end
-
-        def inherit(parent_class, subclass)
-          # copy all the rules
-          if rule_node = rule_node_for(parent_class)
-            rule_node.inherit(subclass)
-          end
-        end
-
-        def delete(clazz)
-          if rule_node = rule_node_for(clazz)
-            rule_node.delete_node
-          end
-        end
-
-        def trigger?(node)
-          classname = node[:_classname]
-          @rule_nodes && classname && rule_node_for(classname)
-        end
-
-        def trigger_rules(node, *changes)
-          classname = node[:_classname]
-          return unless classname # there are no rules if there is not a :_classname property
-          rule_node = rule_node_for(classname)
-          rule_node.execute_rules(node, *changes)
-
-          # recursively add relationships for all the parent classes with rules that also pass for this node
-          if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
-            rule_node = rule_node_for(clazz)
-            rule_node && rule_node.execute_rules(node, *changes)
-          end
-        end
-
-
-        # ----------------------------------------------------------------------------------------------------------------
-        # Event handling methods
-        # ----------------------------------------------------------------------------------------------------------------
-
-        def on_relationship_created(rel, *)
-          trigger_start_node = trigger?(rel._start_node)
-          trigger_end_node = trigger?(rel._end_node)
-          trigger_rules(rel._start_node) if trigger_start_node
-          trigger_rules(rel._end_node) if trigger_end_node
-        end
-
-        def on_property_changed(node, *changes)
-          trigger_rules(node, *changes) if trigger?(node)
-        end
-
-        def on_node_deleted(node, old_properties, data)
-          # have we deleted a rule node ?
-          del_rule_node = @rule_nodes && @rule_nodes.values.find { |rn| rn.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_node_for(clazz)
-          return if rule_node.nil?
-
-          id = node.getId
-          rule_node.rules.each do |rule|
-            next if rule.functions.nil?
-            rule_name = rule.rule_name.to_s
-
-            # is the rule node deleted ?
-            deleted_rule_node = data.deletedNodes.find { |n| n == rule_node.rule_node }
-            next if deleted_rule_node
-
-            rule.functions.each do |function|
-              next unless data.deletedRelationships.find do |r|
-                r.getEndNode().getId() == id && r.rel_type == rule_name
-              end
-              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 on_neo4j_started(*)
-          @rule_nodes.each_value { |rule_node| rule_node.on_neo4j_started } if @rule_nodes
-        end
-
-      end
-    end
-  end
-end