active_scaffold 3.6.20 → 3.7.0

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

@@ -2,15 +2,28 @@ module ActiveScaffold::DataStructures::Association
   class Mongoid < Abstract
     delegate :inverse_klass, :as, :dependent, :inverse, to: :@association
 
+    def belongs_to?
+      # once Ruby 2.6 support is dropped, use macro_mapping? always
+      defined?(::Mongoid::Association) ? macro_mapping?(:belongs_to) : super
+    end
+
+    def has_one? # rubocop:disable Naming/PredicateName
+      defined?(::Mongoid::Association) ? macro_mapping?(:has_one) : super
+    end
+
+    def has_many? # rubocop:disable Naming/PredicateName
+      defined?(::Mongoid::Association) ? macro_mapping?(:has_many) : super
+    end
+
+    def habtm?
+      defined?(::Mongoid::Association) ? macro_mapping?(:has_and_belongs_to_many) : super
+    end
+
     # polymorphic belongs_to
     def polymorphic?
       belongs_to? && @association.polymorphic?
     end
 
-    def primary_key
-      @association[:primary_key]
-    end
-
     def association_primary_key
       @association.primary_key
     end
@@ -19,10 +32,6 @@ module ActiveScaffold::DataStructures::Association
       @association.type
     end
 
-    def counter_cache
-      @association[:counter_cache]
-    end
-
     def table_name
       @association.klass.collection.name
     end
@@ -38,5 +47,9 @@ module ActiveScaffold::DataStructures::Association
     def self.reflect_on_all_associations(klass)
       klass.relations.values
     end
+
+    def macro_mapping?(macro)
+      @association.is_a? ::Mongoid::Association::MACRO_MAPPING[macro]
+    end
   end
 end

data/lib/active_scaffold/data_structures/column.rb

@@ -40,14 +40,27 @@ module ActiveScaffold::DataStructures
     # 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
-    def label
-      as_(@label) || active_record_class.human_attribute_name(name.to_s)
+    def label(record = nil, scope = nil)
+      if @label.respond_to?(:call)
+        if record
+          @label.call(record, self, scope)
+        else
+          # sometimes label is called without a record in context (ie, from table
+          # headers).  In this case fall back to the humanized attribute name
+          # instead of the Proc
+          active_record_class.human_attribute_name(name.to_s)
+        end
+      else
+        as_(@label) || active_record_class.human_attribute_name(name.to_s)
+      end
     end
 
     # a textual description of the column and its contents. this will be displayed with any associated form input widget, so you may want to consider adding a content example.
     attr_writer :description
-    def description
-      if @description
+    def description(record = nil, scope = nil)
+      if @description&.respond_to?(:call)
+        @description.call(record, self, scope)
+      elsif @description
         @description
       else
         I18n.t name, :scope => [:activerecord, :description, active_record_class.to_s.underscore.to_sym], :default => ''
@@ -87,6 +100,19 @@ module ActiveScaffold::DataStructures
     cattr_accessor :send_form_on_update_column, instance_accessor: false
     attr_accessor :send_form_on_update_column
 
+    # add a custom attr_accessor that can contain a Proc (or boolean or symbol)
+    # that will be called when the column renders, such that we can dynamically
+    # hide or show the column with an element that can be replaced by
+    # update_columns, but won't affect the form submission.
+    # The value can be set in the scaffold controller as follows to dynamically
+    # hide the column based on a Proc's output:
+    # config.columns[:my_column].hide_form_column_if = Proc.new { |record, column, scope| record.vehicle_type == 'tractor' }
+    # OR to always hide the column:
+    # config.columns[:my_column].hide_form_column_if = true
+    # OR to call a method on the record to determine whether to hide the column:
+    # config.columns[:my_column].hide_form_column_if = :hide_tractor_fields?
+    attr_accessor :hide_form_column_if
+
     # sorting on a column can be configured four ways:
     #   sort = true               default, uses intelligent sorting sql default
     #   sort = false              sometimes sorting doesn't make sense
@@ -328,7 +354,7 @@ module ActiveScaffold::DataStructures
       @actions_for_association_links = self.class.actions_for_association_links.dup if association
       @select_columns = default_select_columns
 
-      @text = @column.nil? || [:string, :text, String].include?(column_type)
+      @text = @column.nil? || [:string, :text, :citext, String].include?(column_type)
       @number = false
       if @column
         if active_record_class.respond_to?(:defined_enums) && active_record_class.defined_enums[name.to_s]

data/lib/active_scaffold/data_structures/columns.rb

@@ -13,7 +13,7 @@ module ActiveScaffold::DataStructures
     # IT IS NOT MEANT FOR PUBLIC USE (but if you know what you're doing, go ahead)
     def _inheritable=(value)
       @sorted = true
-      @_inheritable = value
+      @_inheritable = ::Set.new(value)
     end
 
     # This accessor is used by ActionColumns to create new Column objects without adding them to this set
@@ -21,8 +21,8 @@ module ActiveScaffold::DataStructures
 
     def initialize(active_record_class, *args)
       @active_record_class = active_record_class
-      @_inheritable = []
-      @set = []
+      @_inheritable = ::Set.new
+      @set = {}
       @sorted = nil
 
       add(*args)
@@ -35,9 +35,11 @@ module ActiveScaffold::DataStructures
       args = args.collect(&:to_sym)
 
       # make the columns inheritable
-      @_inheritable.concat(args)
+      @_inheritable.merge(args)
       # then add columns to @set (unless they already exist)
-      args.each { |a| @set << ActiveScaffold::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
+      args.each do |a|
+        @set[a.to_sym] = ActiveScaffold::DataStructures::Column.new(a, @active_record_class) unless find_by_name(a)
+      end
     end
     alias << add
 
@@ -55,7 +57,7 @@ module ActiveScaffold::DataStructures
       klass = column.association.klass
       columns.each do |col|
         next if find_by_name col
-        @set << ActiveScaffold::DataStructures::Column.new(col, klass, column.association)
+        @set[col.to_sym] = ActiveScaffold::DataStructures::Column.new(col, klass, column.association)
       end
     end
 
@@ -66,24 +68,22 @@ module ActiveScaffold::DataStructures
 
     # returns an array of columns with the provided names
     def find_by_names(*names)
-      @set.find_all { |column| names.include? column.name }
+      names.map { |name| find_by_name name }
     end
 
     # returns the column of the given name.
     def find_by_name(name)
-      # this works because of `def column.=='
-      column = @set.find { |c| c == name }
-      column
+      @set[name.to_sym]
     end
     alias [] find_by_name
 
     def each
-      @set.each { |i| yield i }
+      @set.each_value { |name| yield name }
     end
 
     def _inheritable
       if @sorted
-        @_inheritable
+        @_inheritable.to_a
       else
         @_inheritable.sort do |a, b|
           self[a] <=> self[b]

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -70,6 +70,10 @@ module ActiveScaffold::DataStructures
     def match_model?(model)
       false
     end
+
+    def create_with_parent?
+      false
+    end
   end
 
   class NestedInfoAssociation < NestedInfo
@@ -104,6 +108,14 @@ module ActiveScaffold::DataStructures
       association.through_singular? && source_reflection.reverse
     end
 
+    def create_with_parent?
+      if has_many? && !association.through?
+        false
+      elsif child_association || create_through_singular?
+        true
+      end
+    end
+
     def source_reflection
       @source_reflection ||= ActiveScaffold::DataStructures::Association::ActiveRecord.new(association.source_reflection)
     end

data/lib/active_scaffold/data_structures/sorting.rb

@@ -41,7 +41,7 @@ module ActiveScaffold::DataStructures
       column = get_column(column_name)
       raise ArgumentError, "Could not find column #{column_name}" if column.nil?
       raise ArgumentError, 'Sorting direction unknown' unless %i[ASC DESC].include? direction.to_sym
-      @clauses << [column, direction.untaint] if column.sortable?
+      @clauses << [column, direction] if column.sortable?
       raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
     end
 

data/lib/active_scaffold/engine.rb

@@ -3,7 +3,6 @@ module ActiveScaffold
     initializer 'active_scaffold.action_controller' do
       ActiveSupport.on_load :action_controller do
         include ActiveScaffold::Core
-        include ActiveScaffold::DelayedSetup if ActiveScaffold.delayed_setup
         include ActiveScaffold::RespondsToParent
         include ActiveScaffold::Helpers::ControllerHelpers
         include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Controller

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -119,6 +119,17 @@ module ActiveScaffold #:nodoc:
       end
     end
 
+    def remote_controller_config(controller_path)
+      # attempt to retrieve the active_scaffold_config by constantizing the controller path
+      "#{controller_path}_controller".camelize.constantize.active_scaffold_config
+    rescue NameError
+      # if we couldn't determine the controller config by instantiating the
+      # controller class, parse the ActiveRecord model name from the
+      # controller path, which might be a namespaced controller (e.g., 'admin/admins')
+      model = controller_path.to_s.sub(%r{.*/}, '').singularize
+      active_scaffold_config_for(model)
+    end
+
     def render_embedded(options)
       require 'digest/md5'
 
@@ -144,13 +155,10 @@ module ActiveScaffold #:nodoc:
       else
         url = url_for(url_options)
         content_tag(:div, :id => id, :class => 'active-scaffold-component', :data => {:refresh => url}) do
-          # parse the ActiveRecord model name from the controller path, which
-          # might be a namespaced controller (e.g., 'admin/admins')
-          model = remote_controller.to_s.sub(%r{.*/}, '').singularize
           content_tag(:div, :class => 'active-scaffold-header') do
             content_tag(:h2) do
-              link_label = options[:label] || active_scaffold_config_for(model).list.label
-              link_to(link_label, url, remote: true, class: 'load-embedded', data: {error_msg: as_(:error_500)}) <<
+              label = options[:label] || remote_controller_config(remote_controller).list.label
+              link_to(label, url, remote: true, class: 'load-embedded', data: {error_msg: as_(:error_500)}) <<
                 loading_indicator_tag(url_options)
             end
           end

data/lib/active_scaffold/extensions/cow_proxy.rb

@@ -49,7 +49,7 @@ module CowProxy
       class ActionLinks < ::CowProxy::WrapClass(::ActiveScaffold::DataStructures::ActionLinks)
         def method_missing(name, *args, &block)
           CowProxy.debug { "method missing #{name} in #{__getobj__.name}" }
-          return super if name =~ /[!?]$/
+          return super if name.match?(/[!?]$/)
           subgroup =
             if _instance_variable_defined?("@#{name}")
               _instance_variable_get("@#{name}")

data/lib/active_scaffold/extensions/unsaved_record.rb

@@ -11,15 +11,21 @@ module ActiveScaffold::UnsavedRecord
   end
 
   # automatically unsets the unsaved flag
-  def save(*)
+  def save(**)
     super.tap { self.unsaved = false }
   end
 
   def keeping_errors
     old_errors = errors.dup if errors.present?
     result = yield
-    old_errors&.each do |attr|
-      old_errors[attr].each { |msg| errors.add(attr, msg) unless errors.added?(attr, msg) }
+    old_errors&.each do |e|
+      if e.is_a?(String) || e.is_a?(Symbol)
+        # Rails <6.1 errors API.
+        old_errors[e].each { |msg| errors.add(e, msg) unless errors.added?(e, msg) }
+      else
+        # Rails >=6.1 errors API (https://code.lulalala.com/2020/0531-1013.html).
+        errors.add(e.attribute, e.message) unless errors.added?(e.attribute, e.message)
+      end
     end
     result && old_errors.blank?
   end

data/lib/active_scaffold/finder.rb

@@ -122,7 +122,11 @@ module ActiveScaffold
       def condition_for_search_ui(column, value, like_pattern, search_ui)
         case search_ui
         when :boolean, :checkbox
-          ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+          if value == 'null'
+            condition_for_null_type(column, value)
+          else
+            ['%<search_sql>s = ?', column.column ? ActiveScaffold::Core.column_type_cast(value, column.column) : value]
+          end
         when :integer, :decimal, :float
           condition_for_numeric(column, value)
         when :string, :range

data/lib/active_scaffold/helpers/action_link_helpers.rb

@@ -212,7 +212,7 @@ module ActiveScaffold
       end
 
       def column_in_params_conditions?(key)
-        if key =~ /!$/
+        if key.match?(/!$/)
           conditions_from_params[1..-1].any? { |node| node.left.name.to_s == key[0..-2] }
         else
           conditions_from_params[0].include?(key)

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -38,8 +38,7 @@ module ActiveScaffold
 
         else # final ultimate fallback: use rails' generic input method
           # for textual fields we pass different options
-          text_types = %i[text string integer float decimal]
-          options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+          options = active_scaffold_input_text_options(options) if column.text? || column.number?
           if column.column.type == :string && options[:maxlength].blank?
             options[:maxlength] = column.column.limit
             options[:size] ||= options[:maxlength].to_i > 30 ? 30 : options[:maxlength]
@@ -107,7 +106,11 @@ module ActiveScaffold
         classes = "#{column.name}-input"
         classes += ' numeric-input' if column.number?
 
-        {:name => name, :class => classes, :id => id_control}.merge(options)
+        if column.options[:collapsible]
+          collapsible_id = "container_#{id_control}"
+        end
+
+        {name: name, class: classes, id: id_control, collapsible_id: collapsible_id}.merge(options)
       end
 
       def current_form_columns(record, scope, subform_controller = nil)
@@ -120,15 +123,15 @@ module ActiveScaffold
         end
       end
 
-      def update_columns_options(column, scope, options, force = false)
+      def update_columns_options(column, scope, options, force = false, form_columns: nil, url_params: {})
         record = options[:object]
         subform_controller = controller.class.active_scaffold_controller_for(record.class) if scope
         if @main_columns && (scope.nil? || subform_controller == controller.class)
-          form_columns = @main_columns.visible_columns_names
+          form_columns ||= @main_columns.visible_columns_names
         end
-        form_columns ||= current_form_columns(record, scope, subform_controller)
+        form_columns ||= options[:form_columns] || current_form_columns(record, scope, subform_controller)
         if force || (form_columns && column.update_columns && (column.update_columns & form_columns).present?)
-          url_params = params_for(:action => 'render_field', :column => column.name, :id => record.to_param)
+          url_params.reverse_merge! params_for(action: 'render_field', column: column.name, id: record.to_param)
           if nested? && scope
             url_params[:nested] = url_params.slice(:parent_scaffold, :association, nested.param_name)
             url_params = url_params.except(:parent_scaffold, :association, nested.param_name)
@@ -153,7 +156,14 @@ module ActiveScaffold
       end
 
       def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil) # rubocop:disable Metrics/ParameterLists
-        if (partial = override_form_field_partial(column))
+        if form_column_is_hidden?(column, record, scope)
+          # creates an element that can be replaced by the update_columns routine,
+          # but will not affect the value of the submitted form in this state:
+          # <dl><input type="hidden" class="<%= column.name %>-input"></dl>
+          content_tag :dl, style: 'display: none' do
+            hidden_field_tag(nil, nil, :class => "#{column.name}-input")
+          end
+        elsif (partial = override_form_field_partial(column))
           render :partial => partial, :locals => {:column => column, :only_value => only_value, :scope => scope, :col_class => col_class, :record => record}
         elsif renders_as == :field || override_form_field?(column)
           form_attribute(column, record, scope, only_value, col_class)
@@ -164,6 +174,16 @@ module ActiveScaffold
         end
       end
 
+      def form_column_is_hidden?(column, record, scope = nil)
+        if column.hide_form_column_if&.respond_to?(:call)
+          column.hide_form_column_if.call(record, column, scope)
+        elsif column.hide_form_column_if&.is_a?(Symbol)
+          record.send(column.hide_form_column_if)
+        else
+          column.hide_form_column_if
+        end
+      end
+
       def form_attribute(column, record, scope = nil, only_value = false, col_class = nil)
         column_options = active_scaffold_input_options(column, scope, :object => record)
         attributes = field_attributes(column, record)
@@ -181,12 +201,15 @@ module ActiveScaffold
         end
         if field
           field << loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns
-          field << content_tag(:span, column.description, :class => 'description') if column.description.present?
+          desc = column.description(record, scope)
+          field << content_tag(:span, desc, :class => 'description') if desc.present?
         end
 
+        label = label_tag(label_for(column, column_options), form_column_label(column, record, scope))
+        collapsible_id = column_options.delete :collapsible_id
+        label << h(' ') << link_to_visibility_toggle(collapsible_id) if collapsible_id
         content_tag :dl, attributes do
-          content_tag(:dt, label_tag(label_for(column, column_options), form_column_label(column))) <<
-            content_tag(:dd, field)
+          content_tag(:dt, label) << content_tag(:dd, field, id: collapsible_id)
         end
       end
 
@@ -194,8 +217,8 @@ module ActiveScaffold
         options[:id] unless column.form_ui == :select && column.association&.collection?
       end
 
-      def form_column_label(column)
-        column.label
+      def form_column_label(column, record = nil, scope = nil)
+        column.label(record, scope)
       end
 
       def subform_label(column, hidden)
@@ -298,7 +321,7 @@ module ActiveScaffold
 
         html_options.merge!(column.options[:html_options] || {})
         options.merge!(column.options)
-        active_scaffold_select_name_with_multiple html_options
+        html_options.delete(:multiple) # no point using multiple in a form for singular assoc, but may be set for field search
         active_scaffold_translate_select_options(options)
 
         html =
@@ -312,7 +335,7 @@ module ActiveScaffold
         html
       end
 
-      def active_scaffold_new_record_subform(column, record, html_options, new_record_attributes: nil, locals: {}, skip_link: false) # rubocop:disable Metrics/ParameterLists
+      def active_scaffold_new_record_subform(column, record, html_options, new_record_attributes: nil, locals: {}, skip_link: false)
         klass =
           if column.association.polymorphic? && column.association.belongs_to?
             type = record.send(column.association.foreign_type)
@@ -603,14 +626,17 @@ module ActiveScaffold
       # Column.type-based inputs
       #
 
-      def active_scaffold_input_boolean(column, options)
-        record = options.delete(:object)
-        select_options = []
-        select_options << [as_(:_select_), nil] if !column.virtual? && column.column.null
-        select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
-        select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
+      def active_scaffold_input_boolean(column, html_options)
+        record = html_options.delete(:object)
+        html_options.merge!(column.options[:html_options] || {})
 
-        select_tag(options[:name], options_for_select(select_options, record.send(column.name)), options)
+        options = {selected: record.send(column.name), object: record}
+        options[:include_blank] = :_select_ if column.column&.null
+        options.merge!(column.options)
+        active_scaffold_translate_select_options(options)
+
+        options_for_select = [[as_(:true), true], [as_(:false), false]] # rubocop:disable Lint/BooleanSymbol
+        select(:record, column.name, options_for_select, options, html_options)
       end
 
       def active_scaffold_input_date(column, options)

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -113,8 +113,9 @@ module ActiveScaffold
       end
 
       def tel_to(text)
-        groups = text.to_s.scan(/(?:^\+)?\d+/)
-        extension = groups.pop if text.to_s =~ /\s*[^\d\s]+\s*\d+$/
+        text = text.to_s
+        groups = text.scan(/(?:^\+)?\d+/)
+        extension = groups.pop if text.match?(/\s*[^\d\s]+\s*\d+$/)
         link_to text, "tel:#{[groups.join('-'), extension].compact.join(',')}"
       end
 

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -6,6 +6,8 @@ module ActiveScaffold
       # It does not do any rendering. It only decides which method is responsible for rendering.
       def active_scaffold_search_for(column, options = nil)
         options ||= active_scaffold_search_options(column)
+        search_columns = active_scaffold_config.field_search.columns.visible_columns_names
+        options = update_columns_options(column, nil, options, form_columns: search_columns, url_params: {form_action: :field_search})
         record = options[:object]
         if column.delegated_association
           record = record.send(column.delegated_association.name) || column.active_record_class.new
@@ -42,8 +44,7 @@ module ActiveScaffold
 
         else # final ultimate fallback: use rails' generic input method
           # for textual fields we pass different options
-          text_types = %i[text string integer float decimal]
-          options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+          options = active_scaffold_input_text_options(options) if column.text? || column.number?
           text_field(:record, column.name, options.merge(column.options))
         end
       rescue StandardError => e
@@ -134,6 +135,11 @@ module ActiveScaffold
       def active_scaffold_search_boolean(column, options)
         select_options = []
         select_options << [as_(:_select_), nil]
+        if column.column&.null
+          null_label = column.options[:include_blank] || :null
+          null_label = as_(null_label) if null_label.is_a?(Symbol)
+          select_options << [null_label, 'null']
+        end
         select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
         select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -247,7 +247,7 @@ module ActiveScaffold
 
           message = options.include?(:message) ? options[:message] : as_('errors.template.body')
 
-          error_messages = objects.sum do |object|
+          error_messages = objects.sum([]) do |object|
             object.errors.full_messages.map do |msg|
               options[:list_type] != :br ? content_tag(:li, msg) : msg
             end

data/lib/active_scaffold/registry.rb

@@ -1,33 +1,28 @@
 module ActiveScaffold
   class Registry
-    extend ActiveSupport::PerThreadRegistry
-    attr_accessor :current_user_proc, :current_ability_proc, :marked_records
+    thread_mattr_accessor :current_user_proc, :current_ability_proc, :marked_records
 
-    def user_settings
-      @user_settings ||= {}
+    def self.user_settings
+      RequestStore.store[:attr_Registry_user_settings] ||= {}
     end
 
-    def constraint_columns
-      @constraint_columns ||= Hash.new { |h, k| h[k] = [] }
+    def self.constraint_columns
+      RequestStore.store[:attr_Registry_constraint_columns] ||= Hash.new { |h, k| h[k] = [] }
     end
 
-    def unauthorized_columns
-      @unauthorized_columns ||= Hash.new { |h, k| h[k] = [] }
+    def self.unauthorized_columns
+      RequestStore.store[:attr_Registry_unauthorized_columns] ||= Hash.new { |h, k| h[k] = [] }
     end
 
-    def cache(kind, key = nil, &block)
+    def self.cache(kind, key = nil, &block)
       unless key
         key = kind
         kind = :cache
       end
-      @cache ||= {}
-      cache = @cache[kind] ||= {}
+      RequestStore.store[:attr_Registry_cache] ||= {}
+      cache = RequestStore.store[:attr_Registry_cache][kind] ||= {}
       return cache[key] if cache.include? key
       cache[key] ||= yield
     end
-
-    def self.instance
-      RequestStore.store[@per_thread_registry_key] ||= new
-    end
   end
 end