active_scaffold 3.5.3 → 3.6.0.rc2

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -57,7 +57,7 @@ module ActiveScaffold
 
       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)
+        label = as_(ActiveScaffold::Core.column_type_cast(value, column.column) ? :true : :false) # rubocop:disable Lint/BooleanSymbol
         as_(:boolean, :scope => :human_conditions, :column => attribute, :value => label)
       end
       alias active_scaffold_human_condition_checkbox active_scaffold_human_condition_boolean

data/lib/active_scaffold/helpers/id_helpers.rb

@@ -10,12 +10,16 @@ module ActiveScaffold
         'as_' + id_from_controller(controller)
       end
 
+      def nested?
+        false # will be overrided in AS controllers with helper_method
+      end
+
       def nested_parent_id
         nested_parent_record.id
       end
 
-      def nested_id(controller = params[:controller])
-        "#{nested.parent_scaffold.controller_path}-#{nested_parent_id}-#{controller}" if nested?
+      def nested_id(controller = nil)
+        "#{nested.parent_scaffold.controller_path}-#{nested_parent_id}-#{controller || params[:parent_controller] || params[:controller]}" if nested?
       end
 
       def active_scaffold_id

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -10,8 +10,8 @@ module ActiveScaffold
         else
           value = nil
         end
-        value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6
-        return value
+        value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6 # rubocop:disable Rails/OutputSafety
+        value
       rescue StandardError => e
         logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}, record: #{record.inspect}"
         raise e
@@ -19,7 +19,7 @@ module ActiveScaffold
 
       def get_column_method(record, column)
         # check for an override helper
-        column.list_method ||= begin
+        ActiveScaffold::Registry.cache :column_methods, column.cache_key do
           if (method = column_override(column))
             # we only pass the record as the argument. we previously also passed the formatted_value,
             # but mike perham pointed out that prohibited the usage of overrides to improve on the
@@ -47,8 +47,8 @@ module ActiveScaffold
           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
-          content_tag active_scaffold_config.list.wrap_tag, text
+        elsif column_wrap_tag
+          content_tag column_wrap_tag, text
         else
           text
         end
@@ -57,6 +57,11 @@ module ActiveScaffold
         raise e
       end
 
+      def column_wrap_tag
+        return @_column_wrap_tag if defined? @_column_wrap_tag
+        @_column_wrap_tag = (active_scaffold_config.list.wrap_tag if active_scaffold_config.actions.include?(:list))
+      end
+
       # There are two basic ways to clean a column's value: h() and sanitize(). The latter is useful
       # when the column contains *valid* html data, and you want to just disable any scripting. People
       # can always use field overrides to clean data one way or the other, but having this override
@@ -127,20 +132,21 @@ module ActiveScaffold
 
       # the naming convention for overriding column types with helpers
       def override_column_ui(list_ui)
-        @_column_ui_overrides ||= {}
-        return @_column_ui_overrides[list_ui] if @_column_ui_overrides.include? list_ui
-        method = "active_scaffold_column_#{list_ui}"
-        @_column_ui_overrides[list_ui] = (method if respond_to? method)
+        ActiveScaffold::Registry.cache :column_ui_overrides, list_ui do
+          method = "active_scaffold_column_#{list_ui}"
+          method if respond_to? method
+        end
       end
       alias override_column_ui? override_column_ui
 
       ##
       ## Formatting
       ##
+      FORM_UI_WITH_OPTIONS = %i[select radio].freeze
       def format_column_value(record, column, value = nil)
         value ||= record.send(column.name) unless record.nil?
         if column.association.nil?
-          if %i[select radio].include?(column.form_ui) && column.options[:options]
+          if FORM_UI_WITH_OPTIONS.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
@@ -153,7 +159,7 @@ module ActiveScaffold
           end
         else
           if column.association.collection?
-            associated_size = value.size if column.associated_number? # get count before cache association
+            associated_size = column_association_size(record, column, value) if column.associated_number? # get count before cache association
             if column.association.respond_to_target? && !value.loaded?
               cache_association(record.association(column.name), column, associated_size)
             end
@@ -162,20 +168,27 @@ module ActiveScaffold
         end
       end
 
+      def column_association_size(record, column, value)
+        cached_counts = @counts&.dig(column.name)
+        key = column.association.primary_key if count_on_association_class?(column)
+        cached_counts ? cached_counts[record.send(key || :id)] || 0 : value.size
+      end
+
       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
-          end
+          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
+            end
         end
         clean_column_value(value)
       end
@@ -196,18 +209,26 @@ module ActiveScaffold
         end
       end
 
+      def association_join_text(column = nil)
+        column_value = column&.association_join_text
+        return column_value if column_value
+        return @_association_join_text if defined? @_association_join_text
+        @_association_join_text = active_scaffold_config.list.association_join_text
+      end
+
       def format_collection_association_value(value, column, label_method, size)
-        if column.associated_limit.nil?
+        associated_limit = column.associated_limit
+        if associated_limit.nil?
           firsts = value.collect(&label_method)
-          safe_join firsts, active_scaffold_config.list.association_join_text
-        elsif column.associated_limit.zero?
+          safe_join firsts, association_join_text(column)
+        elsif associated_limit.zero?
           size if column.associated_number?
         else
-          firsts = value.loaded? ? value[0, column.associated_limit] : value.limit(column.associated_limit)
+          firsts = value.loaded? ? value[0, associated_limit] : value.limit(associated_limit)
           firsts = firsts.map(&label_method)
-          firsts << '…' if value.size > column.associated_limit
-          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
+          firsts << '…' if value.size > associated_limit
+          text = safe_join firsts, association_join_text(column)
+          text << " (#{size})" if column.associated_number? && associated_limit && value.size > associated_limit
           text
         end
       end
@@ -237,7 +258,7 @@ module ActiveScaffold
             empty_field_text
           elsif column_value.is_a?(Time) || column_value.is_a?(Date)
             l(column_value, :format => options[:format] || :default)
-          elsif [FalseClass, TrueClass].include?(column_value.class)
+          elsif !!column_value == column_value # rubocop:disable Style/DoubleNegation fast check for boolean
             as_(column_value.to_s.to_sym)
           else
             column_value.to_s
@@ -246,15 +267,21 @@ module ActiveScaffold
       end
 
       def cache_association(association, column, size)
+        associated_limit = column.associated_limit
         # we are not using eager loading, cache firsts records in order not to query the database for whole association in a future
-        if column.associated_limit.nil?
+        if associated_limit.nil?
           logger.warn "ActiveScaffold: Enable eager loading for #{column.name} association to reduce SQL queries"
-        elsif column.associated_limit > 0
+        elsif associated_limit.positive?
           # load at least one record more, is needed to display '...'
-          association.target = association.reader.limit(column.associated_limit + 1).select(column.select_associated_columns || "#{association.klass.quoted_table_name}.*").to_a
+          association.target = association.reader.limit(associated_limit + 1).select(column.select_associated_columns || "#{association.klass.quoted_table_name}.*").to_a
         elsif @cache_associations
           # set array with at least one element if size > 0, so blank? or present? works, saving [nil] may cause exceptions
-          association.target = size.to_i.zero? ? [] : [association.klass.new]
+          association.target =
+            if size.to_i.zero?
+              []
+            else
+              ActiveScaffold::Registry.cache(:cached_empty_association, association.klass) { [association.klass.new] }
+            end
         end
       end
 
@@ -265,14 +292,9 @@ module ActiveScaffold
       def inplace_edit?(record, column)
         return unless column.inplace_edit
         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
+          return Array(controller.send(:update_authorized?, record, column.name))[0]
         end
-        editable || record.authorized_for?(:crud_type => :update, :column => column.name)
+        record.authorized_for?(:crud_type => :update, :column => column.name)
       end
 
       def inplace_edit_cloning?(column)
@@ -280,23 +302,29 @@ module ActiveScaffold
       end
 
       def active_scaffold_inplace_edit_tag_options(record, column)
-        id_options = {:id => record.id.to_s, :action => 'update_column', :name => column.name.to_s}
-        tag_options = {:id => element_cell_id(id_options), :class => 'in_place_editor_field',
-                       :title => as_(:click_to_edit), :data => {:ie_id => record.to_param}}
+        @_inplace_edit_title ||= as_(:click_to_edit)
+        cell_id = ActiveScaffold::Registry.cache :inplace_edit_id, column.cache_key do
+          element_cell_id(id: '--ID--', action: 'update_column', name: column.name.to_s)
+        end
+        tag_options = {id: cell_id.sub('--ID--', record.id.to_s), class: 'in_place_editor_field',
+                       title: @_inplace_edit_title, data: {:ie_id => record.to_param}}
         tag_options[:data][:ie_update] = column.inplace_edit if column.inplace_edit != true
         tag_options
       end
 
       def active_scaffold_inplace_edit(record, column, options = {})
         formatted_column = options[:formatted_column] || format_column_value(record, column)
-        content_tag(:span, as_(:inplace_edit_handle), :class => 'handle') <<
-          content_tag(:span, formatted_column, active_scaffold_inplace_edit_tag_options(record, column))
+        @_inplace_edit_handle ||= content_tag(:span, as_(:inplace_edit_handle), :class => 'handle')
+        span = content_tag(:span, formatted_column, active_scaffold_inplace_edit_tag_options(record, column))
+        @_inplace_edit_handle + span
       end
 
       def inplace_edit_control(column)
         return unless inplace_edit?(active_scaffold_config.model, column) && inplace_edit_cloning?(column)
-        column = column.clone
-        column.options = column.options.clone
+        unless ActiveScaffold.threadsafe
+          column = column.dup
+          column.options = column.options.dup
+        end
         column.form_ui = :select if column.association && column.form_ui.nil?
         options = active_scaffold_input_options(column).merge(:object => column.active_record_class.new)
         options[:class] = "#{options[:class]} inplace_field"
@@ -309,6 +337,7 @@ module ActiveScaffold
         'as_inplace_pattern'
       end
 
+      INPLACE_EDIT_PLURAL_FORM_UI = %i[select record_select].freeze
       def inplace_edit_data(column)
         data = {}
         data[:ie_url] = url_for(params_for(:action => 'update_column', :column => column.name, :id => '__id__'))
@@ -316,7 +345,7 @@ module ActiveScaffold
         data[:ie_loading_text] = column.options[:loading_text] || as_(:loading)
         data[:ie_save_text] = column.options[:save_text] || as_(:update)
         data[:ie_saving_text] = column.options[:saving_text] || as_(:saving)
-        data[:ie_rows] = column.options[:rows] || 5 if column.column.try(:type) == :text
+        data[:ie_rows] = column.options[:rows] || 5 if column.column&.type == :text
         data[:ie_cols] = column.options[:cols] if column.options[:cols]
         data[:ie_size] = column.options[:size] if column.options[:size]
         data[:ie_use_html] = column.options[:use_html] if column.options[:use_html]
@@ -327,7 +356,7 @@ module ActiveScaffold
           data[:ie_mode] = :clone
         elsif column.inplace_edit == :ajax
           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)
+          plural = column.association&.collection? && !override_form_field?(column) && INPLACE_EDIT_PLURAL_FORM_UI.include?(column.form_ui)
           data[:ie_render_url] = url
           data[:ie_mode] = :ajax
           data[:ie_plural] = plural
@@ -366,8 +395,8 @@ module ActiveScaffold
             :ie_mode => :inline_checkbox,
             :ie_url => url_for(params_for(:action => 'mark', :id => '__id__'))
           }
-        else
-          tag_options[:data] = inplace_edit_data(column) if column.inplace_edit
+        elsif column.inplace_edit
+          tag_options[:data] = inplace_edit_data(column)
         end
         content_tag(:th, column_heading_value(column, sorting, sort_direction) + inplace_edit_control(column), tag_options)
       end
@@ -398,16 +427,16 @@ module ActiveScaffold
 
       # CALCULATIONS
 
-      def column_calculation(column)
+      def column_calculation(column, id_condition: true)
         if column.calculate.instance_of? Proc
           column.calculate.call(@records)
         else
-          calculate_query.calculate(column.calculate, column.name)
+          calculate_query(id_condition).calculate(column.calculate, column.name)
         end
       end
 
-      def render_column_calculation(column)
-        calculation = column_calculation(column)
+      def render_column_calculation(column, id_condition: true)
+        calculation = column_calculation(column, id_condition: id_condition)
         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)

data/lib/active_scaffold/helpers/pagination_helpers.rb

@@ -21,8 +21,8 @@ module ActiveScaffold
         start_number = 1 if start_number <= 0
         if current_page.pager.infinite?
           offsets = [20, 100]
-        else
-          end_number = current_page.pager.last.number if end_number > current_page.pager.last.number
+        elsif end_number > current_page.pager.last.number
+          end_number = current_page.pager.last.number
         end
 
         html = []

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -29,25 +29,22 @@ module ActiveScaffold
           send(method, record, options)
 
         # fallback: we get to make the decision
-        else
-          if column.association || column.virtual?
-            active_scaffold_search_text(column, options)
-
-          else # regular model attribute column
-            # if we (or someone else) have created a custom render option for the column type, use that
-            if (method = override_search(column.column.type))
-              send(method, column, options)
-            # if we (or someone else) have created a custom render option for the column type, use that
-            elsif (method = override_input(column.column.type))
-              send(method, column, options)
-            # final ultimate fallback: use rails' generic input method
-            else
-              # for textual fields we pass different options
-              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
-          end
+        elsif column.association || column.virtual?
+          active_scaffold_search_text(column, options)
+
+        elsif (method = override_search(column.column.type))
+          # if we (or someone else) have created a custom render option for the column type, use that
+          send(method, column, options)
+
+        elsif (method = override_input(column.column.type))
+          # if we (or someone else) have created a custom render option for the column type, use that
+          send(method, column, options)
+
+        else # final ultimate fallback: use rails' generic input method
+          # for textual fields we pass different options
+          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
       rescue StandardError => e
         logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
@@ -61,8 +58,10 @@ module ActiveScaffold
 
       def search_attribute(column, record)
         column_options = active_scaffold_search_options(column).merge(:object => record)
-        field = active_scaffold_search_for column, column_options
-        %(<dl><dt>#{label_tag search_label_for(column, column_options), search_column_label(column, record)}</dt><dd>#{field}</dd></dl>).html_safe
+        content_tag :dl do
+          content_tag(:dt, label_tag(search_label_for(column, column_options), search_column_label(column, record))) <<
+            content_tag(:dd, active_scaffold_search_for(column, column_options))
+        end
       end
 
       def search_label_for(column, options)
@@ -135,8 +134,8 @@ module ActiveScaffold
       def active_scaffold_search_boolean(column, options)
         select_options = []
         select_options << [as_(:_select_), nil]
-        select_options << [as_(:true), true]
-        select_options << [as_(:false), false]
+        select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
+        select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 
         select_tag(options[:name], options_for_select(select_options, ActiveScaffold::Core.column_type_cast(options[:value], column.column)), :id => options[:id])
       end
@@ -166,7 +165,7 @@ module ActiveScaffold
       def active_scaffold_search_null(column, options)
         select_options = []
         select_options << [as_(:_select_), nil]
-        select_options.concat ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] }
+        select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
         select_tag(options[:name], options_for_select(select_options, options[:value]), :id => options[:id])
       end
 
@@ -187,7 +186,7 @@ module ActiveScaffold
           select_options.unshift(*comparators)
         end
         if include_null_comparators? column
-          select_options.concat 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
@@ -195,9 +194,9 @@ module ActiveScaffold
       def include_null_comparators?(column)
         return column.options[:null_comparators] if column.options.key? :null_comparators
         if column.association
-          !column.association.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&.null
         else
-          column.column.try(:null)
+          column.column&.null
         end
       end
 
@@ -205,11 +204,7 @@ module ActiveScaffold
         opt_value, from_value, to_value = field_search_params_range_values(column)
 
         select_options = active_scaffold_search_range_comparator_options(column)
-        if active_scaffold_search_range_string?(column)
-          text_field_size = 15
-        else
-          text_field_size = 10
-        end
+        text_field_size = active_scaffold_search_range_string?(column) ? 15 : 10
         opt_value ||= select_options[0][1]
 
         from_value = controller.class.condition_value_for_numeric(column, from_value)
@@ -225,7 +220,7 @@ module ActiveScaffold
             content_tag(
               :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'
+              :id => "#{options[:id]}_between", :class => 'as_search_range_between', :style => ('display: none' unless opt_value == 'BETWEEN')
             )
         end
         content_tag :span, html, :class => 'search_range'
@@ -292,7 +287,7 @@ module ActiveScaffold
       def visibles_and_hiddens(search_config)
         visibles = []
         hiddens = []
-        search_config.columns.each do |column|
+        search_config.columns.each_column do |column|
           next unless column.search_sql
           if search_config.optional_columns.include?(column.name) && !searched_by?(column)
             hiddens << column