nobrainer 0.16.0 → 0.18.1

data/lib/no_brainer/criteria/order_by.rb

@@ -1,16 +1,12 @@
 module NoBrainer::Criteria::OrderBy
   extend ActiveSupport::Concern
 
-  included { attr_accessor :order, :ordering_mode }
-
-  def initialize(options={})
-    super
-    self.order = {}
-  end
+  # The latest order_by() wins
+  included { criteria_option :order_by, :ordering_mode, :merge_with => :set_scalar }
 
   def order_by(*rules, &block)
     # Note: We are relying on the fact that Hashes are ordered (since 1.9)
-    rules = [*rules, block].compact.map do |rule|
+    rules = [*rules, block].flatten.compact.map do |rule|
       case rule
       when Hash then
         bad_rule = rule.values.reject { |v| v.in? [:asc, :desc] }.first
@@ -21,34 +17,20 @@ module NoBrainer::Criteria::OrderBy
       end
     end.reduce({}, :merge)
 
-    chain do |criteria|
-      criteria.order = rules
-      criteria.ordering_mode = :normal
-    end
+    chain(:order_by => rules, :ordering_mode => :normal)
   end
 
   def without_ordering
-    chain { |criteria| criteria.ordering_mode = :disabled }
-  end
-
-  def merge!(criteria, options={})
-    super
-    # The latest order_by() wins
-    self.order = criteria.order if criteria.order.present?
-    self.ordering_mode = criteria.ordering_mode unless criteria.ordering_mode.nil?
-    self
+    chain(:ordering_mode => :disabled)
   end
 
   def reverse_order
-    chain do |criteria|
-      criteria.ordering_mode =
-        case self.ordering_mode
-        when nil       then :reversed
-        when :normal   then :reversed
-        when :reversed then :normal
-        when :disabled then :disabled
-        end
-    end
+    chain(:ordering_mode => case @options[:ordering_mode]
+                            when nil       then :reversed
+                            when :normal   then :reversed
+                            when :reversed then :normal
+                            when :disabled then :disabled
+                            end)
   end
 
   def order_by_indexed?
@@ -62,15 +44,15 @@ module NoBrainer::Criteria::OrderBy
   private
 
   def effective_order
-    self.order.presence || (klass ? {klass.pk_name => :asc} : {})
+    @options[:order_by].presence || (model ? {model.pk_name => :asc} : {})
   end
 
   def reverse_order?
-    self.ordering_mode == :reversed
+    @options[:ordering_mode] == :reversed
   end
 
   def should_order?
-    self.ordering_mode != :disabled
+    @options[:ordering_mode] != :disabled
   end
 
   class IndexFinder < Struct.new(:criteria, :index_name, :rql_proc)
@@ -83,15 +65,15 @@ module NoBrainer::Criteria::OrderBy
     end
 
     def first_key_indexable?
-      (first_key.is_a?(Symbol) || first_key.is_a?(String)) && criteria.klass.has_index?(first_key)
+      (first_key.is_a?(Symbol) || first_key.is_a?(String)) && criteria.model.has_index?(first_key)
     end
 
     def find_index
       return if criteria.without_index?
       return unless first_key_indexable?
 
-      if criteria.with_index_name && criteria.with_index_name != true
-        return unless first_key.to_s == criteria.with_index_name.to_s
+      if criteria.options[:use_index] && criteria.options[:use_index] != true
+        return unless first_key.to_s == criteria.options[:use_index].to_s
       end
 
       # We need make sure that the where index finder has been invoked, it has priority.
@@ -116,9 +98,9 @@ module NoBrainer::Criteria::OrderBy
 
     rql_rules = _effective_order.map do |k,v|
       if order_by_index_finder.index_name == k
-        k = klass.lookup_index_alias(k)
+        k = model.lookup_index_alias(k)
       else
-        k = klass.lookup_field_alias(k)
+        k = model.lookup_field_alias(k)
       end
 
       case v
@@ -127,14 +109,13 @@ module NoBrainer::Criteria::OrderBy
       end
     end
 
-    # We can only apply an index order_by on a table() term.
-    # We are going to try to go so and if we cannot, we'll simply apply
-    # the ordering in pass2, which will happen after a potential filter().
+    # We can only apply an indexed order_by on a table() RQL term.
+    # If we can, great. Otherwise, the ordering is applied in pass2, which will
+    # happen after a potential filter(), which is better for perfs.
     if order_by_index_finder.could_find_index?
       options = { :index => rql_rules.shift }
       rql = rql.order_by(*rql_rules, options)
     else
-      # Stashing @rql_rules for pass2
       @rql_rules_pass2 = rql_rules
     end
 

data/lib/no_brainer/criteria/pluck.rb

@@ -1,7 +1,8 @@
 module NoBrainer::Criteria::Pluck
   extend ActiveSupport::Concern
 
-  included { attr_accessor :missing_attributes }
+  included { criteria_option :missing_attributes, :merge_with =>
+               NoBrainer::Criteria::Pluck.method(:merge_missing_attributes) }
 
   def pluck(*attrs)
     _missing_attributes_criteria(:pluck, attrs)
@@ -16,24 +17,19 @@ module NoBrainer::Criteria::Pluck
   end
 
   def without_plucking
-    chain { |criteria| criteria.missing_attributes = :remove }
+    chain(:missing_attributes => :remove)
   end
 
-  def merge!(criteria, options={})
-    return super unless criteria.missing_attributes
+  def self.merge_missing_attributes(a, b)
+    return nil if b.nil? || b == :remove
 
-    if criteria.missing_attributes == :remove
-      self.missing_attributes = nil
-    else
-      self.missing_attributes ||= {}
-      criteria.missing_attributes.each do |type, attrs|
-        old_attrs = self.missing_attributes[type] || {}.with_indifferent_access
-        new_attrs = old_attrs.deep_merge(attrs)
-        self.missing_attributes[type] = new_attrs
-      end
+    a = a ? a.dup : {}
+    b.each do |type, attrs|
+      old_attrs = a[type] || {}.with_indifferent_access
+      new_attrs = old_attrs.deep_merge(attrs)
+      a[type] = new_attrs
     end
-
-    self
+    a
   end
 
   private
@@ -41,16 +37,14 @@ module NoBrainer::Criteria::Pluck
   def _missing_attributes_criteria(type, args)
     raise ArgumentError if args.size.zero?
     args = [Hash[args.flatten.map { |k| [k, true] }]] unless args.size == 1 && args.first.is_a?(Hash)
-    chain { |criteria| criteria.missing_attributes = {type => args.first} }
-
+    chain(:missing_attributes => {type => args.first})
   end
 
   def effective_missing_attributes
-    return nil if self.missing_attributes.nil?
+    return nil if @options[:missing_attributes].nil?
     @effective_missing_attributes ||= begin
       # pluck gets priority
-
-      missing_attributes = Hash[self.missing_attributes.map do |type, attrs|
+      missing_attributes = Hash[@options[:missing_attributes].map do |type, attrs|
         attrs = attrs.select { |k,v| v } # TODO recursive
         attrs.empty? ? nil : [type, attrs]
       end.compact]
@@ -65,16 +59,16 @@ module NoBrainer::Criteria::Pluck
   end
 
   def _instantiate_model(attrs, options={})
-    return super if missing_attributes.nil?
+    return super if @options[:missing_attributes].nil?
     super(attrs, options.merge(:missing_attributes => effective_missing_attributes,
-                               :lazy_fetch => missing_attributes[:lazy_fetch]))
+                               :lazy_fetch => @options[:missing_attributes][:lazy_fetch]))
   end
 
   def compile_rql_pass2
     rql = super
     if effective_missing_attributes
       type, attrs = effective_missing_attributes.first
-      rql = rql.__send__(type, klass.with_fields_aliased(attrs))
+      rql = rql.__send__(type, model.with_fields_aliased(attrs))
     end
     rql
   end

data/lib/no_brainer/criteria/preload.rb

@@ -1,24 +1,18 @@
 module NoBrainer::Criteria::Preload
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_preloads }
-
-  def initialize(options={})
-    super
-    self._preloads = []
-  end
+  included { criteria_option :preload, :merge_with => :append_array }
 
   def preload(*values)
-    chain(:keep_cache => true) { |criteria| criteria._preloads = values }
+    chain({:preload => values}, :copy_cache_from => self)
   end
 
   def merge!(criteria, options={})
-    super
-    self._preloads = self._preloads + criteria._preloads
-
-    # XXX Not pretty hack
-    if criteria._preloads.present? && cached?
-      perform_preloads(@cache)
+    super.tap do
+      # XXX Not pretty hack
+      if criteria.options[:preload].present? && criteria.cached?
+        perform_preloads(@cache)
+      end
     end
   end
 
@@ -35,7 +29,7 @@ module NoBrainer::Criteria::Preload
   private
 
   def should_preloads?
-    self._preloads.present? && !raw?
+    @options[:preload].present? && !raw?
   end
 
   def get_one(criteria)
@@ -44,7 +38,7 @@ module NoBrainer::Criteria::Preload
 
   def perform_preloads(docs)
     if should_preloads? && docs.present?
-      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, self._preloads)
+      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, @options[:preload])
     end
   end
 end

data/lib/no_brainer/criteria/raw.rb

@@ -1,20 +1,14 @@
 module NoBrainer::Criteria::Raw
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_raw }
+  included { criteria_option :raw, :merge_with => :set_scalar }
 
-  def raw
-    chain { |criteria| criteria._raw = true }
-  end
-
-  def merge!(criteria, options={})
-    super
-    self._raw = criteria._raw unless criteria._raw.nil?
-    self
+  def raw(value = true)
+    chain(:raw => value)
   end
 
   def raw?
-    !!finalized_criteria._raw
+    !!finalized_criteria.options[:raw]
   end
 
   private
@@ -28,6 +22,6 @@ module NoBrainer::Criteria::Raw
   end
 
   def _instantiate_model(attrs, options={})
-    klass.new_from_db(attrs, options)
+    model.new_from_db(attrs, options)
   end
 end

data/lib/no_brainer/criteria/scope.rb

@@ -1,29 +1,23 @@
 module NoBrainer::Criteria::Scope
   extend ActiveSupport::Concern
 
-  included { attr_accessor :use_default_scope }
+  included { criteria_option :use_default_scope, :merge_with => :set_scalar }
 
   def scoped
-    chain { |criteria| criteria.use_default_scope = true }
+    chain(:use_default_scope => true)
   end
 
   def unscoped
-    chain { |criteria| criteria.use_default_scope = false }
-  end
-
-  def merge!(criteria, options={})
-    super
-    self.use_default_scope = criteria.use_default_scope unless criteria.use_default_scope.nil?
-    self
+    chain(:use_default_scope => false)
   end
 
   def respond_to?(name, include_private = false)
-    super || self.klass.respond_to?(name)
+    super || self.model.respond_to?(name)
   end
 
   def method_missing(name, *args, &block)
-    return super unless self.klass.respond_to?(name)
-    criteria = self.klass.method(name).call(*args, &block)
+    return super unless self.model.respond_to?(name)
+    criteria = self.model.method(name).call(*args, &block)
     raise "#{name} did not return a criteria" unless criteria.is_a?(NoBrainer::Criteria)
     merge(criteria)
   end
@@ -31,13 +25,13 @@ module NoBrainer::Criteria::Scope
   private
 
   def should_apply_default_scope?
-    klass.default_scope_proc && use_default_scope != false
+    model.default_scope_proc && @options[:use_default_scope] != false
   end
 
   def _apply_default_scope
     return unless should_apply_default_scope?
-    criteria = klass.default_scope_proc.call
-    raise "Mixing model issue. Contact developer." if [criteria.klass, self.klass].compact.uniq.size == 2
+    criteria = model.default_scope_proc.call
+    raise "Mixing model issue. Contact developer." if [criteria.model, self.model].compact.uniq.size == 2
     criteria.merge(self)
   end
 

data/lib/no_brainer/criteria/update.rb

@@ -3,17 +3,17 @@ module NoBrainer::Criteria::Update
 
   def update_all(*a, &b)
     prepare_args_for_update!(a)
-    run(without_ordering.without_plucking.to_rql.update(*a, &b))
+    run { without_ordering.without_plucking.to_rql.update(*a, &b) }
   end
 
   def replace_all(*a, &b)
     prepare_args_for_update!(a)
-    run(without_ordering.without_plucking.to_rql.replace(*a, &b))
+    run { without_ordering.without_plucking.to_rql.replace(*a, &b) }
   end
 
   private
 
   def prepare_args_for_update!(a)
-    a[0] = klass.persistable_attributes(a[0]) if !a.empty? && a.first.is_a?(Hash)
+    a[0] = model.persistable_attributes(a[0]) if !a.empty? && a.first.is_a?(Hash)
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -1,35 +1,20 @@
 module NoBrainer::Criteria::Where
   extend ActiveSupport::Concern
 
-  included { attr_accessor :where_ast, :with_index_name }
-
-  def initialize(options={})
-    super
+  included do
+    criteria_option :where_ast, :merge_with => NoBrainer::Criteria::Where.method(:merge_where_ast)
   end
 
   def where(*args, &block)
-    chain { |criteria| criteria.where_ast = parse_clause([*args, block].compact) }
+    chain(:where_ast => parse_clause([*args, block].compact))
   end
 
-  def merge!(criteria, options={})
-    super
-
-    if criteria.where_ast
-      if self.where_ast
-        self.where_ast = MultiOperator.new(:and, [self.where_ast, criteria.where_ast])
-      else
-        self.where_ast = criteria.where_ast
-      end
-      self.where_ast = self.where_ast.simplify
-      raise unless criteria.where_ast.is_a?(MultiOperator)
-    end
-
-    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
-    self
+  def self.merge_where_ast(a, b)
+    (a ? MultiOperator.new(:and, [a, b]) : b).simplify
   end
 
   def where_present?
-    finalized_criteria.where_ast.try(:clauses).present?
+    finalized_criteria.options[:where_ast].try(:clauses).present?
   end
 
   def where_indexed?
@@ -134,9 +119,9 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
-        target_klass = association.target_klass
-        opts = { :attr_name => key, :value => value, :type => target_klass}
-        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_klass)
+        target_model = association.target_model
+        opts = { :attr_name => key, :value => value, :type => target_model}
+        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
         value.pk_value
       else
         model.cast_user_to_db_for(key, value)
@@ -200,7 +185,7 @@ module NoBrainer::Criteria::Where
       when :nin then parse_clause(:not => { key.symbol.in => value })
       when :ne  then parse_clause(:not => { key.symbol.eq => value })
       when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else BinaryOperator.new(key.symbol, key.modifier, value, self.klass)
+      else BinaryOperator.new(key.symbol, key.modifier, value, self.model)
       end
     else raise "Invalid key: #{key}"
     end
@@ -208,9 +193,9 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub_eq(key, value)
     case value
-    when Range  then BinaryOperator.new(key, :between, value, self.klass)
-    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.klass)
-    else BinaryOperator.new(key, :eq, value, self.klass)
+    when Range  then BinaryOperator.new(key, :between, value, self.model)
+    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.model)
+    else BinaryOperator.new(key, :eq, value, self.model)
     end
   end
 
@@ -230,10 +215,10 @@ module NoBrainer::Criteria::Where
     def get_usable_indexes(*types)
       @usable_indexes = {}
       @usable_indexes[types] ||= begin
-        indexes = criteria.klass.indexes
-        indexes = indexes.select { |k,v| types.include?(v[:kind]) } if types.present?
-        if criteria.with_index_name && criteria.with_index_name != true
-          indexes = indexes.select { |k,v| k == criteria.with_index_name.to_sym }
+        indexes = criteria.model.indexes.values
+        indexes = indexes.select { |i| types.include?(i.kind) } if types.present?
+        if criteria.options[:use_index] && criteria.options[:use_index] != true
+          indexes = indexes.select { |i| i.name == criteria.options[:use_index].to_sym }
         end
         indexes
       end
@@ -248,16 +233,15 @@ module NoBrainer::Criteria::Where
       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]
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
+        clause = clauses[index.name]
+        self.index_name = index.name
         self.ast = remove_from_ast([clause])
         self.index_type = clause.op == :between ? :between : :get_all
         self.rql_proc = case clause.op
-          when :eq      then ->(rql){ rql.get_all(clause.value, :index => aliased_index) }
-          when :in      then ->(rql){ rql.get_all(*clause.value, :index => aliased_index) }
-          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => aliased_index,
+          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index.aliased_name) }
+          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index.aliased_name) }
+          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index.aliased_name,
                                                   :left_bound => :closed, :right_bound => :closed) }
         end
       end
@@ -267,18 +251,12 @@ module NoBrainer::Criteria::Where
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
       return unless clauses.present?
 
-      index_name, index_values = get_usable_indexes(:compound)
-        .map    { |name, option| [name, option[:what]] }
-        .select { |name, values| values & clauses.keys == values }
-        .first
-
-      if index_name
-        indexed_clauses = index_values.map { |field| clauses[field] }
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+      if index = get_usable_indexes(:compound).select { |i| i.what & clauses.keys == i.what }.first
+        indexed_clauses = index.what.map { |field| clauses[field] }
+        self.index_name = index.name
         self.ast = remove_from_ast(indexed_clauses)
         self.index_type = :get_all
-        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => aliased_index) }
+        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index.aliased_name) }
       end
     end
 
@@ -286,17 +264,16 @@ module NoBrainer::Criteria::Where
       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] }]
+      if index = get_usable_indexes.select { |i| clauses[i.name] }.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]
 
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+        self.index_name = index.name
         self.ast = remove_from_ast([left_bound, right_bound].compact)
 
         options = {}
-        options[:index] = aliased_index
+        options[:index] = index.aliased_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.index_type = :between
@@ -335,7 +312,7 @@ module NoBrainer::Criteria::Where
 
   def where_index_finder
     return finalized_criteria.__send__(:where_index_finder) unless finalized?
-    @where_index_finder ||= IndexFinder.new(self, where_ast).tap { |index_finder| index_finder.find_index }
+    @where_index_finder ||= IndexFinder.new(self, @options[:where_ast]).tap { |index_finder| index_finder.find_index }
   end
 
   def compile_rql_pass1
@@ -346,7 +323,7 @@ module NoBrainer::Criteria::Where
 
   def compile_rql_pass2
     rql = super
-    ast = where_index_finder.could_find_index? ? where_index_finder.ast : self.where_ast
+    ast = where_index_finder.could_find_index? ? where_index_finder.ast : @options[:where_ast]
     rql = rql.filter { |doc| ast.to_rql(doc) } if ast.try(:clauses).present?
     rql
   end

data/lib/no_brainer/criteria.rb

@@ -4,5 +4,5 @@ class NoBrainer::Criteria
   extend NoBrainer::Autoload
   autoload_and_include :Core, :Raw, :AfterFind, :Where, :OrderBy, :Limit,
                        :Pluck, :Count, :Delete, :Enumerable, :First, :Aggregate,
-                       :Preload, :Update, :Cache, :Index, :Scope
+                       :Preload, :Update, :Cache, :Index, :Extend, :Scope
 end

data/lib/no_brainer/document/aliases.rb

@@ -48,7 +48,7 @@ module NoBrainer::Document::Aliases
       end
     end
 
-    def persistable_key(k)
+    def persistable_key(k, options={})
       lookup_field_alias(super)
     end
   end

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

@@ -13,10 +13,10 @@ class NoBrainer::Document::Association::BelongsTo
 
     def primary_key
       # TODO test :primary_key
-      options[:primary_key].try(:to_sym) || target_klass.pk_name
+      options[:primary_key].try(:to_sym) || target_model.pk_name
     end
 
-    def target_klass
+    def target_model
       # TODO test :class_name
       (options[:class_name] || target_name.to_s.camelize).constantize
     end
@@ -29,9 +29,9 @@ class NoBrainer::Document::Association::BelongsTo
       # 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, :as => options[:foreign_key_as], :index => options[:index])
-      owner_klass.validates(target_name, { :presence => true }) if options[:required]
-      owner_klass.validates(target_name, options[:validates]) if options[:validates]
+      owner_model.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
+      owner_model.validates(target_name, { :presence => true }) if options[:required]
+      owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
       add_callback_for(:after_validation)
@@ -54,7 +54,7 @@ class NoBrainer::Document::Association::BelongsTo
     return target if loaded?
 
     if fk = owner.read_attribute(foreign_key)
-      preload(target_klass.unscoped.where(primary_key => fk).first)
+      preload(target_model.unscoped.where(primary_key => fk).first)
     end
   end
 

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

@@ -4,25 +4,25 @@ module NoBrainer::Document::Association::Core
   module Metadata
     extend ActiveSupport::Concern
 
-    attr_accessor :owner_klass, :target_name, :options
+    attr_accessor :owner_model, :target_name, :options
 
-    def initialize(owner_klass, target_name, options={})
-      @owner_klass = owner_klass
+    def initialize(owner_model, target_name, options={})
+      @owner_model = owner_model
       @target_name = target_name
       @options = options
     end
 
-    def association_klass
-      @association_klass ||= self.class.name.deconstantize.constantize
+    def association_model
+      @association_model ||= self.class.name.deconstantize.constantize
     end
 
     def new(owner)
-      association_klass.new(self, owner)
+      association_model.new(self, owner)
     end
 
     def delegate(method_name, target, options={})
       metadata = self
-      owner_klass.inject_in_layer :associations do
+      owner_model.inject_in_layer :associations do
         define_method(method_name) do |*args, &block|
           super(*args, &block) if options[:call_super]
           associations[metadata].__send__(target, *args, &block)
@@ -40,7 +40,7 @@ module NoBrainer::Document::Association::Core
       instance_eval <<-RUBY, __FILE__, __LINE__+1
         if !@added_#{what}
           metadata = self
-          owner_klass.#{what} { associations[metadata].#{what}_callback }
+          owner_model.#{what} { associations[metadata].#{what}_callback }
           @added_#{what} = true
         end
       RUBY
@@ -49,15 +49,15 @@ module NoBrainer::Document::Association::Core
 
   included { attr_accessor :metadata, :owner }
 
-  delegate :primary_key, :foreign_key, :target_name, :target_klass, :to => :metadata
+  delegate :primary_key, :foreign_key, :target_name, :target_model, :to => :metadata
 
   def initialize(metadata, owner)
     @metadata, @owner = metadata, owner
   end
 
   def assert_target_type(value)
-    unless value.is_a?(target_klass) || value.nil?
-      options = { :attr_name => target_name, :value => value, :type => target_klass }
+    unless value.is_a?(target_model) || value.nil?
+      options = { :attr_name => target_name, :value => value, :type => target_model }
       raise NoBrainer::Error::InvalidType.new(options)
     end
   end