active_scaffold 3.7.4 → 3.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9206609200e1c9330a6e04b1731300dad5fcba8a52c70ae26ef6ba6427da4c25
-  data.tar.gz: 0b501f82598b99ff587b1fa484d017a73f1fd018b5a26a7968c065d0152ae74b
+  metadata.gz: cfe45d0a0b28f5cb324e7104add97e7a105de6986accf8d64db02cf5f65f19ea
+  data.tar.gz: f8461b6a58ce6b1c93df2eaf95540a759fdcd73d21f256ee1a38ea4436b73987
 SHA512:
-  metadata.gz: '08c1c4a3b4dad7c731793ebecd4e238a36ee49e340964c8321a88b562fafbf0b12d7992501c5ffad8efa60820a40e80879f0c9e60715cc1da2e31a5c764781bc'
-  data.tar.gz: 310c5bf214800a98efd1d7af45b771608ce85cdf27db3df8437a0ea9cbabb243f2df8d8ee3603c81a9e43a76ba09dcaae20df26aa3a1b0df9bf0b18f2c244bab
+  metadata.gz: a65de91f886605e57d0f183295d9d1f8ea358b4657826143265f8359f4d41761b6325644fcb6d5dc1d5e5d4b87bbc966bf8cd9d4ee66db0ae4048455eb0c6b62
+  data.tar.gz: 9fb4e3b6a38c5f340cdf430146ae9616a5e9a93e66c11e32dece9cb5704229499610da861916371e3bafb973d43705c9716228b5d04c50f896d5538320e0125c

data/CHANGELOG.rdoc

@@ -1,3 +1,22 @@
+= 3.7.6
+- Respect :label_method set in form_ui_options on list.
+- Fix grouped search for PostgreSQL
+- Fix loading current search params when search form is open and store_user_settings is disabled
+
+= 3.7.5
+- Fix always show search for nested list on multi-level through associations
+- Support changing step, min and max options with column options or search_ui options for decimal and integer search_ui
+- Support null and not null comparators in date and datetime search_ui
+- Support defining options_for_association_conditions, association_klass_scoped and active_scaffold_enum_options helpers prefixed with model name. Useful when clear_helpers is not called in ApplicationController.
+- Fix class for columns with form_ui or css_class when refreshing column
+- Eval after_config_callback proc in the context of AS config
+- Fix registering constrained fields on polymorphic association
+- Improve applying constraints for polymorphic associations when constraining with multiple ids, set only the foreign type
+- Support prefixing helpers with base class for models using STI besides model name prefix
+- Support create when nested on through association when source association is singular, as rails creates the joint model
+- Allow to set controller nil for association columns to STI models
+- Add session argument to condition_for_column and condition_for_<column>_column, so custom conditions on columns may use the session, make it optional so it's backwards compatible
+
 = 3.7.4
 - Support loading both jquery and jquery-ui externally
 - Fix subquery in search with STI

data/app/views/active_scaffold_overrides/_list_with_header.html.erb

@@ -5,7 +5,7 @@
   <table>
     <tbody class="before-header" id="<%= before_header_id -%>">
       <% if active_scaffold_config.list.always_show_search %>
-      <% old_record, @record = @record, new_model %>
+      <% old_record, @record = @record, active_scaffold_config.model.new %>
         <tr>
           <td>
             <div class="active-scaffold show_search-view <%= "#{id_from_controller params[:controller]}-view" %> view">

data/app/views/active_scaffold_overrides/_render_field.js.erb

@@ -1,9 +1,10 @@
 <%
-  column = if render_field.is_a? ActiveScaffold::DataStructures::Column
-    render_field
-  else
-    active_scaffold_config.columns[render_field]
-  end
+  column =
+    if render_field.is_a? ActiveScaffold::DataStructures::Column
+      render_field
+    else
+      active_scaffold_config.columns[render_field]
+    end
   return unless @main_columns.include? column.name
   @rendered ||= Set.new
   return if @rendered.include? column.name
@@ -14,13 +15,15 @@
     renders_as = column_renders_as(column)
     form_ui = column.form_ui
   end
+
+  column_css_class = column.css_class unless column.css_class.nil? || column.css_class.is_a?(Proc)
   options = {field_class: "#{column.name}-input", hidden: form_ui == :hidden}
   options[:subform_class] = "#{column.name}-sub-form" if column.association
   options[:attrs] =
     if renders_as == :subform
-      active_scaffold_subform_attributes(column, (column.css_class unless column.css_class.is_a?(Proc)))
+      active_scaffold_subform_attributes(column, column_css_class)
     else
-      {class: 'form-element', id: ''}
+      {class: "form-element #{:required if column.required?(@form_action)} #{column.form_ui} #{column_css_class}", id: ''}
     end
   html =
     if scope

data/lib/active_scaffold/actions/common_search.rb

@@ -3,9 +3,9 @@ module ActiveScaffold::Actions
     def self.included(base)
       return if base < InstanceMethods
       base.send :include, InstanceMethods
-      base.before_action :search_authorized_filter, :only => :show_search
-      base.before_action :store_search_params_into_session, :only => [:index]
-      base.before_action :do_search, :only => [:index]
+      base.before_action :search_authorized_filter, only: :show_search
+      base.before_action :store_search_params_into_session, :only => %i[index show_search]
+      base.before_action :do_search, only: [:index]
       base.helper_method :search_params
     end
 

data/lib/active_scaffold/actions/core.rb

@@ -17,6 +17,7 @@ module ActiveScaffold::Actions
       base.helper_method :embedded?
       base.helper_method :loading_embedded?
       base.helper_method :calculate_query
+      base.helper_method :calculate_subquery
       base.helper_method :new_model
       base.helper_method :touch_device?
       base.helper_method :hover_via_click?
@@ -134,8 +135,8 @@ module ActiveScaffold::Actions
       parent = parent_model.new
       copy_attributes(find_if_allowed(params[:parent_id], :read, parent_model), parent) if params[:parent_id]
       parent.id = params[:parent_id]
-      parent = update_record_from_params(parent, cfg.send(params[:parent_id] ? :update : :create).columns, params[:record], true) if @column.send_form_on_update_column
       apply_constraints_to_record(parent) unless params[:parent_id]
+      parent = update_record_from_params(parent, cfg.send(params[:parent_id] ? :update : :create).columns, params[:record], true) if @column.send_form_on_update_column
       if association.collection?
         record.send(association.name) << parent
       else

data/lib/active_scaffold/actions/create.rb

@@ -93,8 +93,10 @@ module ActiveScaffold::Actions
     def do_create(options = {})
       attributes = options[:attributes] || params[:record]
       active_scaffold_config.model.transaction do
-        @record = update_record_from_params(new_model, active_scaffold_config.create.columns, attributes)
+        @record = new_model
+        # before assign params, to set foreign_type of constraints in polymorphic association with multiple id
         apply_constraints_to_record(@record, :allow_autosave => true)
+        @record = update_record_from_params(@record, active_scaffold_config.create.columns, attributes)
         create_association_with_parent(@record) if nested?
         before_create_save(@record)
         # errors to @record can be added by update_record_from_params when association fails to set and ActiveRecord::RecordNotSaved is raised

data/lib/active_scaffold/actions/field_search.rb

@@ -56,25 +56,33 @@ module ActiveScaffold::Actions
 
       def custom_finder_options
         if grouped_search?
-          group_sql = calculation_for_group_by(search_group_column&.field || search_group_name)
-          select_query = grouped_search_select
-          select_query << group_sql.as(search_group_column.name.to_s) if search_group_column && group_sql.respond_to?(:to_sql)
-          {group: group_sql, select: select_query}
+          grouped_search_finder_options
         else
           super
         end
       end
 
+      def grouped_search_finder_options
+        group_sql = calculation_for_group_by(search_group_column&.field || search_group_name, search_group_function) if search_group_function
+        group_by = group_sql&.to_sql || quoted_select_columns(search_group_column&.select_columns || [search_group_name])
+        select_query = grouped_search_select + (group_sql ? [group_sql.as(search_group_column.name.to_s)] : group_by)
+        {group: group_by, select: select_query, reorder: grouped_sorting(group_by)}
+      end
+
       def grouped_search_select
-        select_query = quoted_select_columns(search_group_column&.select_columns || [search_group_name])
-        if active_scaffold_config.model.columns_hash.include?(active_scaffold_config.model.inheritance_column)
-          select_query << active_scaffold_config.columns[active_scaffold_config.model.inheritance_column].field
-        end
-        grouped_columns_calculations.each do |name, part|
-          select_query << (part.respond_to?(:as) ? part : Arel::Nodes::SqlLiteral.new(part)).as(name.to_s)
+        grouped_columns_calculations.map do |name, part|
+          (part.respond_to?(:as) ? part : Arel::Nodes::SqlLiteral.new(part)).as(name.to_s)
         end
       end
 
+      def grouped_sorting(group_sql)
+        return unless search_group_column && active_scaffold_config.list.user.sorting
+        group_sort = search_group_function ? group_sql : search_group_column.sort[:sql] if search_group_column.sortable?
+        grouped_columns = grouped_columns_calculations.merge(search_group_column.name => group_sort)
+        sorting = active_scaffold_config.list.user.sorting.clause(grouped_columns)
+        active_scaffold_config.active_record? ? sorting&.map(&Arel.method(:sql)) : sorting
+      end
+
       def grouped_columns_calculations
         @grouped_columns_calculations ||= list_columns[1..-1].each_with_object({}) do |c, h|
           h[c.name] = calculation_for_group_search(c)
@@ -85,21 +93,24 @@ module ActiveScaffold::Actions
         sql_function column.calculate.to_s, column.active_record_class.arel_table[column.name]
       end
 
-      def calculation_for_group_by(group_sql)
-        return group_sql unless search_group_function
+      def calculation_for_group_by(group_sql, group_function)
         group_sql = Arel::Nodes::SqlLiteral.new(group_sql)
-        case search_group_function
+        case group_function
         when 'year', 'month', 'quarter'
-          sql_function(search_group_function, group_sql)
+          extract_sql_fn(group_function, group_sql)
         when 'year_month'
-          sql_function('extract', sql_operator(Arel::Nodes::SqlLiteral.new('YEAR_MONTH'), 'FROM', group_sql))
+          sql_operator(sql_operator(extract_sql_fn('year', group_sql), '*', 100), '+', extract_sql_fn('month', group_sql))
         when 'year_quarter'
-          sql_operator(sql_operator(sql_function('year', group_sql), '*', 10), '+', sql_function('quarter', group_sql))
+          sql_operator(sql_operator(extract_sql_fn('year', group_sql), '*', 10), '+', extract_sql_fn('quarter', group_sql))
         else
-          raise "#{search_group_function} unsupported, override calculation_for_group_by in #{self.class.name}"
+          raise "#{group_function} unsupported, override calculation_for_group_by in #{self.class.name}"
         end
       end
 
+      def extract_sql_fn(part, column)
+        sql_function('extract', sql_operator(Arel::Nodes::SqlLiteral.new(part), 'FROM', column))
+      end
+
       def sql_function(function, *args)
         args.map! { |arg| quoted_arel_value(arg) }
         Arel::Nodes::NamedFunction.new(function, args)
@@ -157,7 +168,7 @@ module ActiveScaffold::Actions
         search_params.each do |key, value|
           next unless columns.include? key
           column = active_scaffold_config.columns[key]
-          search_condition = self.class.condition_for_column(column, value, text_search)
+          search_condition = self.class.condition_for_column(column, value, text_search, session)
           next if search_condition.blank?
 
           active_scaffold_conditions << search_condition

data/lib/active_scaffold/constraints.rb

@@ -8,17 +8,20 @@ module ActiveScaffold
 
     # Returns the current constraints
     def active_scaffold_constraints
-      @active_scaffold_constraints ||= active_scaffold_embedded_params[:constraints] || {}
+      @active_scaffold_constraints ||= active_scaffold_embedded_params[:constraints]&.to_unsafe_h || {}
     end
 
-    def register_constraint?(column_name, value)
-      if params_hash?(value)
-        false
-      elsif value.is_a?(Array)
+    def columns_from_constraint(column_name, value)
+      return if params_hash?(value)
+      if value.is_a?(Array)
         column = active_scaffold_config.columns[column_name]
-        column && value.size > (column.association&.polymorphic? ? 2 : 1)
+        if column&.association&.polymorphic?
+          [column.association.foreign_type.to_sym, (column.name if value.size == 2)].compact
+        elsif column && value.size == 1
+          column.name
+        end
       else
-        true
+        column_name.to_sym
       end
     end
 
@@ -31,7 +34,7 @@ module ActiveScaffold
     # we do NOT register the constraint column, as records will have different values in the column.
     def register_constraints_with_action_columns(constrained_fields = nil)
       constrained_fields ||= []
-      constrained_fields |= active_scaffold_constraints.select { |k, v| register_constraint?(k, v) }.keys.collect(&:to_sym)
+      constrained_fields |= active_scaffold_constraints.flat_map { |k, v| columns_from_constraint(k, v) }.compact
       exclude_actions = []
       %i[list update].each do |action_name|
         if active_scaffold_config.actions.include? action_name
@@ -161,12 +164,16 @@ module ActiveScaffold
         column = config.columns[k]
         if column&.association
           if column.association.collection?
-            record.send(k.to_s).send(:<<, column.association.klass.find(v))
+            record.send(k.to_s).send(:<<, column.association.klass.find(v)) unless column.association.nested?
           elsif column.association.polymorphic?
             unless v.is_a?(Array) && v.size >= 2
               raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(column.association), caller
             end
-            record.send("#{k}=", v[0].constantize.find(v[1])) if v.size == 2
+            if v.size == 2
+              record.send("#{k}=", v[0].constantize.find(v[1]))
+            else
+              record.send("#{column.association.foreign_type}=", v[0])
+            end
           elsif !column.association.source_reflection&.options&.include?(:through) && # regular singular association, or one-level through association
                 !v.is_a?(Array)
             record.send("#{k}=", column.association.klass.find(v))
@@ -177,7 +184,7 @@ module ActiveScaffold
             # note that we can't take the extra step to correct this unless we're permitted to
             # run operations where activerecord auto-saves the object.
             reverse = column.association.reverse_association
-            if reverse.singular? && !reverse.belongs_to? && options[:allow_autosave]
+            if reverse&.singular? && !reverse.belongs_to? && options[:allow_autosave]
               record.send(k).send("#{reverse.name}=", record)
             end
           end

data/lib/active_scaffold/core.rb

@@ -63,7 +63,7 @@ module ActiveScaffold
         active_scaffold_config.configure(&block) if block_given?
         active_scaffold_config.class.after_config_callbacks.each do |callback|
           if callback.is_a?(Proc)
-            callback.call
+            instance_eval(&callback)
           elsif active_scaffold_config.respond_to?(callback)
             active_scaffold_config.send(callback)
           end

data/lib/active_scaffold/data_structures/association/abstract.rb

@@ -46,6 +46,10 @@ module ActiveScaffold::DataStructures::Association
       false
     end
 
+    def nested?
+      false
+    end
+
     def through_singular?
       through? && !through_reflection.collection?
     end

data/lib/active_scaffold/data_structures/association/active_record.rb

@@ -10,6 +10,10 @@ module ActiveScaffold::DataStructures::Association
       @association.options[:through].present?
     end
 
+    def nested?
+      @association.nested?
+    end
+
     def readonly?
       scope_values[:readonly]
     end

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -90,15 +90,22 @@ module ActiveScaffold::DataStructures
     delegate :name, :belongs_to?, :has_one?, :has_many?, :habtm?, :readonly?, :to => :association
 
     # A through association with has_one or has_many as source association
-    # create cannot be called in nested through associations, and not-nested through associations
-    # unless is through singular or create columns include through reflection of reverse association
-    # e.g. customer -> networks -> firewall, reverse is firewall -> network -> customer,
-    # firewall can be created if create columns include network
+    # create cannot be called in nested through associations, and not-nested through associations, unless:
+    # 1. is through singular and source association has reverse, e.g.:
+    #    Employee belongs to vendor, Vendor has many rates, Rate belongs to vendor, Employee has many rates through vendor
+    #    Rates association through singular association vendor, source association in Vendor (rates) has reverse (vendor in Rate)
+    #    AS will assign the vendor of the employee to the new Rate
+    # 2. source association is singular, e.g.:
+    #    Customer has many networks, Network has one (or belongs to) firewall, Customer has many firewalls through networks
+    # 3. create columns include through association of reverse association, e.g.:
+    #    Vendor has many employees, Employee has many rates, Vendor has many rates through employees, Rate has one vendor through employee
+    #    RatesController has employee in create action columns (reverse is vendor, and through association employee is in create form).
     def readonly_through_association?(columns)
       return false unless through_association?
       return true if association.through_reflection.options[:through] # create not possible, too many levels
       return true if association.source_reflection.options[:through] # create not possible, too many levels
       return false if create_through_singular? # create allowed, AS has code for this
+      return false unless association.source_reflection.collection? # create allowed if source is singular, rails creates joint model
 
       # create allowed only if through reflection in record to be created is included in create columns
       !child_association || !columns.include?(child_association.through_reflection.name)

data/lib/active_scaffold/data_structures/sorting.rb

@@ -121,14 +121,14 @@ module ActiveScaffold::DataStructures
     end
 
     # builds an order-by clause
-    def clause(grouped_columns_calculations = nil)
+    def clause(grouped_columns = nil)
       return nil if sorts_by_method? || default_sorting?
 
       # unless the sorting is by method, create the sql string
       order = []
       each do |sort_column, sort_direction|
         next if constraint_columns.include? sort_column.name
-        sql = grouped_columns_calculations&.dig(sort_column.name) || sort_column.sort[:sql]
+        sql = grouped_columns ? grouped_columns[sort_column.name] : sort_column.sort[:sql]
         next if sql.blank?
         sql = sql.to_sql if sql.respond_to?(:to_sql)
 
@@ -138,7 +138,7 @@ module ActiveScaffold::DataStructures
         order << parts
       end
 
-      order << @primary_key_order_clause if @sorting_by_primary_key
+      order << @primary_key_order_clause if @sorting_by_primary_key && grouped_columns.nil?
       order.flatten!(1)
       order unless order.empty?
     end

data/lib/active_scaffold/finder.rb

@@ -96,11 +96,14 @@ module ActiveScaffold
       # Generates an SQL condition for the given ActiveScaffold column based on
       # that column's database type (or form_ui ... for virtual columns?).
       # TODO: this should reside on the column, not the controller
-      def condition_for_column(column, value, text_search = :full)
+      def condition_for_column(column, value, text_search, session)
         like_pattern = like_pattern(text_search)
         value = value.with_indifferent_access if value.is_a? Hash
-        if respond_to?("condition_for_#{column.name}_column")
-          return send("condition_for_#{column.name}_column", column, value, like_pattern)
+        column_method = "condition_for_#{column.name}_column"
+        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)
         end
         return unless column&.search_sql && value.present?
         search_ui = column.search_ui || column.column_type
@@ -363,6 +366,8 @@ module ActiveScaffold
 
         if column.search_sql.is_a? Proc
           column.search_sql.call(from_value, to_value, operator)
+        elsif ActiveScaffold::Finder::NULL_COMPARATORS.include?(value['opt'])
+          condition_for_null_type(column, value['opt'], like_pattern)
         elsif operator.nil?
           ['%<search_sql>s BETWEEN ? AND ?', from_value, to_value] unless from_value.nil? || to_value.nil?
         else
@@ -572,7 +577,7 @@ module ActiveScaffold
     def finder_options(options = {})
       search_conditions = all_conditions
 
-      sorting = options[:sorting]&.clause((grouped_columns_calculations if grouped_search?))
+      sorting = options[:sorting]&.clause
       sorting = sorting.map(&Arel.method(:sql)) if sorting && active_scaffold_config.active_record?
       # create a general-use options array that's compatible with Rails finders
       finder_options = {
@@ -650,7 +655,7 @@ module ActiveScaffold
       @last_modified = query.maximum(:updated_at)
     end
 
-    def calculate_query(id_condition = true)
+    def calculate_subquery(id_condition = true)
       conditions = all_conditions(id_condition)
       includes = active_scaffold_config.list.count_includes
       includes ||= active_scaffold_references if conditions.present?
@@ -658,8 +663,11 @@ module ActiveScaffold
       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 = subquery.unscope(:order)
-      active_scaffold_config.model.where(primary_key => subquery)
+      subquery.unscope(:order)
+    end
+
+    def calculate_query(id_condition = true)
+      active_scaffold_config.model.where(active_scaffold_config.primary_key => calculate_subquery(id_condition))
     end
 
     def append_to_query(relation, options)

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -99,7 +99,7 @@ module ActiveScaffold
       def action_link_to_inline_form(link, record)
         link = link.dup
         associated = record.send(link.column.association.name)
-        if link.column.association&.polymorphic?
+        if link.column.association&.polymorphic? || link.controller.nil?
           link.controller = controller_path_for_activerecord(associated.class)
           return link if link.controller.nil?
         end

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -1,3 +1,4 @@
+
 module ActiveScaffold
   module Helpers
     module AssociationHelpers
@@ -12,6 +13,11 @@ module ActiveScaffold
         end
       end
 
+      def association_helper_method(association, method)
+        model = association.inverse_klass
+        override_helper_per_model(method, model)
+      end
+
       # Provides a way to honor the :conditions on an association while searching the association's klass
       def association_options_find(association, conditions = nil, klass = nil, record = nil)
         if klass.nil? && association.polymorphic?
@@ -24,9 +30,9 @@ module ActiveScaffold
           klass ||= association.klass
         end
 
-        conditions ||= options_for_association_conditions(association, record)
+        conditions ||= send(association_helper_method(association, :options_for_association_conditions), association, record)
         cache_association_options(association, conditions, klass, cache) do
-          klass = association_klass_scoped(association, klass, record)
+          klass = send(association_helper_method(association, :association_klass_scoped), association, klass, record)
           relation = klass.where(conditions)
           column = column_for_association(association, record)
           if column&.includes
@@ -80,7 +86,7 @@ module ActiveScaffold
       end
 
       def options_for_association_count(association, record)
-        conditions = options_for_association_conditions(association, record)
+        conditions = send(association_helper_method(association, :options_for_association_conditions), association, record)
         association_options_count(association, conditions)
       end
 

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -486,7 +486,8 @@ module ActiveScaffold
         record = html_options.delete(:object)
         options[:selected] = record.send(column.name)
         options[:object] = record
-        options_for_select = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
+        enum_options_method = override_helper_per_model(:active_scaffold_enum_options, record.class)
+        options_for_select = send(enum_options_method, column, record, ui_options: ui_options).collect do |text, value|
           active_scaffold_translated_option(column, text, value)
         end
         html_options.merge!(ui_options[:html_options] || {})
@@ -535,7 +536,8 @@ module ActiveScaffold
           if column.association
             sorted_association_options_find(column.association, nil, record)
           else
-            active_scaffold_enum_options(column, record, ui_options: ui_options)
+            enum_options_method = override_helper_per_model(:active_scaffold_enum_options, record.class)
+            send(enum_options_method, column, record, ui_options: ui_options)
           end
 
         selected = record.send(column.association.name) if column.association

data/lib/active_scaffold/helpers/human_condition_helpers.rb

@@ -55,6 +55,8 @@ module ActiveScaffold
         when 'PAST', 'FUTURE'
           from, to = controller.class.datetime_from_to(column, value)
           "#{column.active_record_class.human_attribute_name(column.name)} #{as_('BETWEEN'.downcase).downcase} #{I18n.l(from)} - #{I18n.l(to)}"
+        when 'null', 'not_null'
+          "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value['opt'].downcase).downcase}"
         else
           from, to = controller.class.datetime_from_to(column, value)
           "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value['opt'].downcase).downcase} #{I18n.l(from)} #{value['opt'] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -226,7 +226,10 @@ module ActiveScaffold
           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
+        when 'year'
+          value.to_i
+        else
+          value
         end
       end
 
@@ -263,7 +266,7 @@ module ActiveScaffold
       end
 
       def format_association_value(value, column, size)
-        method = column.options[:label_method] || :to_label
+        method = (column.list_ui_options || column.options)[:label_method] || :to_label
         value =
           if column.association.collection?
             format_collection_association_value(value, column, method, size)

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -85,7 +85,8 @@ module ActiveScaffold
             [r.send(method), r.id]
           end
         else
-          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
+          enum_options_method = override_helper_per_model(:active_scaffold_enum_options, record.class)
+          select_options = send(enum_options_method, column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
@@ -103,7 +104,8 @@ module ActiveScaffold
           select_options = sorted_association_options_find(column.association, false, record)
         else
           method = column.name
-          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
+          enum_options_method = override_helper_per_model(:active_scaffold_enum_options, record.class)
+          select_options = send(enum_options_method, column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
@@ -242,11 +244,13 @@ module ActiveScaffold
       alias active_scaffold_search_string active_scaffold_search_range
 
       def active_scaffold_search_integer(column, options, ui_options: column.options)
-        active_scaffold_search_range(column, options, :number_field_tag, {step: '1'}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
+        number_opts = ui_options.slice(:step, :min, :max).reverse_merge(step: '1')
+        active_scaffold_search_range(column, options, :number_field_tag, number_opts, ui_options: ui_options)
       end
 
       def active_scaffold_search_decimal(column, options, ui_options: column.options)
-        active_scaffold_search_range(column, options, :number_field_tag, {step: :any}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
+        number_opts = ui_options.slice(:step, :min, :max).reverse_merge(step: :any)
+        active_scaffold_search_range(column, options, :number_field_tag, number_opts, ui_options: ui_options)
       end
       alias active_scaffold_search_float active_scaffold_search_decimal
 
@@ -255,7 +259,7 @@ module ActiveScaffold
                           'number' => 1, 'unit' => 'DAYS', 'range' => nil}
         current_search.merge!(options[:value]) unless options[:value].nil?
         tags = [
-          active_scaffold_search_datetime_comparator_tag(column, options, current_search),
+          active_scaffold_search_datetime_comparator_tag(column, options, current_search, ui_options: column.options),
           active_scaffold_search_datetime_trend_tag(column, options, current_search),
           active_scaffold_search_datetime_numeric_tag(column, options, current_search, ui_options: ui_options, field_ui: field_ui),
           active_scaffold_search_datetime_range_tag(column, options, current_search)
@@ -275,13 +279,17 @@ module ActiveScaffold
         active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :date)
       end
 
-      def active_scaffold_search_datetime_comparator_options(column)
+      def active_scaffold_search_datetime_comparator_options(column, ui_options: column.options)
         select_options = ActiveScaffold::Finder::DATE_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
-        select_options + ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+        select_options.concat(ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] })
+        if include_null_comparators? column, ui_options: ui_options
+          select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
+        end
+        select_options
       end
 
-      def active_scaffold_search_datetime_comparator_tag(column, options, current_search)
-        choices = options_for_select(active_scaffold_search_datetime_comparator_options(column), current_search['opt'])
+      def active_scaffold_search_datetime_comparator_tag(column, options, current_search, ui_options: column.options)
+        choices = options_for_select(active_scaffold_search_datetime_comparator_options(column, ui_options: ui_options), current_search['opt'])
         select_tag("#{options[:name]}[opt]", choices, id: "#{options[:id]}_opt", class: 'as_search_range_option as_search_date_time_option')
       end
 

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -76,15 +76,9 @@ module ActiveScaffold
         link_to label, '#', :data => data, :style => 'display: none;', :class => 'as-js-button visibility-toggle'
       end
 
-      def list_row_class_method(record)
-        return @_list_row_class_method if defined? @_list_row_class_method
-        class_override_helper = "#{clean_class_name(record.class.name)}_list_row_class"
-        @_list_row_class_method = (class_override_helper if respond_to?(class_override_helper))
-      end
-
       def list_row_class(record)
-        class_override_helper = list_row_class_method(record)
-        class_override_helper ? send(class_override_helper, record) : ''
+        class_override_helper = override_helper_per_model(:list_row_class, record.class)
+        class_override_helper != :list_row_class ? send(class_override_helper, record) : ''
       end
 
       def list_row_attributes(tr_class, tr_id, data_refresh)
@@ -159,21 +153,22 @@ module ActiveScaffold
         name.underscore.tr('/', '_')
       end
 
-      # the naming convention for overriding with helpers
-      def override_helper_name(column, suffix, class_prefix = false)
-        "#{clean_class_name(column.active_record_class.name) + '_' if class_prefix}#{clean_column_name(column.name)}_#{suffix}"
+      def override_helper_per_model(method, model, cache_keys = nil)
+        cache_keys ||= [method, model.name]
+        ActiveScaffold::Registry.cache(*cache_keys) do
+          model_names = [model.name]
+          model_names << model.base_class.name if model.base_class != model
+          method_with_class = model_names.find do |model_name|
+            method_with_class = "#{clean_class_name(model_name)}_#{method}"
+            break method_with_class if respond_to?(method_with_class)
+          end
+          method_with_class || (method if respond_to?(method))
+        end
       end
 
       def override_helper(column, suffix)
-        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
-          else
-            method = override_helper_name(column, suffix)
-            method if respond_to?(method)
-          end
-        end
+        method = "#{clean_column_name(column.name)}_#{suffix}"
+        override_helper_per_model(method, column.active_record_class, [suffix, column.cache_key])
       end
 
       def history_state

data/lib/active_scaffold/version.rb

@@ -2,7 +2,7 @@ module ActiveScaffold
   module Version
     MAJOR = 3
     MINOR = 7
-    PATCH = 4
+    PATCH = 6
     FIX = nil
 
     STRING = [MAJOR, MINOR, PATCH, FIX].compact.join('.')

data/test/helpers/form_column_helpers_test.rb

@@ -2,10 +2,11 @@ require 'test_helper'
 
 class FormColumnHelpersTest < ActionView::TestCase
   include ActiveScaffold::Helpers::FormColumnHelpers
+  include ActiveScaffold::Helpers::ViewHelpers
 
   def setup
     @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
-    @record = stub(:a => nil)
+    @record = ModelStub.new(a: nil)
   end
 
   def test_choices_for_select_form_ui_for_simple_column

data/test/misc/finder_test.rb

@@ -75,13 +75,13 @@ class FinderTest < Minitest::Test
 
   def test_condition_for_column
     column = ActiveScaffold::DataStructures::Column.new('adult', Person)
-    assert_equal ['"people"."adult" = ?', false], ClassWithFinder.condition_for_column(column, '0')
+    assert_equal ['"people"."adult" = ?', false], ClassWithFinder.condition_for_column(column, '0', :full, {})
   end
 
   def test_condition_for_polymorphic_column
     column = ActiveScaffold::DataStructures::Column.new('addressable', Address)
     column.search_sql = [{subquery: [Building, 'name']}]
-    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
     assert_equal Building.where(['name LIKE ?', '%test search%']).select(:id).to_sql, condition[1].to_sql
     assert_equal '"addresses"."addressable_id" IN (?) AND "addresses"."addressable_type" = ?', condition[0]
     assert_equal ['Building'], condition[2..-1]
@@ -90,7 +90,7 @@ class FinderTest < Minitest::Test
   def test_condition_for_polymorphic_column_with_relation
     column = ActiveScaffold::DataStructures::Column.new('contactable', Contact)
     column.search_sql = [{subquery: [Person.joins(:buildings), 'first_name', 'last_name']}]
-    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
     assert_equal Person.joins(:buildings).where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
     assert_equal '"contacts"."contactable_id" IN (?) AND "contacts"."contactable_type" = ?', condition[0]
     assert_equal ['Person'], condition[2..-1]
@@ -100,7 +100,7 @@ class FinderTest < Minitest::Test
     column = ActiveScaffold::DataStructures::Column.new('owner', Building)
     column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0']}]
     column.search_ui = :text
-    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
     assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
     assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0', condition[0]
     assert_equal [], condition[2..-1]
@@ -110,7 +110,7 @@ class FinderTest < Minitest::Test
     column = ActiveScaffold::DataStructures::Column.new('owner', Building)
     column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0 AND name != ?', '']}]
     column.search_ui = :text
-    condition = ClassWithFinder.condition_for_column(column, 'test search')
+    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
     assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
     assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0 AND name != ?', condition[0]
     assert_equal [''], condition[2..-1]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_scaffold
 version: !ruby/object:Gem::Version
-  version: 3.7.4
+  version: 3.7.6
 platform: ruby
 authors:
 - Many, see README
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-20 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails