nobrainer 0.18.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e146036464db0297a156c6987cb51011137f245
-  data.tar.gz: 7f6815c09410489fbe26b1c0faebdc7aefe001e1
+  metadata.gz: 1d6a500e008eff372e800b011e917d121c07e00a
+  data.tar.gz: e43be89ac4963422c26559727c9a68011ee25f8a
 SHA512:
-  metadata.gz: 00b32de4c7ccd965972369698d6619cfa873671d73c5805d03c37e026737eab42cfb5a3d2f94c00323ec05ce84c7baef0702c1572673ed90050f9f02dcf04458
-  data.tar.gz: 661eca7f94fb210e481ecf064829a72b095cc59552de2197856a9226d2978b91c489c26a4045e919368f6d532433b6cbcd3aba8c459c9cd5d2e3bb7f115c6d92
+  metadata.gz: 56015e819aba3537ab60ea5f039d4b391ec803cc61b5bf246e44da642787e62606e9c02339b17f05976d5428ec3e4fa0e335cb51694b840bd2ba7821b6d66b20
+  data.tar.gz: d4b78185fed14f5baa28165462a4088096da640d93c0dfb3f20c851e968deceb1f48f13602850075a7eea2408fa23e52c2694d140bea1c9a937d7d49d5084f53

data/lib/no_brainer/config.rb

@@ -1,30 +1,25 @@
 require 'logger'
 
 module NoBrainer::Config
-  class << self
-    mattr_accessor :app_name, :environment, :rethinkdb_url,
-                   :logger, :warn_on_active_record,
-                   :auto_create_databases, :auto_create_tables,
-                   :max_retries_on_connection_failure, :durability,
-                   :user_timezone, :db_timezone, :colorize_logger,
-                   :distributed_lock_class, :per_thread_connection
+  SETTINGS = {
+    :app_name               => { :default => ->{ default_app_name } },
+    :environment            => { :default => ->{ default_environment } },
+    :rethinkdb_url          => { :default => ->{ default_rethinkdb_url } },
+    :logger                 => { :default => ->{ default_logger } },
+    :warn_on_active_record  => { :default => ->{ true }, :valid_values => [true, false] },
+    :auto_create_databases  => { :default => ->{ true }, :valid_values => [true, false] },
+    :auto_create_tables     => { :default => ->{ true }, :valid_values => [true, false] },
+    :max_retries_on_connection_failure => { :default => ->{ default_max_retries_on_connection_failure } },
+    :durability             => { :default => ->{ default_durability }, :valid_values => [:hard, :soft] },
+    :user_timezone          => { :default => ->{ :local }, :valid_values => [:unchanged, :utc, :local] },
+    :db_timezone            => { :default => ->{ :utc }, :valid_values => [:unchanged, :utc, :local] },
+    :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
+    :distributed_lock_class => { :default => ->{ nil } },
+    :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
+  }
 
-    def apply_defaults
-      self.app_name                          = default_app_name
-      self.environment                       = default_environment
-      self.rethinkdb_url                     = default_rethinkdb_url
-      self.logger                            = default_logger
-      self.warn_on_active_record             = true
-      self.auto_create_databases             = true
-      self.auto_create_tables                = true
-      self.max_retries_on_connection_failure = default_max_retries_on_connection_failure
-      self.durability                        = default_durability
-      self.user_timezone                     = :local
-      self.db_timezone                       = :utc
-      self.colorize_logger                   = true
-      self.distributed_lock_class            = nil
-      self.per_thread_connection             = false
-    end
+  class << self
+    attr_accessor(*SETTINGS.keys)
 
     def max_reconnection_tries=(value)
       STDERR.puts "[NoBrainer] config.max_reconnection_tries is deprecated and will be removed"
@@ -32,14 +27,23 @@ module NoBrainer::Config
       self.max_retries_on_connection_failure = value
     end
 
+    def apply_defaults
+      @applied_defaults_for = SETTINGS.keys.reject { |k| instance_variable_defined?("@#{k}") }
+      @applied_defaults_for.each { |k| __send__("#{k}=", SETTINGS[k][:default].call) }
+    end
+
+    def assert_valid_options!
+      SETTINGS.each { |k,v| assert_array_in(k, v[:valid_values]) if v[:valid_values] }
+    end
+
     def reset!
-      @configured = false
-      apply_defaults
+      instance_variables.each { |ivar| remove_instance_variable(ivar) }
     end
 
     def configure(&block)
-      apply_defaults unless configured?
+      @applied_defaults_for.to_a.each { |k| remove_instance_variable("@#{k}") }
       block.call(self) if block
+      apply_defaults
       assert_valid_options!
       @configured = true
 
@@ -50,20 +54,18 @@ module NoBrainer::Config
       !!@configured
     end
 
-    def assert_valid_options!
-      assert_array_in :durability,    [:hard, :soft]
-      assert_array_in :user_timezone, [:unchanged, :utc, :local]
-      assert_array_in :db_timezone,   [:unchanged, :utc, :local]
-    end
-
     def assert_array_in(name, values)
       unless __send__(name).in?(values)
         raise ArgumentError.new("Unknown configuration for #{name}: #{__send__(name)}. Valid values are: #{values.inspect}")
       end
     end
 
+    def dev_mode?
+      self.environment.to_s.in? %w(development test)
+    end
+
     def default_app_name
-      defined?(Rails) ? Rails.application.class.parent_name.underscore : nil
+      defined?(Rails) ? Rails.application.class.parent_name.underscore.presence : nil rescue nil
     end
 
     def default_environment
@@ -93,9 +95,5 @@ module NoBrainer::Config
     def default_max_retries_on_connection_failure
       dev_mode? ? 1 : 15
     end
-
-    def dev_mode?
-      self.environment.to_sym.in?([:development, :test])
-    end
   end
 end

data/lib/no_brainer/criteria/after_find.rb

@@ -1,23 +1,15 @@
 module NoBrainer::Criteria::AfterFind
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_after_find }
+  included { criteria_option :after_find, :merge_with => :append_array }
 
   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
+    chain(:after_find => [b, block].compact)
   end
 
   def _instantiate_doc(attrs)
     super.tap do |doc|
-      self._after_find.to_a.each { |block| block.call(doc) }
+      @options[:after_find].to_a.each { |block| block.call(doc) }
       doc.run_callbacks(:find) if doc.is_a?(NoBrainer::Document)
     end
   end

data/lib/no_brainer/criteria/cache.rb

@@ -1,14 +1,14 @@
 module NoBrainer::Criteria::Cache
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_with_cache }
+  included { criteria_option :with_cache, :merge_with => :set_scalar }
 
   def with_cache
-    chain { |criteria| criteria._with_cache = true }
+    chain(:with_cache => true)
   end
 
   def without_cache
-    chain { |criteria| criteria._with_cache = false }
+    chain(:with_cache => false)
   end
 
   def inspect
@@ -18,14 +18,14 @@ module NoBrainer::Criteria::Cache
   end
 
   def merge!(criteria, options={})
+    if options[:copy_cache_from] && options[:copy_cache_from].cached?
+      @cache = options[:copy_cache_from].instance_variable_get(:@cache)
+    end
     super
-    self._with_cache = criteria._with_cache unless criteria._with_cache.nil?
-    self.reload unless options[:keep_cache]
-    self
   end
 
   def with_cache?
-    @_with_cache != false
+    finalized_criteria.options[:with_cache] != false
   end
 
   def reload

data/lib/no_brainer/criteria/core.rb

@@ -1,14 +1,26 @@
 module NoBrainer::Criteria::Core
   extend ActiveSupport::Concern
 
-  included { attr_accessor :init_options }
+  included do
+    singleton_class.send(:attr_accessor, :options_definitions)
+    self.options_definitions = {}
+    attr_accessor :options
+
+    criteria_option :model, :merge_with => :set_scalar
+    criteria_option :finalized, :merge_with => :set_scalar
+  end
 
   def initialize(options={})
-    self.init_options = options
+    @options = options
+  end
+
+  def dup
+    # We don't keep any of the instance variables except options.
+    self.class.new(@options.dup)
   end
 
   def model
-    init_options[:model]
+    @options[:model]
   end
 
   def to_rql
@@ -26,7 +38,11 @@ module NoBrainer::Criteria::Core
   end
 
   def merge!(criteria, options={})
-    self.init_options = self.init_options.merge(criteria.init_options)
+    criteria.options.each do |k,v|
+      merge_proc = self.class.options_definitions[k]
+      raise "Non declared option: #{k}" unless merge_proc
+      @options[k] = merge_proc.call(@options[k], v)
+    end
     self
   end
 
@@ -41,10 +57,8 @@ module NoBrainer::Criteria::Core
 
   private
 
-  def chain(options={}, &block)
-    tmp = self.class.new(self.init_options) # we might want to optimize that thing
-    block.call(tmp)
-    merge(tmp, options)
+  def chain(options={}, merge_options={}, &block)
+    merge(self.class.new(options), merge_options)
   end
 
   def compile_rql_pass1
@@ -59,7 +73,7 @@ module NoBrainer::Criteria::Core
   end
 
   def finalized?
-    !!init_options[:finalized]
+    !!@options[:finalized]
   end
 
   def finalized_criteria
@@ -67,8 +81,33 @@ module NoBrainer::Criteria::Core
   end
 
   module ClassMethods
+    def criteria_option(*names)
+      options = names.extract_options!
+
+      names.map(&:to_sym).each do |name|
+        merge_proc = options[:merge_with]
+        merge_proc = MergeStrategies.method(merge_proc) if merge_proc.is_a?(Symbol)
+        self.options_definitions[name] = merge_proc
+      end
+    end
+
     def _finalize_criteria(base)
-      base.merge(base.class.new(:finalized => true))
+      base.__send__(:chain, :finalized => true)
+    end
+  end
+
+  module MergeStrategies
+    extend self
+    def set_scalar(a, b)
+      b
+    end
+
+    def merge_hash(a, b)
+      a ? a.merge(b) : b
+    end
+
+    def append_array(a, b)
+      a ? a+b : b
     end
   end
 end

data/lib/no_brainer/criteria/extend.rb

@@ -1,31 +1,19 @@
 module NoBrainer::Criteria::Extend
   extend ActiveSupport::Concern
 
-  included { attr_accessor :extend_modules }
+  included { criteria_option :extend, :merge_with => :append_array }
 
   def extend(*modules, &block)
     options = modules.extract_options!
     modules << Module.new(&block) if block
 
     return super(*modules) if options[:original_behavior]
-
-    chain do |criteria|
-      criteria.extend_modules ||= []
-      criteria.extend_modules += [modules]
-    end
+    chain(:extend => [modules])
   end
 
   def merge!(criteria, options={})
-    super
-
-    if criteria.extend_modules.present?
-      self.extend_modules = self.extend_modules.to_a + criteria.extend_modules
+    super.tap do
+      @options[:extend].to_a.each { |modules| extend(*modules, :original_behavior => true) }
     end
-
-    if self.extend_modules.present?
-      self.extend_modules.each { |modules| extend(*modules, :original_behavior => true) }
-    end
-
-    self
   end
 end

data/lib/no_brainer/criteria/index.rb

@@ -1,10 +1,10 @@
 module NoBrainer::Criteria::Index
   extend ActiveSupport::Concern
 
-  included { attr_accessor :with_index_name }
+  included { criteria_option :use_index, :merge_with => :set_scalar }
 
   def with_index(index_name=true)
-    chain { |criteria| criteria.with_index_name = index_name }
+    chain(:use_index => index_name)
   end
 
   def without_index
@@ -12,25 +12,19 @@ module NoBrainer::Criteria::Index
   end
 
   def without_index?
-    finalized_criteria.with_index_name == false
+    finalized_criteria.options[:use_index] == false
   end
 
   def used_index
-    # only one of them will be active.
+    # Only one of them will be active.
     where_index_name || order_by_index_name
   end
 
-  def merge!(criteria, options={})
-    super
-    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
-    self
-  end
-
   def compile_rql_pass2
     super.tap do
-      if with_index_name && (!used_index || order_by_index_name.to_s == model.pk_name.to_s)
-        # The implicit ordering on the indexed pk does not count.
-        raise NoBrainer::Error::CannotUseIndex.new(with_index_name)
+      # The implicit ordering on the indexed pk does not count.
+      if @options[:use_index] && (!used_index || order_by_index_name.to_s == model.pk_name.to_s)
+        raise NoBrainer::Error::CannotUseIndex.new(@options[:use_index])
       end
     end
   end

data/lib/no_brainer/criteria/limit.rb

@@ -1,30 +1,23 @@
 module NoBrainer::Criteria::Limit
   extend ActiveSupport::Concern
 
-  included { attr_accessor :_skip, :_limit }
+  included { criteria_option :skip, :limit, :merge_with => :set_scalar }
 
   def limit(value)
-    chain { |criteria| criteria._limit = value }
+    chain(:limit => value)
   end
 
   def skip(value)
-    chain { |criteria| criteria._skip = value }
+    chain(:skip => value)
   end
   alias_method :offset, :skip
 
-  def merge!(criteria, options={})
-    super
-    self._skip = criteria._skip if criteria._skip
-    self._limit = criteria._limit if criteria._limit
-    self
-  end
-
   private
 
   def compile_rql_pass2
     rql = super
-    rql = rql.skip(_skip) if _skip
-    rql = rql.limit(_limit) if _limit
+    rql = rql.skip(@options[:skip]) if @options[:skip]
+    rql = rql.limit(@options[:limit]) if @options[:limit]
     rql
   end
 end

data/lib/no_brainer/criteria/order_by.rb

@@ -1,12 +1,8 @@
 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)
@@ -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 || (model ? {model.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)
@@ -90,8 +72,8 @@ module NoBrainer::Criteria::OrderBy
       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.

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,9 +59,9 @@ 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

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

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,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?
@@ -232,8 +217,8 @@ module NoBrainer::Criteria::Where
       @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 }
+        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
@@ -327,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
@@ -338,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/document/association/eager_loader.rb

@@ -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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nobrainer
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.18.1
 platform: ruby
 authors:
 - Nicolas Viennot