nobrainer 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e146036464db0297a156c6987cb51011137f245
-  data.tar.gz: 7f6815c09410489fbe26b1c0faebdc7aefe001e1
+  metadata.gz: 5dc33c00dc3aa418ae3bd36b0ccb2618a8c0e47f
+  data.tar.gz: 3a4c171e4c41341d14a3c4b6103b463be1b12701
 SHA512:
-  metadata.gz: 00b32de4c7ccd965972369698d6619cfa873671d73c5805d03c37e026737eab42cfb5a3d2f94c00323ec05ce84c7baef0702c1572673ed90050f9f02dcf04458
-  data.tar.gz: 661eca7f94fb210e481ecf064829a72b095cc59552de2197856a9226d2978b91c489c26a4045e919368f6d532433b6cbcd3aba8c459c9cd5d2e3bb7f115c6d92
+  metadata.gz: 70af56ece8a93103f310a729c338631e0bc56b52d4725ea2a304dfdb389e04fb530fda2b3d8039ec36e4f175ae9d510f3eb765fdf2d7a6f155ea37b822f0f464
+  data.tar.gz: 58371614f47e835c11b183fd2b004271b7c0031f27de8b17a9f8b0d3d2c4ee185a4e32efb5e495f5f6cf0b53fa9f64e4510150cfff3305d237431ec195733b13

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/connection.rb

@@ -50,7 +50,7 @@ class NoBrainer::Connection
 
   # Note that truncating each table (purge) is much faster than dropping the
   # database (drop)
-  def purge!(options={})
+  def purge!
     table_list.each do |table_name|
       next if table_name =~ /^nobrainer_/
       NoBrainer.run { |r| r.table(table_name).delete }

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={})
+    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/delete.rb

@@ -6,6 +6,6 @@ module NoBrainer::Criteria::Delete
   end
 
   def destroy_all
-    to_a.each { |doc| doc.destroy }
+    to_a.each(&:destroy)
   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)
@@ -83,15 +65,17 @@ module NoBrainer::Criteria::OrderBy
     end
 
     def first_key_indexable?
-      (first_key.is_a?(Symbol) || first_key.is_a?(String)) && criteria.model.has_index?(first_key)
+      return false unless first_key.is_a?(Symbol) || first_key.is_a?(String)
+      return false unless index = criteria.model.indexes[first_key.to_sym]
+      return !index.multi && !index.geo
     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.
@@ -105,7 +89,7 @@ module NoBrainer::Criteria::OrderBy
 
   def order_by_index_finder
     return finalized_criteria.__send__(:order_by_index_finder) unless finalized?
-    @order_by_index_finder ||= IndexFinder.new(self).tap { |index_finder| index_finder.find_index }
+    @order_by_index_finder ||= IndexFinder.new(self).tap(&:find_index)
   end
 
   def compile_rql_pass1

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