active_scaffold 3.7.12 → 4.0.0.rc1

data/lib/active_scaffold/finder.rb

@@ -7,6 +7,7 @@ module ActiveScaffold
     module ClassMethods
       def self.extended(klass)
         return unless klass.active_scaffold_config
+
         if klass.active_scaffold_config.active_record?
           klass.extend ActiveRecord
         elsif klass.active_scaffold_config.mongoid?
@@ -103,14 +104,15 @@ module ActiveScaffold
         if respond_to?(column_method)
           args = [column, value, like_pattern]
           args << session if method(column_method).arity == 4
-          return send("condition_for_#{column.name}_column", *args)
+          return send(:"condition_for_#{column.name}_column", *args)
         end
-        return unless 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)
+            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
@@ -126,7 +128,7 @@ module ActiveScaffold
               sql_conditions << subquery_sql
               where_values.concat subquery_values
             else
-              sql_conditions << sql % {:search_sql => search_sql}
+              sql_conditions << (sql % {search_sql: search_sql})
               where_values.concat values
             end
           end
@@ -139,14 +141,14 @@ module ActiveScaffold
 
       def subquery_condition(column, sql, options, values)
         relation, *columns = options[:subquery]
-        conditions = [columns.map { |search_sql| sql % {:search_sql => search_sql} }.join(' OR ')]
+        conditions = [columns.map { |search_sql| sql % {search_sql: search_sql} }.join(' OR ')]
         conditions += values * columns.size if values.present?
         subquery = relation.where(conditions)
         subquery = subquery.select(relation.primary_key) if subquery.select_values.blank?
 
         conditions = [["#{options[:field] || column.field} IN (?)", options[:conditions]&.first].compact.join(' AND ')]
         conditions << subquery
-        conditions.concat options[:conditions][1..-1] if options[:conditions]
+        conditions.concat options[:conditions][1..] if options[:conditions]
         if column.association&.polymorphic?
           conditions[0] << " AND #{column.quoted_foreign_type} = ?"
           conditions << relation.base_class.sti_name
@@ -176,7 +178,7 @@ module ActiveScaffold
           if value.is_a?(Hash)
             condition_for_range(column, value, like_pattern)
           else
-            values = Array(value).select(&:present?)
+            values = Array(value).compact_blank
             ['%<search_sql>s in (?)', values] if values.present?
           end
         else
@@ -189,7 +191,7 @@ module ActiveScaffold
           ['%<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])
+        elsif value[:from].blank? || ActiveScaffold::Finder::NUMERIC_COMPARATORS.exclude?(value[:opt])
           nil
         elsif value[:opt] == 'BETWEEN'
           ['(%<search_sql>s BETWEEN ? AND ?)', condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
@@ -200,7 +202,7 @@ module ActiveScaffold
 
       def condition_for_single_value(column, value, like_pattern = nil)
         if column.text?
-          value = column.active_record? ? column.active_record_class.sanitize_sql_like(value) : value
+          value = column.active_record_class.sanitize_sql_like(value) if column.active_record?
           ["%<search_sql>s #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
         else
           ['%<search_sql>s = ?', ActiveScaffold::Core.column_type_cast(value, column.column)]
@@ -211,11 +213,11 @@ module ActiveScaffold
         if ActiveScaffold::Finder::NULL_COMPARATORS.include?(value[:opt])
           condition_for_null_type(column, value[:opt], like_pattern)
         elsif value[:from].is_a?(Array) # opt can be only =
-          from = Array(value[:from]).select(&:present?)
+          from = Array(value[:from]).compact_blank
           ['%<search_sql>s in (?)', from] if from.present?
         elsif value[:from].blank?
           nil
-        elsif ActiveScaffold::Finder::STRING_COMPARATORS.values.include?(value[:opt])
+        elsif ActiveScaffold::Finder::STRING_COMPARATORS.value?(value[:opt])
           text = column.active_record? ? column.active_record_class.sanitize_sql_like(value[:from]) : value[:from]
           [
             "%<search_sql>s #{'NOT ' if value[:opt].start_with?('not_')}#{ActiveScaffold::Finder.like_operator} ?",
@@ -229,18 +231,16 @@ module ActiveScaffold
       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
+        key_index = keys.keys.index_with { |key| format.index(key) }
         keys.select! { |k, _| key_index[k] }
         keys.sort_by { |k, _| key_index[k] }.map do |_, k|
-          I18n.t(k).compact.zip(I18n.t(k, :locale => :en).compact).to_h
+          I18n.t(k).compact.zip(I18n.t(k, locale: :en).compact).to_h
         end
       end
 
@@ -250,6 +250,7 @@ module ActiveScaffold
           regexp = Regexp.union(table.keys)
           index = value.index(regexp)
           next unless index
+
           translated << value.slice!(0...index)
           value.sub!(regexp) do |str|
             translated << table[str]
@@ -259,23 +260,12 @@ module ActiveScaffold
         translated << value
       end
 
-      def format_for_datetime(column, value)
+      def format_for_datetime(column, value, ui_name, ui_options)
         parts = Date._parse(value)
-        if ActiveScaffold.js_framework == :jquery
-          format = I18n.translate "time.formats.#{column.options[:format] || :picker}", :default => ''
-        end
-
-        if format.blank?
-          time_parts = [[:hour, '%H'], [:min, '%M'], [:sec, '%S']].map do |part, format_part|
-            format_part if parts[part].present?
-          end.compact
-          format = "#{I18n.t('date.formats.default')} #{time_parts.join(':')} #{'%z' if parts[:offset].present?}"
-        else
-          [[:hour, '%H'], [:min, ':%M'], [:sec, ':%S']].each do |part, f|
-            format.gsub!(f, '') if parts[part].blank?
-          end
-          format += ' %z' if parts[:offset].present? && format !~ /%z/i
+        time_parts = [[:hour, '%H'], [:min, '%M'], [:sec, '%S']].filter_map do |part, format_part|
+          format_part if parts[part].present?
         end
+        format = "%Y-%m-%d #{time_parts.join(':')} #{'%z' if parts[:offset].present?}"
 
         format.gsub!(/.*(?=%H)/, '') if !parts[:year] && !parts[:month] && !parts[:mday]
         [format, parts[:offset]]
@@ -290,9 +280,9 @@ module ActiveScaffold
         nil
       end
 
-      def format_for_date(column, value, format_name = column.options[:format])
-        if format_name
-          format = I18n.t("date.formats.#{format_name}")
+      def format_for_date(column, value, ui_name, ui_options)
+        if ui_options[:format]
+          format = I18n.t("date.formats.#{ui_options[:format]}")
           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)
         end
@@ -321,8 +311,10 @@ module ActiveScaffold
         nil
       end
 
-      def condition_value_for_datetime(column, value, conversion = :to_time)
+      def condition_value_for_datetime(column, value, conversion = :to_time, ui_method: :search_ui, ui_options: nil)
         return if value.nil? || value.blank?
+
+        ui_options ||= column.send(:"#{ui_method}_options") || column.options
         if value.is_a? Hash
           local_time_from_hash(value, conversion)
         elsif value.respond_to?(:strftime)
@@ -334,20 +326,21 @@ module ActiveScaffold
             value.send(conversion)
           end
         elsif conversion == :to_date
-          parse_date_with_format(*format_for_date(column, value))
+          parse_date_with_format(*format_for_date(column, value, column.send(ui_method), ui_options))
         elsif value.include?('T')
           Time.zone.parse(value)
         else # datetime
-          time = parse_time_with_format(value, *format_for_datetime(column, value))
+          time = parse_time_with_format(value, *format_for_datetime(column, value, column.send(ui_method), ui_options))
           conversion == :to_time ? time : time.send(conversion)
         end
       end
 
       def condition_value_for_numeric(column, value)
         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
+        case column.search_ui || column.column_type
+        when :integer
           if value.is_a?(TrueClass) || value.is_a?(FalseClass)
             value ? 1 : 0
           else
@@ -443,15 +436,16 @@ module ActiveScaffold
         else
           range_type, range = value['range'].downcase.split('_')
           raise ArgumentError unless %w[week month year].include?(range)
+
           case range_type
           when 'this'
-            return datetime_now.send("beginning_of_#{range}".to_sym), datetime_now.send("end_of_#{range}")
+            [datetime_now.send(:"beginning_of_#{range}"), datetime_now.send(:"end_of_#{range}")]
           when 'prev'
-            return datetime_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+            [datetime_now.ago(1.send(range.to_sym)).send(:"beginning_of_#{range}"), datetime_now.ago(1.send(range.to_sym)).send(:"end_of_#{range}")]
           when 'next'
-            return datetime_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), datetime_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
+            [datetime_now.in(1.send(range.to_sym)).send(:"beginning_of_#{range}"), datetime_now.in(1.send(range.to_sym)).send(:"end_of_#{range}")]
           else
-            return nil, nil
+            [nil, nil]
           end
         end
       end
@@ -462,7 +456,7 @@ module ActiveScaffold
 
       def condition_for_record_select_type(column, value, like_pattern = nil)
         if value.is_a?(Array)
-          value = value.select(&:present?)
+          value = value.compact_blank
           ['%<search_sql>s IN (?)', value] if value.present?
         else
           ['%<search_sql>s = ?', value]
@@ -489,12 +483,12 @@ module ActiveScaffold
       'BETWEEN'
     ].freeze
     STRING_COMPARATORS = {
-      :contains    => '%?%',
-      :begins_with => '?%',
-      :ends_with   => '%?',
-      :doesnt_contain    => 'not_%?%',
-      :doesnt_begin_with => 'not_?%',
-      :doesnt_end_with   => 'not_%?'
+      contains:          '%?%',
+      begins_with:       '?%',
+      ends_with:         '%?',
+      doesnt_contain:    'not_%?%',
+      doesnt_begin_with: 'not_?%',
+      doesnt_end_with:   'not_%?'
     }.freeze
     NULL_COMPARATORS = %w[null not_null].freeze
     DATE_COMPARATORS = %w[PAST FUTURE RANGE].freeze
@@ -508,27 +502,24 @@ module ActiveScaffold
 
     protected
 
-    attr_writer :active_scaffold_conditions
+    attr_writer :active_scaffold_conditions, :active_scaffold_preload, :active_scaffold_habtm_joins, :active_scaffold_outer_joins, :active_scaffold_references
+
     def active_scaffold_conditions
       @active_scaffold_conditions ||= []
     end
 
-    attr_writer :active_scaffold_preload
     def active_scaffold_preload
       @active_scaffold_preload ||= []
     end
 
-    attr_writer :active_scaffold_habtm_joins
     def active_scaffold_habtm_joins
       @active_scaffold_habtm_joins ||= []
     end
 
-    attr_writer :active_scaffold_outer_joins
     def active_scaffold_outer_joins
       @active_scaffold_outer_joins ||= []
     end
 
-    attr_writer :active_scaffold_references
     def active_scaffold_references
       @active_scaffold_references ||= []
     end
@@ -550,15 +541,15 @@ module ActiveScaffold
       params_hash active_scaffold_embedded_params[:conditions]
     end
 
-    def all_conditions(include_id_condition = true)
+    def all_conditions(id_condition: true)
       [
-        (id_condition if include_id_condition),       # for list with id (e.g. /users/:id/index)
+        (self.id_condition if 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)
         conditions_from_constraints,                  # from any constraints (embedded scaffolds)
         active_scaffold_embedded_conditions           # embedding conditions (weaker constraints)
-      ].reject(&:blank?)
+      ].compact_blank
     end
 
     def id_condition
@@ -570,14 +561,15 @@ module ActiveScaffold
     # accomplishes this by checking model.#{action}_authorized?
     def find_if_allowed(id, security_options, klass = beginning_of_chain)
       record = klass.find(id)
-      security_options = {:crud_type => security_options.to_sym} unless security_options.is_a? Hash
+      security_options = {crud_type: security_options.to_sym} unless security_options.is_a? Hash
       raise ActiveScaffold::RecordNotAllowed, "#{klass} with id = #{id}" unless record.authorized_for? security_options
+
       record
     end
 
     # valid options may include:
     # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction,
-    #     e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]).
+    #     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
@@ -586,22 +578,22 @@ module ActiveScaffold
       search_conditions = all_conditions
 
       sorting = options[:sorting]&.clause
-      sorting = sorting.map(&Arel.method(:sql)) if sorting && active_scaffold_config.active_record?
+      sorting = sorting.map { |part| Arel.sql(part) } if sorting && active_scaffold_config.active_record?
       # create a general-use options array that's compatible with Rails finders
       finder_options = {
-        :reorder => sorting,
-        :conditions => search_conditions
+        reorder: sorting,
+        conditions: search_conditions
       }
       if active_scaffold_config.mongoid?
         finder_options[:includes] = [active_scaffold_references, active_scaffold_preload].compact.flatten.uniq.presence
       else
         finder_options.merge!(
-          :joins => joins_for_finder,
-          :left_joins => active_scaffold_outer_joins,
-          :preload => active_scaffold_preload,
-          :includes => active_scaffold_references.presence,
-          :references => active_scaffold_references.presence,
-          :select => options[:select]
+          joins:      joins_for_finder,
+          left_joins: active_scaffold_outer_joins,
+          preload:    active_scaffold_preload,
+          includes:   active_scaffold_references.presence,
+          references: active_scaffold_references.presence,
+          select:     options[:select]
         )
       end
 
@@ -611,7 +603,7 @@ module ActiveScaffold
 
     def count_items(query, find_options = {}, count_includes = nil)
       count_includes ||= find_options[:includes] if find_options[:conditions].present?
-      options = find_options.reject { |k, _| %i[select reorder order].include? k }
+      options = find_options.except(:select, :reorder, :order)
       # NOTE: we must use includes in the count query, because some conditions may reference other tables
       options[:includes] = count_includes
 
@@ -650,7 +642,7 @@ module ActiveScaffold
                 end
               else
                 ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-                  query = append_to_query(query, :offset => offset, :limit => per_page) if options[:pagination]
+                  query = append_to_query(query, offset: offset, limit: per_page) if options[:pagination]
                   calculate_last_modified(query)
                   query
                 end
@@ -660,29 +652,30 @@ module ActiveScaffold
 
     def calculate_last_modified(query)
       return unless conditional_get_support? && ActiveScaffold::OrmChecks.columns_hash(query.klass)['updated_at']
+
       @last_modified = query.maximum(:updated_at)
     end
 
-    def calculate_subquery(id_condition = true)
-      conditions = all_conditions(id_condition)
+    def calculate_subquery(id_condition: true)
+      conditions = all_conditions(id_condition: id_condition)
       includes = active_scaffold_config.list.count_includes
       includes ||= active_scaffold_references if conditions.present?
       left_joins = active_scaffold_outer_joins
       left_joins += includes if includes
       primary_key = active_scaffold_config.primary_key
-      subquery = append_to_query(beginning_of_chain, :conditions => conditions, :joins => joins_for_finder, :left_joins => left_joins, :select => active_scaffold_config.columns[primary_key].field)
+      subquery = append_to_query(beginning_of_chain, conditions: conditions, joins: joins_for_finder, left_joins: left_joins, select: active_scaffold_config.columns[primary_key].field)
       subquery.unscope(:order)
     end
 
-    def calculate_query(id_condition = true)
-      active_scaffold_config.model.where(active_scaffold_config.primary_key => calculate_subquery(id_condition))
+    def calculate_query(id_condition: true)
+      active_scaffold_config.model.where(active_scaffold_config.primary_key => calculate_subquery(id_condition: id_condition))
     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
-      relation = options.reject { |_, v| v.blank? }.inject(relation) do |rel, (k, v)|
+      relation = options.compact_blank.inject(relation) do |rel, (k, v)|
         k == :conditions ? apply_conditions(rel, *v) : rel.send(k, v)
       end
       relation.distinct_value = true if options[:left_outer_joins].present? || options[:left_joins].present?
@@ -701,7 +694,7 @@ module ActiveScaffold
     end
 
     def apply_conditions(relation, *conditions)
-      conditions.reject(&:blank?).inject(relation) do |rel, condition|
+      conditions.compact_blank.inject(relation) do |rel, condition|
         if condition.is_a?(Array) && !condition.first.is_a?(String) # multiple conditions
           apply_conditions(rel, *condition)
         else

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -15,7 +15,7 @@ module ActiveScaffold
           if link.security_method_set? || controller.respond_to?(link.security_method, true)
             controller.send(link.security_method, *args)
           else
-            args.empty? ? true : args.first.authorized_for?(:crud_type => link.crud_type, :action => link.action, :reason => true)
+            args.empty? ? true : args.first.authorized_for?(crud_type: link.crud_type, action: link.action, reason: true)
           end
         [auth, reason]
       end
@@ -35,63 +35,47 @@ module ActiveScaffold
         options[:level] ||= 0
         options[:first_action] = true
         output = ActiveSupport::SafeBuffer.new
-        prev_link = separator = nil
 
         action_links.each(reverse: options.delete(:reverse), groups: true) do |link|
-          if link == :separator
-            separator = true if prev_link
-            next
-          end
-          content = nil
           if link.is_a? ActiveScaffold::DataStructures::ActionLinks
-            content = display_action_link_group(link, record, options, &block) unless link.empty?
+            unless link.empty?
+              options[:level] += 1
+              content = display_action_links(link, record, options, &block)
+              options[:level] -= 1
+              if content.present?
+                output << display_action_link(link, content, record, options)
+                options[:first_action] = false
+              end
+            end
           elsif !skip_action_link?(link, *Array(options[:for]))
             authorized, reason = action_link_authorized?(link, *Array(options[:for]))
             next if !authorized && options[:skip_unauthorized]
 
-            content = display_action_link(link, nil, record, options.merge(authorized: authorized, not_authorized_reason: reason))
+            output << display_action_link(link, nil, record, options.merge(authorized: authorized, not_authorized_reason: reason))
             options[:first_action] = false
           end
-          next if content.blank?
-
-          prev_link = true
-          output << display_action_link_separator(options) if separator
-          output << content
-          separator = false
         end
         output
       end
 
-      def display_action_link_group(link, record, options, &block)
-        options[:level] += 1
-        content = display_action_links(link, record, options, &block)
-        options[:level] -= 1
-        display_action_link(link, content, record, options).tap { options[:first_action] = false } if content.present?
-      end
-
-      def display_action_link_separator(options)
-        tag = options[:level_0_tag] || :a if options[:level].zero?
-        content_tag(tag || :li, '&nbsp;'.html_safe, class: 'separator') # rubocop:disable Rails/OutputSafety
-      end
-
       def display_action_link(link, content, record, options)
         if content
           html_classes = hover_via_click? ? 'hover_click ' : ''
-          if options[:level].zero?
+          if (options[:level]).zero?
             html_classes << 'action_group'
             group_tag = :div
           else
             html_classes << 'top' if options[:first_action]
             group_tag = :li
           end
-          content = content_tag(group_tag, :class => html_classes.presence, :onclick => ('' if hover_via_click?)) do
-            content_tag(:div, as_(link.label(record)), :class => link.css_class) << content_tag(:ul, content)
+          content = content_tag(group_tag, class: html_classes.presence, onclick: ('' if hover_via_click?)) do
+            content_tag(:div, as_(link.label(record)), class: link.css_class) << content_tag(:ul, content)
           end
         else
           content = render_action_link(link, record, options)
-          content = content_tag(:li, content, class: ('top' if options[:first_action])) unless options[:level].zero?
+          content = content_tag(:li, content, class: ('top' if options[:first_action])) unless (options[:level]).zero?
         end
-        content = content_tag(options[:level_0_tag], content, options[:options_level_0_tag]) if options[:level].zero? && options[:level_0_tag]
+        content = content_tag(options[:level_0_tag], content, options[:options_level_0_tag]) if (options[:level]).zero? && options[:level_0_tag]
         content
       end
 
@@ -103,7 +87,7 @@ module ActiveScaffold
         end
         if link.action.nil? || (link.type == :member && options.key?(:authorized) && !options[:authorized])
           html_class = "disabled #{link.action}#{" #{link.html_options[:class]}" if link.html_options[:class].present?}"
-          html_options = {:link => action_link_text(link, record, options), :class => html_class, :title => options[:not_authorized_reason]}
+          html_options = {link: action_link_text(link, record, options), class: html_class, title: options[:not_authorized_reason]}
           action_link_html(link, nil, html_options, record)
         else
           url = action_link_url(link, record)
@@ -161,9 +145,9 @@ module ActiveScaffold
             else
               associated
             end
-          authorized, reason = associated_for_authorized.authorized_for?(:crud_type => link.crud_type, :reason => true)
+          authorized, reason = associated_for_authorized.authorized_for?(crud_type: link.crud_type, reason: true)
           if link.crud_type == :create && authorized
-            authorized, reason = record.authorized_for?(:crud_type => :update, :column => column.name, :reason => true)
+            authorized, reason = record.authorized_for?(crud_type: :update, column: column.name, reason: true)
           end
           [authorized, reason]
         else
@@ -172,7 +156,8 @@ module ActiveScaffold
       end
 
       def sti_record?(record)
-        return unless active_scaffold_config.active_record?
+        return false unless active_scaffold_config.active_record?
+
         model = active_scaffold_config.model
         record && model.columns_hash.include?(model.inheritance_column) &&
           record[model.inheritance_column].present? && !record.instance_of?(model)
@@ -213,7 +198,7 @@ module ActiveScaffold
 
       def add_query_string_to_cached_url(link, url)
         query_string, non_nested_query_string = query_string_for_action_links(link)
-        nested_params = (!link.nested_link? && non_nested_query_string)
+        nested_params = !link.nested_link? && non_nested_query_string
         if query_string || nested_params
           url << (url.include?('?') ? '&' : '?')
           url << query_string if query_string
@@ -230,7 +215,7 @@ module ActiveScaffold
 
       def column_in_params_conditions?(key)
         if key.match?(/!$/)
-          conditions_from_params[1..-1].any? { |node| node.left.name.to_s == key[0..-2] }
+          conditions_from_params[1..].any? { |node| node.left.name.to_s == key[0..-2] }
         else
           conditions_from_params[0].include?(key)
         end
@@ -244,6 +229,7 @@ module ActiveScaffold
         if defined?(@query_string) && link.parameters.none? { |k, _| @query_string_params.include? k }
           return [@query_string, @non_nested_query_string]
         end
+
         keep = true
         @query_string_params ||= Set.new
         query_string_options = {}
@@ -286,15 +272,13 @@ module ActiveScaffold
         @action_links_url_options ||= {}
         @action_links_url_options[link.name_to_cache.to_s] || begin
           options = action_link_url_options(link, record)
-          if cache_action_link_url_options?(link, record)
-            @action_links_url_options[link.name_to_cache.to_s] = options
-          end
+          @action_links_url_options[link.name_to_cache.to_s] = options if cache_action_link_url_options?(link, record)
           options
         end
       end
 
       def action_link_url_options(link, record)
-        url_options = {:action => link.action}
+        url_options = {action: link.action}
         url_options[:id] = '--ID--' unless record.nil?
         url_options[:controller] = link.controller.to_s if link.controller
         url_options.merge! link.parameters if link.parameters
@@ -316,7 +300,10 @@ module ActiveScaffold
       end
 
       def action_link_text(link, record, options)
-        text = image_tag(link.image[:name], :size => link.image[:size], :alt => options[:link] || link.label(record), :title => options[:link] || link.label(record)) if link.image
+        if link.image
+          title = options[:link] || link.label(record)
+          text = image_tag(link.image[:name], size: link.image[:size], alt: title, title: title)
+        end
         text || options[:link]
       end
 
@@ -345,7 +332,7 @@ module ActiveScaffold
 
       def action_link_html_options(link, record, options)
         link_id = get_action_link_id(link, record)
-        html_options = link.html_options.merge(:class => [link.html_options[:class], link.action.to_s].compact.join(' '))
+        html_options = link.html_options.merge(class: [link.html_options[:class], link.action.to_s].compact.join(' '))
         html_options[:link] = action_link_text(link, record, options)
 
         # Needs to be in html_options to as the adding _method to the url is no longer supported by Rails
@@ -397,8 +384,10 @@ module ActiveScaffold
         end
         id ||= record&.id&.to_s || (nested? ? nested_parent_id.to_s : '')
         action_link_id = ActiveScaffold::Registry.cache :action_link_id, link.name_to_cache.to_s do
-          action_id = "#{id_from_controller("#{link.controller}-") if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)}#{link.action}"
-          action_link_id(action_id, '--ID--')
+          if params[:parent_controller] || (link.controller && link.controller != controller.controller_path)
+            controller_id = id_from_controller("#{link.controller}-")
+          end
+          action_link_id("#{controller_id}#{link.action}", '--ID--')
         end
         action_link_id.sub('--ID--', id)
       end
@@ -417,9 +406,7 @@ module ActiveScaffold
         if column&.association
           url_options[:parent_scaffold] = controller_path
           url_options[column.model.name.foreign_key.to_sym] = url_options.delete(:id)
-          url_options[:id] = if column.association.singular? && url_options[:action].to_sym != :index
-                               '--CHILD_ID--'
-                             end
+          url_options[:id] = ('--CHILD_ID--' if column.association.singular? && url_options[:action].to_sym != :index)
         elsif link.parameters&.dig(:named_scope)
           url_options[:parent_scaffold] = controller_path
           url_options[active_scaffold_config.model.name.foreign_key.to_sym] = url_options.delete(:id)
@@ -434,6 +421,7 @@ module ActiveScaffold
         # however that will not work if a sti parent is a singular association inline autolink
         return unless link.column.nil?
         return if (sti_controller_path = controller_path_for_activerecord(record.class)).nil?
+
         url_options[:controller] = sti_controller_path
         url_options[:parent_sti] = controller_path
       end

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -1,4 +1,3 @@
-
 module ActiveScaffold
   module Helpers
     module AssociationHelpers
@@ -23,6 +22,7 @@ module ActiveScaffold
         if klass.nil? && association.polymorphic?
           class_name = record.send(association.foreign_type) if association.belongs_to?
           return [] if class_name.blank?
+
           klass = class_name.constantize
           cache = !block_given?
         else
@@ -96,12 +96,13 @@ module ActiveScaffold
       def options_for_association_conditions(association, record = nil)
         return nil if association.through?
         return nil unless association.has_one? || association.has_many?
+
         # Find only orphaned objects
         {association.foreign_key => nil}
       end
 
       def record_select_params_for_add_existing(association, edit_associated_url_options, record)
-        {:onselect => "ActiveScaffold.record_select_onselect(#{url_for(edit_associated_url_options).to_json}, #{active_scaffold_id.to_json}, id);"}
+        {onselect: "ActiveScaffold.record_select_onselect(#{url_for(edit_associated_url_options).to_json}, #{active_scaffold_id.to_json}, id);"}
       end
     end
   end