active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -15,9 +15,17 @@ module ActiveScaffold
         end
       end
 
+      def active_scaffold_grouped_by_label
+        text, = active_scaffold_config.field_search.group_options.find do |text, value|
+          (value || text).to_s == field_search_params['active_scaffold_group']
+        end
+        active_scaffold_translated_option(active_scaffold_group_column, text).first if text
+      end
+
       def format_human_condition(column, opt, from = nil, to = nil)
         attribute = column.active_record_class.human_attribute_name(column.name)
-        opt ||= from && to ? :between : (from ? :'>=' : :'<=')
+        opt ||= :between if from && to
+        opt ||= from ? '>=' : '<='
         "#{attribute} #{as_(opt).downcase} #{from} #{to}"
       end
 
@@ -26,8 +34,8 @@ module ActiveScaffold
         to = "- #{format_number_value(controller.class.condition_value_for_numeric(column, value['to']), column.options)}" if value['opt'] == 'BETWEEN'
         format_human_condition column, value['opt'].downcase, from, to
       end
-      alias_method :active_scaffold_human_condition_decimal, :active_scaffold_human_condition_integer
-      alias_method :active_scaffold_human_condition_float, :active_scaffold_human_condition_integer
+      alias active_scaffold_human_condition_decimal active_scaffold_human_condition_integer
+      alias active_scaffold_human_condition_float active_scaffold_human_condition_integer
 
       def active_scaffold_human_condition_string(column, value)
         opt = ActiveScaffold::Finder::STRING_COMPARATORS.key(value['opt']) || value['opt']
@@ -43,16 +51,16 @@ module ActiveScaffold
         to = "- #{I18n.l to}" if to
         format_human_condition column, value['opt'], from, to
       end
-      alias_method :active_scaffold_human_condition_time, :active_scaffold_human_condition_date
-      alias_method :active_scaffold_human_condition_datetime, :active_scaffold_human_condition_date
-      alias_method :active_scaffold_human_condition_timestamp, :active_scaffold_human_condition_date
+      alias active_scaffold_human_condition_time active_scaffold_human_condition_date
+      alias active_scaffold_human_condition_datetime active_scaffold_human_condition_date
+      alias active_scaffold_human_condition_timestamp active_scaffold_human_condition_date
 
       def active_scaffold_human_condition_boolean(column, value)
         attribute = column.active_record_class.human_attribute_name(column.name)
         label = as_(ActiveScaffold::Core.column_type_cast(value, column.column) ? :true : :false)
         as_(:boolean, :scope => :human_conditions, :column => attribute, :value => label)
       end
-      alias_method :active_scaffold_human_condition_checkbox, :active_scaffold_human_condition_boolean
+      alias active_scaffold_human_condition_checkbox active_scaffold_human_condition_boolean
 
       def active_scaffold_human_condition_null(column, value)
         format_human_condition column, value.to_sym
@@ -66,21 +74,23 @@ module ActiveScaffold
           associated = column.association.klass.where(:id => associated.map(&:to_i)).map(&method)
         elsif column.options[:options]
           associated = associated.collect do |value|
-            text, val = column.options[:options].find { |text, val| (val.nil? ? text : val).to_s == value.to_s }
+            text, val = column.options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
             value = active_scaffold_translated_option(column, text, val).first if text
             value
           end
         end
         as_(:association, :scope => :human_conditions, :column => attribute, :value => associated.join(', '))
       end
-      alias_method :active_scaffold_human_condition_multi_select, :active_scaffold_human_condition_select
-      alias_method :active_scaffold_human_condition_record_select, :active_scaffold_human_condition_select
+      alias active_scaffold_human_condition_multi_select active_scaffold_human_condition_select
+      alias active_scaffold_human_condition_record_select active_scaffold_human_condition_select
+      alias active_scaffold_human_condition_chosen active_scaffold_human_condition_select
+      alias active_scaffold_human_condition_multi_chosen active_scaffold_human_condition_select
 
       # the naming convention for overriding form fields with helpers
       def override_human_condition_column(column)
         override_helper column, 'human_condition_column'
       end
-      alias_method :override_human_condition_column?, :override_human_condition_column
+      alias override_human_condition_column? override_human_condition_column
 
       def override_human_condition?(search_ui)
         respond_to?(override_human_condition(search_ui))

data/lib/active_scaffold/helpers/id_helpers.rb

@@ -130,7 +130,7 @@ module ActiveScaffold
 
       # whitelists id-safe characters
       def clean_id(val)
-        val.gsub /[^-_0-9a-zA-Z]/, '-'
+        val.gsub(/[^-_0-9a-zA-Z]/, '-')
       end
     end
   end

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -1,11 +1,15 @@
-# coding: utf-8
 module ActiveScaffold
   module Helpers
     # Helpers that assist with the rendering of a List Column
     module ListColumnHelpers
       def get_column_value(record, column)
-        method = get_column_method(record, column)
-        value = send(method, record, column)
+        record = record.send(column.delegated_association.name) if column.delegated_association
+        if record
+          method = get_column_method(record, column)
+          value = send(method, record, column)
+        else
+          value = nil
+        end
         value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6
         return value
       rescue StandardError => e
@@ -38,7 +42,9 @@ module ActiveScaffold
         if column.link && !skip_action_link?(column.link, record)
           link = column.link
           associated = record.send(column.association.name) if column.association
-          render_action_link(link, record, :link => text, :authorized => link.action.nil? || column_link_authorized?(link, column, record, associated))
+          authorized = link.action.nil?
+          authorized, reason = column_link_authorized?(link, column, record, associated) unless authorized
+          render_action_link(link, record, :link => text, :authorized => authorized, :not_authorized_reason => reason)
         elsif inplace_edit?(record, column)
           active_scaffold_inplace_edit(record, column, :formatted_column => text)
         elsif active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.wrap_tag
@@ -84,7 +90,7 @@ module ActiveScaffold
         options.delete(:disabled) if inplace_edit?(record, column)
         check_box(:record, column.name, options)
       end
-      
+
       def active_scaffold_column_percentage(record, column)
         options = column.options[:slider] || {}
         options = options.merge(min: record.send(options[:min_method])) if options[:min_method]
@@ -93,10 +99,31 @@ module ActiveScaffold
         as_slider options.merge(value: value || record.send(column.name))
       end
 
+      def active_scaffold_column_month(record, column)
+        l record.send(column.name), format: :year_month
+      end
+
+      def active_scaffold_column_week(record, column)
+        l record.send(column.name), format: :week
+      end
+
+      def tel_to(text)
+        groups = text.to_s.scan(/(?:^\+)?\d+/)
+        extension = groups.pop if text.to_s =~ /\s*[^\d\s]+\s*\d+$/
+        link_to text, "tel:#{[groups.join('-'), extension].compact.join(',')}"
+      end
+
+      def active_scaffold_column_telephone(record, column)
+        phone = record.send column.name
+        return if phone.blank?
+        phone = number_to_phone(phone) unless column.options[:format] == false
+        tel_to phone
+      end
+
       def column_override(column)
         override_helper column, 'column'
       end
-      alias_method :column_override?, :column_override
+      alias column_override? column_override
 
       # the naming convention for overriding column types with helpers
       def override_column_ui(list_ui)
@@ -105,7 +132,7 @@ module ActiveScaffold
         method = "active_scaffold_column_#{list_ui}"
         @_column_ui_overrides[list_ui] = (method if respond_to? method)
       end
-      alias_method :override_column_ui?, :override_column_ui
+      alias override_column_ui? override_column_ui
 
       ##
       ## Formatting
@@ -113,19 +140,23 @@ module ActiveScaffold
       def format_column_value(record, column, value = nil)
         value ||= record.send(column.name) unless record.nil?
         if column.association.nil?
-          if [:select, :radio].include?(column.form_ui) && column.options[:options]
-            text, val = column.options[:options].find { |text, val| (val.nil? ? text : val).to_s == value.to_s }
+          if %i[select radio].include?(column.form_ui) && column.options[:options]
+            text, val = column.options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
             value = active_scaffold_translated_option(column, text, val).first if text
           end
-          if value.is_a? Numeric
+          if grouped_search? && column == search_group_column && search_group_function
+            format_grouped_search_column(value, column.options)
+          elsif value.is_a? Numeric
             format_number_value(value, column.options)
           else
             format_value(value, column.options)
           end
         else
-          if column.plural_association?
+          if column.association.collection?
             associated_size = value.size if column.associated_number? # get count before cache association
-            cache_association(record.association(column.name), column, associated_size) unless value.loaded?
+            if column.association.respond_to_target? && !value.loaded?
+              cache_association(record.association(column.name), column, associated_size)
+            end
           end
           format_association_value(value, column, associated_size)
         end
@@ -134,38 +165,55 @@ module ActiveScaffold
       def format_number_value(value, options = {})
         if value
           value = case options[:format]
-            when :size
-              number_to_human_size(value, options[:i18n_options] || {})
-            when :percentage
-              number_to_percentage(value, options[:i18n_options] || {})
-            when :currency
-              number_to_currency(value, options[:i18n_options] || {})
-            when :i18n_number
-              send("number_with_#{value.is_a?(Integer) ? 'delimiter' : 'precision'}", value, options[:i18n_options] || {})
-            else
-              value
+                  when :size
+                    number_to_human_size(value, options[:i18n_options] || {})
+                  when :percentage
+                    number_to_percentage(value, options[:i18n_options] || {})
+                  when :currency
+                    number_to_currency(value, options[:i18n_options] || {})
+                  when :i18n_number
+                    send("number_with_#{value.is_a?(Integer) ? 'delimiter' : 'precision'}", value, options[:i18n_options] || {})
+                  else
+                    value
           end
         end
         clean_column_value(value)
       end
 
+      def format_grouped_search_column(value, options = {})
+        case search_group_function
+        when 'year_month'
+          year, month = value.to_s.scan(/(\d*)(\d{2})/)[0]
+          I18n.l(Date.new(year.to_i, month.to_i, 1), format: options[:group_format] || search_group_function.to_sym)
+        when 'year_quarter'
+          year, quarter = value.to_s.scan(/(\d*)(\d)/)[0]
+          I18n.t(options[:group_format] || search_group_function, scope: 'date.formats', year: year, quarter: quarter)
+        when 'quarter'
+          I18n.t(options[:group_format] || search_group_function, scope: 'date.formats', num: value)
+        when 'month'
+          I18n.l(Date.new(Time.zone.today.year, value, 1), format: options[:group_format] || search_group_function.to_sym)
+        else value
+        end
+      end
+
       def format_collection_association_value(value, column, label_method, size)
         if column.associated_limit.nil?
           firsts = value.collect(&label_method)
-        elsif column.associated_limit == 0
+          safe_join firsts, active_scaffold_config.list.association_join_text
+        elsif column.associated_limit.zero?
           size if column.associated_number?
         else
-          firsts = value.first(column.associated_limit)
-          firsts.collect!(&label_method)
+          firsts = value.loaded? ? value[0, column.associated_limit] : value.limit(column.associated_limit)
+          firsts = firsts.map(&label_method)
           firsts << '…' if value.size > column.associated_limit
-          text = firsts.join(h(active_scaffold_config.list.association_join_text)).html_safe
+          text = safe_join firsts, active_scaffold_config.list.association_join_text
           text << " (#{size})" if column.associated_number? && column.associated_limit && value.size > column.associated_limit
           text
         end
       end
 
       def format_singular_association_value(value, column, label_method)
-        if column.polymorphic_association?
+        if column.association.polymorphic?
           "#{value.class.model_name.human}: #{value.send(label_method)}"
         else
           value.send(label_method)
@@ -215,7 +263,14 @@ module ActiveScaffold
 
       def inplace_edit?(record, column)
         return unless column.inplace_edit
-        editable = controller.send(:update_authorized?, record) if controller.respond_to?(:update_authorized?, true)
+        if controller.respond_to?(:update_authorized?, true)
+          if controller.method(:update_authorized?).parameters.size == 2
+            return Array(controller.send(:update_authorized?, record, column.name))[0]
+          else
+            ActiveSupport::Deprecation.warn 'add column = nil parameter to update_authorized? on your controller'
+            editable = Array(controller.send(:update_authorized?, record))[0]
+          end
+        end
         editable || record.authorized_for?(:crud_type => :update, :column => column.name)
       end
 
@@ -239,17 +294,14 @@ module ActiveScaffold
 
       def inplace_edit_control(column)
         return unless inplace_edit?(active_scaffold_config.model, column) && inplace_edit_cloning?(column)
-        old_record, @record = @record, active_scaffold_config.model.new # TODO: remove when relying on @record is removed
         column = column.clone
         column.options = column.options.clone
         column.form_ui = :select if column.association && column.form_ui.nil?
-        options = active_scaffold_input_options(column).merge(:object => active_scaffold_config.model.new)
+        options = active_scaffold_input_options(column).merge(:object => column.active_record_class.new)
         options[:class] = "#{options[:class]} inplace_field"
         options[:"data-id"] = options[:id]
         options[:id] = nil
-        content_tag(:div, active_scaffold_input_for(column, nil, options), :style => 'display:none;', :class => inplace_edit_control_css_class).tap do
-          @record = old_record # TODO: remove when relying on @record is removed
-        end
+        content_tag(:div, active_scaffold_input_for(column, nil, options), :style => 'display:none;', :class => inplace_edit_control_css_class)
       end
 
       def inplace_edit_control_css_class
@@ -273,8 +325,8 @@ module ActiveScaffold
         elsif inplace_edit_cloning?(column)
           data[:ie_mode] = :clone
         elsif column.inplace_edit == :ajax
-          url = url_for(:controller => params_for[:controller], :action => 'render_field', :id => '__id__', :update_column => column.name)
-          plural = column.plural_association? && !override_form_field?(column) && [:select, :record_select].include?(column.form_ui)
+          url = url_for(params_for(:controller => params_for[:controller], :action => 'render_field', :id => '__id__', :update_column => column.name))
+          plural = column.association.try(:collection?) && !override_form_field?(column) && %i[select record_select].include?(column.form_ui)
           data[:ie_render_url] = url
           data[:ie_mode] = :ajax
           data[:ie_plural] = plural
@@ -282,6 +334,8 @@ module ActiveScaffold
         data
       end
 
+      # MARK
+
       def all_marked?
         if active_scaffold_config.mark.mark_all_mode == :page
           @page.items.detect { |record| !marked_records.include?(record.id) }.nil?
@@ -298,6 +352,8 @@ module ActiveScaffold
         content_tag(:span, check_box_tag("#{controller_id}_mark_heading_span_input", '1', all_marked?), tag_options)
       end
 
+      # COLUMN HEADINGS
+
       def column_heading_attributes(column, sorting, sort_direction)
         {:id => active_scaffold_column_header_id(column), :class => column_heading_class(column, sorting), :title => strip_tags(column.description).presence}
       end
@@ -322,11 +378,12 @@ module ActiveScaffold
           options = {:id => nil, :class => 'as_sort',
                      'data-page-history' => controller_id,
                      :remote => true, :method => :get}
-          # :id needed because rails reuse it even if we delete from params (like do_refresh_list does)
-          url_options = params_for(:action => :index, :page => 1, :id => params[:id],
-                                   :sort => column.name, :sort_direction => sort_direction)
+          url_options = {action: :index, page: 1, sort: column.name, sort_direction: sort_direction}
+          # :id needed because rails reuse it even if it was deleted from params (like do_refresh_list does)
+          url_options[:id] = nil if @remove_id_from_list_links
+          url_options = params_for(url_options)
           unless active_scaffold_config.store_user_settings
-            url_options.merge!(:search => search_params) if search_params.present?
+            url_options[:search] = search_params if respond_to?(:search_params) && search_params.present?
           end
           link_to column_heading_label(column), url_options, options
         else
@@ -337,6 +394,27 @@ module ActiveScaffold
       def column_heading_label(column)
         column.label
       end
+
+      # CALCULATIONS
+
+      def column_calculation(column)
+        if column.calculate.instance_of? Proc
+          column.calculate.call(@records)
+        else
+          calculate_query.calculate(column.calculate, column.name)
+        end
+      end
+
+      def render_column_calculation(column)
+        calculation = column_calculation(column)
+        override_formatter = "render_#{column.name}_#{column.calculate.is_a?(Proc) ? :calculate : column.calculate}"
+        calculation = send(override_formatter, calculation) if respond_to? override_formatter
+        format_column_calculation(column, calculation)
+      end
+
+      def format_column_calculation(column, calculation)
+        "#{"#{as_(column.calculate)}: " unless column.calculate.is_a? Proc}#{format_column_value nil, column, calculation}"
+      end
     end
   end
 end

data/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -6,14 +6,11 @@ module ActiveScaffold
       end
 
       def pagination_url_options(url_options = nil)
-        # :id needed because rails reuse it even if we delete from params (like do_refresh_list does)
-        url_options ||= params_for(:action => @pagination_action || :index, :id => params[:id])
-        unless active_scaffold_config.store_user_settings
-          url_options.merge!(:search => search_params) if search_params.present?
-          if active_scaffold_config.list.user.user_sorting?
-            column, direction = active_scaffold_config.list.user.sorting.first
-            url_options.merge!(:sort => column.name, :sort_direction => direction)
-          end
+        if url_options.nil?
+          url_options = {action: @pagination_action || :index}
+          # :id needed because rails reuse it even if it was deleted from params (like do_refresh_list does)
+          url_options[:id] = nil if @remove_id_from_list_links
+          url_options = params_for(url_options)
         end
         url_options
       end
@@ -51,11 +48,11 @@ module ActiveScaffold
         html << '..' if start_number > last_page + 1
 
         [start_number, last_page + 1].max.upto(end_number) do |num|
-          if current_page.number == num
-            html << content_tag(:span, num.to_s, :class => 'as_paginate current')
-          else
-            html << pagination_ajax_link(num, url_options, options)
-          end
+          html << if current_page.number == num
+                    content_tag(:span, num.to_s, :class => 'as_paginate current')
+                  else
+                    pagination_ajax_link(num, url_options, options)
+                  end
         end
 
         if current_page.pager.infinite?
@@ -68,7 +65,7 @@ module ActiveScaffold
             html << pagination_ajax_link(num, url_options, options)
           end
         end
-        html.join(' ').html_safe
+        safe_join html, ' '
       end
     end
   end

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -7,8 +7,10 @@ module ActiveScaffold
       def active_scaffold_search_for(column, options = nil)
         options ||= active_scaffold_search_options(column)
         record = options[:object]
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
+        if column.delegated_association
+          record = record.send(column.delegated_association.name) || column.active_record_class.new
+          options[:object] = record
+        end
 
         # first, check if the dev has created an override for this specific field for search
         if (method = override_search_field(column))
@@ -41,7 +43,7 @@ module ActiveScaffold
             # final ultimate fallback: use rails' generic input method
             else
               # for textual fields we pass different options
-              text_types = [:text, :string, :integer, :float, :decimal]
+              text_types = %i[text string integer float decimal]
               options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
               text_field(:record, column.name, options.merge(column.options))
             end
@@ -64,7 +66,7 @@ module ActiveScaffold
       end
 
       def search_label_for(column, options)
-        options[:id] unless [:range, :integer, :decimal, :float, :string, :date_picker, :datetime_picker, :calendar_date_select].include? column.search_ui
+        options[:id] unless %i[range integer decimal float string date_picker datetime_picker calendar_date_select].include? column.search_ui
       end
 
       ##
@@ -73,8 +75,6 @@ module ActiveScaffold
 
       def active_scaffold_search_multi_select(column, options)
         record = options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         associated = options.delete :value
         associated = [associated].compact unless associated.is_a? Array
 
@@ -96,12 +96,10 @@ module ActiveScaffold
 
       def active_scaffold_search_select(column, html_options, options = {})
         record = html_options.delete(:object)
-        ActiveSupport::Deprecation.warn 'Relying on @record is deprecated, include :object in html_options with record.', caller if record.nil? # TODO: Remove when relying on @record is removed
-        record ||= @record # TODO: Remove when relying on @record is removed
         associated = html_options.delete :value
         if column.association
           associated = associated.is_a?(Array) ? associated.map(&:to_i) : associated.to_i unless associated.nil?
-          method = column.association.macro == :belongs_to ? column.association.foreign_key : column.name
+          method = column.association.belongs_to? ? column.association.foreign_key : column.name
           select_options = sorted_association_options_find(column.association, false, record)
         else
           method = column.name
@@ -113,7 +111,7 @@ module ActiveScaffold
         options = options.merge(:selected => associated).merge column.options
         html_options.merge! column.options[:html_options] || {}
         if html_options[:multiple]
-          html_options[:name] += '[]'
+          active_scaffold_select_name_with_multiple html_options
         else
           options[:include_blank] ||= as_(:_select_)
           active_scaffold_translate_select_options(options)
@@ -143,7 +141,27 @@ module ActiveScaffold
         select_tag(options[:name], options_for_select(select_options, ActiveScaffold::Core.column_type_cast(options[:value], column.column)), :id => options[:id])
       end
       # we can't use checkbox ui because it's not possible to decide whether search for this field or not
-      alias_method :active_scaffold_search_checkbox, :active_scaffold_search_boolean
+      alias active_scaffold_search_checkbox active_scaffold_search_boolean
+
+      def active_scaffold_group_search_column(record, options)
+        select_tag 'search[active_scaffold_group]', options_for_select(active_scaffold_group_search_options, selected: field_search_params['active_scaffold_group'])
+      end
+
+      def active_scaffold_group_search_options
+        options = active_scaffold_config.field_search.group_options.collect do |text, value|
+          active_scaffold_translated_option(active_scaffold_group_column, text, value)
+        end
+        [[as_(:no_group), '']].concat options
+      end
+
+      def active_scaffold_group_column
+        return if active_scaffold_config.field_search.group_options.blank?
+        @_active_scaffold_group_column ||= begin
+          column = ActiveScaffold::DataStructures::Column.new(:active_scaffold_group, active_scaffold_config.model)
+          column.label = :group_by
+          column
+        end
+      end
 
       def active_scaffold_search_null(column, options)
         select_options = []
@@ -165,10 +183,11 @@ module ActiveScaffold
       def active_scaffold_search_range_comparator_options(column)
         select_options = ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
         if active_scaffold_search_range_string?(column)
-          select_options.unshift *ActiveScaffold::Finder::STRING_COMPARATORS.collect { |title, comp| [as_(title), comp] }
+          comparators = ActiveScaffold::Finder::STRING_COMPARATORS.collect { |title, comp| [as_(title), comp] }
+          select_options.unshift(*comparators)
         end
         if include_null_comparators? column
-          select_options += ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] }
+          select_options.concat ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] }
         end
         select_options
       end
@@ -176,13 +195,13 @@ module ActiveScaffold
       def include_null_comparators?(column)
         return column.options[:null_comparators] if column.options.key? :null_comparators
         if column.association
-          column.association.macro != :belongs_to || active_scaffold_config.columns[column.association.foreign_key].column.try(:null)
+          !column.association.belongs_to? || active_scaffold_config.columns[column.association.foreign_key].column.try(:null)
         else
           column.column.try(:null)
         end
       end
 
-      def active_scaffold_search_range(column, options)
+      def active_scaffold_search_range(column, options, input_method = :text_field_tag, input_options = {})
         opt_value, from_value, to_value = field_search_params_range_values(column)
 
         select_options = active_scaffold_search_range_comparator_options(column)
@@ -199,34 +218,48 @@ module ActiveScaffold
         to_value = format_number_value(to_value, column.options) if to_value.is_a?(Numeric)
         html = select_tag("#{options[:name]}[opt]", options_for_select(select_options, opt_value),
                           :id => "#{options[:id]}_opt", :class => 'as_search_range_option')
+        from_options = active_scaffold_input_text_options(input_options.merge(:id => options[:id], :size => text_field_size))
+        to_options = from_options.merge(:id => "#{options[:id]}_to")
         html << content_tag('span', :id => "#{options[:id]}_numeric", :style => ActiveScaffold::Finder::NULL_COMPARATORS.include?(opt_value) ? 'display: none' : nil) do
-          text_field_tag("#{options[:name]}[from]", from_value, active_scaffold_input_text_options(:id => options[:id], :size => text_field_size)) <<
+          send(input_method, "#{options[:name]}[from]", from_value, input_options) <<
             content_tag(
-              :span, (
-                ' - ' + text_field_tag("#{options[:name]}[to]", to_value,
-                                       active_scaffold_input_text_options(:id => "#{options[:id]}_to", :size => text_field_size))
-              ).html_safe,
+              :span,
+              safe_join([' - ', send(input_method, "#{options[:name]}[to]", to_value, to_options)]),
               :id => "#{options[:id]}_between", :class => 'as_search_range_between', :style => (opt_value == 'BETWEEN') ? nil : 'display: none'
             )
         end
         content_tag :span, html, :class => 'search_range'
       end
-      alias_method :active_scaffold_search_integer, :active_scaffold_search_range
-      alias_method :active_scaffold_search_decimal, :active_scaffold_search_range
-      alias_method :active_scaffold_search_float, :active_scaffold_search_range
-      alias_method :active_scaffold_search_string, :active_scaffold_search_range
+      alias active_scaffold_search_string active_scaffold_search_range
+
+      def active_scaffold_search_integer(column, options)
+        active_scaffold_search_range(column, options, :number_field_tag, step: '1')
+      end
+
+      def active_scaffold_search_decimal(column, options)
+        active_scaffold_search_range(column, options, :number_field_tag, step: :any)
+      end
+      alias active_scaffold_search_float active_scaffold_search_decimal
 
       def field_search_datetime_value(value)
-        DateTime.new(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
+        Time.zone.local(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
       end
 
       def active_scaffold_search_datetime(column, options)
         _, from_value, to_value = field_search_params_range_values(column)
         options = column.options.merge(options)
-        helper = "select_#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
+        type = "#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
+        use_select = options.delete(:use_select)
+        helper = use_select ? "select_#{type}" : "#{type}#{'_local' if type == 'datetime'}_field"
+        if use_select
+          default_from_options = {include_blank: true, prefix: "#{options[:name]}[from]"}
+          default_to_options = {include_blank: true, prefix: "#{options[:name]}[to]"}
+        end
 
-        send(helper, field_search_datetime_value(from_value), {:include_blank => true, :prefix => "#{options[:name]}[from]"}.merge(options)) <<
-          ' - '.html_safe << send(helper, field_search_datetime_value(to_value), {:include_blank => true, :prefix => "#{options[:name]}[to]"}.merge(options))
+        safe_join [
+          send(helper, field_search_datetime_value(from_value), options.reverse_merge(default_from_options || {})),
+          send(helper, field_search_datetime_value(to_value), options.reverse_merge(default_to_options || {}))
+        ], ' - '
       end
 
       def active_scaffold_search_date(column, options)
@@ -236,7 +269,7 @@ module ActiveScaffold
       def active_scaffold_search_time(column, options)
         active_scaffold_search_datetime(column, options.merge!(:discard_date => true))
       end
-      alias_method :active_scaffold_search_timestamp, :active_scaffold_search_datetime
+      alias active_scaffold_search_timestamp active_scaffold_search_datetime
 
       ##
       ## Search column override signatures
@@ -267,16 +300,20 @@ module ActiveScaffold
             visibles << column
           end
         end
+        if active_scaffold_group_column
+          columns = grouped_search? || search_config.optional_columns.empty? ? visibles : hiddens
+          columns << active_scaffold_group_column
+        end
         [visibles, hiddens]
       end
 
       def searched_by?(column)
-        value = field_search_params[column.name]
+        value = field_search_params[column.name.to_s]
         case value
         when Hash
-          !value['from'].blank?
+          value['from'].present?
         when String
-          !value.blank?
+          value.present?
         else
           false
         end