active_scaffold 3.7.5 → 3.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba64ea5cfd0c7476b2a534dd60d646c9b25b00f86278873e132d930336007673
-  data.tar.gz: 5ec04a9180e01392a6718ba25453a2731819a53551ef15de1e58e207533b1881
+  metadata.gz: 5777dd56be3d144f2c62d8b2fa3cf8a0e765155d3afd445b5d150ce25c203155
+  data.tar.gz: 2c2ef1fbe12d539b84d81d48d1a2d373f3634a864664d61ab27099c783f404c4
 SHA512:
-  metadata.gz: 67a8322a087fbb94b4c2b51d2bb8a4687fe76e0d4c73eae18d57b30d2457fb85bbe30d67c5b84a1e3b6dfd0100710b79cd304d81cac087d49f9f0967900343df
-  data.tar.gz: ff5d7ae043ba814460a375d3f146115fc8b9fd0a21b5d9ea7c31410ff52b85c83641d27ac5ab9c99724b22e38265542eb141c8eafd64ba173e76e0c4145ecefb
+  metadata.gz: e13283f6ae89cf8618e070ee0e6afa87a47389eaee7043a669ab771f82c6aec2dbbdf2317c57ca6872785622e601d0d1278140e53cf24ca5245a88f9353dfe97
+  data.tar.gz: ea569709001c16bae097715c62fe9a9717597c288b2504d2c930e55aa01b28e77b53c29583d3e0462c86f329aebae8c8a82d73c832b14332a8999ee777d42e3c

data/CHANGELOG.rdoc

@@ -1,3 +1,16 @@
+= 3.7.7
+- Fix usage with mongoid, broken on 3.7.5
+- Support proc or lambda in label of action links
+- Set successful to false when update_column is not authorized for the column
+- Use action link's label for flash message when custom action is not authorized
+- Add default_value to columns, so default_value can be defined in AS config, overriding DB default
+- Fix caching query from association_klass_scoped in subforms, when returns different queries for the same association on different rows
+
+= 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

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

@@ -4,7 +4,7 @@
       <h4><%= link.confirm(h(record&.to_label)) -%></h4>
 
       <p class="form-footer">
-        <%= submit_tag as_(link.label), :class => 'submit' %>
+        <%= submit_tag as_(link.label(record)), :class => 'submit' %>
         <%= link_to as_(:cancel), main_path_to_return, :class => 'cancel' %>
       </p>
 

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

@@ -294,7 +294,7 @@ module ActiveScaffold::Actions
       end
     end
 
-    def new_model
+    def empty_model
       relation = beginning_of_chain
       if nested? && nested.plural_association? && nested.match_model?(active_scaffold_config.model)
         build_options = sti_nested_build_options(relation.klass)
@@ -302,6 +302,18 @@ module ActiveScaffold::Actions
       relation.respond_to?(:build) ? relation.build(build_options || {}) : relation.new
     end
 
+    def new_model
+      empty_model.tap do |record|
+        assign_default_attributes record
+      end
+    end
+
+    def assign_default_attributes(record)
+      active_scaffold_config.columns.each do |column|
+        record.write_attribute column.name, column.default_value if column.default_value?
+      end
+    end
+
     def sti_nested_build_options(klass)
       config = active_scaffold_config_for(klass)
       return unless config
@@ -391,7 +403,7 @@ module ActiveScaffold::Actions
           get_row(crud_type_or_security_options)
           if @record.nil?
             self.successful = false
-            flash[:error] = as_(:no_authorization_for_action, :action => action_name)
+            flash[:error] = as_(:no_authorization_for_action, :action => @action_link&.label(nil) || action_name)
           else
             yield @record
           end

data/lib/active_scaffold/actions/field_search.rb

@@ -12,7 +12,7 @@ module ActiveScaffold::Actions
       # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
       # This facilitates for example, textual searches against associations via .search_sql
       def show_search
-        @record = new_model
+        @record = empty_model
         super
       end
 
@@ -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)

data/lib/active_scaffold/actions/update.rb

@@ -150,9 +150,8 @@ module ActiveScaffold::Actions
       params.delete(:original_html)
       params.delete(:original_value)
       @column = active_scaffold_config.columns[column]
-      value_record = record_for_update_column
-      return unless value_record
 
+      value_record = record_for_update_column
       value = value_for_update_column(value, @column, value_record)
       value_record.send("#{@column.name}=", value)
       before_update_save(@record)
@@ -168,16 +167,19 @@ module ActiveScaffold::Actions
         end
       end
       after_update_save(@record)
+    rescue ActiveScaffold::ActionNotAllowed
+      self.successful = false
     end
 
     def record_for_update_column
       @record = find_if_allowed(params[:id], :read)
-      return unless @record.authorized_for?(:crud_type => :update, :column => @column.name)
+      raise ActiveScaffold::ActionNotAllowed unless @record.authorized_for?(:crud_type => :update, :column => @column.name)
 
       if @column.delegated_association
         value_record = @record.send(@column.delegated_association.name)
         value_record ||= @record.association(@column.delegated_association.name).build
-        value_record if value_record.authorized_for?(:crud_type => :update, :column => @column.name)
+        raise ActiveScaffold::ActionNotAllowed unless value_record.authorized_for?(:crud_type => :update, :column => @column.name)
+        value_record
       else
         @record
       end
@@ -185,7 +187,7 @@ module ActiveScaffold::Actions
 
     def value_for_update_column(param_value, column, record)
       unless param_value
-        param_value = ActiveScaffold::Core.column_type_cast column.default_for_empty_value, column.column
+        param_value = column.default_for_empty_value
         param_value = false if param_value == true
       end
       value = column_value_from_param_value(record, column, param_value)

data/lib/active_scaffold/core.rb

@@ -267,12 +267,12 @@ module ActiveScaffold
     end
 
     def self.mongoid_column_type_cast(value, column)
-      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && [Time, DateTime].include?(column.type)
+      return Time.zone.at(value.to_i) if [Time, DateTime].include?(column.type) && value =~ /\A\d+\z/
       column.type.evolve value
     end
 
     def self.active_record_column_type_cast(value, column_or_type)
-      return Time.zone.at(value.to_i) if value =~ /\A\d+\z/ && %i[time datetime].include?(column_or_type.type)
+      return Time.zone.at(value.to_i) if %i[time datetime].include?(column_or_type.type) && value =~ /\A\d+\z/
       cast_type = column_or_type.is_a?(ActiveRecord::ConnectionAdapters::Column) ? ActiveRecord::Type.lookup(column_or_type.type) : column_or_type
       cast_type ? cast_type.cast(value) : value
     end

data/lib/active_scaffold/data_structures/action_link.rb

@@ -77,8 +77,15 @@ module ActiveScaffold::DataStructures
 
     # what string to use to represent this action
     attr_writer :label
-    def label
-      @label.is_a?(Symbol) ? ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) } : @label
+    def label(record = nil)
+      case @label
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) }
+      when Proc
+        @label.call(record)
+      else
+        @label
+      end
     end
 
     # image to use {:name => 'arrow.png', :size => '16x16'}

data/lib/active_scaffold/data_structures/action_links.rb

@@ -139,8 +139,15 @@ module ActiveScaffold::DataStructures
     end
 
     attr_writer :label
-    def label
-      as_(@label) if @label
+    def label(record)
+      case @label
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) }
+      when Proc
+        @label.call(record)
+      else
+        @label
+      end
     end
 
     def method_missing(name, *args, &block)

data/lib/active_scaffold/data_structures/column.rb

@@ -37,6 +37,19 @@ module ActiveScaffold::DataStructures
       @params ||= NO_PARAMS.dup
     end
 
+    def default_value
+      @default_value || @db_default_value
+    end
+
+    def default_value=(value)
+      raise ArgumentError, "Can't set default value for non-DB columns (virtual columns or associations)" unless column
+      @default_value = value
+    end
+
+    def default_value?
+      defined? @default_value
+    end
+
     # the display-name of the column. this will be used, for instance, as the column title in the table and as the field name in the form.
     # if left alone it will utilize human_attribute_name which includes localization
     attr_writer :label
@@ -377,6 +390,7 @@ module ActiveScaffold::DataStructures
       if @column.nil? && active_record? && active_record_class._default_attributes.key?(name.to_s)
         @column = active_record_class._default_attributes[name.to_s]
       end
+      @db_default_value = ActiveScaffold::OrmChecks.default_value active_record_class, name if @column
       @delegated_association = delegated_association
       @cache_key = [@active_record_class.name, name].compact.map(&:to_s).join('#')
       setup_association_info
@@ -455,10 +469,8 @@ module ActiveScaffold::DataStructures
       return nil unless column
       if column.is_a?(ActiveModel::Attribute)
         column.value
-      elsif active_record?
-        null? ? nil : column.default
-      elsif mongoid?
-        column.default_val
+      else
+        default_value
       end
     end
 
@@ -487,10 +499,6 @@ module ActiveScaffold::DataStructures
       ActiveScaffold::OrmChecks.column_type active_record_class, name
     end
 
-    def default_value
-      ActiveScaffold::OrmChecks.column_type active_record_class, name
-    end
-
     def attributes=(opts)
       opts.each do |setting, value|
         send "#{setting}=", value

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

@@ -577,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 = {

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -68,7 +68,7 @@ module ActiveScaffold
             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), :class => link.name.to_s.downcase) << content_tag(:ul, content)
+            content_tag(:div, as_(link.label(record)), :class => link.name.to_s.downcase) << content_tag(:ul, content)
           end
         else
           content = render_action_link(link, record, options)
@@ -86,7 +86,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, 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)
@@ -298,8 +298,8 @@ module ActiveScaffold
         url_options
       end
 
-      def action_link_text(link, options)
-        text = image_tag(link.image[:name], :size => link.image[:size], :alt => options[:link] || link.label, :title => options[:link] || link.label) if link.image
+      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
         text || options[:link]
       end
 
@@ -329,7 +329,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] = action_link_text(link, options)
+        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
         html_options[:method] = link.method if link.method != :get
@@ -388,7 +388,7 @@ module ActiveScaffold
 
       def action_link_html(link, url, html_options, record)
         label = html_options.delete(:link)
-        label ||= link.label
+        label ||= link.label(record)
         if url.nil?
           content_tag(:a, label, html_options)
         else

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -6,7 +6,7 @@ module ActiveScaffold
       def cache_association_options(association, conditions, klass, cache = true)
         if active_scaffold_config.cache_association_options && cache
           @_associations_cache ||= Hash.new { |h, k| h[k] = {} }
-          key = [association.name, association.inverse_klass.name, klass.name].join('/')
+          key = [association.name, association.inverse_klass.name, klass.respond_to?(:cache_key) ? klass.cache_key : klass.name].join('/')
           @_associations_cache[key][conditions] ||= yield
         else
           yield
@@ -31,8 +31,8 @@ module ActiveScaffold
         end
 
         conditions ||= send(association_helper_method(association, :options_for_association_conditions), association, record)
+        klass = send(association_helper_method(association, :association_klass_scoped), association, klass, record)
         cache_association_options(association, conditions, klass, cache) do
-          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

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -181,6 +181,7 @@ module ActiveScaffold
           parent_record.send("build_#{association.name}")
         else
           association.klass.new.tap do |record|
+            assign_default_attributes record
             save_record_to_association(record, association.reverse_association, parent_record) # set inverse
           end
         end

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/view_helpers.rb

@@ -157,7 +157,7 @@ module ActiveScaffold
         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
+          model_names << model.base_class.name if model.respond_to?(:base_class) && 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)

data/lib/active_scaffold/orm_checks.rb

@@ -85,9 +85,9 @@ module ActiveScaffold
 
       def default_value(klass, column_name)
         if ActiveScaffold::OrmChecks.mongoid? klass
-          columns_hash(klass)[column_name]&.default_val
+          columns_hash(klass)[column_name.to_s]&.default_val
         elsif ActiveScaffold::OrmChecks.active_record? klass
-          klass._default_attributes[column_name]&.value
+          klass._default_attributes[column_name.to_s]&.value
         end
       end
 

data/lib/active_scaffold/version.rb

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

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.5
+  version: 3.7.7
 platform: ruby
 authors:
 - Many, see README
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails