neo4j 1.2.1-java → 1.2.2-java

data/CHANGELOG

@@ -1,10 +1,22 @@
-  == 1.2.1 / 2011-08-29
+ == 1.2.2 / 2011-09-15
+* Added compositions support for rails mode (Deepak N)
+* Added support for nested transactions at the Rails model level (Vivek Prahlad)
+* Fixing issue where save for invalid entities puts them into an inconsistent state (Vivek Prahlad)
+* Fix for issue with save when validation fails (Vivek Prahlad)
+* Fix for accepts_nested_attributes_for when the associated entities are created before a new node (Vivek Prahlad)
+* Fix to allow has_one relationships to handle nil assignments in models (Vivek Prahlad)
+* Observers support for neo4j rails model using active model (Deepak N)
+* Override ActiveModel i18n_scope for neo4j (Deepak N)
+* Added finders similar to active record and mongoid (Deepak N)
+* Added find!, find_or_create_by and find_or_initialize_by methods, similar to active record finders (Deepak N)
+
+ == 1.2.1 / 2011-08-29
 * Fixed failing RSpecs for devise-neo4j gem - column_names method on neo4j orm adapter throws NoMethodError (thanks Deepak N)
 
-  == 1.2.0 / 2011-08-16
+ == 1.2.0 / 2011-08-16
 * Upgrade to java library neo4j 1.4.1, see http://neo4j.rubyforge.org/guides/configuration.html
 
-  == 1.1.4 / 2011-08-10
+ == 1.1.4 / 2011-08-10
 * Fixed dependency to will_paginate, locked to 3.0.pre4 (newly released 3.0.0 does not work yet with neo4j.rb)
 
   == 1.1.3 / 2011-08-09
@@ -12,12 +24,12 @@
 * BUG: not able to create array properties on relationships (Pere Urbon)
 * BUG: lucene did not work if starting up neo4j in read only mode (like rails console when the rails is already running)
 
-  == 1.1.2 / 2011-06-08
+ == 1.1.2 / 2011-06-08
 * Added configuration option 'enable_rules' to disable the _all relationships and custom rules [#176]
 * Added a #node method on the Neo4j::Node and Neo4j::NodeMixin. Works like the #rel method but returns the node instead. [#174]
 * Simplify creating relationship between two existing nodes [#175]
 
-== 1.1.1 / 2011-05-26
+ == 1.1.1 / 2011-05-26
 * Made neo4j compatible with rails 3.1.0.rc1 [#170]
 * Fix for neo4j-devise [#171]
 * BUG: Neo4j::GraphAlgo shortest path does raise exception if two nodes are not connected [#172]
@@ -45,7 +57,7 @@
 * Lots of improvements of the API
 * Better ActiveModel/Rails integration
 
-    == 0.4.4 / 2010-08-01
+== 0.4.4 / 2010-08-01
 * Fixed bug on traversing when using the RelationshipMixin (#121)
 * BatchInserter and JRuby 1.6 - Fix iteration error with trying to modify in-place hash
 

data/CONTRIBUTORS

@@ -3,6 +3,7 @@ Maintainer:
 
 Contributors:
 
+* Vivek Prahlad
 * Deepak N
 * Frédéric Vanclef
 * Pere Urbon

data/Gemfile

@@ -7,7 +7,10 @@ group 'test' do
   gem "rdoc", ">= 2.5.10"
   gem "horo", ">= 1.0.2"
   gem "rspec", ">= 2.0.0"
-  gem "rspec-rails-matchers", ">= 0.2.1"
+
+  # use this version for rspec-rails-matchers which work with latest RSpec (Rspec => RSpec)
+  gem "rspec-rails-matchers", :git => 'git://github.com/afcapel/rspec-rails-matchers.git'
+
   gem "test-unit"
   gem 'rcov'
 end

data/lib/neo4j/node.rb

@@ -49,17 +49,25 @@ module Neo4j
   # The property operations give access to the key-value property pairs.
   # Property keys are always strings. Valid property value types are the primitives(<tt>String</tt>, <tt>Fixnum</tt>, <tt>Float</tt>, <tt>Boolean</tt>), and arrays of those primitives.
   #
-  # === Instance Methods form Included Mixins
+  # === Instance Methods from Included Mixins
   # * Neo4j::Property - methods that deal with properties
-  # * Neo4j::NodeRelationship methods for relationship
+  # * Neo4j::Rels methods for accessing incoming and outgoing relationship and nodes of depth one.
   # * Neo4j::Equal equality operators: <tt>eql?</tt>, <tt>equal</tt>, <tt>==</tt>
   # * Neo4j::Index lucene index methods, like indexing a node
+  # * Neo4j::Traversal - provides an API for accessing outgoing and incoming nodes by traversing from this node of any depth.
   #
   # === Class Methods from Included Mixins
   # * Neo4j::Index::ClassMethods lucene index class methods, like find
   # * Neo4j::Load - methods for loading a node
   #
-  # See also the Neo4j::NodeMixin (Neo4j::Mapping::NodeMixin) if you want to wrap a node with your own Ruby class.
+  # === Neo4j::Node#new and Wrappers 
+  #
+  # The Neo4j::Node#new method does not return a new Ruby instance (!). Instead it will call the Neo4j Java API which will return a 
+  # *org.neo4j.kernel.impl.core.NodeProxy* object. This java object includes those mixins, see above. The #class method on the java object
+  # returns Neo4j::Node in order to make it feel like an ordnary Ruby object.
+  #
+  # If you want to map your own class to a neo4j node you can use the  Neo4j::NodeMixin or the Neo4j::Rails::Model.
+  # The Neo4j::NodeMixin and Neo4j::Rails::Model wraps the Neo4j::Node object. The raw java node/Neo4j::Node object can be access with the Neo4j::NodeMixin#java_node method.
   #
   class Node
     extend Neo4j::Index::ClassMethods

data/lib/neo4j/rails/callbacks.rb

@@ -2,7 +2,15 @@ module Neo4j
 	module Rails
 		module Callbacks #:nodoc:
 			extend ActiveSupport::Concern
-			
+
+      CALLBACKS = [
+        :before_validation, :after_validation,
+        :before_create, :around_create, :after_create,
+        :before_destroy, :around_destroy, :after_destroy,
+        :before_save, :around_save, :after_save,
+        :before_update, :around_update, :after_update,
+        ].freeze
+
 			included do
 				[:valid?, :create_or_update, :create, :update, :destroy].each do |method|
 					alias_method_chain method, :callbacks

data/lib/neo4j/rails/compositions.rb

@@ -0,0 +1,256 @@
+module Neo4j
+  module Rails
+    # = Neo4j Rails Model Compositions
+    module Compositions # :nodoc:
+      extend ActiveSupport::Concern
+
+      def clear_composition_cache #:nodoc:
+        composition_cache.clear if persisted?
+      end
+
+      def composition_cache
+        @composition_cache ||= {}
+      end
+
+      # Neo4j Rails Model implements composition through a macro-like class method called +composed_of+
+      # for representing attributes  as value objects. It expresses relationships like "Account [is]
+      # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
+      # to the macro adds a description of how the value objects  are created from the attributes of
+      # the entity object (when the entity is initialized either  as a new object or from finding an
+      # existing object) and how it can be turned back into attributes  (when the entity is saved to
+      # the database).
+      #
+      #   class Customer < Neo4j::Rails::Model
+      #     composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
+      #     composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
+      #   end
+      #
+      # The customer class now has the following methods to manipulate the value objects:
+      # * <tt>Customer#balance, Customer#balance=(money)</tt>
+      # * <tt>Customer#address, Customer#address=(address)</tt>
+      #
+      # These methods will operate with value objects like the ones described below:
+      #
+      #  class Money
+      #    include Comparable
+      #    attr_reader :amount, :currency
+      #    EXCHANGE_RATES = { "USD_TO_DKK" => 6 }
+      #
+      #    def initialize(amount, currency = "USD")
+      #      @amount, @currency = amount, currency
+      #    end
+      #
+      #    def exchange_to(other_currency)
+      #      exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
+      #      Money.new(exchanged_amount, other_currency)
+      #    end
+      #
+      #    def ==(other_money)
+      #      amount == other_money.amount && currency == other_money.currency
+      #    end
+      #
+      #    def <=>(other_money)
+      #      if currency == other_money.currency
+      #        amount <=> amount
+      #      else
+      #        amount <=> other_money.exchange_to(currency).amount
+      #      end
+      #    end
+      #  end
+      #
+      #  class Address
+      #    attr_reader :street, :city
+      #    def initialize(street, city)
+      #      @street, @city = street, city
+      #    end
+      #
+      #    def close_to?(other_address)
+      #      city == other_address.city
+      #    end
+      #
+      #    def ==(other_address)
+      #      city == other_address.city && street == other_address.street
+      #    end
+      #  end
+      #
+      # Now it's possible to access attributes from the database through the value objects instead. If
+      # you choose to name the composition the same as the attribute's name, it will be the only way to
+      # access that attribute. That's the case with our +balance+ attribute. You interact with the value
+      # objects just like you would any other attribute, though:
+      #
+      #   customer.balance = Money.new(20)     # sets the Money value object and the attribute
+      #   customer.balance                     # => Money value object
+      #   customer.balance.exchange_to("DKK")  # => Money.new(120, "DKK")
+      #   customer.balance > Money.new(10)     # => true
+      #   customer.balance == Money.new(20)    # => true
+      #   customer.balance < Money.new(5)      # => false
+      #
+      # Value objects can also be composed of multiple attributes, such as the case of Address. The order
+      # of the mappings will determine the order of the parameters.
+      #
+      #   customer.address_street = "Hyancintvej"
+      #   customer.address_city   = "Copenhagen"
+      #   customer.address        # => Address.new("Hyancintvej", "Copenhagen")
+      #   customer.address = Address.new("May Street", "Chicago")
+      #   customer.address_street # => "May Street"
+      #   customer.address_city   # => "Chicago"
+      #
+      # == Writing value objects
+      #
+      # Value objects are immutable and interchangeable objects that represent a given value, such as
+      # a Money object representing $5. Two Money objects both representing $5 should be equal (through
+      # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
+      # unlike entity objects where equality is determined by identity. An entity class such as Customer can
+      # easily have two different objects that both have an address on Hyancintvej. Entity identity is
+      # determined by object or relational unique identifiers (such as primary keys). Normal
+      # Neo4j::Rails::Model classes are entity objects.
+      #
+      # It's also important to treat the value objects as immutable. Don't allow the Money object to have
+      # its amount changed after creation. Create a new Money object with the new value instead. This
+      # is exemplified by the Money#exchange_to method that returns a new value object instead of changing
+      # its own values. Neo4j Rails Model won't persist value objects that have been changed through means
+      # other than the writer method.
+      #
+      # The immutable requirement is enforced by Neo4j Rails Model by freezing any object assigned as a value
+      # object. Attempting to change it afterwards will result in a ActiveSupport::FrozenObjectError.
+      #
+      # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
+      # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
+      #
+      # == Custom constructors and converters
+      #
+      # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
+      # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
+      # option, as arguments. If the value class doesn't support this convention then +composed_of+ allows
+      # a custom constructor to be specified.
+      #
+      # When a new value is assigned to the value object the default assumption is that the new value
+      # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
+      # converted to an instance of value class if necessary.
+      #
+      # For example, the NetworkResource model has +network_address+ and +cidr_range+ attributes that
+      # should be aggregated using the NetAddr::CIDR value class (http://netaddr.rubyforge.org). The constructor
+      # for the value class is called +create+ and it expects a CIDR address string as a parameter. New
+      # values can be assigned to the value object using either another NetAddr::CIDR object, a string
+      # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
+      # these requirements:
+      #
+      #   class NetworkResource < Neo4j::Rails::Model
+      #     composed_of :cidr,
+      #                 :class_name => 'NetAddr::CIDR',
+      #                 :mapping => [ %w(network_address network), %w(cidr_range bits) ],
+      #                 :allow_nil => true,
+      #                 :constructor => Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
+      #                 :converter => Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
+      #   end
+      #
+      #   # This calls the :constructor
+      #   network_resource = NetworkResource.new(:network_address => '192.168.0.1', :cidr_range => 24)
+      #
+      #   # These assignments will both use the :converter
+      #   network_resource.cidr = [ '192.168.2.1', 8 ]
+      #   network_resource.cidr = '192.168.0.1/24'
+      #
+      #   # This assignment won't use the :converter as the value is already an instance of the value class
+      #   network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')
+      #
+      #   # Saving and then reloading will use the :constructor on reload
+      #   network_resource.save
+      #   network_resource.reload
+      #
+      # == [TBD] Finding records by a value object [TBD]
+      #
+      # Once a +composed_of+ relationship is specified for a model, records can be loaded from the database
+      # by specifying an instance of the value object in the conditions hash. The following example
+      # finds all customers with +balance_amount+ equal to 20 and +balance_currency+ equal to "USD":
+      #
+      #   Customer.where(:balance => Money.new(20, "USD")).all
+      #
+      module ClassMethods
+        # Adds reader and writer methods for manipulating a value object:
+        # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
+        #
+        # Options are:
+        # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
+        #   can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
+        #   to the Address class, but if the real class name is CompanyAddress, you'll have to specify it
+        #   with this option.
+        # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
+        #   object. Each mapping is represented as an array where the first item is the name of the
+        #   entity attribute and the second item is the name the attribute in the value object. The
+        #   order in which mappings are defined determine the order in which attributes are sent to the
+        #   value class constructor.
+        # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
+        #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
+        #   mapped attributes.
+        #   This defaults to +false+.
+        # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
+        #   is called to initialize the value object. The constructor is passed all of the mapped attributes,
+        #   in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
+        #   to instantiate a <tt>:class_name</tt> object.
+        #   The default is <tt>:new</tt>.
+        # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
+        #   or a Proc that is called when a new value is assigned to the value object. The converter is
+        #   passed the single value that is used in the assignment and is only called if the new value is
+        #   not an instance of <tt>:class_name</tt>.
+        #
+        # Option examples:
+        #   composed_of :temperature, :mapping => %w(reading celsius)
+        #   composed_of :balance, :class_name => "Money", :mapping => %w(balance amount), :converter => Proc.new { |balance| balance.to_money }
+        #   composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
+        #   composed_of :gps_location
+        #   composed_of :gps_location, :allow_nil => true
+        #   composed_of :ip_address,
+        #               :class_name => 'IPAddr',
+        #               :mapping => %w(ip to_i),
+        #               :constructor => Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
+        #               :converter => Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
+        #
+        def composed_of(part_id, options = {})
+          options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
+
+          name        = part_id.id2name
+          class_name  = options[:class_name]  || name.camelize
+          mapping     = options[:mapping]     || [ name, name ]
+          mapping     = [ mapping ] unless mapping.first.is_a?(Array)
+          allow_nil   = options[:allow_nil]   || false
+          constructor = options[:constructor] || :new
+          converter   = options[:converter]
+
+          reader_method(name, class_name, mapping, allow_nil, constructor)
+          writer_method(name, class_name, mapping, allow_nil, converter)
+        end
+
+        private
+          def reader_method(name, class_name, mapping, allow_nil, constructor)
+            define_method(name) do
+              if composition_cache[name].nil? && (!allow_nil || mapping.any? {|pair| !self[pair.first].nil? })
+                attrs = mapping.collect { |pair| self[pair.first] }
+                object = constructor.respond_to?(:call) ? constructor.call(*attrs) : class_name.constantize.send(constructor, *attrs)
+                composition_cache[name] = object
+              end
+              composition_cache[name]
+            end
+          end
+
+          def writer_method(name, class_name, mapping, allow_nil, converter)
+            define_method("#{name}=") do |part|
+              if part.nil? && allow_nil
+                mapping.each { |pair| self[pair.first] = nil }
+                composition_cache[name] = nil
+              else
+                unless part.is_a?(class_name.constantize) || converter.nil?
+                  part = converter.respond_to?(:call) ?
+                    converter.call(part) :
+                    class_name.constantize.send(converter, part)
+                end
+
+                mapping.each { |pair| self[pair.first] = part.send(pair.last) }
+                composition_cache[name] = part.freeze
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/finders.rb

@@ -1,5 +1,8 @@
 module Neo4j
   module Rails
+    class RecordNotFoundError < StandardError
+    end
+
     module Finders
       extend ActiveSupport::Concern
 
@@ -81,6 +84,46 @@ module Neo4j
           end
         end
 
+        # Finds a model by given id or matching given criteria.
+        # When node not found, raises RecordNotFoundError
+        def find!(*args)
+          self.find(*args).tap do |result|
+            raise Neo4j::Rails::RecordNotFoundError if result.nil?
+          end
+        end
+
+        # Find the first Node given the conditions, or creates a new node
+        # with the conditions that were supplied.
+        #
+        # @example Find or create the node.
+        #   Person.find_or_create_by(:name => "test")
+        #
+        # @param [ Hash ] attrs The attributes to check.
+        #
+        # @return [ Node ] A matching or newly created node.
+        def find_or_create_by(attrs = {}, &block)
+          find_or(:create, attrs, &block)
+        end
+
+        # Similar to find_or_create_by,calls create! instead of create
+        # Raises RecordInvalidError if model is invalid.
+        def find_or_create_by!(attrs = {}, &block)
+          find_or(:create!, attrs, &block)
+        end
+
+        # Find the first Node given the conditions, or initializes a new node
+        # with the conditions that were supplied.
+        #
+        # @example Find or initialize the node.
+        #   Person.find_or_initialize_by(:name => "test")
+        #
+        # @param [ Hash ] attrs The attributes to check.
+        #
+        # @return [ Node ] A matching or newly initialized node.
+        def find_or_initialize_by(attrs = {}, &block)
+          find_or(:new, attrs, &block)
+        end
+
         def all(*args)
           if !conditions_in?(*args)
             # use the _all rule to recover all the stored instances of this node
@@ -160,6 +203,19 @@ module Neo4j
           Thread.current[:neo4j_lucene_connection] << hits
           hits
         end
+
+        # Find the first object or create/initialize it.
+        #
+        # @example Find or perform an action.
+        #   Person.find_or(:create, :name => "Dev")
+        #
+        # @param [ Symbol ] method The method to invoke.
+        # @param [ Hash ] attrs The attributes to query or set.
+        #
+        # @return [ Node ] The first or new node.
+        def find_or(method, attrs = {}, &block)
+          first(:conditions => attrs) || send(method, attrs, &block)
+        end
       end
     end
   end

data/lib/neo4j/rails/model.rb

@@ -29,6 +29,7 @@ module Neo4j
         reset_attributes
         clear_relationships
         self.attributes = attributes if attributes.is_a?(Hash)
+        yield self if block_given?
       end
 
       def id
@@ -86,7 +87,7 @@ module Neo4j
         def entity_load(id)
           Neo4j::Node.load(id)
         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.
@@ -127,6 +128,13 @@ module Neo4j
 
           end
         end
+
+        # Set the i18n scope to overwrite ActiveModel.
+        #
+        # @return [ Symbol ] :neo4j
+        def i18n_scope
+          :neo4j
+        end
       end
     end
 
@@ -140,8 +148,10 @@ module Neo4j
       include Timestamps # handle created_at, updated_at timestamp properties
       include Validations # enable validations
       include Callbacks # enable callbacks
+      include ActiveModel::Observing # enable observers
       include Finders # ActiveRecord style find
       include Relationships # for none persisted relationships
+      include Compositions
     end
   end
 end

data/lib/neo4j/rails/observer.rb

@@ -0,0 +1,161 @@
+module Neo4j
+  module Rails
+    # Observer classes respond to life cycle callbacks to implement trigger-like
+    # behavior outside the original class. This is a great way to reduce the
+    # clutter that normally comes when the model class is burdened with
+    # functionality that doesn't pertain to the core responsibility of the
+    # class. Neo4j's observers work similar to ActiveRecord's. Example:
+    #
+    #   class CommentObserver < Neo4j::Rails::Observer
+    #     def after_save(comment)
+    #       Notifications.comment(
+    #         "admin@do.com", "New comment was posted", comment
+    #       ).deliver
+    #     end
+    #   end
+    #
+    # This Observer sends an email when a Comment#save is finished.
+    #
+    #   class ContactObserver < Neo4j::Rails::Observer
+    #     def after_create(contact)
+    #       contact.logger.info('New contact added!')
+    #     end
+    #
+    #     def after_destroy(contact)
+    #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+    #     end
+    #   end
+    #
+    # This Observer uses logger to log when specific callbacks are triggered.
+    #
+    # == Observing a class that can't be inferred
+    #
+    # Observers will by default be mapped to the class with which they share a
+    # name. So CommentObserver will be tied to observing Comment,
+    # ProductManagerObserver to ProductManager, and so on. If you want to
+    # name your observer differently than the class you're interested in
+    # observing, you can use the Observer.observe class method which takes
+    # either the concrete class (Product) or a symbol for that class (:product):
+    #
+    #   class AuditObserver < Neo4j::Rails::Observer
+    #     observe :account
+    #
+    #     def after_update(account)
+    #       AuditTrail.new(account, "UPDATED")
+    #     end
+    #   end
+    #
+    # If the audit observer needs to watch more than one kind of object,
+    # this can be specified with multiple arguments:
+    #
+    #   class AuditObserver < Neo4j::Rails::Observer
+    #     observe :account, :balance
+    #
+    #     def after_update(record)
+    #       AuditTrail.new(record, "UPDATED")
+    #     end
+    #   end
+    #
+    # The AuditObserver will now act on both updates to Account and Balance
+    # by treating them both as records.
+    #
+    # == Available callback methods
+    #
+    # * before_validation
+    # * after_validation
+    # * before_create
+    # * around_create
+    # * after_create
+    # * before_update
+    # * around_update
+    # * after_update
+    # * before_save
+    # * around_save
+    # * after_save
+    # * before_destroy
+    # * around_destroy
+    # * after_destroy
+    #
+    # == Storing Observers in Rails
+    #
+    # If you're using Neo4j within Rails, observer classes are usually stored
+    # in +app/models+ with the naming convention of +app/models/audit_observer.rb+.
+    #
+    # == Configuration
+    #
+    # In order to activate an observer, list it in the +config.neo4j.observers+
+    # configuration setting in your +config/application.rb+ file.
+    #
+    #   config.neo4j.observers = :comment_observer, :signup_observer
+    #
+    # Observers will not be invoked unless you define them in your
+    # application configuration.
+    #
+    # == Loading
+    #
+    # Observers register themselves with the model class that they observe,
+    # since it is the class that notifies them of events when they occur.
+    # As a side-effect, when an observer is loaded, its corresponding model
+    # class is loaded.
+    #
+    # Observers are loaded after the application initializers, so that
+    # observed models can make use of extensions. If by any chance you are
+    # using observed models in the initialization, you can
+    # still load their observers by calling +ModelObserver.instance+ before.
+    # Observers are singletons and that call instantiates and registers them.
+    class Observer < ActiveModel::Observer
+
+      # Instantiate the new observer. Will add all child observers as well.
+      #
+      # @example Instantiate the observer.
+      #   Neo4j::Rails::Observer.new
+      def initialize
+        super and observed_descendants.each { |klass| add_observer!(klass) }
+      end
+
+      protected
+
+      # Get all the child observers.
+      #
+      # @example Get the children.
+      #   observer.observed_descendants
+      #
+      # @return [ Array<Class> ] The children.
+      def observed_descendants
+        observed_classes.inject([]) { |all, klass| all += klass.descendants }
+      end
+
+      # Adds the specified observer to the class.
+      #
+      # @example Add the observer.
+      #   observer.add_observer!(Document)
+      #
+      # @param [ Class ] klass The child observer to add.
+      def add_observer!(klass)
+        super and define_callbacks(klass)
+      end
+
+      # Defines all the callbacks for each observer of the model.
+      #
+      # @example Define all the callbacks.
+      #   observer.define_callbacks(Document)
+      #
+      # @param [ Class ] klass The model to define them on.
+      def define_callbacks(klass)
+        tap do |observer|
+          observer_name = observer.class.name.underscore.gsub('/', '__')
+          Neo4j::Rails::Callbacks::CALLBACKS.each do |callback|
+            next unless respond_to?(callback)
+            callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+            unless klass.respond_to?(callback_meth)
+              klass.send(:define_method, callback_meth) do |&block|
+                observer.send(callback, self, &block)
+              end
+              klass.send(callback, callback_meth)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/rails/persistence.rb

@@ -73,6 +73,7 @@ module Neo4j
       def reload(options = nil)
         clear_changes
         clear_relationships
+        clear_composition_cache
         reset_attributes
         unless reload_from_database
           set_deleted_properties
@@ -196,10 +197,13 @@ module Neo4j
           write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
         end
       end
-
-      def _add_relationship(rel_type, attr)
+      
+      def _create_entity(rel_type, attr)
         clazz = self.class._decl_rels[rel_type.to_sym].target_class
-        node  = clazz.new(attr)
+        _add_relationship(rel_type, clazz.new(attr))
+      end
+      
+      def _add_relationship(rel_type, node)
         if respond_to?("#{rel_type}=")
           send("#{rel_type}=", node)
         elsif respond_to?("#{rel_type}")
@@ -220,32 +224,29 @@ module Neo4j
           raise "oops #{rel_type}"
         end
       end
+      
+      def _has_relationship(rel_type, id)
+        !_find_node(rel_type,id).nil?
+      end
 
       def update_nested_attributes(rel_type, attr, options)
         allow_destroy, reject_if = [options[:allow_destroy], options[:reject_if]] if options
-
-        if new?
-          # We are updating a node that was created with the 'new' method.
-          # The relationship will only be kept in the Value object.
-          _add_relationship(rel_type, attr) unless reject_if?(reject_if, attr) || (allow_destroy && attr[:_destroy] && attr[:_destroy] != '0')
-        else
-          # We have a node that was created with the #create method - has real Neo4j relationships
-          # does it exist ?
-          found   = _find_node(rel_type, attr[:id])
-
+        begin
           # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
-          destroy = attr[:_destroy] && attr[:_destroy] != '0'
-
-          if found
-            if destroy
-              found.destroy if allow_destroy
+          destroy = allow_destroy && attr[:_destroy] && attr[:_destroy] != '0'
+          found = Neo4j::Node.load(attr[:id])
+          if destroy
+            found.destroy if found
+          else
+            if not found
+              _create_entity(rel_type, attr) #Create new node from scratch
             else
-              found.update_attributes(attr) # it already exist, so update that one
+              #Create relationship to existing node in case it doesn't exist already
+              _add_relationship(rel_type, found) if (not _has_relationship(rel_type,attr[:id])) 
+              found.update_attributes(attr)              
             end
-          elsif !destroy && !reject_if?(reject_if, attr)
-            _add_relationship(rel_type, attr)
           end
-        end
+        end unless reject_if?(reject_if, attr)
       end
 
       public

data/lib/neo4j/rails/rails.rb

@@ -9,6 +9,8 @@ require 'neo4j/rails/finders'
 require 'neo4j/rails/mapping/property'
 require 'neo4j/rails/validations'
 require 'neo4j/rails/callbacks'
+require 'neo4j/rails/observer'
+require 'neo4j/rails/compositions'
 require 'neo4j/rails/timestamps'
 require 'neo4j/rails/serialization'
 require 'neo4j/rails/attributes'

data/lib/neo4j/rails/railtie.rb

@@ -5,7 +5,7 @@ module Neo4j
     initializer "neo4j.tx" do |app|
       app.config.middleware.use Neo4j::Rails::LuceneConnectionCloser
     end
-    
+
     # Add ActiveModel translations to the I18n load_path
     initializer "i18n" do |app|
     	config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]
@@ -16,5 +16,18 @@ module Neo4j
     initializer "neo4j.start", :after => :load_config_initializers do |app|
       Neo4j::Config.setup.merge!(app.config.neo4j.to_hash)
     end
+
+    # Instantitate any registered observers after Rails initialization and
+    # instantiate them after being reloaded in the development environment
+    initializer "instantiate.observers" do
+      config.after_initialize do
+        ::Neo4j::Rails::Model.observers = config.neo4j.observers || []
+        ::Neo4j::Rails::Model.instantiate_observers
+
+        ActionDispatch::Callbacks.to_prepare do
+          ::Neo4j::Rails::Model.instantiate_observers
+        end
+      end
+    end
   end
 end

data/lib/neo4j/rails/rel_persistence.rb

@@ -149,16 +149,18 @@ module Neo4j
       end
 
       def create()
-        # prevent calling create twice
-        @start_node.rm_outgoing_rel(type, self)
-        @end_node.rm_incoming_rel(type, self)
-
-        _persist_start_node
-        _persist_end_node
-
-        @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
-        init_on_create
-        clear_changes
+        begin
+          # prevent calling create twice
+          @start_node.rm_outgoing_rel(type, self)
+          @end_node.rm_incoming_rel(type, self)
+
+          _persist_start_node
+          _persist_end_node
+
+          @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
+          init_on_create
+          clear_changes
+        end unless @end_node.nil?
         true
       end
 

data/lib/neo4j/rails/relationships/storage.rb

@@ -141,7 +141,7 @@ module Neo4j
           @incoming_rels.clear
 
           out_rels.each do |rel|
-            rel.end_node.rm_incoming_rel(@rel_type.to_sym, rel)
+            rel.end_node.rm_incoming_rel(@rel_type.to_sym, rel) if rel.end_node
             success = rel.persisted? || rel.save
             # don't think this can happen - just in case, TODO
             raise "Can't save outgoing #{rel}, validation errors ? #{rel.errors.inspect}" unless success

data/lib/neo4j/rails/transaction.rb

@@ -12,11 +12,6 @@ module Neo4j
     #  end
     class Transaction
       class << self
-        def new
-          finish if Thread.current[:neo4j_transaction]
-          Thread.current[:neo4j_transaction] = Neo4j::Transaction.new
-        end
-
         def current
           Thread.current[:neo4j_transaction]
         end
@@ -50,16 +45,25 @@ module Neo4j
         end
 
         def run
-          begin
-            new
-            ret = yield self
-          rescue
-            fail
-            raise
-          ensure
-            finish
+          if running?
+            yield self
+          else
+            begin
+              new
+              ret = yield self
+            rescue
+              fail
+              raise
+            ensure
+              finish
+            end
+            ret
           end
-          ret
+        end
+        
+        private
+        def new
+          Thread.current[:neo4j_transaction] = Neo4j::Transaction.new
         end
       end
     end

data/lib/neo4j/rails/tx_methods.rb

@@ -6,7 +6,7 @@ module Neo4j
           tx_method = "#{method}_in_tx"
           send(:alias_method, tx_method, method)
           send(:define_method, method) do |*args|
-            Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
+            Neo4j::Rails::Transaction.run { send(tx_method, *args) }
           end
         end
       end

data/lib/neo4j/rails/validations.rb

@@ -10,7 +10,11 @@ module Neo4j
       # The validation process on save can be skipped by passing false. The regular Model#save method is
       # replaced with this when the validations module is mixed in, which it is by default.
       def save(options={})
-        perform_validations(options) ? super : false
+        result = perform_validations(options) ? super : false
+        if !result
+          Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running?
+        end
+        result
       end
 
       def valid?(context = nil)

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.1
+  version: 1.2.2
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-29 00:00:00 +02:00
+date: 2011-09-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -128,6 +128,7 @@ files:
   - lib/neo4j/rails/railtie.rb
   - lib/neo4j/rails/rails.rb
   - lib/neo4j/rails/lucene_connection_closer.rb
+  - lib/neo4j/rails/observer.rb
   - lib/neo4j/rails/transaction.rb
   - lib/neo4j/rails/timestamps.rb
   - lib/neo4j/rails/callbacks.rb
@@ -135,6 +136,7 @@ files:
   - lib/neo4j/rails/rel_persistence.rb
   - lib/neo4j/rails/finders.rb
   - lib/neo4j/rails/relationship.rb
+  - lib/neo4j/rails/compositions.rb
   - lib/neo4j/rails/relationships/rels_dsl.rb
   - lib/neo4j/rails/relationships/node_dsl.rb
   - lib/neo4j/rails/relationships/relationships.rb