nobrainer 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cf2f24165387c78884eaffc90c04da535bc571f
-  data.tar.gz: b8d3b1bd887c454e3f017664a559c70bec9a6312
+  metadata.gz: 0e146036464db0297a156c6987cb51011137f245
+  data.tar.gz: 7f6815c09410489fbe26b1c0faebdc7aefe001e1
 SHA512:
-  metadata.gz: fa00190b18bbd8a498c855ef04fe7720c169c51edbb0d360939dc2ea5c4b76db47361615bc86153207e22be8096946bdce120c35d3b3da6fe99a9db4a4b58f94
-  data.tar.gz: 034d21dabdce9c900b11c899e20d5e69af34560ec2980bbfdba386974bc30828ac6fb9d590fc73a4ac9b568dbfdbdb9a9fb60760c4aeceac963396fd8128e679
+  metadata.gz: 00b32de4c7ccd965972369698d6619cfa873671d73c5805d03c37e026737eab42cfb5a3d2f94c00323ec05ce84c7baef0702c1572673ed90050f9f02dcf04458
+  data.tar.gz: 661eca7f94fb210e481ecf064829a72b095cc59552de2197856a9226d2978b91c489c26a4045e919368f6d532433b6cbcd3aba8c459c9cd5d2e3bb7f115c6d92

data/lib/no_brainer/config.rb

@@ -2,25 +2,34 @@ require 'logger'
 
 module NoBrainer::Config
   class << self
-    mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
+    mattr_accessor :app_name, :environment, :rethinkdb_url,
+                   :logger, :warn_on_active_record,
                    :auto_create_databases, :auto_create_tables,
-                   :max_reconnection_tries, :durability,
+                   :max_retries_on_connection_failure, :durability,
                    :user_timezone, :db_timezone, :colorize_logger,
                    :distributed_lock_class, :per_thread_connection
 
     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
+      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
+
+    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 reset!
@@ -53,9 +62,18 @@ module NoBrainer::Config
       end
     end
 
+    def default_app_name
+      defined?(Rails) ? Rails.application.class.parent_name.underscore : 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 +87,15 @@ 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
+
+    def dev_mode?
+      self.environment.to_sym.in?([:development, :test])
     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.rb

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

data/lib/no_brainer/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/core.rb

@@ -7,8 +7,8 @@ module NoBrainer::Criteria::Core
     self.init_options = options
   end
 
-  def klass
-    init_options[:klass]
+  def model
+    init_options[:model]
   end
 
   def to_rql
@@ -16,12 +16,13 @@ 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={})
@@ -48,8 +49,8 @@ module NoBrainer::Criteria::Core
 
   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

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,31 @@
+module NoBrainer::Criteria::Extend
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :extend_modules }
+
+  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
+  end
+
+  def merge!(criteria, options={})
+    super
+
+    if criteria.extend_modules.present?
+      self.extend_modules = self.extend_modules.to_a + criteria.extend_modules
+    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/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

@@ -28,7 +28,7 @@ module NoBrainer::Criteria::Index
 
   def compile_rql_pass2
     super.tap do
-      if with_index_name && (!used_index || order_by_index_name.to_s == klass.pk_name.to_s)
+      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)
       end

data/lib/no_brainer/criteria/limit.rb

@@ -1,5 +1,4 @@
 module NoBrainer::Criteria::Limit
-  # TODO Test these guys
   extend ActiveSupport::Concern
 
   included { attr_accessor :_skip, :_limit }

data/lib/no_brainer/criteria/order_by.rb

@@ -10,7 +10,7 @@ module NoBrainer::Criteria::OrderBy
 
   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
@@ -62,7 +62,7 @@ module NoBrainer::Criteria::OrderBy
   private
 
   def effective_order
-    self.order.presence || (klass ? {klass.pk_name => :asc} : {})
+    self.order.presence || (model ? {model.pk_name => :asc} : {})
   end
 
   def reverse_order?
@@ -83,7 +83,7 @@ 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
@@ -116,9 +116,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 +127,13 @@ module NoBrainer::Criteria::OrderBy
       end
     end
 
-    # We can only apply an index order_by on a table() term.
-    # We are going to try to go so and if we cannot, we'll simply apply
-    # the ordering in pass2, which will happen after a potential filter().
+    # We can only apply an indexed order_by on a table() RQL term.
+    # If we can, great. Otherwise, the ordering is applied in pass2, which will
+    # happen after a potential filter(), which is better for perfs.
     if order_by_index_finder.could_find_index?
       options = { :index => rql_rules.shift }
       rql = rql.order_by(*rql_rules, options)
     else
-      # Stashing @rql_rules for pass2
       @rql_rules_pass2 = rql_rules
     end
 

data/lib/no_brainer/criteria/pluck.rb

@@ -74,7 +74,7 @@ module NoBrainer::Criteria::Pluck
     rql = super
     if effective_missing_attributes
       type, attrs = effective_missing_attributes.first
-      rql = rql.__send__(type, klass.with_fields_aliased(attrs))
+      rql = rql.__send__(type, model.with_fields_aliased(attrs))
     end
     rql
   end

data/lib/no_brainer/criteria/raw.rb

@@ -28,6 +28,6 @@ module NoBrainer::Criteria::Raw
   end
 
   def _instantiate_model(attrs, options={})
-    klass.new_from_db(attrs, options)
+    model.new_from_db(attrs, options)
   end
 end

data/lib/no_brainer/criteria/scope.rb

@@ -18,12 +18,12 @@ module NoBrainer::Criteria::Scope
   end
 
   def respond_to?(name, include_private = false)
-    super || self.klass.respond_to?(name)
+    super || self.model.respond_to?(name)
   end
 
   def method_missing(name, *args, &block)
-    return super unless self.klass.respond_to?(name)
-    criteria = self.klass.method(name).call(*args, &block)
+    return super unless self.model.respond_to?(name)
+    criteria = self.model.method(name).call(*args, &block)
     raise "#{name} did not return a criteria" unless criteria.is_a?(NoBrainer::Criteria)
     merge(criteria)
   end
@@ -31,13 +31,13 @@ module NoBrainer::Criteria::Scope
   private
 
   def should_apply_default_scope?
-    klass.default_scope_proc && use_default_scope != false
+    model.default_scope_proc && use_default_scope != false
   end
 
   def _apply_default_scope
     return unless should_apply_default_scope?
-    criteria = klass.default_scope_proc.call
-    raise "Mixing model issue. Contact developer." if [criteria.klass, self.klass].compact.uniq.size == 2
+    criteria = model.default_scope_proc.call
+    raise "Mixing model issue. Contact developer." if [criteria.model, self.model].compact.uniq.size == 2
     criteria.merge(self)
   end
 

data/lib/no_brainer/criteria/update.rb

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

data/lib/no_brainer/criteria/where.rb

@@ -134,9 +134,9 @@ module NoBrainer::Criteria::Where
 
       case association
       when NoBrainer::Document::Association::BelongsTo::Metadata
-        target_klass = association.target_klass
-        opts = { :attr_name => key, :value => value, :type => target_klass}
-        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_klass)
+        target_model = association.target_model
+        opts = { :attr_name => key, :value => value, :type => target_model}
+        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
         value.pk_value
       else
         model.cast_user_to_db_for(key, value)
@@ -200,7 +200,7 @@ module NoBrainer::Criteria::Where
       when :nin then parse_clause(:not => { key.symbol.in => value })
       when :ne  then parse_clause(:not => { key.symbol.eq => value })
       when :eq  then parse_clause_stub_eq(key.symbol, value)
-      else BinaryOperator.new(key.symbol, key.modifier, value, self.klass)
+      else BinaryOperator.new(key.symbol, key.modifier, value, self.model)
       end
     else raise "Invalid key: #{key}"
     end
@@ -208,9 +208,9 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub_eq(key, value)
     case value
-    when Range  then BinaryOperator.new(key, :between, value, self.klass)
-    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.klass)
-    else BinaryOperator.new(key, :eq, value, self.klass)
+    when Range  then BinaryOperator.new(key, :between, value, self.model)
+    when Regexp then BinaryOperator.new(key, :match, value.inspect[1..-2], self.model)
+    else BinaryOperator.new(key, :eq, value, self.model)
     end
   end
 
@@ -230,10 +230,10 @@ module NoBrainer::Criteria::Where
     def get_usable_indexes(*types)
       @usable_indexes = {}
       @usable_indexes[types] ||= begin
-        indexes = criteria.klass.indexes
-        indexes = indexes.select { |k,v| types.include?(v[:kind]) } if types.present?
+        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 { |k,v| k == criteria.with_index_name.to_sym }
+          indexes = indexes.select { |i| i.name == criteria.with_index_name.to_sym }
         end
         indexes
       end
@@ -248,16 +248,15 @@ module NoBrainer::Criteria::Where
       clauses = Hash[get_candidate_clauses(:eq, :in, :between).map { |c| [c.key, c] }]
       return unless clauses.present?
 
-      if index_name = (get_usable_indexes.keys & clauses.keys).first
-        clause = clauses[index_name]
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
+        clause = clauses[index.name]
+        self.index_name = index.name
         self.ast = remove_from_ast([clause])
         self.index_type = clause.op == :between ? :between : :get_all
         self.rql_proc = case clause.op
-          when :eq      then ->(rql){ rql.get_all(clause.value, :index => aliased_index) }
-          when :in      then ->(rql){ rql.get_all(*clause.value, :index => aliased_index) }
-          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => aliased_index,
+          when :eq      then ->(rql){ rql.get_all(clause.value, :index => index.aliased_name) }
+          when :in      then ->(rql){ rql.get_all(*clause.value, :index => index.aliased_name) }
+          when :between then ->(rql){ rql.between(clause.value.min, clause.value.max, :index => index.aliased_name,
                                                   :left_bound => :closed, :right_bound => :closed) }
         end
       end
@@ -267,18 +266,12 @@ module NoBrainer::Criteria::Where
       clauses = Hash[get_candidate_clauses(:eq).map { |c| [c.key, c] }]
       return unless clauses.present?
 
-      index_name, index_values = get_usable_indexes(:compound)
-        .map    { |name, option| [name, option[:what]] }
-        .select { |name, values| values & clauses.keys == values }
-        .first
-
-      if index_name
-        indexed_clauses = index_values.map { |field| clauses[field] }
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+      if index = get_usable_indexes(:compound).select { |i| i.what & clauses.keys == i.what }.first
+        indexed_clauses = index.what.map { |field| clauses[field] }
+        self.index_name = index.name
         self.ast = remove_from_ast(indexed_clauses)
         self.index_type = :get_all
-        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => aliased_index) }
+        self.rql_proc = ->(rql){ rql.get_all(indexed_clauses.map { |c| c.value }, :index => index.aliased_name) }
       end
     end
 
@@ -286,17 +279,16 @@ module NoBrainer::Criteria::Where
       clauses = get_candidate_clauses(:gt, :ge, :lt, :le).group_by(&:key)
       return unless clauses.present?
 
-      if index_name = (get_usable_indexes.keys & clauses.keys).first
-        op_clauses = Hash[clauses[index_name].map { |c| [c.op, c] }]
+      if index = get_usable_indexes.select { |i| clauses[i.name] }.first
+        op_clauses = Hash[clauses[index.name].map { |c| [c.op, c] }]
         left_bound = op_clauses[:gt] || op_clauses[:ge]
         right_bound = op_clauses[:lt] || op_clauses[:le]
 
-        aliased_index = criteria.klass.indexes[index_name][:as]
-        self.index_name = index_name
+        self.index_name = index.name
         self.ast = remove_from_ast([left_bound, right_bound].compact)
 
         options = {}
-        options[:index] = aliased_index
+        options[:index] = index.aliased_name
         options[:left_bound]  = {:gt => :open, :ge => :closed}[left_bound.op] if left_bound
         options[:right_bound] = {:lt => :open, :le => :closed}[right_bound.op] if right_bound
         self.index_type = :between