neo4j 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f576c543973dba1fb67e8c000487496014fdf85
-  data.tar.gz: 46a1e8b4d8f7fcc2c388f4791fecea6bf6fec6c9
+  metadata.gz: d5ecc7877175dbfe04e305498f2c5501818abf22
+  data.tar.gz: eec46ea5ca11ab14fbc8844c14264b332ec56de4
 SHA512:
-  metadata.gz: 844a3cd13ec87c091166cf8aef59e4ea5876b8a18b6552167ff5f61aed62f8d04abcb2ba33b303d8c9285c6cd1251427af866b48b6ea72bcbaa62ca5dedfca31
-  data.tar.gz: 3824b4d1fd649f99f2eaf8f6bc93289008388ce578375b865d10372f56f5e35dd5430d2a5f5b0bb7ab80a8b1314a2773515fc16909b7fa1ed4c45c0d42439845
+  metadata.gz: a0514bacb5f60da1bba7e25b04a57fb016b0d7bae4b5fa4fb95a22e8ed746f541f63c6898864c34a174449318ed9216953e5faab84b78bdf97bdf25a9a02851f
+  data.tar.gz: d489717468051817dfb88e5fa878f15059e798bdf83b387ec0f3156e8cbf47371fefefae77b3d1b7b556d30c5d6e534f5ae2a38983e864d366b8d36bc0ef8adb

data/CHANGELOG

@@ -1,3 +1,13 @@
+== 4.1.0
+This release includes many performance fixes and new features. The most notable:
+* Huge stylist cleanup/refactoring by Brian on the entire gem by Brian armed with Rubocop. See http://neo4jrb.io/blog/2014/12/29/stay-out-of-trouble.html.
+* Every node create, update, and destroy is now wrapped in a transaction. See http://neo4jrb.io/blog/2015/01/06/transactions_everywhere.html.
+* New `dependent` options for associations: `:delete`, `:destroy`, `:delete_orphans`, `:destroy_orphans`. See http://neo4jrb.io/blog/2015/01/07/association_dependent_options.html.
+* New `unique: true` option for associations, `creates_unique_rel` class method for ActiveRel. Both of these will result in relationship creation Cypher using "CREATE UNIQUE" instead of "CREATE".
+* Fixed an n+1 query issue during node creation and update.
+* Dieter simplified some code related to frozen attributes. See https://github.com/neo4jrb/neo4j/pull/655.
+We now have a new website online at http://neo4jrb.io! Keep an eye on it for news and blogs related to this and other projects.
+
 == 4.0.0
 * Change neo4j-core dependency from 3.1.0 to 4.0.0.
 

data/Gemfile

@@ -2,24 +2,14 @@ source 'http://rubygems.org'
 
 gemspec
 
-#gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
-#gem 'neo4j-core', git: 'https://github.com/neo4jrb/neo4j-core'
-#gem 'orm_adapter', :path => '../orm_adapter'
-
-gem 'coveralls', require: false
-
-
-group 'development' do
-  gem 'pry'
-  gem 'os' # for neo4j-server rake task
-  gem 'rake'
-  gem 'yard'
-end
+gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
+# gem 'neo4j-core', path: '../neo4j-core'
 
 group 'test' do
+  gem 'coveralls', require: false
   gem 'simplecov', require: false
   gem 'simplecov-html', require: false
-  gem "rspec", '~> 2.0'
-  gem "its"
-  gem "test-unit"
+  gem 'rspec', '~> 2.0'
+  gem 'its'
+  gem 'test-unit'
 end

data/README.md

@@ -1,8 +1,10 @@
 # Welcome to Neo4j.rb
-[![Build Status](https://secure.travis-ci.org/neo4jrb/neo4j.png?branch=master)](http://travis-ci.org/neo4jrb/neo4j) [![Coverage Status](https://coveralls.io/repos/neo4jrb/neo4j/badge.png?branch=master)](https://coveralls.io/r/neo4jrb/neo4j?branch=master) [![Code Climate](https://codeclimate.com/github/neo4jrb/neo4j.png)](https://codeclimate.com/github/andreasronge/neo4j)
+[![Build Status](https://secure.travis-ci.org/neo4jrb/neo4j.png?branch=master)](http://travis-ci.org/neo4jrb/neo4j) [![Coverage Status](https://coveralls.io/repos/neo4jrb/neo4j/badge.png?branch=master)](https://coveralls.io/r/neo4jrb/neo4j?branch=master) [![Code Climate](https://codeclimate.com/github/neo4jrb/neo4j.png)](https://codeclimate.com/github/neo4jrb/neo4j) [![PullReview stats](https://www.pullreview.com/github/neo4jrb/neo4j/badges/master.svg?)](https://www.pullreview.com/github/neo4jrb/neo4j/reviews/master)
 
 Neo4j.rb is an Active Model compliant Ruby/JRuby wrapper for [the Neo4j graph database](http://www.neo4j.org/). It uses the [neo4j-core](https://github.com/neo4jrb/neo4j-core) and [active_attr](https://github.com/cgriego/active_attr) gems.
 
+For a general overview see our website: http://neo4jrb.io/
+
 Winner of a 2014 Graphie for "Best Community Contribution" at Neo4j's [Graph Connect](http://graphconnect.com) conference!
 ![2014 Graphie](http://i.imgur.com/CkOoTTYm.jpg)
 
@@ -12,6 +14,7 @@ The master branch of this repo now holds stable builds of the v4 version of the
 
 ## Modern (3.X) Documentation
 
+* [Website](http://neo4jrb.io/) (for an introduction)
 * [Wiki](https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v3-Introduction)
 
 ## Legacy (2.x) Documentation
@@ -34,7 +37,7 @@ The master branch of this repo now holds stable builds of the v4 version of the
 
 ## Contributing
 
-Pull request with high test coverage and good [code climate](https://codeclimate.com/github/andreasronge/neo4j) values will be accepted faster.
+Pull request with high test coverage and good [code climate](https://codeclimate.com/github/neo4jrb/neo4j) values will be accepted faster.
 
 
 ## License

data/bin/neo4j-jars

@@ -10,7 +10,7 @@ It copies all jar files which has been required (neo4j-community, neo4j-advanced
   Usage: neo4j-jars <community|advanced|enterprise>
 
 TEXT
-exit
+  exit
 end
 
 if ARGV.include?('community')
@@ -20,14 +20,14 @@ elsif ARGV.include?('advanced')
 elsif ARGV.include?('enterprise')
   require 'neo4j-enterprise' # not really needed
 else
-  puts "Expected community, advanced, enterprise"
-  exit -1
+  puts 'Expected community, advanced, enterprise'
+  exit(-1)
 end
 
 lib_dir = File.join(Dir.pwd, 'lib')
-raise "Expected a lib folder where to copy the jars file, mkdir #{lib_dir}? " unless File.exist?(lib_dir)
+fail "Expected a lib folder where to copy the jars file, mkdir #{lib_dir}? " unless File.exist?(lib_dir)
 
-files = $CLASSPATH.find_all{|x| x =~ /\.jar$/}.collect{|y| y.sub('file:', '')}
-files.each {|file| FileUtils.cp(file, lib_dir)}
+files = $CLASSPATH.find_all { |x| x =~ /\.jar$/ }.collect { |y| y.sub('file:', '') }
+files.each { |file| FileUtils.cp(file, lib_dir) }
 
 puts "copied #{files.size} files to #{lib_dir}"

data/lib/neo4j.rb

@@ -1,17 +1,17 @@
 require 'neo4j/version'
 
-#require "delegate"
-#require "time"
-#require "set"
+# require "delegate"
+# require "time"
+# require "set"
 #
-#require "active_support/core_ext"
-#require "active_support/json"
-#require "active_support/inflector"
-#require "active_support/time_with_zone"
+# require "active_support/core_ext"
+# require "active_support/json"
+# require "active_support/inflector"
+# require "active_support/time_with_zone"
 
-require "neo4j-core"
+require 'neo4j-core'
 require 'neo4j/core/query'
-require "active_model"
+require 'active_model'
 require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'
 
@@ -43,8 +43,12 @@ require 'neo4j/active_rel/related_node'
 require 'neo4j/active_rel/types'
 require 'neo4j/active_rel'
 
+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_methods'
+require 'neo4j/active_node/query/query_proxy_enumerable'
 require 'neo4j/active_node/query/query_proxy_find_in_batches'
 require 'neo4j/active_node/labels'
 require 'neo4j/active_node/id_property'

data/lib/neo4j/active_node.rb

@@ -1,5 +1,4 @@
 module Neo4j
-
   # Makes Neo4j nodes and relationships behave like ActiveRecord objects.
   # By including this module in your class it will create a mapping for the node to your ruby class
   # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
@@ -39,24 +38,25 @@ module Neo4j
     include Neo4j::ActiveNode::Rels
     include Neo4j::ActiveNode::HasN
     include Neo4j::ActiveNode::Scope
+    include Neo4j::ActiveNode::Dependent
 
     def neo4j_obj
-      _persisted_obj || raise("Tried to access native neo4j object on a non persisted object")
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
     end
 
     included do
       def self.inherited(other)
-        inherit_id_property(other) if self.has_id_property?
+        inherit_id_property(other) if self.id_property?
         inherited_indexes(other) if self.respond_to?(:indexed_properties)
-        attributes.each_pair { |k,v| other.attributes[k] = v }
+        attributes.each_pair { |k, v| other.attributes[k] = v }
         inherit_serialized_properties(other) if self.respond_to?(:serialized_properties)
         Neo4j::ActiveNode::Labels.add_wrapped_class(other)
         super
       end
 
       def self.inherited_indexes(other)
-       return if indexed_properties.nil?
-       self.indexed_properties.each { |property| other.index property }
+        return if indexed_properties.nil?
+        self.indexed_properties.each { |property| other.index property }
       end
 
       def self.inherit_serialized_properties(other)
@@ -65,17 +65,17 @@ module Neo4j
 
       def self.inherit_id_property(other)
         id_prop = self.id_property_info
-        conf = id_prop[:type].empty? ? { auto: :uuid } : id_prop[:type]
+        conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
         other.id_property id_prop[:name], conf
       end
 
       Neo4j::Session.on_session_available do |_|
-        id_property :uuid, auto: :uuid unless self.has_id_property?
+        id_property :uuid, auto: :uuid unless self.id_property?
 
         name = Neo4j::Config[:id_property]
         type = Neo4j::Config[:id_property_type]
         value = Neo4j::Config[:id_property_type_value]
-        id_property(name, type => value) if (name && type && value)
+        id_property(name, type => value) if name && type && value
       end
     end
 

data/lib/neo4j/active_node/dependent.rb

@@ -0,0 +1,11 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      def dependent_children
+        @dependent_children ||= []
+      end
+
+      attr_writer :called_by
+    end
+  end
+end

data/lib/neo4j/active_node/dependent/association_methods.rb

@@ -0,0 +1,28 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      module AssociationMethods
+        def add_destroy_callbacks(model)
+          return if dependent.nil?
+          # Bound value for procs
+          assoc = self
+
+          fn = case dependent
+               when :delete
+                 proc { |o| o.send("#{assoc.name}_query_proxy").delete_all }
+               when :delete_orphans
+                 proc { |o| o.as(:self).unique_nodes(assoc, :self, :n, :other_rel).query.delete(:n, :other_rel).exec }
+               when :destroy
+                 proc { |o| o.send("#{assoc.name}_query_proxy").each_for_destruction(o) { |node| node.destroy } }
+               when :destroy_orphans
+                 proc { |o| o.as(:self).unique_nodes(assoc, :self, :n, :other_rel).each_for_destruction(o) { |node| node.destroy } }
+               else
+                 fail "Unknown dependent option #{dependent}"
+               end
+
+          model.before_destroy fn
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/dependent/query_proxy_methods.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module ActiveNode
+    module Dependent
+      # methods used to resolve association dependencies
+      module QueryProxyMethods
+        # Used as part of `dependent: :destroy` and may not have any utility otherwise.
+        # It keeps track of the node responsible for a cascading `destroy` process.
+        # @param [#dependent_children] caller The node that called this method. Typically, we would use QueryProxy's `caller` method
+        # but this is not always available, so we require it explicitly.
+        def each_for_destruction(owning_node)
+          target = owning_node.called_by || owning_node
+          enumerable_query(identity).each do |obj|
+            # Cypher can return nil objects, check for empty results
+            next if !obj || target.dependent_children.include?(obj)
+            obj.called_by = target
+            target.dependent_children << obj
+            yield obj
+          end
+        end
+
+        # This will match nodes who only have a single relationship of a given type.
+        # It's used  by `dependent: :delete_orphans` and `dependent: :destroy_orphans` and may not have much utility otherwise.
+        # @param [Neo4j::ActiveNode::HasN::Association] association The Association object used throughout the match.
+        # @param [String, Symbol] other_node The identifier to use for the other end of the chain.
+        # @param [String, Symbol] other_rel The identifier to use for the relationship in the optional match.
+        # @return [Neo4j::ActiveNode::Query::QueryProxy]
+        def unique_nodes(association, self_identifer, other_node, other_rel)
+          fail 'Only supported by in QueryProxy chains started by an instance' unless caller
+          both_string = "-[:`#{association.relationship_type}`]-"
+          in_string = "<#{both_string}"
+          out_string = "#{both_string}>"
+          primary_rel, inverse_rel =  case association.direction
+                                      when :out
+                                        [out_string, in_string]
+                                      when :in
+                                        [in_string, out_string]
+                                      else
+                                        [both_string, both_string]
+                                      end
+
+          query.with(identity).proxy_as_optional(caller.class, self_identifer)
+            .send("#{association.name}", other_node, other_rel)
+            .where("NOT EXISTS((#{self_identifer})#{primary_rel}(#{other_node})#{inverse_rel}())")
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/has_n.rb

@@ -1,135 +1,143 @@
 module Neo4j::ActiveNode
-module HasN
-  extend ActiveSupport::Concern
+  module HasN
+    extend ActiveSupport::Concern
 
-  class NonPersistedNodeError < StandardError; end
+    class NonPersistedNodeError < StandardError; end
 
-  # Clears out the association cache.
-  def clear_association_cache #:nodoc:
-    association_cache.clear if persisted?
-  end
-
-  # Returns the current association cache. It is in the format
-  # { :association_name => { :hash_of_cypher_string => [collection] }}
-  def association_cache
-    @association_cache ||= {}
-  end
-
-  # Returns the specified association instance if it responds to :loaded?, nil otherwise.
-  # @param [String] cypher_string the cypher, with params, used for lookup
-  # @param [Enumerable] association_obj the HasN::Association object used to perform this query
-  def association_instance_get(cypher_string, association_obj)
-    return if association_cache.nil? || association_cache.empty?
-    lookup_obj = cypher_hash(cypher_string)
-    reflection = association_reflection(association_obj)
-    return if reflection.nil?
-    association_cache[reflection.name] ? association_cache[reflection.name][lookup_obj] : nil
-  end
+    # Clears out the association cache.
+    def clear_association_cache #:nodoc:
+      association_cache.clear if _persisted_obj
+    end
 
-  # @return [Hash] A hash of all queries in @association_cache created from the association owning this reflection
-  def association_instance_get_by_reflection(reflection_name)
-    association_cache[reflection_name]
-  end
+    # Returns the current association cache. It is in the format
+    # { :association_name => { :hash_of_cypher_string => [collection] }}
+    def association_cache
+      @association_cache ||= {}
+    end
 
-  # Caches an association result. Unlike ActiveRecord, which stores results in @association_cache using { :association_name => [collection_result] },
-  # ActiveNode stores it using { :association_name => { :hash_string_of_cypher => [collection_result] }}.
-  # This is necessary because an association name by itself does not take into account :where, :limit, :order, etc,... so it's prone to error.
-  # @param [Neo4j::ActiveNode::Query::QueryProxy] query_proxy The QueryProxy object that resulted in this result
-  # @param [Enumerable] collection_result The result of the query after calling :each
-  # @param [Neo4j::ActiveNode::HasN::Association] association_obj The association traversed to create the result
-  def association_instance_set(cypher_string, collection_result, association_obj)
-    return collection_result if Neo4j::Transaction.current
-    cache_key = cypher_hash(cypher_string)
-    reflection = association_reflection(association_obj)
-    return if reflection.nil?
-    if @association_cache[reflection.name]
-      @association_cache[reflection.name][cache_key] = collection_result
-    else
-      @association_cache[reflection.name] = { cache_key => collection_result }
+    # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+    # @param [String] cypher_string the cypher, with params, used for lookup
+    # @param [Enumerable] association_obj the HasN::Association object used to perform this query
+    def association_instance_get(cypher_string, association_obj)
+      return if association_cache.nil? || association_cache.empty?
+      lookup_obj = cypher_hash(cypher_string)
+      reflection = association_reflection(association_obj)
+      return if reflection.nil?
+      association_cache[reflection.name] ? association_cache[reflection.name][lookup_obj] : nil
     end
-    collection_result
-  end
 
-  def association_reflection(association_obj)
-    self.class.reflect_on_association(association_obj.name)
-  end
+    # @return [Hash] A hash of all queries in @association_cache created from the association owning this reflection
+    def association_instance_get_by_reflection(reflection_name)
+      association_cache[reflection_name]
+    end
 
-  # Uses the cypher generated by a QueryProxy object, complete with params, to generate a basic non-cryptographic hash
-  # for use in @association_cache.
-  # @param [String] the cypher used in the query
-  # @return [String] A basic hash of the query
-  def cypher_hash(cypher_string)
-    cypher_string.hash.abs
-  end
+    # Caches an association result. Unlike ActiveRecord, which stores results in @association_cache using { :association_name => [collection_result] },
+    # ActiveNode stores it using { :association_name => { :hash_string_of_cypher => [collection_result] }}.
+    # This is necessary because an association name by itself does not take into account :where, :limit, :order, etc,... so it's prone to error.
+    # @param [Neo4j::ActiveNode::Query::QueryProxy] query_proxy The QueryProxy object that resulted in this result
+    # @param [Enumerable] collection_result The result of the query after calling :each
+    # @param [Neo4j::ActiveNode::HasN::Association] association_obj The association traversed to create the result
+    def association_instance_set(cypher_string, collection_result, association_obj)
+      return collection_result if Neo4j::Transaction.current
+      cache_key = cypher_hash(cypher_string)
+      reflection = association_reflection(association_obj)
+      return if reflection.nil?
+      if @association_cache[reflection.name]
+        @association_cache[reflection.name][cache_key] = collection_result
+      else
+        @association_cache[reflection.name] = {cache_key => collection_result}
+      end
+      collection_result
+    end
 
-  module ClassMethods
-    def has_association?(name)
-      !!associations[name.to_sym]
+    def association_reflection(association_obj)
+      self.class.reflect_on_association(association_obj.name)
     end
 
-    def associations
-      @associations || {}
+    # Uses the cypher generated by a QueryProxy object, complete with params, to generate a basic non-cryptographic hash
+    # for use in @association_cache.
+    # @param [String] the cypher used in the query
+    # @return [String] A basic hash of the query
+    def cypher_hash(cypher_string)
+      cypher_string.hash.abs
     end
 
-    # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
-    def inherited(klass)
-      klass.instance_variable_set(:@associations, associations.clone)
+    module ClassMethods
+      # :nocov:
+      # rubocop:disable Style/PredicateName
+      def has_association?(name)
+        ActiveSupport::Deprecation.warn 'has_association? is deprecated and may be removed from future releases, use association? instead.', caller
 
-      super
-    end
+        association?(name)
+      end
+      # rubocop:enable Style/PredicateName
+      # :nocov:
+
+      def association?(name)
+        !!associations[name.to_sym]
+      end
 
-    def has_many(direction, name, options = {})
-      name = name.to_sym
-
-      association = Neo4j::ActiveNode::HasN::Association.new(:has_many, direction, name, options)
-      @associations ||= {}
-      @associations[name] = association
-
-      target_class_name = association.target_class_name || 'nil'
-      create_reflection(:has_many, name, association)
-
-      # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
-      module_eval(%Q{
-        def #{name}(node = nil, rel = nil)
-          return [].freeze unless self.persisted?
-          Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
-                                                   self.class.associations[#{name.inspect}],
-                                                   {
-                                                     session: self.class.neo4j_session,
-                                                     start_object: self,
-                                                     node: node,
-                                                     rel: rel,
-                                                     context: '#{self.name}##{name}',
-                                                     caller: self
-                                                   })
+      def associations
+        @associations || {}
+      end
 
+      # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
+      def inherited(klass)
+        klass.instance_variable_set(:@associations, associations.clone)
+        super
+      end
+
+      # rubocop:disable Style/PredicateName
+      def has_many(direction, name, options = {})
+        name = name.to_sym
+        association = build_association(:has_many, direction, name, options)
+        # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
+        module_eval(%{
+          def #{name}(node = nil, rel = nil)
+            return [].freeze unless self._persisted_obj
+            #{name}_query_proxy(node: node, rel: rel)
+          end
+
+          def #{name}_query_proxy(options = {})
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{association.target_class_name_or_nil},
+                                                     self.class.associations[#{name.inspect}],
+                                                     {
+                                                       session: self.class.neo4j_session,
+                                                       start_object: self,
+                                                       node: options[:node],
+                                                       rel: options[:rel],
+                                                       context: '#{self.name}##{name}',
+                                                       caller: self
+                                                     })
           end
 
           def #{name}=(other_nodes)
             #{name}(nil, :r).query_as(:n).delete(:r).exec
             clear_association_cache
-            other_nodes.each do |node|
-              #{name} << node
-            end
+            other_nodes.each { |node| #{name} << node }
           end
 
           def #{name}_rels
             #{name}(nil, :r).pluck(:r)
           end}, __FILE__, __LINE__)
 
-        instance_eval(%Q{
+        instance_eval(%{
           def #{name}(node = nil, rel = nil, proxy_obj = nil)
-            query_proxy = proxy_obj || Neo4j::ActiveNode::Query::QueryProxy.new(::#{self.name}, nil, {
+            #{name}_query_proxy(node: node, rel: rel, proxy_obj: proxy_obj)
+          end
+
+          def #{name}_query_proxy(options = {})
+            query_proxy = options[:proxy_obj] || Neo4j::ActiveNode::Query::QueryProxy.new(::#{self.name}, nil, {
                   session: self.neo4j_session, query_proxy: nil, context: '#{self.name}' + '##{name}'
                 })
             context = (query_proxy && query_proxy.context ? query_proxy.context : '#{self.name}') + '##{name}'
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
-                                                     @associations[#{name.inspect}],
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{association.target_class_name_or_nil},
+                                                     associations[#{name.inspect}],
                                                      {
                                                        session: self.neo4j_session,
                                                        query_proxy: query_proxy,
-                                                       node: node,
-                                                       rel: rel,
+                                                       node: options[:node],
+                                                       rel: options[:rel],
                                                        context: context,
                                                        optional: query_proxy.optional?,
                                                        caller: query_proxy.caller
@@ -139,17 +147,11 @@ module HasN
 
       def has_one(direction, name, options = {})
         name = name.to_sym
+        association = build_association(:has_one, direction, name, options)
 
-        association = Neo4j::ActiveNode::HasN::Association.new(:has_one, direction, name, options)
-        @associations ||= {}
-        @associations[name] = association
-
-        target_class_name = association.target_class_name || 'nil'
-        create_reflection(:has_one, name, association)
-
-        module_eval(%Q{
+        module_eval(%{
           def #{name}=(other_node)
-            raise(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self.persisted?
+            raise(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self._persisted_obj
             clear_association_cache
             #{name}_query_proxy(rel: :r).query_as(:n).delete(:r).exec
             #{name}_query_proxy << other_node
@@ -164,17 +166,17 @@ module HasN
           end
 
           def #{name}(node = nil, rel = nil)
-            return nil unless self.persisted?
+            return nil unless self._persisted_obj
             result = #{name}_query_proxy(node: node, rel: rel, context: '#{self.name}##{name}')
             association = self.class.reflect_on_association(__method__)
             query_return = association_instance_get(result.to_cypher_with_params, association)
             query_return || association_instance_set(result.to_cypher_with_params, result.first, association)
           end}, __FILE__, __LINE__)
 
-        instance_eval(%Q{
+        instance_eval(%{
           def #{name}_query_proxy(options = {})
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name},
-                                                     @associations[#{name.inspect}],
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{association.target_class_name_or_nil},
+                                                     associations[#{name.inspect}],
                                                      {session: self.neo4j_session}.merge(options))
           end
 
@@ -183,7 +185,17 @@ module HasN
             #{name}_query_proxy(query_proxy: query_proxy, node: node, rel: rel, context: context)
           end}, __FILE__, __LINE__)
       end
+      # rubocop:enable Style/PredicateName
+
+      private
+
+      def build_association(macro, direction, name, options)
+        Neo4j::ActiveNode::HasN::Association.new(macro, direction, name, options).tap do |association|
+          @associations ||= {}
+          @associations[name] = association
+          create_reflection(macro, name, association, self)
+        end
+      end
     end
   end
-
 end