nobrainer 0.18.0 → 0.22.0

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
@@ -150,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/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/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)
@@ -30,21 +24,14 @@ module NoBrainer::Criteria::Scope
 
   private
 
-  def should_apply_default_scope?
-    model.default_scope_proc && 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