neo4j 4.1.5 → 5.0.0.rc.1

data/CONTRIBUTORS

@@ -1,29 +1,8 @@
-Maintainer:
-  Andreas Ronge <andreas dot ronge at gmail dot com>
+Maintainers:
+  Chris Grigg <subvertallchris @ GitHub>
+  Brian Underwood <cheerfulstoic @ GitHub>
 
-Contributors:
-* Dmytrii Nagirniak
-* Marcio Toshio
-* Kalyan Akella
-* Vivek Prahlad
-* Deepak N
-* Frédéric Vanclef
-* Pere Urbon
-* Joe Leaver
-* Junegunn Choi
-* Jay Adkisson 
-* Stephan Hagemann
-* Bobby Calderwood
-* Ben Jackson
-* Dwight van Tuyl
-* Martin Kleppmann
-* Peter Neubauer
-* Jan-Felix Wittmann
-* Marius Mårnes Mathiesen
-* Bert Fitié
-* Jan Berkel
-* David Beckwith
-* Johny Ho
-* Carlo Cabanilla
-* Anders Janmyr
-* Nick Sieger
+Creator:
+  Andreas Ronge <andreasronge @ GitHub>
+
+See: https://github.com/neo4jrb/neo4j/graphs/contributors

data/Gemfile

@@ -2,14 +2,19 @@ source 'http://rubygems.org'
 
 gemspec
 
-gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
+# gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
 # gem 'neo4j-core', path: '../neo4j-core'
 
+# gem 'active_attr', github: 'neo4jrb/active_attr', branch: 'performance'
+# gem 'active_attr', path: '../active_attr'
+
 group 'test' do
   gem 'coveralls', require: false
+  gem 'codecov', require: false
   gem 'simplecov', require: false
   gem 'simplecov-html', require: false
   gem 'rspec', '~> 2.0'
   gem 'its'
   gem 'test-unit'
+  gem 'overcommit'
 end

data/README.md

@@ -1,8 +1,36 @@
 # Welcome to Neo4j.rb
+
+## Code Status
+
 [![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)
 
+## Issues
+
+[![Next Release](https://badge.waffle.io/neo4jrb/neo4j.png?label=Next%20Release&title=Next%20Release) ![In Progress](https://badge.waffle.io/neo4jrb/neo4j.png?label=In%20Progress&title=In%20Progress) ![In Master](https://badge.waffle.io/neo4jrb/neo4j.png?label=In%20Master&title=In%20Master)](https://waffle.io/neo4jrb/neo4j)
+
+[![Post an issue](https://img.shields.io/badge/Bug%3F-Post%20an%20issue!-blue.svg)](https://waffle.io/neo4jrb/neo4j)
+
+## Get Support
+
+  [![StackOverflow](https://img.shields.io/badge/StackOverflow-Ask%20a%20question!-blue.svg)](http://stackoverflow.com/questions/ask?tags=neo4j.rb+neo4j+ruby)  [![Gitter](https://img.shields.io/badge/Gitter-Join%20our%20chat!-blue.svg)](https://gitter.im/neo4jrb/neo4j?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)  [![Twitter](https://img.shields.io/badge/Twitter-Tweet%20with%20us!-blue.svg)](https://twitter.com/neo4jrb)  [![Mailing list](https://img.shields.io/badge/Mailing%20list-Mail%20us!-blue.svg)](https://groups.google.com/forum/#!forum/neo4jrb)
+
+# Introduction
+
 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.
 
+Neo4j is a transactional, open-source graph database.  A graph database manages data in a connected data structure, capable of  representing any kind of data in a very accessible way.  Information is stored in nodes and relationships connecting them, both of which can have arbitrary properties.  To learn more visit [What is a Graph Database?](http://neo4j.com/developer/graph-database/)
+
+With this gem you not only do you get a convenient higher level wrapper around Neo4j, but you have access to a powerful high-level query building interface which lets you take advantage of the power of Neo4j like this:
+
+```ruby
+# Break down the top countries where friends' favorite beers come from
+person.friends.favorite_beers.country_of_origin(:country).
+  order('count(country) DESC').
+  pluck(:country, count: 'count(country)')
+```
+
+It can be installed in your `Gemfile` with a simple `gem 'neo4j'`
+
 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!
@@ -10,6 +38,25 @@ Winner of a 2014 Graphie for "Best Community Contribution" at Neo4j's [Graph Con
 
 Neo4j.rb v4.1.0 was released in January of 2015. Its changes are outlined [here](https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v4-Introduction) and in the [announcement message](http://neo4jrb.io/blog/2015/01/09/neo4j-rb_v4-1_released.html). It will take a little time before all documentation is updated to reflect the new release but unless otherwise noted, all 3.X documentation is totally valid for v4.
 
+## Neo4j version support
+
+| **Neo4j Version** | v2.x | v3.x | v4.x |
+|-------------------|------|------|------|
+| 1.9.x             | Yes  | No   | No   |
+| 2.0.x             | No   | Yes  | No   |
+| 2.1.x             | No   | Yes  | Yes  |
+| 2.2.x             | No   | No   | Yes  |
+
+## Neo4j feature support
+
+| **Neo4j Feature**          |   v2.x | v3.x | v4.x |
+|----------------------------|--------|------|------|
+| Auth                       |   No   |  No  | Yes  |
+| Remote Cypher              |   Yes  |  Yes | Yes  |
+| Transactions               |   Yes  |  Yes | Yes  |
+| High Availability          |   No   |  Yes | Yes  |
+| Embedded JVM support       |   Yes  |  Yes | Yes  |
+
 ## Modern (3.x/4.X) Documentation
 
 * [Website](http://neo4jrb.io/) (for an introduction)
@@ -20,23 +67,22 @@ Neo4j.rb v4.1.0 was released in January of 2015. Its changes are outlined [here]
 * [README](https://github.com/neo4jrb/neo4j/tree/2.x)
 * [Wiki](https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3ARails-Introduction)
 
-## Support
-
-* Open an [issue](https://github.com/neo4jrb/neo4j/issues), post to [Stack Overflow](http://stackoverflow.com/questions/tagged/neo4j+ruby), or contact one of the developers.
-* [Neo4j.rb mailing list](https://groups.google.com/forum/#!forum/neo4jrb)
-* Consulting support? Ask any of the developers, info below.
-
 ## Developers
 
+### Original Author
+
 * [Andreas Ronge](https://github.com/andreasronge)
+
+### Current Maintainers
+
 * [Brian Underwood](https://github.com/cheerfulstoic)
 * [Chris Grigg](https://github.com/subvertallchris)
 
+* Consulting support? Contact [Chris](http://subvertallmedia.com/) and/or [Brian](http://www.brian-underwood.codes/)
 
 ## Contributing
 
-Pull request with high test coverage and good [code climate](https://codeclimate.com/github/neo4jrb/neo4j) values will be accepted faster.
-
+Always welcome!  Please review the [guidelines for contributing](CONTRIBUTING.md) to this repository.
 
 ## License
 

data/lib/neo4j.rb

@@ -16,6 +16,7 @@ require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'
 
 require 'active_attr'
+require 'neo4j/errors'
 require 'neo4j/config'
 require 'neo4j/wrapper'
 require 'neo4j/active_rel/rel_wrapper'
@@ -26,11 +27,14 @@ require 'neo4j/type_converters'
 require 'neo4j/paginated'
 
 require 'neo4j/shared/callbacks'
+require 'neo4j/shared/declared_property'
+require 'neo4j/shared/declared_property_manager'
 require 'neo4j/shared/property'
 require 'neo4j/shared/persistence'
 require 'neo4j/shared/validations'
 require 'neo4j/shared/identity'
 require 'neo4j/shared/serialized_properties'
+require 'neo4j/shared/typecaster'
 require 'neo4j/shared'
 
 require 'neo4j/active_rel/callbacks'
@@ -50,6 +54,7 @@ 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/query/query_proxy_link'
 require 'neo4j/active_node/labels'
 require 'neo4j/active_node/id_property'
 require 'neo4j/active_node/callbacks'

data/lib/neo4j/active_node.rb

@@ -51,6 +51,7 @@ module Neo4j
         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
 

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

@@ -2,26 +2,44 @@ module Neo4j
   module ActiveNode
     module Dependent
       module AssociationMethods
+        def validate_dependent(value)
+          fail ArgumentError, "Invalid dependent value: #{value.inspect}" if not valid_dependent_value?(value)
+        end
+
         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
+
+          model.before_destroy(&method("dependent_#{dependent}_callback"))
+        rescue NameError
+          raise "Unknown dependent option #{dependent}"
+        end
+
+        private
+
+        def valid_dependent_value?(value)
+          return true if value.nil?
+
+          self.respond_to?("dependent_#{value}_callback", true)
+        end
+
+        # Callback methods
+        def dependent_delete_callback(object)
+          object.association_query_proxy(name).delete_all
+        end
+
+        def dependent_delete_orphans_callback(object)
+          object.as(:self).unique_nodes(self, :self, :n, :other_rel).query.delete(:n, :other_rel).exec
+        end
+
+        def dependent_destroy_callback(object)
+          object.association_query_proxy(name).each_for_destruction(object, &:destroy)
+        end
+
+        def dependent_destroy_orphans_callback(object)
+          object.as(:self).unique_nodes(self, :self, :n, :other_rel).each_for_destruction(object, &:destroy)
         end
+
+        # End callback methods
       end
     end
   end

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

@@ -5,13 +5,15 @@ module Neo4j
       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
+        # @param [#dependent_children] source_object The node that called this method. Typically, we would use QueryProxy's `source_object` 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)
+          objects = pluck(identity).compact.reject do |obj|
+            target.dependent_children.include?(obj)
+          end
+
+          objects.each do |obj|
             obj.called_by = target
             target.dependent_children << obj
             yield obj
@@ -25,22 +27,22 @@ module Neo4j
         # @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
+          fail 'Only supported by in QueryProxy chains started by an instance' unless source_object
+
+          unique_nodes_query(association, self_identifer, other_node, other_rel)
+            .proxy_as(association.target_class, other_node)
+        end
+
+        private
 
-          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}())")
+        def unique_nodes_query(association, self_identifer, other_node, other_rel)
+          query.with(identity).proxy_as_optional(source_object.class, self_identifer)
+            .send(association.name, other_node, other_rel)
+            .query
+            .with(other_node)
+            .match("()#{association.arrow_cypher}(#{other_node})")
+            .with(other_node, count: 'count(*)')
+            .where('count = 1')
         end
       end
     end

data/lib/neo4j/active_node/has_n.rb

@@ -4,54 +4,138 @@ module Neo4j::ActiveNode
 
     class NonPersistedNodeError < StandardError; end
 
-    # Clears out the association cache.
-    def clear_association_cache #:nodoc:
-      association_cache.clear if _persisted_obj
-    end
+    # Return this object from associations
+    # 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)
+        @query_proxy = query_proxy
+        cache_result(cached_result)
 
-    # Returns the current association cache. It is in the format
-    # { :association_name => { :hash_of_cypher_string => [collection] }}
-    def association_cache
-      @association_cache ||= {}
-    end
+        # Represents the thing which can be enumerated
+        # default to @query_proxy, but will be set to
+        # @cached_result if that is set
+        @enumerable = @query_proxy
+      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
+      # States:
+      # Default
+      def inspect
+        if @cached_result
+          @cached_result.inspect
+        else
+          "<AssociationProxy @query_proxy=#{@query_proxy.inspect}>"
+        end
+      end
+
+      extend Forwardable
+      %w(include? empty? count find ==).each do |delegated_method|
+        def_delegator :@enumerable, delegated_method
+      end
+
+      include Enumerable
+
+      def each(&block)
+        result.each(&block)
+      end
+
+      def result
+        return @cached_result if @cached_result
+
+        cache_query_proxy_result
+
+        @cached_result
+      end
+
+      def cache_result(result)
+        @cached_result = result
+        @enumerable = (@cached_result || @query_proxy)
+      end
+
+      def cache_query_proxy_result
+        @query_proxy.to_a.tap do |result|
+          result.each do |object|
+            object.instance_variable_set('@association_proxy', self)
+          end
+          cache_result(result)
+        end
+      end
+
+      def clear_cache_result
+        cache_result(nil)
+      end
+
+      def cached?
+        !!@cached_result
+      end
+
+      QUERY_PROXY_METHODS = [:<<, :delete]
+      CACHED_RESULT_METHODS = []
+
+      def method_missing(method_name, *args, &block)
+        target = target_for_missing_method(method_name)
+
+        cache_query_proxy_result if !cached? && !target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+
+        clear_cache_result if target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+
+        return if target.nil?
+
+        target.public_send(method_name, *args, &block)
+      end
+
+      def with_associations(*spec)
+        return_object_clause = '[' + spec.map { |n| "collect(#{n})" }.join(',') + ']'
+        query_from_association_spec(spec).pluck(:previous, return_object_clause).map do |record, eager_data|
+          eager_data.each_with_index do |eager_records, index|
+            record.send(spec[index]).cache_result(eager_records)
+          end
+
+          record
+        end
+      end
+
+      private
 
-    # @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]
+      def query_from_association_spec(spec)
+        spec.inject(@query_proxy.query_as(:previous).return(:previous)) do |query, association_name|
+          association = @query_proxy.model.associations[association_name]
+          query.optional_match("previous#{association.arrow_cypher}#{association_name}")
+        end
+      end
+
+      def target_for_missing_method(method_name)
+        case method_name
+        when *QUERY_PROXY_METHODS
+          @query_proxy
+        when *CACHED_RESULT_METHODS
+          @cached_result
+        else
+          if @cached_result && @cached_result.respond_to?(method_name)
+            @cached_result
+          elsif @query_proxy.respond_to?(method_name)
+            @query_proxy
+          end
+        end
+      end
     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
+    # Returns the current AssociationProxy cache for the association cache. It is in the format
+    # { :association_name => AssociationProxy}
+    # This is so that we
+    # * don't need to re-build the QueryProxy objects
+    # * also because the QueryProxy object caches it's results
+    # * so we don't need to query again
+    # * so that we can cache results from association calls or eager loading
+    def association_proxy_cache
+      @association_proxy_cache ||= {}
     end
 
-    def association_reflection(association_obj)
-      self.class.reflect_on_association(association_obj.name)
+    def association_proxy_cache_fetch(key)
+      association_proxy_cache.fetch(key) do
+        value = yield
+        association_proxy_cache[key] = value
+      end
     end
 
     # Uses the cypher generated by a QueryProxy object, complete with params, to generate a basic non-cryptographic hash
@@ -62,6 +146,54 @@ module Neo4j::ActiveNode
       cypher_string.hash.abs
     end
 
+    def association_query_proxy(name, options = {})
+      self.class.send(:association_query_proxy, name, {start_object: self}.merge(options))
+    end
+
+    def association_proxy(name, options = {})
+      name = name.to_sym
+      hash = [name, options.values_at(:node, :rel)].hash
+
+      association_proxy_cache_fetch(hash) do
+        if previous_association_proxy = self.instance_variable_get('@association_proxy')
+          result_by_previous_id = previous_association_proxy_results_by_previous_id(previous_association_proxy, name)
+
+          previous_association_proxy.result.inject(nil) do |proxy_to_return, object|
+            proxy = fresh_association_proxy(name, options, result_by_previous_id[object.neo_id])
+
+            object.association_proxy_cache[hash] = proxy
+
+            (self == object ? proxy : proxy_to_return)
+          end
+        else
+          fresh_association_proxy(name, options)
+        end
+      end
+    end
+
+    private
+
+    def fresh_association_proxy(name, options = {}, cached_result = nil)
+      AssociationProxy.new(association_query_proxy(name, options), cached_result)
+    end
+
+    def previous_association_proxy_results_by_previous_id(association_proxy, association_name)
+      query_proxy = self.class.as(:previous).where(neo_id: association_proxy.result.map(&:neo_id))
+      query_proxy = self.class.send(:association_query_proxy, association_name, previous_query_proxy: query_proxy, node: :next)
+
+      Hash[*query_proxy.pluck('ID(previous)', 'collect(next)').flatten(1)]
+    end
+
+    def handle_non_persisted_node(other_node)
+      return unless Neo4j::Config[:autosave_on_assignment]
+      other_node.try(:save)
+      save
+    end
+
+    def validate_persisted_for_association!
+      fail(Neo4j::ActiveNode::HasN::NonPersistedNodeError, 'Unable to create relationship with non-persisted nodes') unless self._persisted_obj
+    end
+
     module ClassMethods
       # :nocov:
       # rubocop:disable Style/PredicateName
@@ -78,119 +210,232 @@ module Neo4j::ActiveNode
       end
 
       def associations
-        @associations || {}
+        @associations ||= {}
+      end
+
+      def associations_keys
+        @associations_keys ||= associations.keys
       end
 
       # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
       def inherited(klass)
         klass.instance_variable_set(:@associations, associations.clone)
+        @associations_keys = klass.associations_keys.clone
         super
       end
 
-      # rubocop:disable Style/PredicateName
-      def has_many(direction, name, options = {})
+      # For defining an "has many" association on a model.  This defines a set of methods on
+      # your model instances.  For instance, if you define the association on a Person model:
+      #
+      # has_many :out, :vehicles, type: :has_vehicle
+      #
+      # This would define the following methods:
+      #
+      # **#vehicles**
+      #   Returns a QueryProxy object.  This is an Enumerable object and thus can be iterated
+      #   over.  It also has the ability to accept class-level methods from the Vehicle model
+      #   (including calls to association methods)
+      #
+      # **#vehicles=**
+      #   Takes an array of Vehicle objects and replaces all current ``:HAS_VEHICLE`` relationships
+      #   with new relationships refering to the specified objects
+      #
+      # **.vehicles**
+      #   Returns a QueryProxy object.  This would represent all ``Vehicle`` objects associated with
+      #   either all ``Person`` nodes (if ``Person.vehicles`` is called), or all ``Vehicle`` objects
+      #   associated with the ``Person`` nodes thus far represented in the QueryProxy chain.
+      #   For example:
+      #     ``company.people.where(age: 40).vehicles``
+      #
+      # Arguments:
+      #   **direction:**
+      #     **Available values:** ``:in``, ``:out``, or ``:both``.
+      #
+      #     Refers to the relative to the model on which the association is being defined.
+      #
+      #     Example:
+      #       ``Person.has_many :out, :posts, type: :wrote``
+      #
+      #         means that a `WROTE` relationship goes from a `Person` node to a `Post` node
+      #
+      #   **name:**
+      #     The name of the association.  The affects the methods which are created (see above).
+      #     The name is also used to form default assumptions about the model which is being referred to
+      #
+      #     Example:
+      #       ``Person.has_many :out, :posts, type: :wrote``
+      #
+      #       will assume a `model_class` option of ``'Post'`` unless otherwise specified
+      #
+      #   **options:** A ``Hash`` of options.  Allowed keys are:
+      #     *type*: The Neo4j relationship type.  This option is required unless either the
+      #       `origin` or `rel_class` options are specified
+      #
+      #     *origin*: The name of the association from another model which the `type` and `model_class`
+      #       can be gathered.
+      #
+      #       Example:
+      #         ``Person.has_many :out, :posts, origin: :author`` (`model_class` of `Post` is assumed here)
+      #
+      #         ``Post.has_one :in, :author, type: :has_author, model_class: 'Person'``
+      #
+      #     *model_class*: The model class to which the association is referring.  Can be either a
+      #       model object ``include`` ing ``ActiveNode`` or a string (or an ``Array`` of same).
+      #       **A string is recommended** to avoid load-time issues
+      #
+      #     *rel_class*: The ``ActiveRel`` class to use for this association.  Can be either a
+      #       model object ``include`` ing ``ActiveRel`` or a string (or an ``Array`` of same).
+      #       **A string is recommended** to avoid load-time issues
+      #
+      #     *dependent*: Enables deletion cascading.
+      #       **Available values:** ``:delete``, ``:delete_orphans``, ``:destroy``, ``:destroy_orphans``
+      #       (note that the ``:destroy_orphans`` option is known to be "very metal".  Caution advised)
+      #
+      def has_many(direction, name, options = {}) # rubocop:disable Style/PredicateName
+        validate_association_options!(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
+        build_association(:has_many, direction, name, options)
 
-          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],
-                                                       optional: options[:optional],
-                                                       context: '#{self.name}##{name}',
-                                                       caller: self
-                                                     })
-          end
+        define_has_many_methods(name)
+      end
 
-          def #{name}=(other_nodes)
-            #{name}(nil, :r).query_as(:n).delete(:r).exec
-            clear_association_cache
-            other_nodes.each { |node| #{name} << node }
-          end
+      # For defining an "has one" association on a model.  This defines a set of methods on
+      # your model instances.  For instance, if you define the association on a Person model:
+      #
+      # has_one :out, :vehicle, type: :has_vehicle
+      #
+      # This would define the methods: ``#vehicle``, ``#vehicle=``, and ``.vehicle``.
+      #
+      # See :ref:`#has_many <Neo4j/ActiveNode/HasN/ClassMethods#has_many>` for anything
+      # not specified here
+      #
+      def has_one(direction, name, options = {}) # rubocop:disable Style/PredicateName
+        validate_association_options!(name, options)
+        name = name.to_sym
+        build_association(:has_one, direction, name, options)
 
-          def #{name}_rels
-            #{name}(nil, :r).pluck(:r)
-          end}, __FILE__, __LINE__)
+        define_has_one_methods(name)
+      end
 
-        instance_eval(%{
-          def #{name}(node = nil, rel = nil, proxy_obj = nil, options = {})
-            #{name}_query_proxy({node: node, rel: rel, proxy_obj: proxy_obj}.merge(options))
-          end
+      private
 
-          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(#{association.target_class_name_or_nil},
-                                                     associations[#{name.inspect}],
-                                                     {
-                                                       session: self.neo4j_session,
-                                                       query_proxy: query_proxy,
-                                                       node: options[:node],
-                                                       rel: options[:rel],
-                                                       context: context,
-                                                       optional: options[:optional] || query_proxy.optional?,
-                                                       caller: query_proxy.caller
-                                                     })
-          end}, __FILE__, __LINE__)
-      end
-
-      def has_one(direction, name, options = {})
-        name = name.to_sym
-        association = build_association(:has_one, direction, name, options)
-
-        module_eval(%{
-          def #{name}=(other_node)
-            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
-          end
+      VALID_ASSOCIATION_OPTION_KEYS = [:type, :origin, :model_class, :rel_class, :dependent, :before, :after]
 
-          def #{name}_query_proxy(options = {})
-            self.class.#{name}_query_proxy({start_object: self}.merge(options))
-          end
+      def validate_association_options!(association_name, options)
+        type_keys = (options.keys & [:type, :origin, :rel_class])
+        message = case
+                  when type_keys.size > 1
+                    "Only one of 'type', 'origin', or 'rel_class' options are allowed for associations (#{self.class}##{association_name})"
+                  when type_keys.empty?
+                    "The 'type' option must be specified( even if it is `nil`) or `origin`/`rel_class` must be specified (#{self.class}##{association_name})"
+                  when (unknown_keys = options.keys - VALID_ASSOCIATION_OPTION_KEYS).size > 0
+                    "Unknown option(s) specified: #{unknown_keys.join(', ')} (#{self.class}##{association_name})"
+                  end
 
-          def #{name}_rel
-            #{name}_query_proxy(rel: :r).pluck(:r).first
-          end
+        fail ArgumentError, message if message
+      end
 
-          def #{name}(node = nil, rel = nil)
-            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(%{
-          def #{name}_query_proxy(options = {})
-            Neo4j::ActiveNode::Query::QueryProxy.new(#{association.target_class_name_or_nil},
-                                                     associations[#{name.inspect}],
-                                                     {session: self.neo4j_session}.merge(options))
-          end
+      def define_has_many_methods(name)
+        define_method(name) do |node = nil, rel = nil, options = {}|
+          return [].freeze unless self._persisted_obj
+
+          association_proxy(name, {node: node, rel: rel, source_object: self}.merge(options))
+        end
 
-          def #{name}(node = nil, rel = nil, query_proxy = nil, options = {})
-            context = (query_proxy && query_proxy.context ? query_proxy.context : '#{self.name}') + '##{name}'
-            #{name}_query_proxy({query_proxy: query_proxy, node: node, rel: rel, context: context}.merge(options))
-          end}, __FILE__, __LINE__)
+        define_has_many_setter(name)
+
+        define_class_method(name) do |node = nil, rel = nil, options = {}|
+          association_proxy(name, {node: node, rel: rel}.merge(options))
+        end
       end
-      # rubocop:enable Style/PredicateName
 
-      private
+      def define_has_many_setter(name)
+        define_method("#{name}=") do |other_nodes|
+          association_proxy_cache.clear
+
+          Neo4j::Transaction.run { association_proxy(name).replace_with(other_nodes) }
+        end
+      end
+
+      def define_has_one_methods(name)
+        define_method(name) do |node = nil, rel = nil|
+          return nil unless self._persisted_obj
+
+          association_proxy(name, node: node, rel: rel).first
+        end
+
+        define_has_one_setter(name)
+
+        define_class_method(name) do |node = nil, rel = nil, options = {}|
+          association_proxy(name, {node: node, rel: rel}.merge(options))
+        end
+      end
+
+      def define_has_one_setter(name)
+        define_method("#{name}=") do |other_node|
+          handle_non_persisted_node(other_node)
+          validate_persisted_for_association!
+          association_proxy_cache.clear # TODO: Should probably just clear for this association...
+
+          Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
+        end
+      end
+
+      def define_class_method(*args, &block)
+        klass = class << self; self; end
+        klass.instance_eval do
+          define_method(*args, &block)
+        end
+      end
+
+      def association_query_proxy(name, options = {})
+        previous_query_proxy = options[:previous_query_proxy] || current_scope
+        query_proxy = previous_query_proxy || default_association_query_proxy(name)
+
+        Neo4j::ActiveNode::Query::QueryProxy.new(association_target_class(name),
+                                                 associations[name],
+                                                 {session: neo4j_session,
+                                                  query_proxy: query_proxy,
+                                                  context: "#{query_proxy.context || self.name}##{name}",
+                                                  optional: query_proxy.optional?,
+                                                  source_object: query_proxy.source_object}.merge(options)).tap do |query_proxy_result|
+                                                    target_classes = association_target_classes(name)
+                                                    return query_proxy_result.as_models(target_classes) if target_classes
+                                                  end
+      end
+
+      def association_proxy(name, options = {})
+        query_proxy = association_query_proxy(name, options)
+
+        AssociationProxy.new(query_proxy)
+      end
+
+      def association_target_class(name)
+        target_classes_or_nil = associations[name].target_classes_or_nil
+
+        return if !target_classes_or_nil.is_a?(Array) || target_classes_or_nil.size != 1
+
+        target_classes_or_nil[0]
+      end
+
+      def association_target_classes(name)
+        target_classes_or_nil = associations[name].target_classes_or_nil
+
+        return if !target_classes_or_nil.is_a?(Array) || target_classes_or_nil.size <= 1
+
+        target_classes_or_nil
+      end
+
+      def default_association_query_proxy(name)
+        Neo4j::ActiveNode::Query::QueryProxy.new("::#{self.name}".constantize,
+                                                 nil,
+                                                 session: neo4j_session,
+                                                 query_proxy: nil,
+                                                 context: "#{self.name}##{name}")
+      end
 
       def build_association(macro, direction, name, options)
+        associations_keys << name
         Neo4j::ActiveNode::HasN::Association.new(macro, direction, name, options).tap do |association|
           @associations ||= {}
           @associations[name] = association