active_scaffold 3.6.0.pre → 3.6.0.rc1

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,6 +10,10 @@ 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

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -10,7 +10,7 @@ module ActiveScaffold
         else
           value = nil
         end
-        value = ' '.html_safe if value.nil? || value.blank? # fix for IE 6
+        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}"
@@ -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.positive?
+        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,17 +302,21 @@ 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)
@@ -311,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__'))
@@ -329,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&.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
@@ -368,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

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
@@ -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)

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -14,12 +14,10 @@ module ActiveScaffold
         # second, check if the dev has specified a valid list_ui for this column
         elsif column.show_ui && (method = override_show_column_ui(column.show_ui))
           send(method, value_record, column)
+        elsif column.column && (method = override_show_column_ui(column.column.type))
+          send(method, value_record, column)
         else
-          if column.column && (method = override_show_column_ui(column.column.type))
-            send(method, value_record, column)
-          else
-            get_column_value(record, column)
-          end
+          get_column_value(record, column)
         end
       end
 

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -17,8 +17,10 @@ module ActiveScaffold
       ## Delegates
       ##
 
-      def active_scaffold_controller_for(*args)
-        controller.class.active_scaffold_controller_for(*args)
+      def active_scaffold_controller_for(klass)
+        ActiveScaffold::Registry.cache :as_controller, klass do
+          controller.class.active_scaffold_controller_for(klass)
+        end
       end
 
       ##
@@ -56,17 +58,22 @@ module ActiveScaffold
 
       # a general-use loading indicator (the "stuff is happening, please wait" feedback)
       def loading_indicator_tag(options)
-        image_tag 'active_scaffold/indicator.gif', :style => 'visibility:hidden;', :id => loading_indicator_id(options), :alt => 'loading indicator', :class => 'loading-indicator'
+        # it's call many times and we can cache same result
+        @_loading_indicator_path ||= image_path('active_scaffold/indicator.gif')
+        # it's call many times in long lists, image_tag is a bit slower
+        tag :img, src: @_loading_indicator_path, style: 'visibility:hidden;', id: loading_indicator_id(options), alt: 'loading indicator', class: 'loading-indicator'
       end
 
       # Creates a javascript-based link that toggles the visibility of some element on the page.
-      # By default, it toggles the visibility of the sibling after the one it's nested in. You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
+      # By default, it toggles the visibility of the sibling after the one it's nested in.
+      # You may pass custom javascript logic in options[:of] to change that, though. For example, you could say :of => '$("my_div_id")'.
       # You may also flag whether the other element is visible by default or not, and the initial text will adjust accordingly.
       def link_to_visibility_toggle(id, options = {})
-        options[:default_visible] = true if options[:default_visible].nil?
         options[:hide_label] ||= as_(:hide)
         options[:show_label] ||= as_(:show_block)
-        link_to options[:default_visible] ? options[:hide_label] : options[:show_label], '#', :data => {:show => options[:show_label], :hide => options[:hide_label], :toggable => id}, :style => 'display: none;', :class => 'as-js-button visibility-toggle'
+        label = options[:default_visible].nil? || options[:default_visible] ? options[:hide_label] : options[:show_label]
+        data = {:show => options[:show_label], :hide => options[:hide_label], :toggable => id}
+        link_to label, '#', :data => data, :style => 'display: none;', :class => 'as-js-button visibility-toggle'
       end
 
       def list_row_class_method(record)
@@ -80,6 +87,10 @@ module ActiveScaffold
         class_override_helper ? send(class_override_helper, record) : ''
       end
 
+      def list_row_attributes(tr_class, tr_id, data_refresh)
+        {class: "record #{tr_class}", id: tr_id, data: {refresh: data_refresh}}
+      end
+
       def column_attributes(column, record)
         method = override_helper column, 'column_attributes'
         return send(method, record) if method
@@ -87,15 +98,14 @@ module ActiveScaffold
       end
 
       def column_class(column, column_value, record)
-        @_column_classes ||= {}
-        @_column_classes[column.name] ||= begin
+        classes = ActiveScaffold::Registry.cache :column_classes, column.cache_key do
           classes = "#{column.name}-column "
           classes << 'sorted ' if active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.user.sorting.sorts_on?(column)
           classes << 'numeric ' if column.number?
-          classes << column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
+          classes << column.css_class << ' ' unless column.css_class.nil? || column.css_class.is_a?(Proc)
           classes
         end
-        classes = "#{@_column_classes[column.name]} "
+        classes = classes.dup
         classes << 'empty ' if column_empty? column_value
         classes << 'in_place_editor_field ' if inplace_edit?(record, column) || column.list_ui == :marked
         if column.css_class.is_a?(Proc)
@@ -118,18 +128,23 @@ module ActiveScaffold
         classes
       end
 
+      def as_main_div_data
+        params[:eid] ? {eid: id_from_controller(params[:eid])} : {}
+      end
+
       def column_empty?(column_value)
+        @_empty_values ||= ['&nbsp;', empty_field_text].compact
         empty = column_value.nil?
         # column_value != false would force boolean to be cast to integer
         # when comparing to column_value of IPAddr class (PostgreSQL inet column type)
-        # rubocop:disable Style/YodaCondition
-        empty ||= false != column_value && column_value.blank?
-        empty ||= ['&nbsp;', empty_field_text].include? column_value if column_value.is_a? String
+        empty ||= false != column_value && column_value.blank? # rubocop:disable Style/YodaCondition
+        empty ||= @_empty_values.include? column_value
         empty
       end
 
       def empty_field_text
-        active_scaffold_config.list.empty_field_text if active_scaffold_config.actions.include?(:list)
+        return @_empty_field_text if defined? @_empty_field_text
+        @_empty_field_text = (active_scaffold_config.list.empty_field_text if active_scaffold_config.actions.include?(:list))
       end
 
       def as_slider(options)
@@ -150,11 +165,7 @@ module ActiveScaffold
       end
 
       def override_helper(column, suffix)
-        hash = @_override_helpers ||= {}
-        hash = hash[suffix] ||= {}
-        hash = hash[column.active_record_class.name] ||= {}
-        return hash[column.name] if hash.include? column.name
-        hash[column.name] = begin
+        ActiveScaffold::Registry.cache suffix, column.cache_key do
           method_with_class = override_helper_name(column, suffix, true)
           if respond_to?(method_with_class)
             method_with_class
@@ -205,9 +216,7 @@ module ActiveScaffold
           object = instance_variable_get("@#{object}") unless object.respond_to?(:to_model)
           object = convert_to_model(object)
 
-          if object.class.respond_to?(:model_name)
-            options[:object_name] ||= object.class.model_name.human.downcase
-          end
+          options[:object_name] ||= object.class.model_name.human.downcase if object.class.respond_to?(:model_name)
 
           object
         end