nobrainer 0.17.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cf2f24165387c78884eaffc90c04da535bc571f
-  data.tar.gz: b8d3b1bd887c454e3f017664a559c70bec9a6312
+  metadata.gz: 1d6a500e008eff372e800b011e917d121c07e00a
+  data.tar.gz: e43be89ac4963422c26559727c9a68011ee25f8a
 SHA512:
-  metadata.gz: fa00190b18bbd8a498c855ef04fe7720c169c51edbb0d360939dc2ea5c4b76db47361615bc86153207e22be8096946bdce120c35d3b3da6fe99a9db4a4b58f94
-  data.tar.gz: 034d21dabdce9c900b11c899e20d5e69af34560ec2980bbfdba386974bc30828ac6fb9d590fc73a4ac9b568dbfdbdb9a9fb60760c4aeceac963396fd8128e679
+  metadata.gz: 56015e819aba3537ab60ea5f039d4b391ec803cc61b5bf246e44da642787e62606e9c02339b17f05976d5428ec3e4fa0e335cb51694b840bd2ba7821b6d66b20
+  data.tar.gz: d4b78185fed14f5baa28165462a4088096da640d93c0dfb3f20c851e968deceb1f48f13602850075a7eea2408fa23e52c2694d140bea1c9a937d7d49d5084f53

data/lib/no_brainer/config.rb

@@ -1,36 +1,49 @@
 require 'logger'
 
 module NoBrainer::Config
+  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] },
+  }
+
   class << self
-    mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
-                   :auto_create_databases, :auto_create_tables,
-                   :max_reconnection_tries, :durability,
-                   :user_timezone, :db_timezone, :colorize_logger,
-                   :distributed_lock_class, :per_thread_connection
+    attr_accessor(*SETTINGS.keys)
+
+    def max_reconnection_tries=(value)
+      STDERR.puts "[NoBrainer] config.max_reconnection_tries is deprecated and will be removed"
+      STDERR.puts "[NoBrainer] use config.max_retries_on_connection_failure instead."
+      self.max_retries_on_connection_failure = value
+    end
 
     def apply_defaults
-      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_reconnection_tries  = 10
-      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
+      @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
 
@@ -41,21 +54,28 @@ 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.presence : nil rescue nil
+    end
+
+    def default_environment
+      return Rails.env if defined?(Rails.env)
+      ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || :production
+    end
+
     def default_rethinkdb_url
       db = ENV['RETHINKDB_DB'] || ENV['RDB_DB']
-      db ||= "#{Rails.application.class.parent_name.underscore}_#{Rails.env}" rescue nil
+      db ||= "#{self.app_name}_#{self.environment}" if self.app_name && self.environment
       host = ENV['RETHINKDB_HOST'] || ENV['RDB_HOST'] || 'localhost'
       port = ENV['RETHINKDB_PORT'] || ENV['RDB_PORT']
       auth = ENV['RETHINKDB_AUTH'] || ENV['RDB_AUTH']
@@ -69,7 +89,11 @@ module NoBrainer::Config
     end
 
     def default_durability
-      (defined?(Rails.env) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
+      dev_mode? ? :soft : :hard
+    end
+
+    def default_max_retries_on_connection_failure
+      dev_mode? ? 1 : 15
     end
   end
 end

data/lib/no_brainer/connection.rb

@@ -52,6 +52,7 @@ class NoBrainer::Connection
   # database (drop)
   def purge!(options={})
     table_list.each do |table_name|
+      next if table_name =~ /^nobrainer_/
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true

data/lib/no_brainer/connection_manager.rb

@@ -43,7 +43,7 @@ module NoBrainer::ConnectionManager
   end
 
   def _disconnect
-    self.current_connection.try(:disconnect, :noreply_wait => true) rescue nil
+    self.current_connection.try(:close, :noreply_wait => false) rescue nil
     self.current_connection = nil
   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/aggregate.rb

@@ -2,24 +2,27 @@ module NoBrainer::Criteria::Aggregate
   extend ActiveSupport::Concern
 
   def min(*a, &b)
-    instantiate_doc NoBrainer.run { aggregate_rql(:min, *a, &b) }
+    instantiate_doc run { aggregate_rql(:min, *a, &b) }
   end
 
   def max(*a, &b)
-    instantiate_doc NoBrainer.run { aggregate_rql(:max, *a, &b) }
+    instantiate_doc run { aggregate_rql(:max, *a, &b) }
   end
 
   def sum(*a, &b)
-    NoBrainer.run { aggregate_rql(:sum, *a, &b) }
+    run { aggregate_rql(:sum, *a, &b) }
   end
 
   def avg(*a, &b)
-    NoBrainer.run { aggregate_rql(:avg, *a, &b) }
+    run { aggregate_rql(:avg, *a, &b) }
   end
 
   private
 
   def aggregate_rql(type, *a, &b)
-    without_ordering.without_plucking.to_rql.__send__(type, *klass.with_fields_aliased(a), &b)
+    rql = without_ordering.without_plucking.to_rql
+    rql = rql.__send__(type, *model.with_fields_aliased(a), &b)
+    rql = rql.default(nil) unless type == :sum
+    rql
   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 klass
-    init_options[:klass]
+  def model
+    @options[:model]
   end
 
   def to_rql
@@ -16,16 +28,21 @@ module NoBrainer::Criteria::Core
   end
 
   def inspect
-    # rescue super because sometimes klass is not set.
+    # rescue super because sometimes model is not set.
     to_rql.inspect rescue super
   end
 
-  def run(rql=nil)
-    NoBrainer.run(:criteria => self) { (rql || to_rql) }
+  def run(&block)
+    block ||= proc { to_rql }
+    NoBrainer.run(:criteria => self, &block)
   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
 
@@ -40,16 +57,14 @@ 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
     # This method is overriden by other modules.
-    raise "Criteria not bound to a class" unless klass
-    klass.rql_table
+    raise "Criteria not bound to a model" unless model
+    model.rql_table
   end
 
   def compile_rql_pass2
@@ -58,7 +73,7 @@ module NoBrainer::Criteria::Core
   end
 
   def finalized?
-    !!init_options[:finalized]
+    !!@options[:finalized]
   end
 
   def finalized_criteria
@@ -66,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/count.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Count
   extend ActiveSupport::Concern
 
   def count
-    run(without_ordering.without_plucking.to_rql.count)
+    run { without_ordering.without_plucking.to_rql.count }
   end
 
   def empty?

data/lib/no_brainer/criteria/delete.rb

@@ -2,7 +2,7 @@ module NoBrainer::Criteria::Delete
   extend ActiveSupport::Concern
 
   def delete_all
-    run(without_ordering.without_plucking.to_rql.delete)
+    run { without_ordering.without_plucking.to_rql.delete }
   end
 
   def destroy_all

data/lib/no_brainer/criteria/extend.rb

@@ -0,0 +1,19 @@
+module NoBrainer::Criteria::Extend
+  extend ActiveSupport::Concern
+
+  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(:extend => [modules])
+  end
+
+  def merge!(criteria, options={})
+    super.tap do
+      @options[:extend].to_a.each { |modules| extend(*modules, :original_behavior => true) }
+    end
+  end
+end

data/lib/no_brainer/criteria/first.rb

@@ -18,7 +18,7 @@ module NoBrainer::Criteria::First
   end
 
   def sample(n=nil)
-    result = NoBrainer.run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
+    result = run { self.without_ordering.to_rql.sample(n.nil? ? 1 : n) }
     result = result.map(&method(:instantiate_doc))
     n.nil? ? result.first : result
   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 == klass.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,31 +1,23 @@
 module NoBrainer::Criteria::Limit
-  # TODO Test these guys
   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,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