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

data/lib/neo4j/rails/nested_attributes.rb

@@ -0,0 +1,108 @@
+module Neo4j
+  module Rails
+    module NestedAttributes
+      extend ActiveSupport::Concern
+      extend TxMethods
+
+      def update_nested_attributes(rel_type, attr, options)
+        allow_destroy, reject_if = [options[:allow_destroy], options[:reject_if]] if options
+        begin
+          # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
+          destroy = attr.delete(:_destroy)
+          found = _find_node(rel_type, attr[:id]) || Neo4j::Rails::Model.find(attr[:id])
+          if allow_destroy && destroy && destroy != '0'
+            found.destroy if found
+          else
+            if not found
+              _create_entity(rel_type, attr) #Create new node from scratch
+            else
+              #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
+          end
+        end unless reject_if?(reject_if, attr)
+      end
+      tx_methods :update_nested_attributes
+
+
+      module ClassMethods
+        def accepts_nested_attributes_for(*attr_names)
+          options = attr_names.pop if attr_names[-1].is_a?(Hash)
+
+          attr_names.each do |association_name|
+            # Do some validation that we have defined the relationships we want to nest
+            rel = self._decl_rels[association_name.to_sym]
+            raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
+            raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless rel.target_class
+
+            if rel.has_one?
+              send(:define_method, "#{association_name}_attributes=") do |attributes|
+                update_nested_attributes(association_name.to_sym, attributes, options)
+              end
+            else
+              send(:define_method, "#{association_name}_attributes=") do |attributes|
+                if attributes.is_a?(Array)
+                  attributes.each do |attr|
+                    update_nested_attributes(association_name.to_sym, attr, options)
+                  end
+                else
+                  attributes.each_value do |attr|
+                    update_nested_attributes(association_name.to_sym, attr, options)
+                  end
+                end
+              end
+            end
+
+          end
+        end
+      end
+
+      protected
+
+      def _create_entity(rel_type, attr)
+        clazz = self.class._decl_rels[rel_type.to_sym].target_class
+        _add_relationship(rel_type, clazz.new(attr))
+      end
+
+      def _add_relationship(rel_type, node)
+        if respond_to?("#{rel_type}_rel")
+          send("#{rel_type}=", node)
+        elsif respond_to?("#{rel_type}_rels")
+          has_n = send("#{rel_type}")
+          has_n << node
+        else
+          raise "oops #{rel_type}"
+        end
+      end
+
+      def _find_node(rel_type, id)
+        return nil if id.nil?
+        if respond_to?("#{rel_type}_rel")
+          send("#{rel_type}")
+        elsif respond_to?("#{rel_type}_rels")
+          has_n = send("#{rel_type}")
+          has_n.find { |n| n.id == id }
+        else
+          raise "oops #{rel_type}"
+        end
+      end
+
+      def _has_relationship(rel_type, id)
+        !_find_node(rel_type, id).nil?
+      end
+
+      def reject_if?(proc_or_symbol, attr)
+        return false if proc_or_symbol.nil?
+        if proc_or_symbol.is_a?(Symbol)
+          meth = method(proc_or_symbol)
+          meth.arity == 0 ? meth.call : meth.call(attr)
+        else
+          proc_or_symbol.call(attr)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/neo4j/rails/node_persistance.rb

@@ -0,0 +1,56 @@
+module Neo4j
+  module Rails
+    module NodePersistence
+      extend TxMethods
+
+      def initialize(attributes = nil)
+        initialize_relationships
+        initialize_attributes(attributes)
+      end
+
+
+      def create
+        node = Neo4j::Node.new
+        init_on_load(node)
+        Neo4j::IdentityMap.add(node, self)
+        init_on_create
+        write_changed_relationships
+        clear_relationships
+        true
+      end
+
+      def update
+        super
+        write_changed_relationships
+        clear_relationships
+        true
+      end
+
+      # Reload the object from the DB
+      def reload(options = nil)
+        # Can't reload a none persisted node
+        return self if new_record?
+        clear_changes
+        clear_relationships
+        clear_composition_cache
+        reset_attributes
+        unless reload_from_database
+          set_deleted_properties
+          freeze
+        end
+        self
+      end
+
+
+      def reload_from_database
+        Neo4j::IdentityMap.remove_node_by_id(neo_id)
+        if reloaded = self.class.load_entity(neo_id)
+          send(:attributes=, reloaded.attributes, false)
+        end
+        reloaded
+      end
+
+
+    end
+  end
+end

data/lib/neo4j/rails/observer.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/class/attribute_accessors'
-
 module Neo4j
   module Rails
     # Observer classes respond to life cycle callbacks to implement trigger-like

data/lib/neo4j/rails/persistence.rb

@@ -2,11 +2,8 @@ module Neo4j
   module Rails
     module Persistence
       extend ActiveSupport::Concern
+      extend TxMethods
 
-      included do
-        extend TxMethods
-        tx_methods :destroy, :create, :update, :update_nested_attributes, :delete, :update_attributes, :update_attributes!
-      end
 
       # Persist the object to the database.  Validations and Callbacks are included
       # by default but validation can be disabled by passing :validate => false
@@ -14,6 +11,7 @@ module Neo4j
       def save(*)
         create_or_update
       end
+      tx_methods :save
 
       # Persist the object to the database.  Validations and Callbacks are included
       # by default but validation can be disabled by passing :validate => false
@@ -26,18 +24,14 @@ module Neo4j
         end
       end
 
-      # Updates a single attribute and saves the record.
-      # This is especially useful for boolean flags on existing records. Also note that
-      #
-      # * Validation is skipped.
-      # * Callbacks are invoked.
-      # * Updates all the attributes that are dirty in this object.
-      #
-      def update_attribute(name, value)
-        respond_to?("#{name}=") ? send("#{name}=", value) : self[name] = value
-        save(:validate => false)
+      def update
+        write_changed_attributes
+        clear_changes
+        true
       end
 
+
+
       # Removes the node from Neo4j and freezes the object.
       def destroy
         delete
@@ -47,39 +41,14 @@ module Neo4j
       # Same as #destroy but doesn't run destroy callbacks and doesn't freeze
       # the object
       def delete
-        del unless new_record?
+        del unless new_record? || destroyed?
         set_deleted_properties
       end
+      tx_methods :delete
 
       # Returns true if the object was destroyed.
-      def destroyed?()
-        @_deleted || Neo4j::Node._load(id).nil?
-      end
-
-      # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
-      # If saving fails because the resource is invalid then false will be returned.
-      def update_attributes(attributes)
-        self.attributes = attributes
-        save
-      end
-
-      # Same as #update_attributes, but raises an exception if saving fails.
-      def update_attributes!(attributes)
-        self.attributes = attributes
-        save!
-      end
-
-      # Reload the object from the DB.
-      def reload(options = nil)
-        clear_changes
-        clear_relationships
-        clear_composition_cache
-        reset_attributes
-        unless reload_from_database
-          set_deleted_properties
-          freeze
-        end
-        self
+      def destroyed?
+        @_deleted || (!new_record? && !self.class.load_entity(neo_id))
       end
 
       # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
@@ -89,23 +58,38 @@ module Neo4j
 
       # Returns true if the record hasn't been saved to Neo4j yet.
       def new_record?
-        _java_node.nil?
+        _java_entity.nil?
       end
 
       alias :new? :new_record?
 
       # Freeze the properties hash.
       def freeze
-        @properties.freeze; self
+        @_properties.freeze
+        self
       end
 
       # Returns +true+ if the properties hash has been frozen.
       def frozen?
-        reload
-        @properties.frozen?
+        reload unless new_record?
+        @_properties.frozen?
       end
 
+
       module ClassMethods
+
+        def transaction(&block)
+          Neo4j::Rails::Transaction.run do |tx|
+            block.call(tx)
+          end
+        end
+
+        def new(*args, &block)
+          instance = orig_new(*args, &block)
+          instance.instance_eval(&block) if block
+          instance
+        end
+
         # Initialize a model and set a bunch of attributes at the same time.  Returns
         # the object whether saved successfully or not.
         def create(*args)
@@ -143,114 +127,8 @@ module Neo4j
         end
       end
 
-      def update
-        write_changed_attributes
-        write_changed_relationships
-        clear_changes
-        clear_relationships
-        true
-      end
-
-      def create
-        node = Neo4j::Node.new
-        @_java_node = node
-        Neo4j::IdentityMap.add(node, self)
-        init_on_create
-        clear_changes
-        clear_relationships
-        true
-      end
-
-      def init_on_create(*)
-        self._classname = self.class.to_s
-        write_default_attributes
-        write_changed_attributes
-        write_changed_relationships
-      end
-
-      def reset_attributes
-        @properties = {}
-      end
-
-      def reload_from_database
-        Neo4j::IdentityMap.remove_node_by_id(id)
-        if reloaded = self.class.load(id)
-          clear_relationships
-          send(:attributes=, reloaded.attributes, false)
-        end
-        reloaded
-      end
-
       def set_deleted_properties
-        @_deleted   = true
-        @_persisted = false
-        @_java_node = nil
-      end
-
-      # Ensure any defaults are stored in the DB
-      def write_default_attributes
-        attribute_defaults.each do |attribute, value|
-          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class, false)) unless changed_attributes.has_key?(attribute) || _java_node.has_property?(attribute)
-        end
-      end
-
-      # Write attributes to the Neo4j DB only if they're altered
-      def write_changed_attributes
-        @properties.each do |attribute, value|
-          write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
-        end
-      end
-
-      def _create_entity(rel_type, attr)
-        clazz = self.class._decl_rels[rel_type.to_sym].target_class
-        _add_relationship(rel_type, clazz.new(attr))
-      end
-
-      def _add_relationship(rel_type, node)
-        if respond_to?("#{rel_type}_rel")
-          send("#{rel_type}=", node)
-        elsif respond_to?("#{rel_type}_rels")
-          has_n = send("#{rel_type}")
-          has_n << node
-        else
-          raise "oops #{rel_type}"
-        end
-      end
-
-      def _find_node(rel_type, id)
-        return nil if id.nil?
-        if respond_to?("#{rel_type}_rel")
-          send("#{rel_type}")
-        elsif respond_to?("#{rel_type}_rels")
-          has_n = send("#{rel_type}")
-          has_n.find { |n| n.id == id }
-        else
-          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
-        begin
-          # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
-          destroy = attr.delete(:_destroy)
-          found = _find_node(rel_type, attr[:id]) || Model.find(attr[:id])
-          if allow_destroy && destroy && destroy != '0'
-            found.destroy if found
-          else
-            if not found
-              _create_entity(rel_type, attr) #Create new node from scratch
-            else
-              #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
-          end
-        end unless reject_if?(reject_if, attr)
+        @_deleted = true
       end
 
       public

data/lib/neo4j/rails/rack_middleware.rb

@@ -2,18 +2,42 @@ module Neo4j
   module Rails
     # close lucene connections
     # reset the Neo4j.threadlocal_ref_node (Multitenancy)
-    class RackMiddleware  #:nodoc:
+    # clear the identity map
+    class Middleware
+      class Body #:nodoc:
+        def initialize(target, original)
+          @target = target
+          @original = original
+        end
+
+        def each(&block)
+          @target.each(&block)
+        end
+
+        def close
+          @target.close if @target.respond_to?(:close)
+        ensure
+          IdentityMap.enabled = @original
+          IdentityMap.clear
+        end
+      end
+
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        @app.call(env)
+        enabled = IdentityMap.enabled
+        IdentityMap.enabled = Neo4j::Config[:identity_map]
+        status, headers, body = @app.call(env)
+        [status, headers, Body.new(body, enabled)]
       ensure
         Neo4j::Rails::Model.close_lucene_connections
         Neo4j.threadlocal_ref_node = Neo4j.default_ref_node
       end
     end
+
   end
 
+
 end