nobrainer 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fa1301301888d07f8c607cfd1102555aad40a92
-  data.tar.gz: f05a189ae40c4e6b1f2d420dd84a4928a6f65203
+  metadata.gz: f9f0fb2d3cb21fba6fad94403706e6f5274f72f4
+  data.tar.gz: 74bfea6252ccc4eee6e67c003ed3facc7bbffe69
 SHA512:
-  metadata.gz: 1bfa4718cb043f4847f972d46b2728c772475b8d07683a591d38d6ec039d06c09508d2df855791e935bbaa85f5d11780a367a383e9ebae0c19dce278dab7c83d
-  data.tar.gz: 4584d38e6646c426672cea00c0f9aa58f05a6df4778586ae2d699662d927984b1f32ba3b87ebc3b787d4ad9181b19e9e4ecf3f4cfafdbc116f85920566534ed0
+  metadata.gz: 8da93f62774128bc6bfc485c356fd1e27b68ae0f3c5ccd0e9e81545210856a9282dccf0936369d3b92da90904e598d1c16d264a36b82e050e328ad02bda2758c
+  data.tar.gz: c8f6e9c112d89df7062d2ffde33952e688d6c7c47becde0d3391949abac41851149a3d3625025908f00429565152157366bf90d1147bf4d0e705e68e57b1c31a

data/LICENSE

@@ -0,0 +1,169 @@
+Copyright (c) Nicolas Viennot
+
+NoBrainer is licensed under the terms of the LGPLv3 license.
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/lib/no_brainer/criteria/after_find.rb

@@ -0,0 +1,24 @@
+module NoBrainer::Criteria::AfterFind
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_after_find }
+
+  def after_find(b=nil, &block)
+    chain { |criteria| criteria._after_find = [b || block] }
+  end
+
+  def merge!(criteria, options={})
+    super
+    if criteria._after_find.present?
+      self._after_find = (self._after_find || []) + criteria._after_find
+    end
+    self
+  end
+
+  def instantiate_doc(attrs)
+    super.tap do |doc|
+      self._after_find.to_a.each { |block| block.call(doc) }
+      doc.run_callbacks(:find) if doc.is_a?(NoBrainer::Document)
+    end
+  end
+end

data/lib/no_brainer/criteria/{termination/cache.rb → cache.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Cache
+module NoBrainer::Criteria::Cache
   extend ActiveSupport::Concern
 
   included { attr_accessor :_with_cache }

data/lib/no_brainer/criteria/{chainable/core.rb → core.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Chainable::Core
+module NoBrainer::Criteria::Core
   extend ActiveSupport::Concern
 
   included { attr_accessor :init_options }

data/lib/no_brainer/criteria/{termination/count.rb → count.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Count
+module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count

data/lib/no_brainer/criteria/{termination/delete.rb → delete.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Delete
+module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all

data/lib/no_brainer/criteria/{termination/enumerable.rb → enumerable.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Enumerable
+module NoBrainer::Criteria::Enumerable
   extend ActiveSupport::Concern
 
   def each(options={}, &block)

data/lib/no_brainer/criteria/{termination/first.rb → first.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::First
+module NoBrainer::Criteria::First
   extend ActiveSupport::Concern
 
   def first

data/lib/no_brainer/criteria/{termination/inc.rb → inc.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Inc
+module NoBrainer::Criteria::Inc
   extend ActiveSupport::Concern
 
   def inc_all(field, value=1)

data/lib/no_brainer/criteria/{chainable/limit.rb → limit.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Chainable::Limit
+module NoBrainer::Criteria::Limit
   # TODO Test these guys
   extend ActiveSupport::Concern
 

data/lib/no_brainer/criteria/{chainable/order_by.rb → order_by.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Chainable::OrderBy
+module NoBrainer::Criteria::OrderBy
   extend ActiveSupport::Concern
 
   included { attr_accessor :order, :_reverse_order }

data/lib/no_brainer/criteria/preload.rb

@@ -0,0 +1,55 @@
+module NoBrainer::Criteria::Preload
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_preloads }
+
+  def initialize(options={})
+    super
+    self._preloads = []
+  end
+
+  def preload(*values)
+    chain(:keep_cache => true) { |criteria| criteria._preloads = values }
+  end
+
+  def includes(*values)
+    NoBrainer.logger.warn "[NoBrainer] includes() is deprecated and will be removed, use preload() instead."
+    preload(*values)
+  end
+
+  def merge!(criteria, options={})
+    super
+    self._preloads = self._preloads + criteria._preloads
+
+    # XXX Not pretty hack
+    if criteria._preloads.present? && cached?
+      perform_preloads(@cache)
+    end
+  end
+
+  def each(options={}, &block)
+    return super unless should_preloads? && !options[:no_preloading] && block
+
+    docs = []
+    super(options.merge(:no_preloading => true)) { |doc| docs << doc }
+    perform_preloads(docs)
+    docs.each(&block)
+    self
+  end
+
+  private
+
+  def should_preloads?
+    self._preloads.present? && !raw?
+  end
+
+  def get_one(criteria)
+    super.tap { |doc| perform_preloads([doc]) }
+  end
+
+  def perform_preloads(docs)
+    if should_preloads? && docs.present?
+      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, self._preloads)
+    end
+  end
+end

data/lib/no_brainer/criteria/raw.rb

@@ -0,0 +1,25 @@
+module NoBrainer::Criteria::Raw
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_raw }
+
+  def raw
+    chain { |criteria| criteria._raw = true }
+  end
+
+  def merge!(criteria, options={})
+    super
+    self._raw = criteria._raw unless criteria._raw.nil?
+    self
+  end
+
+  private
+
+  def raw?
+    !!_raw
+  end
+
+  def instantiate_doc(attrs)
+    raw? ? attrs : klass.new_from_db(attrs)
+  end
+end

data/lib/no_brainer/criteria/{chainable/scope.rb → scope.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Chainable::Scope
+module NoBrainer::Criteria::Scope
   extend ActiveSupport::Concern
 
   included { attr_accessor :use_default_scope }

data/lib/no_brainer/criteria/{termination/update.rb → update.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Termination::Update
+module NoBrainer::Criteria::Update
   extend ActiveSupport::Concern
 
   def update_all(attrs={}, &block)

data/lib/no_brainer/criteria/{chainable/where.rb → where.rb}

@@ -1,4 +1,4 @@
-module NoBrainer::Criteria::Chainable::Where
+module NoBrainer::Criteria::Where
   extend ActiveSupport::Concern
 
   included { attr_accessor :where_ast, :with_index_name }
@@ -54,19 +54,32 @@ module NoBrainer::Criteria::Chainable::Where
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value)
+  class BinaryOperator < Struct.new(:key, :op, :value, :criteria)
     def simplify
-      # TODO Simplify the in uniq
-      self
+      case op
+      when :in then
+        case value
+        when Range then BinaryOperator.new(key, :between, (cast(value.min)..cast(value.max)), criteria)
+        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast)).uniq, criteria)
+        else raise ArgumentError.new ":in takes an array/range, not #{value}"
+        end
+      else BinaryOperator.new(key, op, cast(value), criteria)
+      end
     end
 
     def to_rql(doc)
       case op
       when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
-      when :in then value.map { |v| doc[key].eq(v) }.reduce { |a,b| a | b }
+      when :in then RethinkDB::RQL.new.expr(value).contains(doc[key])
       else doc[key].__send__(op, value)
       end
     end
+
+    private
+
+    def cast(value)
+      criteria.klass.cast_value_for(key, value)
+    end
   end
 
   class UnaryOperator < Struct.new(:op, :value)
@@ -110,27 +123,30 @@ module NoBrainer::Criteria::Chainable::Where
     when :and then MultiOperator.new(:and, value.map { |v| parse_clause(v) })
     when :or  then MultiOperator.new(:or,  value.map { |v| parse_clause(v) })
     when :not then UnaryOperator.new(:not, parse_clause(value))
-    when String, Symbol then parse_clause_stub(key.to_sym.eq, value)
+    when String, Symbol then parse_clause_stub_eq(key, value)
     when NoBrainer::DecoratedSymbol then
       case key.modifier
       when :ne then parse_clause(:not => { key.symbol => value })
-      when :eq then
-        case value
-        when Range  then BinaryOperator.new(key.symbol, :between, value)
-        when Regexp then BinaryOperator.new(key.symbol, :match, value.inspect[1..-2])
-        else BinaryOperator.new(key.symbol, key.modifier, value)
-        end
-      else BinaryOperator.new(key.symbol, key.modifier, value)
+      when :eq then parse_clause_stub_eq(key.symbol, value)
+      else BinaryOperator.new(key.symbol, key.modifier, value, self)
       end
     else raise "Invalid key: #{key}"
     end
   end
 
+  def parse_clause_stub_eq(key, value)
+    case value
+    when Range  then BinaryOperator.new(key, :between, value, self)
+    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self)
+    else BinaryOperator.new(key, :eq, value, self)
+    end
+  end
+
   def without_index?
     self.with_index_name == false
   end
 
-  class IndexFinder < Struct.new(:criteria, :index_name, :indexed_values, :ast)
+  class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc, :ast)
     def initialize(*args)
       super
       find_index
@@ -143,9 +159,7 @@ module NoBrainer::Criteria::Chainable::Where
     private
 
     def get_candidate_clauses(*types)
-      Hash[criteria.where_ast.clauses
-        .select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
-        .map { |c| [c.key, c] }]
+      criteria.where_ast.clauses.select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
     end
 
     def get_usable_indexes(*types)
@@ -156,19 +170,24 @@ module NoBrainer::Criteria::Chainable::Where
     end
 
     def find_index_canonical
-      clauses = get_candidate_clauses(:eq, :in)
+      clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
       return unless clauses.present?
 
       if index_name = (get_usable_indexes.keys & clauses.keys).first
         clause = clauses[index_name]
         self.index_name = index_name
-        self.indexed_values = clause.op == :in ? clause.value : [clause.value]
         self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [clause])
+        self.rql_proc = case clause.op
+          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index_name) }
+          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index_name) }
+          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index_name,
+                                                  :left_bound => :closed, :right_bound => :closed) }
+        end
       end
     end
 
     def find_index_compound
-      clauses = get_candidate_clauses(:eq)
+      clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
       return unless clauses.present?
 
       index_name, index_values = get_usable_indexes(:compound)
@@ -179,14 +198,33 @@ module NoBrainer::Criteria::Chainable::Where
       if index_name
         indexed_clauses = index_values.map { |field| clauses[field] }
         self.index_name = index_name
-        self.indexed_values = [indexed_clauses.map { |c| c.value }]
         self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - indexed_clauses)
+        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index_name) }
+      end
+    end
+
+    def find_index_hidden_between
+      clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
+      return unless clauses.present?
+
+      if index_name = (get_usable_indexes.keys & clauses.keys).first
+        op_clauses = Hash[clauses[index_name].map { |c| [c.op, c] }]
+        left_bound = op_clauses[:gt] || op_clauses[:ge]
+        right_bound = op_clauses[:lt] || op_clauses[:le]
+
+        self.index_name = index_name
+        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [left_bound, right_bound].compact)
+
+        options = {:index => index_name}
+        options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
+        options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
+        self.rql_proc = ->(rql){ rql.between(left_bound.try(:value), right_bound.try(:value), options) }
       end
     end
 
     def find_index
       return if criteria.__send__(:without_index?)
-      find_index_canonical || find_index_compound
+      find_index_canonical || find_index_compound || find_index_hidden_between
       if criteria.with_index_name && !could_find_index?
         raise NoBrainer::Error::CannotUseIndex.new("Cannot use index #{criteria.with_index_name}")
       end
@@ -200,9 +238,7 @@ module NoBrainer::Criteria::Chainable::Where
 
   def compile_rql_pass1
     rql = super
-    if index_finder.could_find_index?
-      rql = rql.get_all(*index_finder.indexed_values, :index => index_finder.index_name)
-    end
+    rql = index_finder.rql_proc.call(rql) if index_finder.could_find_index?
     rql
   end
 

data/lib/no_brainer/criteria.rb

@@ -1,20 +1,8 @@
 require 'rethinkdb'
 
 class NoBrainer::Criteria
-  # The disctinction between Chainable and Termination is purely cosmetic.
-  module Chainable
-    extend NoBrainer::Autoload
-    extend ActiveSupport::Concern
-    autoload_and_include :Core, :Scope, :Raw, :Where, :OrderBy, :Limit
-  end
-
-  module Termination
-    extend NoBrainer::Autoload
-    extend ActiveSupport::Concern
-    autoload_and_include :Count, :Delete, :Enumerable, :First, :EagerLoading,
-                         :Inc, :Update, :Cache
-  end
-
-  include Chainable
-  include Termination
+  extend NoBrainer::Autoload
+  autoload_and_include :Core, :Scope, :Raw, :AfterFind, :Where, :OrderBy, :Limit,
+                       :Count, :Delete, :Enumerable, :First, :Preload, :Inc,
+                       :Update, :Cache
 end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:foreign_key, :class_name, :index]
+    VALID_OPTIONS = [:foreign_key, :class_name, :index, :validates]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -19,7 +19,14 @@ class NoBrainer::Document::Association::BelongsTo
     def hook
       super
 
-      owner_klass.field foreign_key, :index => options[:index]
+      # TODO It would be good to set the type we want to work with, but because
+      # the target class is eager loaded, we are not doing it.
+      # This would have the effect of loading all the models because they
+      # are likely to be related to each other. So we don't know the type
+      # of the primary key of the target.
+      owner_klass.field(foreign_key, :index => options[:index])
+      owner_klass.validates(target_name, options[:validates]) if options[:validates]
+
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
       # TODO test if we are not overstepping on another foreign_key

data/lib/no_brainer/document/association/core.rb

@@ -57,8 +57,8 @@ module NoBrainer::Document::Association::Core
 
   def assert_target_type(value)
     unless value.is_a?(target_klass) || value.nil?
-      msg = "Trying to use a #{value.class} as a #{target_name}"
-      raise NoBrainer::Error::InvalidType.new(msg)
+      options = { :attr_name => target_name, :value => value, :type => target_klass }
+      raise NoBrainer::Error::InvalidType.new(options)
     end
   end
 end

data/lib/no_brainer/document/association/eager_loader.rb

@@ -40,19 +40,19 @@ class NoBrainer::Document::Association::EagerLoader
     association.eager_load(docs, criteria)
   end
 
-  def eager_load(docs, includes)
-    case includes
-    when Hash  then includes.each do |k,v|
+  def eager_load(docs, preloads)
+    case preloads
+    when Hash  then preloads.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
-        nested_includes, v._includes = v._includes, []
-        eager_load(eager_load_association(docs, k, v), nested_includes)
+        nested_preloads, v._preloads = v._preloads, []
+        eager_load(eager_load_association(docs, k, v), nested_preloads)
       else
         eager_load(eager_load_association(docs, k), v)
       end
     end
-    when Array then includes.each { |v| eager_load(docs, v) }
-    else eager_load_association(docs, includes)
+    when Array then preloads.each { |v| eager_load(docs, v) }
+    else eager_load_association(docs, preloads)
     end
     true
   end

data/lib/no_brainer/document/association/has_many.rb

@@ -39,7 +39,7 @@ class NoBrainer::Document::Association::HasMany
 
   def target_criteria
     @target_criteria ||= target_klass.where(foreign_key => owner.id)
-                                     ._after_instantiate(set_inverse_proc)
+                                     .after_find(set_inverse_proc)
   end
 
   def read