neo4j 6.0.0.rc.4 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3dc2eaadf6662bef798f4f7eabb1b32c39ded0fe
-  data.tar.gz: 07eea640b9818e8d77ef95f281be24fdbde658ca
+  metadata.gz: 5e75b34e6d901afdd9e426ecdb467541b6d89c28
+  data.tar.gz: ddc468292508fcfff1ad7371977503ec7a0274ae
 SHA512:
-  metadata.gz: 0bd648f94fd9b1985d715576bd2568c878c3e34a8bfb07506e1dc38ea4a5b2d00a5f69f32f10689754e7263431356532cfb2869a088773209cf8cc970f0aab93
-  data.tar.gz: 51497e8c6a42bdd565a08ab8ad0dcc540f5fce691199df458db002bba7d2eb7cea2a6b463d40fcfb2aecbf24ae8fc5807c558cefe9d7c6f249849dc0bf9cac4a
+  metadata.gz: 9cb421908fc3da97ba84eb9a7c5254a3f5d6568dd1bd9cdeadae15fdea333881113327a7710b1eb1094a2cb32a37330005653c97be07689ea194d64780add3bb
+  data.tar.gz: 8542d356502f221d0e054e913608aa1eb4134999495b309c589473f9c6850d4012096ef8c331f61c4c7880925b7634ecf525af1982d5160557b30f6ae07add9a

data/CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [Unreleased]
+
+### Fixed
+
+- Refactor unpersisted association logic to store objects directly on the object rather than the association proxy since different association proxies may be created at different times (see #1043)
+
 ## [6.0.0.rc.4] - 11-19-2015
 
 ### Fixed

data/lib/neo4j.rb

@@ -61,7 +61,6 @@ require 'neo4j/active_node/dependent'
 require 'neo4j/active_node/dependent/query_proxy_methods'
 require 'neo4j/active_node/dependent/association_methods'
 require 'neo4j/active_node/query_methods'
-require 'neo4j/active_node/query/query_proxy_unpersisted'
 require 'neo4j/active_node/query/query_proxy_methods'
 require 'neo4j/active_node/query/query_proxy_enumerable'
 require 'neo4j/active_node/query/query_proxy_find_in_batches'

data/lib/neo4j/active_node.rb

@@ -50,6 +50,16 @@ module Neo4j
       _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
     end
 
+    module ClassMethods
+      def nodeify(object)
+        if object.is_a?(::Neo4j::ActiveNode) || object.nil?
+          object
+        else
+          self.find(object)
+        end
+      end
+    end
+
     included do
       include Neo4j::Timestamps if Neo4j::Config[:record_timestamps]
 

data/lib/neo4j/active_node/has_n.rb

@@ -8,8 +8,10 @@ module Neo4j::ActiveNode
     # It uses a QueryProxy to get results
     # But also caches results and can have results cached on it
     class AssociationProxy
-      def initialize(query_proxy, cached_result = nil)
+      def initialize(query_proxy, deferred_objects = [], cached_result = nil)
         @query_proxy = query_proxy
+        @deferred_objects = deferred_objects
+
         cache_result(cached_result)
 
         # Represents the thing which can be enumerated
@@ -48,21 +50,27 @@ module Neo4j::ActiveNode
       end
 
       def result
-        return @cached_result if @cached_result
+        (@deferred_objects || []) + result_without_deferred
+      end
 
-        cache_query_proxy_result
+      def result_without_deferred
+        cache_query_proxy_result if !@cached_result
 
         @cached_result
       end
 
       def result_nodes
-        return result if !@query_proxy.model
+        return result_objects if !@query_proxy.model
 
-        @cached_result = result.map do |object|
+        result_objects.map do |object|
           object.is_a?(Neo4j::ActiveNode) ? object : @query_proxy.model.find(object)
         end
       end
 
+      def result_objects
+        @deferred_objects + result_without_deferred
+      end
+
       def result_ids
         result.map do |object|
           object.is_a?(Neo4j::ActiveNode) ? object.id : object
@@ -80,9 +88,7 @@ module Neo4j::ActiveNode
       end
 
       def cache_query_proxy_result
-        @query_proxy.to_a.tap do |result|
-          cache_result(result)
-        end
+        @query_proxy.to_a.tap { |result| cache_result(result) }
       end
 
       def clear_cache_result
@@ -93,6 +99,12 @@ module Neo4j::ActiveNode
         !!@cached_result
       end
 
+      def replace_with(*args)
+        @cached_result = nil
+
+        @query_proxy.public_send(:replace_with, *args)
+      end
+
       QUERY_PROXY_METHODS = [:<<, :delete]
       CACHED_RESULT_METHODS = []
 
@@ -177,7 +189,7 @@ module Neo4j::ActiveNode
     private
 
     def fresh_association_proxy(name, options = {}, cached_result = nil)
-      AssociationProxy.new(association_query_proxy(name, options), cached_result)
+      AssociationProxy.new(association_query_proxy(name, options), deferred_nodes_for_association(name), cached_result)
     end
 
     def previous_proxy_results_by_previous_id(result_cache, association_name)
@@ -356,6 +368,8 @@ module Neo4j::ActiveNode
         define_method("#{name}=") do |other_nodes|
           association_proxy_cache.clear
 
+          clear_deferred_nodes_for_association(name)
+
           Neo4j::Transaction.run { association_proxy(name).replace_with(other_nodes) }
         end
       end
@@ -366,6 +380,7 @@ module Neo4j::ActiveNode
         end
 
         define_method_unless_defined("#{name.to_s.singularize}_ids=") do |ids|
+          clear_deferred_nodes_for_association(name)
           association_proxy(name).replace_with(ids)
         end
 
@@ -415,7 +430,13 @@ module Neo4j::ActiveNode
           if options[:rel_length] && !options[:rel_length].is_a?(Fixnum)
             association_proxy
           else
-            association_proxy.result_nodes.first
+            target_class = self.class.send(:association_target_class, name)
+            o = association_proxy.result.first
+            if target_class
+              target_class.send(:nodeify, o)
+            else
+              o
+            end
           end
         end
       end
@@ -428,7 +449,8 @@ module Neo4j::ActiveNode
             Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
             # handle_non_persisted_node(other_node)
           else
-            association_proxy(name).defer_create(other_node)
+            defer_create(name, other_node, clear: true)
+            other_node
           end
         end
       end
@@ -457,8 +479,7 @@ module Neo4j::ActiveNode
       end
 
       def association_proxy(name, options = {})
-        query_proxy = association_query_proxy(name, options)
-        AssociationProxy.new(query_proxy)
+        AssociationProxy.new(association_query_proxy(name, options))
       end
 
       def association_target_class(name)
@@ -478,11 +499,8 @@ module Neo4j::ActiveNode
       end
 
       def default_association_query_proxy
-        Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize,
-                                                 nil,
-                                                 session: neo4j_session,
-                                                 query_proxy: nil,
-                                                 context: "#{self.name}")
+        Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize, nil,
+                                                 session: neo4j_session, query_proxy: nil, context: "#{self.name}")
       end
 
       def build_association(macro, direction, name, options)

data/lib/neo4j/active_node/persistence.rb

@@ -85,10 +85,9 @@ module Neo4j::ActiveNode
     # build the processable hash before it begins. If there are nodes and associations that
     # need to be created after the node is saved, a new transaction is started.
     def cascade_save
-      deferred_nodes = pending_associations_with_nodes
-      Neo4j::Transaction.run(!deferred_nodes.blank?) do
+      Neo4j::Transaction.run(pending_deferred_creations?) do
         result = yield
-        process_unpersisted_nodes!(deferred_nodes) if deferred_nodes
+        process_unpersisted_nodes!
         result
       end
     end

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -6,7 +6,6 @@ module Neo4j
         include Neo4j::ActiveNode::Query::QueryProxyMethods
         include Neo4j::ActiveNode::Query::QueryProxyFindInBatches
         include Neo4j::ActiveNode::Query::QueryProxyEagerLoading
-        include Neo4j::ActiveNode::Query::QueryProxyUnpersisted
         include Neo4j::ActiveNode::Dependent::QueryProxyMethods
 
         # The most recent node to start a QueryProxy chain.
@@ -164,7 +163,13 @@ module Neo4j
 
         # To add a relationship for the node for the association on this QueryProxy
         def <<(other_node)
-          @start_object._persisted_obj ? create(other_node, {}) : defer_create(other_node)
+          if @start_object._persisted_obj
+            create(other_node, {})
+          elsif @association
+            @start_object.defer_create(@association.name, other_node)
+          else
+            fail 'Another crazy error!'
+          end
           self
         end
 

data/lib/neo4j/active_node/unpersisted.rb

@@ -1,52 +1,47 @@
 module Neo4j
   module ActiveNode
     module Unpersisted
-      def pending_associations
-        @pending_associations ||= []
+      # The values in this Hash are returned and used outside by reference
+      # so any modifications to the Array should be in-place
+      def deferred_create_cache
+        @deferred_create_cache ||= {}
       end
 
-      def pending_associations?
-        !@pending_associations.blank?
+      def defer_create(association_name, object, options = {})
+        clear_deferred_nodes_for_association(association_name) if options[:clear]
+
+        deferred_nodes_for_association(association_name) << object
       end
 
-      private
+      def deferred_nodes_for_association(association_name)
+        deferred_create_cache[association_name.to_sym] ||= []
+      end
 
-      # TODO: Change this method's name.
-      # Takes the pending_associations hash, which is in the format { cache_key => [:association_name, :association_operator]},
-      # and returns them as { association_name => [[nodes_for_persistence], :operator] }
-      def pending_associations_with_nodes
-        return unless pending_associations?
-        {}.tap do |deferred_nodes|
-          pending_associations.uniq.each do |association_name|
-            nodes_for_creation = association_proxy(association_name)
-            nodes_for_creation = nodes_for_creation.reject(&:persisted?) if self.persisted?
-
-            deferred_nodes[association_name] = nodes_for_creation
-          end
-        end
+      def pending_deferred_creations?
+        !deferred_create_cache.values.all?(&:empty?)
       end
 
-      # @param [Hash] deferred_nodes A hash created by :pending_associations_with_nodes
-      def process_unpersisted_nodes!(deferred_nodes)
-        deferred_nodes.each_pair do |k, v|
-          save_and_associate_queue(k, v)
-        end
+      def clear_deferred_nodes_for_association(association_name)
+        deferred_nodes_for_association(association_name.to_sym).clear
       end
 
+      private
 
-      def save_and_associate_queue(association_name, node_queue)
-        association_proc = proc { |node| save_and_associate_node(association_name, node) }
-        node_queue.each do |element|
-          element.is_a?(Array) ? element.each { |node| association_proc.call(node) } : association_proc.call(element)
-        end
-      end
+      def process_unpersisted_nodes!
+        deferred_create_cache.each do |association_name, nodes|
+          association_proxy = association_proxy(association_name)
+
+          nodes.each do |node|
+            if node.respond_to?(:changed?)
+              node.save if node.changed? || !node.persisted?
+              fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
+            end
+
+            association_proxy << node
+          end
 
-      def save_and_associate_node(association_name, node)
-        if node.respond_to?(:changed?)
-          node.save if node.changed? || !node.persisted?
-          fail "Unable to defer node persistence, could not save #{node.inspect}" unless node.persisted?
+          @deferred_create_cache = {}
         end
-        association_proxy(association_name) << node
       end
     end
   end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = '6.0.0.rc.4'
+  VERSION = '6.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 6.0.0.rc.4
+  version: 6.0.0
 platform: ruby
 authors:
 - Andreas Ronge, Brian Underwood, Chris Grigg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-19 00:00:00.000000000 Z
+date: 2015-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -251,7 +251,6 @@ files:
 - lib/neo4j/active_node/query/query_proxy_find_in_batches.rb
 - lib/neo4j/active_node/query/query_proxy_link.rb
 - lib/neo4j/active_node/query/query_proxy_methods.rb
-- lib/neo4j/active_node/query/query_proxy_unpersisted.rb
 - lib/neo4j/active_node/query_methods.rb
 - lib/neo4j/active_node/reflection.rb
 - lib/neo4j/active_node/rels.rb
@@ -327,9 +326,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: neo4j
 rubygems_version: 2.4.5.1

data/lib/neo4j/active_node/query/query_proxy_unpersisted.rb

@@ -1,13 +0,0 @@
-module Neo4j
-  module ActiveNode
-    module Query
-      module QueryProxyUnpersisted
-        def defer_create(other_node)
-          @start_object.pending_associations << @association.name
-
-          @start_object.association_proxy(@association.name).add_to_cache(other_node)
-        end
-      end
-    end
-  end
-end