active_scaffold 3.5.3 → 3.6.0.rc2

data/lib/active_scaffold/extensions/left_outer_joins.rb

@@ -18,11 +18,6 @@ if Rails.version < '5.0.0'
       end
       alias left_joins left_outer_joins
 
-      def outer_joins(*args)
-        ActiveSupport::Deprecation.warn 'use left_outer_joins or left_joins which is added to Rails 5.0.0'
-        left_outer_joins(*args)
-      end
-
       def left_outer_joins!(*args)
         self.joins_values += [''] # HACK: for using left_outer_joins in update_all/delete_all
         self.left_outer_joins_values += args
@@ -30,39 +25,19 @@ if Rails.version < '5.0.0'
       end
       alias left_joins! left_outer_joins!
 
-      def outer_joins!(*args)
-        ActiveSupport::Deprecation.warn 'use left_outer_joins! or left_joins! which is added to Rails 5.0.0'
-        left_outer_joins!(*args)
-      end
-
-      if Rails.version < '4.1'
-        def build_arel
-          if left_outer_joins_values.empty?
-            super
-          else
-            relation = except(:left_outer_joins)
-            join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, left_outer_joins_values, [])
-            join_dependency.join_associations.each do |association|
-              relation = association.join_relation(relation)
-            end
-            relation.build_arel
-          end
-        end
-      else
-        def build_arel
-          if left_outer_joins_values.empty?
-            super
-          else
-            relation = except(:left_outer_joins)
-            relation.joins! ActiveRecord::Associations::JoinDependency.new(@klass, left_outer_joins_values, [])
-            relation.build_arel
-          end
+      def build_arel
+        if left_outer_joins_values.empty?
+          super
+        else
+          relation = except(:left_outer_joins)
+          relation.joins! ActiveRecord::Associations::JoinDependency.new(@klass, left_outer_joins_values, [])
+          relation.build_arel
         end
       end
     end
   end
   ActiveRecord::Relation.send :include, ActiveScaffold::OuterJoins
   module ActiveRecord::Querying
-    delegate :left_outer_joins, :left_joins, :outer_joins, :to => :all
+    delegate :left_outer_joins, :left_joins, :to => :all
   end
 end

data/lib/active_scaffold/extensions/localize.rb

@@ -1,7 +1,9 @@
 class Object
   def as_(key, options = {})
     if key.present?
-      text = I18n.translate(key.to_s, {:scope => [:active_scaffold, *options.delete(:scope)], :default => key.is_a?(String) ? key : key.to_s.titleize}.merge(options)).html_safe
+      scope = [:active_scaffold, *options.delete(:scope)]
+      options = options.reverse_merge(:scope => scope, :default => key.is_a?(String) ? key : key.to_s.titleize)
+      text = I18n.translate(key.to_s, options).html_safe # rubocop:disable Rails/OutputSafety
       # text = nil if text.include?('translation missing:')
     end
     text || key

data/lib/active_scaffold/extensions/routing_mapper.rb

@@ -16,9 +16,9 @@ module ActiveScaffold
 
       def get_actions(actions_hash, options)
         default_actions = default_actions(actions_hash)
-        if only = options[:only]
+        if (only = options[:only])
           Array(only).map(&:to_sym)
-        elsif except = options[:except]
+        elsif (except = options[:except])
           default_actions - Array(except).map(&:to_sym)
         else
           default_actions
@@ -29,13 +29,13 @@ module ActiveScaffold
         actions = get_actions(ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING, options)
 
         mapper.collection do
-          ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each do |name, type|
+          ActiveScaffold::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each do |name, type|
             mapper.match(name, via: type) if actions.include? name
           end
         end
 
         mapper.member do
-          ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:member].each do |name, type|
+          ActiveScaffold::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:member].each do |name, type|
             mapper.match(name, via: type) if actions.include? name
           end
         end
@@ -52,13 +52,13 @@ module ActiveScaffold
         actions = get_actions(ACTIVE_SCAFFOLD_CORE_ROUTING, options)
 
         mapper.collection do
-          ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each do |name, type|
+          ActiveScaffold::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each do |name, type|
             mapper.match(name, via: type) if actions.include? name
           end
         end
 
         mapper.member do
-          ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each do |name, type|
+          ActiveScaffold::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each do |name, type|
             mapper.match(name, via: type) if actions.include? name
           end
           mapper.get 'list', action: :index if mapper.send(:parent_resource).actions.include? :index
@@ -72,47 +72,8 @@ end
 
 module ActionDispatch
   module Routing
-    ACTIVE_SCAFFOLD_CORE_ROUTING = ActiveScaffold::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING
-    ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = ActiveScaffold::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING
-
     class Mapper
       module Resources
-        def parent_options
-          opts = parent_resource.instance_variable_get(:@options)
-          if Rails.version >= '5.0.0'
-            opts.merge(
-              only: parent_resource.instance_variable_get(:@only),
-              except: parent_resource.instance_variable_get(:@except)
-            )
-          end
-          opts
-        end
-
-        def define_active_scaffold_concern
-          ActiveSupport::Deprecation.warn 'Add concern :active_scaffold, ActiveScaffold::Routing::Basic.new(association: true) to your routes file.'
-          concern :active_scaffold, ActiveScaffold::Routing::Basic.new(association: true)
-        end
-
-        def define_active_scaffold_association_concern
-          ActiveSupport::Deprecation.warn 'Add concern :active_scaffold_association, ActiveScaffold::Routing::Association.new to your routes file.'
-          concern :active_scaffold_association, ActiveScaffold::Routing::Association.new
-        end
-
-        def as_routes(opts = {association: true})
-          define_active_scaffold_concern unless @concerns[:active_scaffold]
-          if opts[:association] && !@concerns[:active_scaffold_association]
-            define_active_scaffold_association_concern
-          end
-          ActiveSupport::Deprecation.warn 'Use concerns: :active_scaffold in resources instead of as_routes, or concerns :active_scaffold in resources block if want to disable association routes or restrict routes with only or except options.'
-          concerns :active_scaffold, parent_options.merge(association: opts[:association])
-        end
-
-        def as_association_routes
-          define_active_scaffold_association_concern unless @concerns[:active_scaffold_association]
-          ActiveSupport::Deprecation.warn 'Use concerns: :active_scaffold_association in resources instead of as_association_routes, or concerns :active_scaffold_association in resources block if want to restrict routes with only or except options.'
-          concerns :active_scaffold_association, parent_options
-        end
-
         def as_nested_resources(*resources)
           options = resources.extract_options!
           nested_options = options.merge(parent_scaffold: parent_scaffold)

data/lib/active_scaffold/extensions/to_label.rb

@@ -1,8 +1,9 @@
 # the ever-useful to_label method
 class ActiveRecord::Base
   def to_label
-    %i[name label title to_s].each do |attribute|
-      return send(attribute).to_s if respond_to?(attribute)
+    to_label_method = ActiveScaffold::Registry.cache :to_label, self.class.name do
+      %i[name label title to_s].find { |attribute| respond_to?(attribute) }
     end
+    send(to_label_method).to_s if to_label_method
   end
 end

data/lib/active_scaffold/extensions/unsaved_record.rb

@@ -18,10 +18,8 @@ module ActiveScaffold::UnsavedRecord
   def keeping_errors
     old_errors = errors.dup if errors.present?
     result = yield
-    if old_errors
-      old_errors.each do |attr|
-        old_errors[attr].each { |msg| errors.add(attr, msg) unless errors.added?(attr, msg) }
-      end
+    old_errors&.each do |attr|
+      old_errors[attr].each { |msg| errors.add(attr, msg) unless errors.added?(attr, msg) }
     end
     result && old_errors.blank?
   end

data/lib/active_scaffold/finder.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold
   module Finder
     def self.like_operator
-      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? 'ILIKE' : 'LIKE'
+      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name.in?(%w[PostgreSQL PostGIS]) ? 'ILIKE' : 'LIKE'
     end
 
     module ClassMethods
@@ -68,7 +68,9 @@ module ActiveScaffold
               value = columns_token[column.name]
               value = /#{value}/ if column.text?
               column.search_sql.map do |search_sql|
-                {search_sql => value}
+                # call .to_s so String is returned from CowProxy::String in threadsafe mode
+                # in other case, or method from Mongoid would fail
+                {search_sql.to_s => value}
               end
             end.flatten
             active_scaffold_config.model.or(token_conditions).selector
@@ -95,18 +97,16 @@ module ActiveScaffold
         if respond_to?("condition_for_#{column.name}_column")
           return send("condition_for_#{column.name}_column", column, value, like_pattern)
         end
-        return unless column && column.search_sql && value.present?
+        return unless column&.search_sql && value.present?
         search_ui = column.search_ui || column.column_type
         begin
           sql, *values =
             if search_ui && respond_to?("condition_for_#{search_ui}_type")
               send("condition_for_#{search_ui}_type", column, value, like_pattern)
+            elsif column.search_sql.instance_of? Proc
+              column.search_sql.call(value)
             else
-              if column.search_sql.instance_of? Proc
-                column.search_sql.call(value)
-              else
-                condition_for_search_ui(column, value, like_pattern, search_ui)
-              end
+              condition_for_search_ui(column, value, like_pattern, search_ui)
             end
           return nil unless sql
 
@@ -122,7 +122,7 @@ module ActiveScaffold
       def condition_for_search_ui(column, value, like_pattern, search_ui)
         case search_ui
         when :boolean, :checkbox
-          ['%{search_sql} = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+          ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
         when :integer, :decimal, :float
           condition_for_numeric(column, value)
         when :string, :range
@@ -131,57 +131,59 @@ module ActiveScaffold
           condition_for_datetime(column, value)
         when :select, :multi_select, :country, :usa_state, :chosen, :multi_chosen
           values = Array(value).select(&:present?)
-          ['%{search_sql} in (?)', values] if values.present?
+          ['%<search_sql>s in (?)', values] if values.present?
         else
           if column.text?
-            ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+            ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
           else
-            ['%{search_sql} = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
+            ['%<search_sql>s = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
           end
         end
       end
 
       def condition_for_numeric(column, value)
         if !value.is_a?(Hash)
-          ['%{search_sql} = ?', condition_value_for_numeric(column, value)]
+          ['%<search_sql>s = ?', condition_value_for_numeric(column, value)]
         elsif ActiveScaffold::Finder::NULL_COMPARATORS.include?(value[:opt])
           condition_for_null_type(column, value[:opt])
         elsif value[:from].blank? || !ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
           nil
         elsif value[:opt] == 'BETWEEN'
-          ['(%{search_sql} BETWEEN ? AND ?)', condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
+          ['(%<search_sql>s BETWEEN ? AND ?)', condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
         else
-          ["%{search_sql} #{value[:opt]} ?", condition_value_for_numeric(column, value[:from])]
+          ["%<search_sql>s #{value[:opt]} ?", condition_value_for_numeric(column, value[:from])]
         end
       end
 
       def condition_for_range(column, value, like_pattern = nil)
         if !value.is_a?(Hash)
           if column.text?
-            ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+            ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
           else
-            ['%{search_sql} = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
+            ['%<search_sql>s = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
           end
         elsif ActiveScaffold::Finder::NULL_COMPARATORS.include?(value[:opt])
           condition_for_null_type(column, value[:opt], like_pattern)
         elsif value[:from].blank?
           nil
         elsif ActiveScaffold::Finder::STRING_COMPARATORS.values.include?(value[:opt])
-          ["%{search_sql} #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
+          ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", value[:opt].sub('?', value[:from])]
         elsif value[:opt] == 'BETWEEN'
-          ['(%{search_sql} BETWEEN ? AND ?)', value[:from], value[:to]]
+          ['(%<search_sql>s BETWEEN ? AND ?)', value[:from], value[:to]]
         elsif ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(value[:opt])
-          ["%{search_sql} #{value[:opt]} ?", value[:from]]
+          ["%<search_sql>s #{value[:opt]} ?", value[:from]]
         end
       end
 
       def tables_for_translating_days_and_months(format)
+        # rubocop:disable Style/FormatStringToken
         keys = {
           '%A' => 'date.day_names',
           '%a' => 'date.abbr_day_names',
           '%B' => 'date.month_names',
           '%b' => 'date.abbr_month_names'
         }
+        # rubocop:enable Style/FormatStringToken
         key_index = keys.keys.map { |key| [key, format.index(key)] }.to_h
         keys.select! { |k, _| key_index[k] }
         keys.sort_by { |k, _| key_index[k] }.map do |_, k|
@@ -226,37 +228,60 @@ module ActiveScaffold
         [format, parts[:offset]]
       end
 
+      def local_time_from_hash(value, conversion = :to_time)
+        time = Time.zone.local(*%i[year month day hour minute second].collect { |part| value[part].to_i })
+        time.send(conversion)
+      rescue StandardError => e
+        message = "Error creating time from #{value.inspect}:"
+        Rails.logger.warn "#{message}\n#{e.message}\n#{e.backtrace.join("\n")}"
+        nil
+      end
+
+      def parse_date_with_format(value, format_name)
+        format = I18n.t("date.formats.#{format_name || :default}")
+        format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
+        en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
+        Date.strptime(en_value, format)
+      rescue StandardError => e
+        message = "Error parsing date from #{en_value}"
+        message << " (#{value})" if en_value != value
+        message << ", with format #{format}" if format
+        Rails.logger.warn "#{message}:\n#{e.message}\n#{e.backtrace.join("\n")}"
+        nil
+      end
+
+      def parse_time_with_format(value, format, offset)
+        format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
+        en_value = I18n.locale == :en ? value : translate_days_and_months(value, format)
+        time = Time.strptime(en_value, format)
+        offset ? time : Time.zone.local_to_utc(time).in_time_zone
+      rescue StandardError => e
+        message = "Error parsing time from #{en_value}"
+        message << " (#{value})" if en_value != value
+        message << ", with format #{format}" if format
+        Rails.logger.warn "#{message}:\n#{e.message}\n#{e.backtrace.join("\n")}"
+        nil
+      end
+
       def condition_value_for_datetime(column, value, conversion = :to_time)
-        unless value.nil? || value.blank?
-          if value.is_a? Hash
-            time = Time.zone.local(*%i[year month day hour minute second].collect { |part| value[part].to_i }) rescue nil
-            time.send(conversion) if time
-          elsif value.respond_to?(:strftime)
-            if conversion == :to_time
-              # Explicitly get the current zone, because TimeWithZone#to_time in rails 3.2.3 returns UTC.
-              # https://github.com/rails/rails/pull/2453
-              value.to_time.in_time_zone
-            else
-              value.send(conversion)
-            end
-          elsif conversion == :to_date
-            format = I18n.t("date.formats.#{column.options[:format] || :default}")
-            format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
-            value = translate_days_and_months(value, format) if I18n.locale != :en
-            Date.strptime(value, format) rescue nil
-          elsif value.include?('T')
-            Time.zone.parse(value)
-          else # datetime
-            format, offset = format_for_datetime(column, value)
-            format.gsub!(/%-d|%-m|%_m/) { |s| s.gsub(/[-_]/, '') } # strptime fails with %-d, %-m, %_m
-            value = translate_days_and_months(value, format) if I18n.locale != :en
-            time = DateTime.strptime(value, format) rescue nil
-            if time
-              time = Time.zone.local_to_utc(time).in_time_zone unless offset
-              time = time.send(conversion) unless conversion == :to_time
-            end
-            time
+        return if value.nil? || value.blank?
+        if value.is_a? Hash
+          local_time_from_hash(value, conversion)
+        elsif value.respond_to?(:strftime)
+          if conversion == :to_time
+            # Explicitly get the current zone, because TimeWithZone#to_time in rails 3.2.3 returns UTC.
+            # https://github.com/rails/rails/pull/2453
+            value.to_time.in_time_zone
+          else
+            value.send(conversion)
           end
+        elsif conversion == :to_date
+          parse_date_with_format(value, column.options[:format])
+        elsif value.include?('T')
+          Time.zone.parse(value)
+        else # datetime
+          time = parse_time_with_format(value, *format_for_datetime(column, value))
+          conversion == :to_time ? time : time.send(conversion)
         end
       end
 
@@ -264,14 +289,15 @@ module ActiveScaffold
         return value if value.nil?
         value = column.number_to_native(value) if column.options[:format] && column.search_ui != :number
         case (column.search_ui || column.column.type)
-        when :integer   then value.to_i rescue value ? 1 : 0
-        when :float     then value.to_f
-        when :decimal
-          if Rails.version >= '4.2.0'
-            ::ActiveRecord::Type::Decimal.new.type_cast_from_user(value)
+        when :integer   then
+          if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            value ? 1 : 0
           else
-            ::ActiveRecord::ConnectionAdapters::Column.value_to_decimal(value)
+            value.to_i
           end
+        when :float     then value.to_f
+        when :decimal
+          ::ActiveRecord::Type::Decimal.new.type_cast_from_user(value)
         else
           value
         end
@@ -293,28 +319,28 @@ module ActiveScaffold
         if from_value.nil? && to_value.nil?
           nil
         elsif !from_value
-          ['%{search_sql} <= ?', to_value.to_s(:db)]
+          ['%<search_sql>s <= ?', to_value.to_s(:db)]
         elsif !to_value
-          ['%{search_sql} >= ?', from_value.to_s(:db)]
+          ['%<search_sql>s >= ?', from_value.to_s(:db)]
         else
-          ['%{search_sql} BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)]
+          ['%<search_sql>s BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)]
         end
       end
 
       def condition_for_record_select_type(column, value, like_pattern = nil)
         if value.is_a?(Array)
-          ['%{search_sql} IN (?)', value]
+          ['%<search_sql>s IN (?)', value]
         else
-          ['%{search_sql} = ?', value]
+          ['%<search_sql>s = ?', value]
         end
       end
 
       def condition_for_null_type(column, value, like_pattern = nil)
         case value.to_s
         when 'null'
-          ['%{search_sql} is null', []]
+          ['%<search_sql>s is null', []]
         when 'not_null'
-          ['%{search_sql} is not null', []]
+          ['%<search_sql>s is not null', []]
         end
       end
     end
@@ -366,10 +392,12 @@ module ActiveScaffold
       @active_scaffold_references ||= []
     end
 
-    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
+    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List).
+    # The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
     def conditions_for_collection; end
 
-    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
+    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).
+    # The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
     def joins_for_collection; end
 
     # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
@@ -381,9 +409,9 @@ module ActiveScaffold
       params_hash active_scaffold_embedded_params[:conditions]
     end
 
-    def all_conditions
+    def all_conditions(include_id_condition = true)
       [
-        id_condition,                                 # for list with id (e.g. /users/:id/index)
+        (id_condition if include_id_condition),       # for list with id (e.g. /users/:id/index)
         active_scaffold_conditions,                   # from the search modules
         conditions_for_collection,                    # from the dev
         conditions_from_params,                       # from the parameters (e.g. /users/list?first_name=Fred)
@@ -407,15 +435,20 @@ module ActiveScaffold
     end
 
     # valid options may include:
-    # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction, e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]). please note that multi-column sorting has some limitations: if any column in a multi-field sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
+    # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction,
+    #     e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]).
+    #     please note that multi-column sorting has some limitations: if any column in a multi-field
+    #     sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
     # * :per_page
     # * :page
     def finder_options(options = {})
       search_conditions = all_conditions
 
+      sorting = options[:sorting]&.clause((grouped_columns_calculations if grouped_search?))
+      sorting = sorting.map(&Arel.method(:sql)) if sorting && active_scaffold_config.active_record?
       # create a general-use options array that's compatible with Rails finders
       finder_options = {
-        :reorder => options[:sorting].try(:clause, (grouped_columns_calculations if grouped_search?)),
+        :reorder => sorting,
         :conditions => search_conditions
       }
       if active_scaffold_config.mongoid?
@@ -466,7 +499,7 @@ module ActiveScaffold
 
       query = append_to_query(query, find_options)
       # we build the paginator differently for method- and sql-based sorting
-      pager = if options[:sorting] && options[:sorting].sorts_by_method?
+      pager = if options[:sorting]&.sorts_by_method?
                 ::Paginator.new(count, options[:per_page]) do |offset, per_page|
                   calculate_last_modified(query)
                   sorted_collection = sort_collection_by_column(query.to_a, *options[:sorting].first)
@@ -484,12 +517,12 @@ module ActiveScaffold
     end
 
     def calculate_last_modified(query)
-      return unless conditional_get_support? && query.klass.columns_hash['updated_at']
+      return unless conditional_get_support? && ActiveScaffold::OrmChecks.columns_hash(query.klass)['updated_at']
       @last_modified = query.maximum(:updated_at)
     end
 
-    def calculate_query
-      conditions = all_conditions
+    def calculate_query(id_condition = true)
+      conditions = all_conditions(id_condition)
       includes = active_scaffold_config.list.count_includes
       includes ||= active_scaffold_references if conditions.present?
       left_joins = active_scaffold_outer_joins
@@ -501,13 +534,13 @@ module ActiveScaffold
     end
 
     def append_to_query(relation, options)
-      options.assert_valid_keys :where, :select, :having, :group, :reorder, :order, :limit, :offset, :joins, :left_joins, :left_outer_joins, :includes, :lock, :readonly, :from, :conditions, :preload, :references
+      options.assert_valid_keys :where, :select, :having, :group, :reorder, :order, :limit, :offset,
+                                :joins, :left_joins, :left_outer_joins, :includes, :lock, :readonly,
+                                :from, :conditions, :preload, :references
       relation = options.reject { |_, v| v.blank? }.inject(relation) do |rel, (k, v)|
         k == :conditions ? apply_conditions(rel, *v) : rel.send(k, v)
       end
-      if options[:left_outer_joins].present? || options[:left_joins].present?
-        relation.distinct_value = true
-      end
+      relation.distinct_value = true if options[:left_outer_joins].present? || options[:left_joins].present?
       relation
     end
 
@@ -536,7 +569,7 @@ module ActiveScaffold
     def sort_collection_by_column(collection, column, order)
       sorter = column.sort[:method]
       collection = collection.sort_by do |record|
-        value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter.to_s)
+        value = sorter.is_a?(Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter.to_s)
         value = '' if value.nil?
         value
       end