Done for the night

lib/neo4j/active_node/has_n.rb

@@ -71,6 +71,7 @@ def method_missing(method_name, *args, &block)
         cache_query_proxy if !cached?
 
         target = target_for_missing_method(method_name)
+        clear_cache_result if target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
 
         return if target.nil?
 
@@ -82,13 +83,11 @@ def method_missing(method_name, *args, &block)
       def target_for_missing_method(method_name)
         case method_name
         when *QUERY_PROXY_METHODS
-          clear_cache_result
           @query_proxy
         when *CACHED_RESULT_METHODS
           @cached_result
         else
           if @query_proxy.respond_to?(method_name)
-            clear_cache_result
             @query_proxy
           elsif @cached_result && @cached_result.respond_to?(method_name)
             @cached_result
@@ -253,8 +252,8 @@ def define_has_many_methods(name)
           association_proxy(name).replace_with(other_nodes)
         end
 
-        define_class_method(name) do |node = nil, rel = nil, previous_query_proxy = nil, options = {}|
-          association_proxy(name, {node: node, rel: rel, previous_query_proxy: previous_query_proxy}.merge(options))
+        define_class_method(name) do |node = nil, rel = nil, options = {}|
+          association_proxy(name, {node: node, rel: rel}.merge(options))
         end
       end
 
@@ -271,8 +270,8 @@ def define_has_one_methods(name)
           association_proxy(name).replace_with(other_node)
         end
 
-        define_class_method(name) do |node = nil, rel = nil, previous_query_proxy = nil, options = {}|
-          association_proxy(name, {previous_query_proxy: previous_query_proxy, node: node, rel: rel}.merge(options))
+        define_class_method(name) do |node = nil, rel = nil, options = {}|
+          association_proxy(name, {node: node, rel: rel}.merge(options))
         end
       end
 
@@ -284,7 +283,7 @@ def define_class_method(*args, &block)
       end
 
       def association_query_proxy(name, options = {})
-        query_proxy = options[:previous_query_proxy] || default_association_query_proxy(name)
+        query_proxy = current_scope || default_association_query_proxy(name)
 
         Neo4j::ActiveNode::Query::QueryProxy.new(association_target_class(name),
                                                  associations[name],

lib/neo4j/active_node/query/query_proxy.rb

@@ -126,7 +126,8 @@ def _model_label_string
         # Please check unscoped if you want to remove all previous scopes (including
         # the default_scope) during the execution of a block.
         def scoping
-          previous, @model.current_scope = @model.current_scope, self
+          previous = @model.current_scope
+          @model.current_scope = self
           yield
         ensure
           @model.current_scope = previous
@@ -169,7 +170,7 @@ def [](index)
         end
 
         def create(other_nodes, properties)
-          fail 'Can only create associations on associations' unless @association
+          fail 'Can only create relationships on associations' if !@association
           other_nodes = _nodeify(*other_nodes)
 
           properties = @association.inject_classname(properties)
@@ -224,7 +225,6 @@ def read_attribute_for_serialization(*args)
         # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
         def method_missing(method_name, *args, &block)
           if @model && @model.respond_to?(method_name)
-            args[2] = self if @model.association?(method_name) || @model.scope?(method_name)
             scoping { @model.public_send(method_name, *args, &block) }
           else
             super

lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -128,7 +128,7 @@ def destroy(node)
 
         # A shortcut for attaching a new, optional match to the end of a QueryProxy chain.
         def optional(association, node_var = nil, rel_var = nil)
-          self.send(association, node_var, rel_var, nil, optional: true)
+          self.send(association, node_var, rel_var, optional: true)
         end
 
         # Takes an Array of ActiveNode models and applies the appropriate WHERE clause

lib/neo4j/active_node/scope.rb

@@ -37,14 +37,14 @@ module ClassMethods
       def scope(name, proc)
         _scope[name.to_sym] = proc
 
-        define_method(name) do |query_params = nil, some_var = nil, query_proxy = nil|
-          self.class.send(name, query_params, some_var, query_proxy)
+        define_method(name) do |query_params = nil, some_var = nil|
+          self.class.send(name, query_params, some_var, current_scope)
         end
 
         klass = class << self; self; end
         klass.instance_eval do
-          define_method(name) do |query_params = nil, _ = nil, query_proxy = nil|
-            eval_context = ScopeEvalContext.new(self, query_proxy || self.query_proxy)
+          define_method(name) do |query_params = nil, _ = nil|
+            eval_context = ScopeEvalContext.new(self, current_scope || self.query_proxy)
             proc = _scope[name.to_sym]
             _call_scope_context(eval_context, query_params, proc)
           end

spec/e2e/active_model_spec.rb

@@ -1,46 +1,59 @@
 require 'spec_helper'
 
-IceLolly = UniqueClass.create do
-  include Neo4j::ActiveNode
-  property :flavour
-  property :name
-  property :a
-  property :b
-  property :required_on_create
-  property :required_on_update
-  property :created
-  property :start, type: Time
 
-  property :created_at
-  property :updated_at
+# class ExtendedIceLolly < IceLolly
+#  property :extended_property
+# end
 
-  attr_reader :saved
+describe 'Neo4j::ActiveNode' do
+  before(:each) do
+    clear_model_memory_caches
+    delete_db
 
-  index :flavour
+    stub_active_node_class('IceLolly') do
+      property :flavour
+      property :name
+      property :a
+      property :b
+      property :required_on_create
+      property :required_on_update
+      property :created
+      property :start, type: Time
 
-  validates :flavour, presence: true
-  validates :required_on_create, presence: true, on: :create
-  validates :required_on_update, presence: true, on: :update
+      property :created_at
+      property :updated_at
 
-  before_create :timestamp
-  after_create :mark_saved
+      attr_reader :saved
 
-  protected
+      index :flavour
 
-  def timestamp
-    self.created = 'yep'
-  end
+      validates :flavour, presence: true
+      validates :required_on_create, presence: true, on: :create
+      validates :required_on_update, presence: true, on: :update
+
+      before_create :timestamp
+      after_create :mark_saved
+
+      protected
+
+      def timestamp
+        self.created = 'yep'
+      end
 
-  def mark_saved
-    @saved = true
+      def mark_saved
+        @saved = true
+      end
+    end
+
+    stub_active_node_class('IceCream') do
+      property :flavour, index: :exact
+      # has_n(:ingredients).to(Ingredient)
+      validates_presence_of :flavour
+    end
   end
-end
 
-# class ExtendedIceLolly < IceLolly
-#  property :extended_property
-# end
+  subject { IceLolly.new }
 
-describe IceLolly, type: :integration do
   context 'when valid' do
     before :each do
       subject.flavour = 'vanilla'
@@ -119,46 +132,6 @@ def mark_saved
     it_should_behave_like 'uncreatable model'
     it_should_behave_like 'non-updatable model'
   end
-end
-
-
-# describe ExtendedIceLolly, :type => :integration do
-#
-#  it "should have inherited all the properties" do
-#    subject.attribute_names.should include("flavour")
-#  end
-#
-#  it { should respond_to(:flavour) }
-#
-#  context "when valid" do
-#    subject { ExtendedIceLolly.new(:flavour => "vanilla", :required_on_create => "true", :required_on_update => "true") }
-#
-#    it_should_behave_like "new model"
-#    it_should_behave_like "loadable model"
-#    it_should_behave_like "saveable model"
-#    it_should_behave_like "creatable model"
-#    it_should_behave_like "destroyable model"
-#    it_should_behave_like "updatable model"
-#
-#    context "after being saved" do
-#      before { subject.save }
-#
-#      it { should eq(subject.class.find(flavour: 'vanilla')) }
-#    end
-#  end
-# end
-#
-
-IceCream = UniqueClass.create do
-  include Neo4j::ActiveNode
-  property :flavour, index: :exact
-  # has_n(:ingredients).to(Ingredient)
-  validates_presence_of :flavour
-end
-
-describe Neo4j::ActiveNode do
-  # before(:each) { @tx = Neo4j::Transaction.new }
-  # after(:each) { @tx.close }
 
   describe 'validations' do
     it 'does not have any errors if its valid' do
@@ -176,25 +149,26 @@ def mark_saved
 
 
   describe 'callbacks' do
-    class Company
-      attr_accessor :update_called, :save_called, :destroy_called, :validation_called
-      include Neo4j::ActiveNode
-      property :name
+    before(:each) do
+      stub_active_node_class('Company') do
+        attr_accessor :update_called, :save_called, :destroy_called, :validation_called
+        property :name
 
-      before_save do
-        @save_called = true
-      end
+        before_save do
+          @save_called = true
+        end
 
-      before_update do
-        @update_called = true
-      end
+        before_update do
+          @update_called = true
+        end
 
-      before_destroy do
-        @destroy_called = true
-      end
+        before_destroy do
+          @destroy_called = true
+        end
 
-      before_validation do
-        @validation_called = true
+        before_validation do
+          @validation_called = true
+        end
       end
     end
 

spec/e2e/active_rel_spec.rb

@@ -1,29 +1,32 @@
 require 'spec_helper'
 
 describe 'ActiveRel' do
-  class ToClass; end
-  class MyRelClass; end
+  before(:each) do
+    clear_model_memory_caches
+    delete_db
 
-  class FromClass
-    include Neo4j::ActiveNode
-    has_many :out, :others, model_class: ToClass, rel_class: MyRelClass
-  end
+    stub_named_class('ToClass')
 
-  class ToClass
-    include Neo4j::ActiveNode
-    has_many :in, :others, model_class: FromClass, rel_class: MyRelClass
-    has_many :in, :string_others, model_class: 'FromClass', rel_class: 'MyRelClass'
-  end
+    stub_named_class('MyRelClass')
+
+    stub_active_node_class('FromClass') do
+      has_many :out, :others, model_class: 'ToClass', rel_class: 'MyRelClass'
+    end
+
+    stub_active_node_class('ToClass') do
+      has_many :in, :others, model_class: 'FromClass', rel_class: 'MyRelClass'
+      has_many :in, :string_others, model_class: 'FromClass', rel_class: 'MyRelClass'
+    end
 
-  class MyRelClass
-    include Neo4j::ActiveRel
-    from_class FromClass
-    to_class ToClass
-    type 'rel_class_type'
+    stub_active_rel_class('MyRelClass') do
+      from_class 'FromClass'
+      to_class 'ToClass'
+      type 'rel_class_type'
 
-    property :score
-    property :links
-    serialize :links
+      property :score
+      property :links
+      serialize :links
+    end
   end
 
   let(:from_node) { FromClass.create }
@@ -67,13 +70,14 @@ class MyRelClass
   end
 
   describe 'types' do
-    class AutomaticRelType
-      include Neo4j::ActiveRel
-      from_class FromClass
-      to_class ToClass
-    end
+    before(:each) do
+      stub_active_rel_class('AutomaticRelType') do
+        from_class 'FromClass'
+        to_class 'ToClass'
+      end
 
-    class InheritedRelClass < AutomaticRelType; end
+      stub_named_class('InheritedRelClass', AutomaticRelType)
+    end
 
     it 'allows omission of `type`' do
       expect(AutomaticRelType._type).to eq 'AUTOMATIC_REL_TYPE'