nobrainer 0.18.0 → 0.19.0

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

data/lib/no_brainer/criteria/scope.rb

@@ -1,20 +1,14 @@
 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)
@@ -31,7 +25,7 @@ module NoBrainer::Criteria::Scope
   private
 
   def should_apply_default_scope?
-    model.default_scope_proc && use_default_scope != false
+    model.default_scope_proc && @options[:use_default_scope] != false
   end
 
   def _apply_default_scope

data/lib/no_brainer/criteria/where.rb

@@ -1,47 +1,41 @@
 module NoBrainer::Criteria::Where
-  extend ActiveSupport::Concern
+  NON_CHAINABLE_OPERATORS = %w(in nin eq ne not gt ge gte lt le lte defined).map(&:to_sym)
+  CHAINABLE_OPERATORS = %w(any all).map(&:to_sym)
+  OPERATORS = CHAINABLE_OPERATORS + NON_CHAINABLE_OPERATORS
+
+  require 'symbol_decoration'
+  Symbol::Decoration.register(*NON_CHAINABLE_OPERATORS)
+  Symbol::Decoration.register(*CHAINABLE_OPERATORS, :chainable => true)
 
-  included { attr_accessor :where_ast, :with_index_name }
+  extend ActiveSupport::Concern
 
-  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?
-    !!where_index_name
+    where_index_name.present?
   end
 
   def where_index_name
-    where_index_finder.index_name
+    index = where_index_finder.strategy.try(:index)
+    index.is_a?(Array) ? index.map(&:name) : index.try(:name)
   end
 
   def where_index_type
-    where_index_finder.index_type
+    where_index_finder.strategy.try(:rql_op)
   end
 
   private
@@ -49,7 +43,7 @@ module NoBrainer::Criteria::Where
   class MultiOperator < Struct.new(:op, :clauses)
     def simplify
       clauses = self.clauses.map(&:simplify)
-      if self.clauses.size == 1 && self.clauses.first.is_a?(self.class)
+      if clauses.size == 1 && clauses.first.is_a?(self.class)
         return clauses.first
       end
 
@@ -57,19 +51,19 @@ module NoBrainer::Criteria::Where
         v.is_a?(self.class) && (v.clauses.size == 1 || v.op == self.op)
       end
       simplified_clauses = other_clauses + same_op_clauses.map(&:clauses).flatten(1)
-      simplified_clauses =  BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
+      simplified_clauses = BinaryOperator.simplify_clauses(op, simplified_clauses.uniq)
       self.class.new(op, simplified_clauses)
     end
 
     def to_rql(doc)
       case op
-      when :and then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a & b }
-      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a | b }
+      when :and then clauses.map { |c| c.to_rql(doc) }.reduce(:&)
+      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce(:|)
       end
     end
   end
 
-  class BinaryOperator < Struct.new(:key, :op, :value, :model, :casted_values)
+  class BinaryOperator < Struct.new(:key, :key_modifier, :op, :value, :model, :casted_values)
     def self.get_candidate_clauses(clauses, *types)
       clauses.select { |c| c.is_a?(self) && types.include?(c.op) }
     end
@@ -78,14 +72,14 @@ module NoBrainer::Criteria::Where
       # This code assumes that simplfy() has already been called on all clauses.
       if op == :or
         eq_clauses = get_candidate_clauses(ast_clauses, :in, :eq)
-        new_clauses = eq_clauses.group_by(&:key).map do |key, clauses|
-          case clauses.size
-          when 1 then clauses.first
-          else
+        new_clauses = eq_clauses.group_by { |c| [c.key, c.key_modifier] }.map do |(key, key_modifier), clauses|
+          if key_modifier.in?([:scalar, :any]) && clauses.size > 1
             values = clauses.map { |c| c.op == :in ? c.value : [c.value] }.flatten(1).uniq
-            BinaryOperator.new(key, :in, values, clauses.first.model, true)
+            [BinaryOperator.new(key, key_modifier, :in, values, clauses.first.model, true)]
+          else
+            clauses
           end
-        end
+        end.flatten(1)
 
         if new_clauses.size != eq_clauses.size
           ast_clauses = ast_clauses - eq_clauses + new_clauses
@@ -96,29 +90,49 @@ module NoBrainer::Criteria::Where
     end
 
     def simplify
-      key = cast_key(self.key)
-      case op
-      when :in then
-        case value
-        when Range then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
-        when Array then BinaryOperator.new(key, :in, value.map(&method(:cast_value)).uniq, model, true)
-        else raise ArgumentError.new ":in takes an array/range, not #{value}"
-        end
-      when :between then BinaryOperator.new(key, :between, (cast_value(value.min)..cast_value(value.max)), model, true)
-      else BinaryOperator.new(key, op, cast_value(value), model, true)
+      new_key = cast_key(key)
+      new_op, new_value = case op
+        when :in then
+          case value
+          when Range then [:between, (cast_value(value.min)..cast_value(value.max))]
+          when Array then [:in, value.map(&method(:cast_value)).uniq]
+          else raise ArgumentError.new ":in takes an array/range, not #{value}"
+          end
+        when :between then [op, (cast_value(value.min)..cast_value(value.max))]
+        when :defined
+          raise "Incorrect use of `#{op}' and `#{key_modifier}'" if key_modifier != :scalar
+          [op, cast_value(value)]
+        else [op, cast_value(value)]
       end
+      BinaryOperator.new(new_key, key_modifier, new_op, new_value, model, true)
     end
 
     def to_rql(doc)
       key = model.lookup_field_alias(self.key)
+
+      case key_modifier
+      when :scalar then
+        case op
+        when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
+        else to_rql_scalar(doc[key])
+        end
+      when :any then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(true)
+      when :all then doc[key].map { |lvalue| to_rql_scalar(lvalue) }.contains(false).not
+      end
+    end
+
+    def to_rql_scalar(lvalue)
       case op
-      when :defined then value ? doc.has_fields(key) : doc.has_fields(key).not
-      when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
-      when :in      then RethinkDB::RQL.new.expr(value).contains(doc[key])
-      else doc[key].__send__(op, value)
+      when :between then (lvalue >= value.min) & (lvalue <= value.max)
+      when :in      then RethinkDB::RQL.new.expr(value).contains(lvalue)
+      else lvalue.__send__(op, value)
       end
     end
 
+    def compatible_with_index?(index)
+      [key_modifier, index.multi].in?([[:any, true], [:scalar, false]])
+    end
+
     private
 
     def association
@@ -135,11 +149,14 @@ module NoBrainer::Criteria::Where
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
         target_model = association.target_model
-        opts = { :attr_name => key, :value => value, :type => 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)
+        case key_modifier
+        when :scalar    then model.cast_user_to_db_for(key, value)
+        when :any, :all then model.cast_user_to_db_for(key, [value]).first
+        end
       end
     end
 
@@ -148,9 +165,14 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata then association.foreign_key
-      else key
+      else ensure_valid_key!(key); key
       end
     end
+
+    def ensure_valid_key!(key)
+      return if model.has_field?(key) || model.has_index?(key) || model < NoBrainer::Document::DynamicAttributes
+      raise NoBrainer::Error::UnknownAttribute, "`#{key}' is not a declared attribute of #{model}"
+    end
   end
 
   class UnaryOperator < Struct.new(:op, :value)
@@ -180,7 +202,7 @@ module NoBrainer::Criteria::Where
     when Array then MultiOperator.new(:and, clause.map { |c| parse_clause(c) })
     when Hash  then MultiOperator.new(:and, clause.map { |k,v| parse_clause_stub(k,v) })
     when Proc  then Lambda.new(clause)
-    when NoBrainer::DecoratedSymbol
+    when Symbol::Decoration
       case clause.args.size
       when 1 then parse_clause_stub(clause, clause.args.first)
       else raise "Invalid argument: #{clause}"
@@ -195,12 +217,15 @@ module NoBrainer::Criteria::Where
     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_eq(key, value)
-    when NoBrainer::DecoratedSymbol then
-      case key.modifier
+    when Symbol::Decoration then
+      case key.decorator
+      when :any, :all then parse_clause_stub_eq(key, value)
+      when :not, :ne  then parse_clause(:not => { key.symbol.eq => value })
       when :nin then parse_clause(:not => { key.symbol.in => value })
-      when :ne  then parse_clause(:not => { key.symbol.eq => value })
+      when :gte then parse_clause(key.symbol.ge => value)
+      when :lte then parse_clause(key.symbol.le => value)
       when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else BinaryOperator.new(key.symbol, key.modifier, value, self.model)
+      else instantiate_binary_op(key.symbol, key.decorator, value)
       end
     else raise "Invalid key: #{key}"
     end
@@ -208,137 +233,154 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub_eq(key, value)
     case value
-    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)
+    when Range  then instantiate_binary_op(key, :between, value)
+    when Regexp then instantiate_binary_op(key, :match, value.inspect[1..-2])
+    else instantiate_binary_op(key, :eq, value)
     end
   end
 
-  class IndexFinder < Struct.new(:criteria, :ast, :index_name, :index_type, :rql_proc)
-    def initialize(*args)
-      super
+  def instantiate_binary_op(key, op, value)
+    case key
+    when Symbol::Decoration then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
+    else BinaryOperator.new(key, :scalar, op, value, self.model)
     end
+  end
 
-    def could_find_index?
-      !!self.index_name
+  class IndexFinder < Struct.new(:criteria, :ast, :strategy)
+    class Strategy < Struct.new(:rql_op, :index, :ast, :rql_proc); end
+    class IndexStrategy < Struct.new(:criteria_ast, :optimized_clauses, :index, :rql_op, :rql_args, :rql_options)
+      def ast
+        MultiOperator.new(criteria_ast.op, criteria_ast.clauses - optimized_clauses)
+      end
+
+      def rql_proc
+        lambda do |rql|
+          opt = (rql_options || {}).merge(:index => index.aliased_name)
+          r = rql.__send__(rql_op, *rql_args, opt)
+          # TODO distinct: waiting for issue #3345
+          # TODO coerce_to: waiting for issue #3346
+          index.multi ? r.coerce_to('array').distinct : r
+        end
+      end
     end
 
     def get_candidate_clauses(*types)
       BinaryOperator.get_candidate_clauses(ast.clauses, *types)
     end
 
-    def get_usable_indexes(*types)
-      @usable_indexes = {}
-      @usable_indexes[types] ||= begin
-        indexes = criteria.model.indexes.values
-        indexes = indexes.select { |i| types.include?(i.kind) } if types.present?
-        if criteria.with_index_name && criteria.with_index_name != true
-          indexes = indexes.select { |i| i.name == criteria.with_index_name.to_sym }
-        end
-        indexes
+    def get_usable_indexes(options={})
+      indexes = criteria.model.indexes.values
+      options.each { |k,v| indexes = indexes.select { |i| v == i.__send__(k) } }
+      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
 
-    def remove_from_ast(clauses)
-      new_ast = MultiOperator.new(ast.op, ast.clauses - clauses)
-      return new_ast if new_ast.clauses.present?
-    end
-
-    def find_index_canonical
+    def find_strategy_canonical
       clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
+      get_usable_indexes.each do |index|
         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 => 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) }
+        next unless clause.try(:compatible_with_index?, index)
+
+        args = case clause.op
+          when :eq      then [:get_all, [clause.value]]
+          when :in      then [:get_all, clause.value]
+          when :between then [:between, [clause.value.min, clause.value.max],
+                              :left_bound => :closed, :right_bound => :closed]
         end
+        return IndexStrategy.new(ast, [clause], index, *args)
       end
+      return nil
     end
 
-    def find_index_compound
+    def find_strategy_compound
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      if index = get_usable_indexes(:compound).select { |i| i.what & clauses.keys == i.what }.first
+      get_usable_indexes(:kind => :compound, :multi => false).each do |index|
         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 => index.aliased_name) }
+        next unless indexed_clauses.all? { |c| c.try(:compatible_with_index?, index) }
+
+        return IndexStrategy.new(ast, indexed_clauses, index, :get_all, [indexed_clauses.map(&:value)])
       end
+      return nil
     end
 
-    def find_index_hidden_between
+    def find_strategy_hidden_between
       clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
-      return unless clauses.present?
+      return nil unless clauses.present?
 
-      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]
+      get_usable_indexes.each do |index|
+        matched_clauses = clauses[index.name].try(:select) { |c| c.compatible_with_index?(index) }
+        next unless matched_clauses.present?
+
+        op_clauses = Hash[matched_clauses.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 = remove_from_ast([left_bound, right_bound].compact)
+        # XXX we must keep only one bound when using `any', otherwise we get different semantics.
+        right_bound = nil if index.multi && left_bound && right_bound
 
         options = {}
-        options[:index] = index.aliased_name
-        options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
+        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
-        self.rql_proc = ->(rql){ rql.between(left_bound.try(:value), right_bound.try(:value), options) }
+
+        return IndexStrategy.new(ast, [left_bound, right_bound].compact, index, :between,
+                                 [left_bound.try(:value), right_bound.try(:value)], options)
       end
+      return nil
     end
 
-    def find_union_index
-      indexes = []
-      index_finder = self
-
-      loop do
-        index_finder = index_finder.dup
-        break unless index_finder.find_index_canonical
-        # TODO To use a compound index, we'd have to add all permutations in the query
-        indexes << index_finder
-        break unless index_finder.ast
+    def find_strategy_union
+      strategies = ast.clauses.map do |inner_ast|
+        inner_ast = MultiOperator.new(:and, [inner_ast]) unless inner_ast.is_a?(MultiOperator)
+        raise 'fatal' unless inner_ast.op == :and
+        self.class.new(criteria, inner_ast).find_strategy
       end
 
-      if indexes.present? && !index_finder.ast
-        self.ast = nil
-        self.index_name = indexes.map(&:index_name)
-        self.index_type = indexes.map(&:index_type)
-        self.rql_proc = ->(rql){ indexes.map { |index| index.rql_proc.call(rql) }.reduce { |a,b| a.union(b) } }
+      return nil if strategies.any?(&:nil?)
+
+      rql_proc = lambda do |base_rql|
+        strategies.map do |strategy|
+          rql = strategy.rql_proc.call(base_rql)
+          rql = rql.filter { |doc| strategy.ast.to_rql(doc) } if strategy.ast.try(:clauses).present?
+          rql
+        end.reduce(:union).distinct
       end
+
+      Strategy.new(:union, strategies.map(&:index), nil, rql_proc)
     end
 
-    def find_index
-      return if ast.nil? || criteria.without_index?
+    def find_strategy
+      return nil unless ast.try(:clauses).present? && !criteria.without_index?
       case ast.op
-      when :and then find_index_compound || find_index_canonical || find_index_hidden_between
-      when :or  then find_union_index
+      when :and then find_strategy_compound || find_strategy_canonical || find_strategy_hidden_between
+      when :or  then find_strategy_union
       end
     end
+
+    def find_strategy!
+      self.strategy = find_strategy
+    end
   end
 
   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(&:find_strategy!)
   end
 
   def compile_rql_pass1
     rql = super
-    rql = where_index_finder.rql_proc.call(rql) if where_index_finder.could_find_index?
+    rql = where_index_finder.strategy.rql_proc.call(rql) if where_indexed?
     rql
   end
 
   def compile_rql_pass2
     rql = super
-    ast = where_index_finder.could_find_index? ? where_index_finder.ast : self.where_ast
+    ast = where_indexed? ? where_index_finder.strategy.ast : @options[:where_ast]
     rql = rql.filter { |doc| ast.to_rql(doc) } if ast.try(:clauses).present?
     rql
   end

data/lib/no_brainer/document/aliases.rb

@@ -12,9 +12,17 @@ module NoBrainer::Document::Aliases
 
   module ClassMethods
     def _field(attr, options={})
+      if options[:store_as]
+        self.alias_map[attr.to_s] = options[:store_as].to_s
+        self.alias_reverse_map[options[:store_as].to_s] = attr.to_s
+      end
+      super
+    end
+
+    def field(attr, options={})
       if options[:as]
-        self.alias_map[attr.to_s] = options[:as].to_s
-        self.alias_reverse_map[options[:as].to_s] = attr.to_s
+        STDERR.puts "[NoBrainer] `:as' is deprecated and will be removed. Please use `:store_as' instead (from the #{self} model)"
+        options[:store_as] = options.delete(:as)
       end
       super
     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 = [:primary_key, :foreign_key, :class_name, :foreign_key_as, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_store_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -29,8 +29,8 @@ 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_model.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
-      owner_model.validates(target_name, { :presence => true }) if options[:required]
+      owner_model.field(foreign_key, :store_as => options[:foreign_key_store_as], :index => options[:index])
+      owner_model.validates(target_name, :presence => options[:required]) if options[:required]
       owner_model.validates(target_name, options[:validates]) if options[:validates]
 
       delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)

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

@@ -37,7 +37,7 @@ module NoBrainer::Document::Association::Core
     end
 
     def add_callback_for(what)
-      instance_eval <<-RUBY, __FILE__, __LINE__+1
+      instance_eval <<-RUBY, __FILE__, __LINE__ + 1
         if !@added_#{what}
           metadata = self
           owner_model.#{what} { associations[metadata].#{what}_callback }

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

@@ -17,7 +17,7 @@ class NoBrainer::Document::Association::EagerLoader
         if owner_keys.present?
           targets = criteria.where(target_key.in => owner_keys)
                             .map { |target| [target.read_attribute(target_key), target] }
-                            .reduce(Hash.new { |k,v| k[v] = [] }) { |h,(k,v)| h[k] << v; h }
+                            .each_with_object(Hash.new { |k,v| k[v] = [] }) { |(k,v),h| h[k] << v }
 
           unloaded_docs.each do |doc|
             doc_targets = targets[doc.read_attribute(owner_key)]
@@ -45,14 +45,15 @@ class NoBrainer::Document::Association::EagerLoader
     when Hash  then preloads.each do |k,v|
       if v.is_a?(NoBrainer::Criteria)
         v = v.dup
-        nested_preloads, v._preloads = v._preloads, []
+        nested_preloads, v.options[:preload] = v.options[:preload], []
         eager_load(eager_load_association(docs, k, v), nested_preloads)
       else
         eager_load(eager_load_association(docs, k), v)
       end
     end
     when Array then preloads.each { |v| eager_load(docs, v) }
-    else eager_load_association(docs, preloads)
+    when nil then;
+    else eager_load_association(docs, preloads) # String and Symbol
     end
     true
   end

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

@@ -53,7 +53,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def write(new_children)
-    raise "You can't assign #{target_name}. " +
+    raise "You can't assign #{target_name}. " \
           "Instead, you must modify delete and create #{target_model} manually."
   end
 
@@ -80,7 +80,7 @@ class NoBrainer::Document::Association::HasMany
   end
 
   def set_inverse_proc
-    lambda { |target| set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
+    ->(target){ set_inverses_of([target]) if target.is_a?(NoBrainer::Document) }
   end
 
   def before_destroy_callback