nobrainer 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 745af373e58173ca12eaee6f9be89f13ab3f56dd
-  data.tar.gz: 97d1cd1c63e4385ce5088b388bdd6392209dbe2e
+  metadata.gz: 2f2246b107585644fff659c53223f7c821bbc628
+  data.tar.gz: 9c2b99c8969e58ac8a3e9c447a887ab30d6ee402
 SHA512:
-  metadata.gz: 68609237b83a8df18d129dc5732eb02e83ed03f362d78c605b092bb96f2e00527a33c6f498f41fe5544ee0b258e3ca3104ffab456d85ed2a33dfe26ac6869c24
-  data.tar.gz: e74bef453c44b4b3588e23756e8204d228c27a1cfe0868ae5a887f86fce37b8247956ebec9aca2f71f2fb3b06694dc8d3aed498482f60a5c3c16af8fe5629f07
+  metadata.gz: 96d2a9de23fc93e7283618a61107043d02fdf4e04623201e654663e4973f248d20122bdfa79f6818580d71169f7d65f56b2dfb4b75dd26f554ed0094996fe6ff
+  data.tar.gz: 7c16007cb6fd8c4e1b0d9bb1b2a590f4cddb489f78c9215315870cfacea4cda86b6de1b63429a46d9641bb3c77216d0a5108c48f4b78459e06bdee174bbcfa4d

data/lib/no_brainer/autoload.rb

@@ -17,9 +17,4 @@ module NoBrainer::Autoload
     constants.each { |constant| autoload constant }
     constants.each { |constant| include const_get(constant) }
   end
-
-  def eager_autoload_and_include(*constants)
-    eager_autoload(*constants)
-    constants.each { |constant| include const_get(constant) }
-  end
 end

data/lib/no_brainer/config.rb

@@ -6,27 +6,32 @@ module NoBrainer::Config
     :environment            => { :default => ->{ default_environment } },
     :rethinkdb_url          => { :default => ->{ default_rethinkdb_url } },
     :logger                 => { :default => ->{ default_logger } },
+    :colorize_logger        => { :default => ->{ true }, :valid_values => [true, false] },
     :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] },
+    :max_string_length      => { :default => -> { 255 } },
     :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 } },
+    :geo_options            => { :default => ->{ {:geo_system => 'WGS84', :unit => 'm'} } },
+    :distributed_lock_class => { :default => ->{ NoBrainer::Lock } },
+    :lock_options           => { :default => ->{ { :expire => 60, :timeout => 10 } } },
     :per_thread_connection  => { :default => ->{ false }, :valid_values => [true, false] },
     :machine_id             => { :default => ->{ default_machine_id } },
-    :geo_options            => { :default => ->{ {:geo_system => 'WGS84', :unit => 'm'} } },
+    :criteria_cache_max_entries => { :default => -> { 10_000 } },
   }
 
   class << self
     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
+    def auto_create_databases=(value)
+      STDERR.puts "[NoBrainer] config.auto_create_databases is no longer active."
+      STDERR.puts "[NoBrainer] The current behavior is now to always auto create databases"
+    end
+
+    def auto_create_tables=(value)
+      STDERR.puts "[NoBrainer] config.auto_create_tables is no longer active."
+      STDERR.puts "[NoBrainer] The current behavior is now to always auto create tables"
     end
 
     def apply_defaults

data/lib/no_brainer/connection.rb

@@ -52,11 +52,9 @@ class NoBrainer::Connection
   # database (drop)
   def purge!
     table_list.each do |table_name|
-      next if table_name =~ /^nobrainer_/
+      next if table_name == 'nobrainer_index_meta' # keeping because indexes are not going away
       NoBrainer.run { |r| r.table(table_name).delete }
     end
     true
-  rescue RuntimeError => e
-    raise e unless e.message =~ /No entry with that name/
   end
 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, :Extend, :Scope
+                       :EagerLoad, :Update, :Cache, :Index, :Extend, :Scope
 end

data/lib/no_brainer/criteria/aggregate.rb

@@ -2,11 +2,11 @@ module NoBrainer::Criteria::Aggregate
   extend ActiveSupport::Concern
 
   def min(*a, &b)
-    instantiate_doc run { aggregate_rql(:min, *a, &b) }
+    order_by(a, &b).first
   end
 
   def max(*a, &b)
-    instantiate_doc run { aggregate_rql(:max, *a, &b) }
+    order_by(a, &b).last
   end
 
   def sum(*a, &b)

data/lib/no_brainer/criteria/cache.rb

@@ -37,15 +37,20 @@ module NoBrainer::Criteria::Cache
   end
 
   def each(options={}, &block)
-    return super unless with_cache? && !options[:no_cache] && block
+    return super unless with_cache? && !options[:no_cache] && block && !@cache_too_small
     return @cache.each(&block) if @cache
 
     cache = []
     super(options.merge(:no_cache => true)) do |instance|
       block.call(instance)
-      cache << instance
+      cache << instance unless @cache_too_small
+
+      if cache.size > NoBrainer::Config.criteria_cache_max_entries
+        cache = []
+        @cache_too_small = true
+      end
     end
-    @cache = cache
+    @cache = cache unless @cache_too_small
     self
   end
 

data/lib/no_brainer/criteria/core.rb

@@ -47,7 +47,7 @@ module NoBrainer::Criteria::Core
   end
 
   def merge(criteria, options={})
-    dup.tap { |new_criteria| new_criteria.merge!(criteria, options) }
+    dup.merge!(criteria, options)
   end
 
   def ==(other)
@@ -102,10 +102,6 @@ module NoBrainer::Criteria::Core
       b
     end
 
-    def merge_hash(a, b)
-      a ? a.merge(b) : b
-    end
-
     def append_array(a, b)
       a ? a+b : b
     end

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_distinct.without_ordering.without_plucking.to_rql.delete }
   end
 
   def destroy_all

data/lib/no_brainer/criteria/eager_load.rb

@@ -0,0 +1,51 @@
+module NoBrainer::Criteria::EagerLoad
+  extend ActiveSupport::Concern
+
+  included { criteria_option :eager_load, :merge_with => :append_array }
+
+  def eager_load(*values)
+    chain({:eager_load => values}, :copy_cache_from => self)
+  end
+
+  def preload(*values)
+    STDERR.puts "[NoBrainer] `preload' is deprecated and will be removed, please use `eager_load' instead"
+    eager_load(*values)
+  end
+
+  def merge!(criteria, options={})
+    super.tap do
+      # If we already have some cached documents, and we need to so some eager
+      # loading, then we it now. It's easier than doing it lazily.
+      if self.cached? && criteria.options[:eager_load].present?
+        perform_eager_load(@cache)
+      end
+    end
+  end
+
+  def each(options={}, &block)
+    return super unless should_eager_load? && !options[:no_eager_loading] && block
+
+    docs = []
+    super(options.merge(:no_eager_loading => true)) { |doc| docs << doc }
+    # TODO batch the eager loading with NoBrainer::Config.criteria_cache_max_entries
+    perform_eager_load(docs)
+    docs.each(&block)
+    self
+  end
+
+  private
+
+  def should_eager_load?
+    @options[:eager_load].present? && !raw?
+  end
+
+  def get_one(criteria)
+    super.tap { |doc| perform_eager_load([doc]) }
+  end
+
+  def perform_eager_load(docs)
+    if should_eager_load? && docs.present?
+      NoBrainer::Document::Association::EagerLoader.new.eager_load(docs, @options[:eager_load])
+    end
+  end
+end

data/lib/no_brainer/criteria/order_by.rb

@@ -134,6 +134,6 @@ module NoBrainer::Criteria::OrderBy
   end
 
   def raise_bad_rule(rule)
-    raise "Please pass something like ':field1 => :desc, :field2 => :asc', not #{rule}"
+    raise "order_by() takes arguments such as `:field1 => :desc, :field2 => :asc', not `#{rule}'"
   end
 end

data/lib/no_brainer/criteria/scope.rb

@@ -24,21 +24,14 @@ module NoBrainer::Criteria::Scope
 
   private
 
-  def should_apply_default_scope?
-    model.default_scope_proc && @options[:use_default_scope] != false
-  end
-
   def _apply_default_scope
-    return unless should_apply_default_scope?
-    criteria = model.default_scope_proc.call
-    raise "Mixing model issue. Contact developer." if [criteria.model, self.model].compact.uniq.size == 2
-    criteria.merge(self)
+    return self if @options[:use_default_scope] == false
+    (model.default_scopes.map(&:call).compact + [self]).reduce(:merge)
   end
 
   module ClassMethods
     def _finalize_criteria(base)
-      criteria = super
-      criteria.__send__(:_apply_default_scope) || criteria
+      super.__send__(:_apply_default_scope)
     end
   end
 end

data/lib/no_brainer/criteria/update.rb

@@ -2,18 +2,20 @@ module NoBrainer::Criteria::Update
   extend ActiveSupport::Concern
 
   def update_all(*a, &b)
-    prepare_args_for_update!(a)
-    run { without_ordering.without_plucking.to_rql.update(*a, &b) }
+    perform_update(:update, a, b)
   end
 
   def replace_all(*a, &b)
-    prepare_args_for_update!(a)
-    run { without_ordering.without_plucking.to_rql.replace(*a, &b) }
+    perform_update(:replace, a, b)
   end
 
   private
 
-  def prepare_args_for_update!(a)
-    a[0] = model.persistable_attributes(a[0]) if !a.empty? && a.first.is_a?(Hash)
+  def perform_update(type, args, block)
+    args[0] = model.persistable_attributes(args[0]) if !args.empty? && args.first.is_a?(Hash)
+    # can't use without_distinct when passed a block as the operation may be
+    # performed many times, which might not be idempotent.
+    clause = block ? self : without_distinct
+    run { clause.without_plucking.to_rql.__send__(type, *args, &block) }
   end
 end

data/lib/no_brainer/criteria/where.rb

@@ -8,9 +8,11 @@ module NoBrainer::Criteria::Where
   Symbol::Decoration.register(*CHAINABLE_OPERATORS, :chainable => true)
 
   extend ActiveSupport::Concern
+  include ActiveModel::ForbiddenAttributesProtection
 
   included do
     criteria_option :where_ast, :merge_with => NoBrainer::Criteria::Where.method(:merge_where_ast)
+    criteria_option :without_distinct, :merge_with => :set_scalar
   end
 
   def where(*args, &block)
@@ -38,6 +40,11 @@ module NoBrainer::Criteria::Where
     where_index_finder.strategy.try(:rql_op)
   end
 
+  def without_distinct(value = true)
+    # helper for delete_all which can't operate on distinct
+    chain(:without_distinct => value)
+  end
+
   private
 
   class MultiOperator < Struct.new(:op, :clauses)
@@ -157,11 +164,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 }
-        raise NoBrainer::Error::InvalidType.new(opts) unless value.is_a?(target_model)
+        unless value.is_a?(target_model)
+          opts = { :model => model, :attr_name => key, :type => target_model, :value => value }
+          raise NoBrainer::Error::InvalidType.new(opts)
+        end
         value.pk_value
       else
         case op
+        when :defined then NoBrainer::Boolean.nobrainer_cast_user_to_model(value)
         when :intersects
           raise "Use a geo object with `intersects`" unless value.is_a?(NoBrainer::Geo::Base)
           value
@@ -225,6 +235,7 @@ module NoBrainer::Criteria::Where
   end
 
   def parse_clause(clause)
+    clause = sanitize_for_mass_assignment(clause)
     case clause
     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) })
@@ -240,9 +251,11 @@ module NoBrainer::Criteria::Where
 
   def parse_clause_stub(key, value)
     case key
-    when :and then MultiOperator.new(:and, value.map { |v| parse_clause(v) })
-    when :or  then MultiOperator.new(:or,  value.map { |v| parse_clause(v) })
-    when :not then UnaryOperator.new(:not, parse_clause(value))
+    when :and  then parse_multi_value(:and, value)
+    when :or   then parse_multi_value(:or,  value)
+    when :_and then parse_multi_value(:and, value, :safe => true)
+    when :_or  then parse_multi_value(:or,  value, :safe => true)
+    when :not  then UnaryOperator.new(:not, parse_clause(value))
     when String, Symbol then parse_clause_stub_eq(key, value)
     when Symbol::Decoration then
       case key.decorator
@@ -258,14 +271,38 @@ module NoBrainer::Criteria::Where
     end
   end
 
+  def parse_multi_value(op, value, options={})
+    raise "The `#{op}' operator takes an array as argument" unless value.is_a?(Array)
+    if value.size == 1 && value.first.is_a?(Hash) && !options[:safe]
+      raise "The `#{op}' operator was provided an array with a single hash element.\n" +
+            "In Ruby, [:a => :b, :c => :d] means [{:a => :b, :c => :d}] which is not the same as [{:a => :b}, {:c => :d}].\n" +
+            "To prevent mistakes, the former construct is prohibited as you probably mean the latter.\n" +
+            "However, if you know what you are doing, you can use the `_#{op}' operator instead."
+    end
+    MultiOperator.new(op, value.map { |v| parse_clause(v) })
+  end
+
   def parse_clause_stub_eq(key, value)
     case value
     when Range  then instantiate_binary_op(key, :between, value)
-    when Regexp then instantiate_binary_op(key, :match, value.inspect[1..-2])
+    when Regexp then instantiate_binary_op(key, :match, translate_regexp_to_re2_syntax(value))
     else instantiate_binary_op(key, :eq, value)
     end
   end
 
+  def translate_regexp_to_re2_syntax(value)
+    # Ruby always uses what RE2 calls "multiline mode" (the "m" flag),
+    # meaning that "foo\nbar" matches /^bar$/.
+    #
+    # Ruby's /m modifier means that . matches \n and corresponds to RE2's "s" flag.
+
+    flags = "m"
+    flags << "s" if value.options & Regexp::MULTILINE != 0
+    flags << "i" if value.options & Regexp::IGNORECASE != 0
+
+    "(?#{flags})#{value.source}"
+  end
+
   def instantiate_binary_op(key, op, value)
     case key
     when Symbol::Decoration then BinaryOperator.new(key.symbol, key.decorator, op, value, self.model)
@@ -274,8 +311,8 @@ module NoBrainer::Criteria::Where
   end
 
   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)
+    class Strategy < Struct.new(:index_finder, :rql_op, :index, :ast, :rql_proc); end
+    class IndexStrategy < Struct.new(:index_finder, :criteria_ast, :optimized_clauses, :index, :rql_op, :rql_args, :rql_options)
       def ast
         MultiOperator.new(criteria_ast.op, criteria_ast.clauses - optimized_clauses)
       end
@@ -287,7 +324,7 @@ module NoBrainer::Criteria::Where
           r = r.map { |i| i['doc'] } if rql_op == :get_nearest
           # TODO distinct: waiting for issue #3345
           # TODO coerce_to: waiting for issue #3346
-          r = r.coerce_to('array').distinct if index.multi
+          r = r.coerce_to('array').distinct if index.multi && !index_finder.criteria.options[:without_distinct]
           r
         end
       end
@@ -327,7 +364,7 @@ module NoBrainer::Criteria::Where
           when :between then [:between, [clause.value.min, clause.value.max],
                               :left_bound => :closed, :right_bound => :closed]
         end
-        IndexStrategy.new(ast, [clause], index, *args)
+        IndexStrategy.new(self, ast, [clause], index, *args)
       end.compact.sort_by { |strat| usable_indexes.values.index(strat.index) }.first
     end
 
@@ -339,7 +376,7 @@ module NoBrainer::Criteria::Where
         indexed_clauses = index.what.map { |field| clauses[field] }
         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)])
+        return IndexStrategy.new(self, ast, indexed_clauses, index, :get_all, [indexed_clauses.map(&:value)])
       end
       return nil
     end
@@ -363,7 +400,7 @@ module NoBrainer::Criteria::Where
         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
 
-        return IndexStrategy.new(ast, [left_bound, right_bound].compact, index, :between,
+        return IndexStrategy.new(self, ast, [left_bound, right_bound].compact, index, :between,
                                  [left_bound.try(:value), right_bound.try(:value)], options)
       end
       return nil
@@ -386,7 +423,7 @@ module NoBrainer::Criteria::Where
         end.reduce(:union).distinct
       end
 
-      Strategy.new(:union, strategies.map(&:index), nil, rql_proc)
+      Strategy.new(self, :union, strategies.map(&:index), nil, rql_proc)
     end
 
     def find_strategy

data/lib/no_brainer/document.rb

@@ -4,8 +4,8 @@ module NoBrainer::Document
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
-  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly, :Validation,
-                       :Persistance, :Types, :Uniqueness, :Callbacks, :Dirty, :PrimaryKey,
+  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
+                       :Persistance, :Validation, :Types, :Callbacks, :Dirty, :PrimaryKey,
                        :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
                        :MissingAttributes, :LazyFetch, :AtomicOps
 

data/lib/no_brainer/document/aliases.rb

@@ -19,14 +19,6 @@ module NoBrainer::Document::Aliases
       super
     end
 
-    def field(attr, options={})
-      if options[:as]
-        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
-
     def _remove_field(attr, options={})
       super