active_scaffold 4.4.1 → 4.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62f92c20382d4b5a33b53bb1525e677d81259a2d89a51996caefcb68ab314ed2
-  data.tar.gz: 2b8b5f59b6bdf856af6bdb4cfd5697caca0095960c41278bdb16ea5d51e0d03b
+  metadata.gz: 53bf726d56ef1da11ee5ecdf4bc039b59ef10e74dd1ac9d31e2723e3e27716e1
+  data.tar.gz: 625f6798df882567a08bac210c6af4c9dbb246364ba739fc0a68bdad695c7b94
 SHA512:
-  metadata.gz: cffce904d4531775442f630fe004153a6ff602fdf7d1d416601712038324d0ad27b75c0e075dca01cefe0cc05d103769de538c2295ae5ab0d670a85944bf59c7
-  data.tar.gz: d7b32cbea9ac2da0d506de89ccd6dd5fbfefd7f3565780e4c93d97308bf2e1808d3a4bf396e63d7f7aeaedef7b72efaa2dd03c1d9f63fb7f49390a23382e8bdf
+  metadata.gz: 1948177220ec25858dc4d4a19e0313db67f8cafc544ab6bfdf5129bbd418918c9d6f4e4af1f134213e39cc97fb2da485972feca80628547f7fcbc9ad1687e2b9
+  data.tar.gz: 21308ad93ecc7bed4293d82dc4b011eb516e43171d9283ea26fdf24fd67f3283f280ba2c11033c3fdd1008194fef34821a9b134b2c672c8159611eb1b73eac59

data/CHANGELOG.rdoc

@@ -1,3 +1,60 @@
+= 4.4.5
+- Authorize the PaperTrail deleted-records action and allow overriding its version query with +deleted_records_query+
+- Deprecate passing optional boolean arguments positionally; keyword arguments will be required in 4.5.
+
+  Overrides which only forward arguments can replace anonymous +*+ with +...+. This accepts the positional argument from 4.4 and forwards the keyword argument used by 4.5:
+
+    # Before
+    def find_or_create_for_params(params, parent_column, parent_record, *)
+      super
+    end
+
+    # Compatible with both 4.4 and 4.5
+    def find_or_create_for_params(params, parent_column, parent_record, ...)
+      super
+    end
+
+  An override which reads or changes the optional argument must temporarily accept both forms. It must call +super+ explicitly with keywords; bare +super+ would forward the original positional arguments and keep producing the warning:
+
+    # Before
+    def update_columns_options(column, scope, options, force = false)
+      super(column, scope, options, true)
+    end
+
+    # Compatible with both 4.4 and 4.5
+    def update_columns_options(column, scope, options, *legacy_force, force: false, **kwargs)
+      force = legacy_force.first unless legacy_force.empty?
+      force = true
+      super(column, scope, options, force: force, **kwargs)
+    end
+
+  After requiring ActiveScaffold 4.5, the compatibility rest argument can be removed:
+
+    def update_columns_options(column, scope, options, force: false, **kwargs)
+      super(column, scope, options, force: true, **kwargs)
+    end
+
+  For methods such as +form_attribute+, where another positional argument followed the boolean, normalize both arguments before calling +super+:
+
+    def form_attribute(column, record, scope = nil, *legacy_arguments,
+                       only_value: false, col_class: nil, **kwargs)
+      only_value = legacy_arguments.shift unless legacy_arguments.empty?
+      col_class = legacy_arguments.shift unless legacy_arguments.empty?
+
+      super(column, record, scope, only_value: only_value, col_class: col_class, **kwargs)
+    end
+
+= 4.4.4
+- Fix the inconsistent behaviour for constraints containing an array with only one value
+- Wait for dynamically loaded plugins and bridges to finish registering their ready and setup callbacks before initial setup, fixing initialization on directly rendered forms
+- Show all association records in select and multi-select search UIs instead of applying form association conditions
+
+= 4.4.3 (yanked)
+- Yanked because it accidentally included unreleased 4.5 functionality
+
+= 4.4.2 (yanked)
+- Yanked because it accidentally included unreleased 4.5 functionality
+
 = 4.4.1
 - Avoid unnecessary DISTINCT in searches without joins or with only belongs_to joins, fixing PostgreSQL searches on models with json columns
 - Update install generator for the supported rails versions and asset pipelines

data/app/assets/javascripts/active_scaffold/active_scaffold.js

@@ -1695,8 +1695,10 @@
 
       // call setup on document.ready if Turbolinks not enabled
       if ((typeof(Turbolinks) == 'undefined' || !Turbolinks.supported) && typeof(Turbo) == 'undefined') {
-        ActiveScaffold.setup_history_state();
-        ActiveScaffold.setup(document);
+        if (!ActiveScaffold.config.deferInitialSetup) {
+          ActiveScaffold.setup_history_state();
+          ActiveScaffold.setup(document);
+        }
       }
       if (ActiveScaffold.config.warn_changes) ActiveScaffold.setup_warn_changes();
       jQuery(document).on('as:element_updated as:element_created', function(e, action_link) {
@@ -1732,7 +1734,7 @@
     });
 
     jQuery(document).on('turbolinks:load turbo:load', function($) {
-      ActiveScaffold.setup(document);
+      if (!ActiveScaffold.config.deferInitialSetup) ActiveScaffold.setup(document);
     });
     jQuery(window).on('scroll resize', ActiveScaffold.update_floating_form_footer);
   };

data/app/assets/javascripts/active_scaffold/load.js

@@ -1,6 +1,10 @@
 // ActiveScaffold main entry point
 (function() {
   const config = window.ActiveScaffold?.config || {};
+  config.deferInitialSetup = true;
+  const scriptLoads = new Map();
+  const readyHeld = typeof window.jQuery?.holdReady === 'function';
+  if (readyHeld) window.jQuery.holdReady(true);
 
   // Load dependencies based on configuration
   const loadDependencies = async () => {
@@ -17,23 +21,14 @@
     await loadScript(RAILS_ASSET_URL('/active_scaffold/active_scaffold.js'));
     await loadScript(RAILS_ASSET_URL('/active_scaffold/jquery.editinplace.js'));
 
-    // Load plugins
-    if (config.plugins) {
-      for (const plugin of config.plugins) {
-        await loadScript(plugin);
-      }
-    }
-
-    // Load bridges
-    if (config.bridges) {
-      for (const bridge of config.bridges) {
-        await loadScript(bridge);
-      }
-    }
+    // Load plugins and bridges in order. Some of them depend on scripts loaded
+    // before them and register callbacks while they are being evaluated.
+    await loadScripts(config.plugins);
+    await loadScripts(config.bridges);
 
     // ALL DEPENDENCIES ARE LOADED NOW
     // Initialize everything
-    initializeActiveScaffold();
+    await initializeActiveScaffold();
   };
 
   const loadJQueryUI = async () => {
@@ -57,8 +52,16 @@
     initializeJQueryUI();
   };
 
+  const loadScripts = async (paths = []) => {
+    for (const path of paths || []) {
+      await loadScript(path);
+    }
+  };
+
   const loadScript = (path) => {
-    return new Promise((resolve, reject) => {
+    if (scriptLoads.has(path)) return scriptLoads.get(path);
+
+    const promise = new Promise((resolve, reject) => {
       // Check if already loaded
       if (document.querySelector(`script[src*="${path}"]`)) {
         resolve();
@@ -72,6 +75,9 @@
       script.onerror = reject;
       document.head.appendChild(script);
     });
+
+    scriptLoads.set(path, promise);
+    return promise;
   };
 
   const initializeJQueryUI = function() {
@@ -100,13 +106,26 @@
     }
   };
 
-  // NEW: Initialize everything after all scripts are loaded
-  const initializeActiveScaffold = () => {
-    // Run any post-load initialization
-    if (window.jQuery) {
-      jQuery(document).trigger('active-scaffold:loaded');
+  // Initialize only after plugins and bridges are available. This is especially
+  // important when this file is loaded as a regular script after DOM ready.
+  const initializeActiveScaffold = () => new Promise((resolve) => {
+    if (!window.jQuery || !window.ActiveScaffold) {
+      resolve();
+      return;
     }
-  };
+
+    jQuery(function() {
+      config.deferInitialSetup = false;
+      if ((typeof(Turbolinks) == 'undefined' || !Turbolinks.supported) && typeof(Turbo) == 'undefined') {
+        ActiveScaffold.setup_history_state();
+      }
+      ActiveScaffold.setup(document);
+      jQuery(document).trigger('active-scaffold:loaded');
+      resolve();
+    });
+
+    if (readyHeld) window.jQuery.holdReady(false);
+  });
 
   // Start loading when DOM is ready
   if (document.readyState === 'loading') {
@@ -114,4 +133,4 @@
   } else {
     loadDependencies();
   }
-})();
+})();

data/lib/active_scaffold/attribute_params.rb

@@ -57,7 +57,13 @@ module ActiveScaffold
     #
     # This is a secure way to apply params to a record, because it's based on a loop over the columns
     # set. The columns set will not yield unauthorized columns, and it will not yield unregistered columns.
-    def update_record_from_params(parent_record, columns, attributes, avoid_changes = false, search_attributes: false)
+    def update_record_from_params(parent_record, columns, attributes,
+                                  positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                  avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN, search_attributes: false)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       crud_type = parent_record.new_record? ? :create : :update
       return parent_record unless parent_record.authorized_for?(crud_type: crud_type)
 
@@ -91,7 +97,13 @@ module ActiveScaffold
       column.params.select { |p| attributes.key? p }.each { |p| parent_record.send(:"#{p}=", attributes[p]) }
     end
 
-    def update_column_from_params(parent_record, column, attribute, avoid_changes = false)
+    def update_column_from_params(parent_record, column, attribute,
+                                  positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                  avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       value = column_value_from_param_value(parent_record, column, attribute, avoid_changes)
       if column.association
         update_column_association(parent_record, column, attribute, value, avoid_changes)
@@ -110,7 +122,13 @@ module ActiveScaffold
       parent_record.send(:"#{column.association.foreign_key}=", value&.id) if column.association.belongs_to?
     end
 
-    def update_column_association(parent_record, column, attribute, value, avoid_changes = false)
+    def update_column_association(parent_record, column, attribute, value,
+                                  positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                  avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       if avoid_changes
         assign_column_association(parent_record, column, attribute, value)
       elsif column.association.collection? && column.association.through_singular?
@@ -126,7 +144,13 @@ module ActiveScaffold
       parent_record.association(column.name).target = value
     end
 
-    def column_value_from_param_value(parent_record, column, value, avoid_changes = false)
+    def column_value_from_param_value(parent_record, column, value,
+                                      positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                      avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       # convert the value, possibly by instantiating associated objects
       form_ui = column.form_ui || column.column&.type
       if form_ui && respond_to?(:"column_value_for_#{form_ui}_type", true)
@@ -205,7 +229,13 @@ module ActiveScaffold
       end
     end
 
-    def column_value_from_param_hash_value(parent_record, column, value, avoid_changes = false)
+    def column_value_from_param_hash_value(parent_record, column, value,
+                                           positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                           avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       if column.association&.singular?
         manage_nested_record_from_params(parent_record, column, value, avoid_changes)
       elsif column.association&.collection?
@@ -233,7 +263,13 @@ module ActiveScaffold
       columns ? subform_cfg.build_action_columns(columns) : subform_cfg.columns
     end
 
-    def manage_nested_record_from_params(parent_record, column, attributes, avoid_changes = false)
+    def manage_nested_record_from_params(parent_record, column, attributes,
+                                         positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                         avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       return nil unless avoid_changes || build_record_from_params?(attributes, column, parent_record)
 
       record = find_or_create_for_params(attributes, column, parent_record, avoid_changes)
@@ -259,7 +295,13 @@ module ActiveScaffold
     # Attempts to create or find an instance of the klass of the association in parent_column from the
     # request parameters given. If params[primary_key] exists it will attempt to find an existing object
     # otherwise it will build a new one.
-    def find_or_create_for_params(params, parent_column, parent_record, avoid_changes = false)
+    def find_or_create_for_params(params, parent_column, parent_record,
+                                  positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                  avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       current = parent_record.send(parent_column.name)
       klass = parent_column.association.klass(parent_record)
       if params.key? klass.primary_key
@@ -277,7 +319,13 @@ module ActiveScaffold
 
     # Attempts to find an instance of klass (which must be an ActiveRecord object) with id primary key
     # Returns record from current if it's included or find from DB
-    def record_from_current_or_find(klass, id, current, avoid_changes = false)
+    def record_from_current_or_find(klass, id, current,
+                                    positional_avoid_changes = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                    avoid_changes: POSITIONAL_ARGUMENT_NOT_GIVEN)
+      avoid_changes = ActiveScaffold.deprecated_positional_argument(
+        positional_avoid_changes, avoid_changes,
+        method_name: __method__, argument_name: :avoid_changes, default: false
+      )
       record = record_from_current(current, id)
       record ||= klass.new(klass.primary_key => id) if avoid_changes
       record ||= klass.find(id)

data/lib/active_scaffold/bridges/paper_trail/actions.rb

@@ -3,6 +3,7 @@
 module ActiveScaffold::Actions
   module DeletedRecords
     def self.included(base)
+      base.before_action :deleted_authorized_filter, only: :deleted
       base.class_eval do
         config = active_scaffold_config
         if config.actions.include?(:nested) && config.deleted_records.nested_link_group
@@ -14,13 +15,7 @@ module ActiveScaffold::Actions
     end
 
     def deleted
-      query = PaperTrail::Version.destroys.where(item_type: active_scaffold_config.model.name)
-      if nested? && nested.child_association&.belongs_to? && PaperTrail::Version.respond_to?(:where_object)
-        foreign_key = nested.child_association.foreign_key
-        parent_id = nested.parent_id
-        parent_id = parent_id&.to_i if self.class.active_scaffold_config.columns[foreign_key]&.number?
-        query = query.where_object(foreign_key => parent_id)
-      end
+      query = deleted_records_query
       pager = Paginator.new(query.count, active_scaffold_config.list.per_page) do |offset, per_page|
         query.offset(offset).limit(per_page).map(&:reify)
       end
@@ -29,5 +24,26 @@ module ActiveScaffold::Actions
       @records = @page.items
       respond_to_action(:list)
     end
+
+    protected
+
+    def deleted_records_query
+      query = PaperTrail::Version.destroys.where(item_type: active_scaffold_config.model.name)
+      if nested? && nested.child_association&.belongs_to? && PaperTrail::Version.respond_to?(:where_object)
+        foreign_key = nested.child_association.foreign_key
+        parent_id = nested.parent_id
+        parent_id = parent_id&.to_i if self.class.active_scaffold_config.columns[foreign_key]&.number?
+        query = query.where_object(foreign_key => parent_id)
+      end
+      query
+    end
+
+    def deleted_authorized?
+      list_authorized?
+    end
+
+    def deleted_authorized_filter
+      raise ActiveScaffold::ActionNotAllowed unless deleted_authorized?
+    end
   end
 end

data/lib/active_scaffold/constraints.rb

@@ -163,8 +163,9 @@ module ActiveScaffold
       elsif association.polymorphic?
         apply_constraint_on_polymorphic_association(record, association, value)
       elsif !association.source_reflection&.through? && # regular singular association, or one-level through association
-            !value.is_a?(Array)
-        record.send(:"#{association.name}=", association.klass.find(value))
+            (!value.is_a?(Array) || value.size == 1)
+        constraint_value = value.is_a?(Array) ? value.first : value
+        record.send(:"#{association.name}=", association.klass.find(constraint_value))
 
         # setting the belongs_to side of a has_one isn't safe. if the has_one was already
         # specified, rails won't automatically clear out the previous associated record.

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -4,7 +4,13 @@ module ActiveScaffold
   module Helpers
     module AssociationHelpers
       # Cache the options for select
-      def cache_association_options(association, conditions, klass, cache = true)
+      def cache_association_options(association, conditions, klass,
+                                    positional_cache = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                    cache: POSITIONAL_ARGUMENT_NOT_GIVEN)
+        cache = ActiveScaffold.deprecated_positional_argument(
+          positional_cache, cache,
+          method_name: __method__, argument_name: :cache, default: 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.respond_to?(:cache_key) ? klass.cache_key : klass.name].join('/')

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -52,7 +52,20 @@ module ActiveScaffold
         handle_exception_on_column(e, column, record)
       end
 
-      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil, form_columns: nil) # rubocop:disable Metrics/ParameterLists
+      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, *positional_arguments,
+                                                add_class: POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                                record: POSITIONAL_ARGUMENT_NOT_GIVEN, form_columns: nil)
+        raise ArgumentError, 'too many positional arguments' if positional_arguments.size > 2
+
+        positional_add_class = positional_arguments.fetch(0, POSITIONAL_ARGUMENT_NOT_GIVEN)
+        positional_record = positional_arguments.fetch(1, POSITIONAL_ARGUMENT_NOT_GIVEN)
+        add_class = ActiveScaffold.deprecated_positional_argument(
+          positional_add_class, add_class,
+          method_name: __method__, argument_name: :add_class, default: false
+        )
+        record = ActiveScaffold.positional_or_keyword_argument(
+          positional_record, record, argument_name: :record, default: nil
+        )
         if add_class
           col_class = []
           col_class << 'required' if column.required?(action_for_validation(record))
@@ -156,7 +169,13 @@ module ActiveScaffold
         url_params
       end
 
-      def update_columns_options(column, scope, options, force = false, form_columns: nil, url_params: {})
+      def update_columns_options(column, scope, options,
+                                 positional_force = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                 force: POSITIONAL_ARGUMENT_NOT_GIVEN, form_columns: nil, url_params: {})
+        force = ActiveScaffold.deprecated_positional_argument(
+          positional_force, force,
+          method_name: __method__, argument_name: :force, default: false
+        )
         record = options[:object]
         subform_controller = controller.class.active_scaffold_controller_for(record.class) if scope
         form_columns ||= current_form_columns(record, scope, subform_controller)
@@ -249,7 +268,20 @@ module ActiveScaffold
         as_element(:form_field_description, h(desc) + as_element(:form_field_description_close)) if desc.present?
       end
 
-      def form_attribute(column, record, scope = nil, only_value = false, col_class = nil, form_columns: nil, field: nil)
+      def form_attribute(column, record, scope = nil, *positional_arguments,
+                         only_value: POSITIONAL_ARGUMENT_NOT_GIVEN,
+                         col_class: POSITIONAL_ARGUMENT_NOT_GIVEN, form_columns: nil, field: nil)
+        raise ArgumentError, 'too many positional arguments' if positional_arguments.size > 2
+
+        positional_only_value = positional_arguments.fetch(0, POSITIONAL_ARGUMENT_NOT_GIVEN)
+        positional_col_class = positional_arguments.fetch(1, POSITIONAL_ARGUMENT_NOT_GIVEN)
+        only_value = ActiveScaffold.deprecated_positional_argument(
+          positional_only_value, only_value,
+          method_name: __method__, argument_name: :only_value, default: false
+        )
+        col_class = ActiveScaffold.positional_or_keyword_argument(
+          positional_col_class, col_class, argument_name: :col_class, default: nil
+        )
         column_options = active_scaffold_input_options(column, scope, object: record)
         collapsible_id = column_options.delete :collapsible_id
         attributes = field_attributes(column, record)
@@ -293,14 +325,26 @@ module ActiveScaffold
         column.label unless hidden
       end
 
-      def form_hidden_attribute(column, record, scope = nil, clear = false)
+      def form_hidden_attribute(column, record, scope = nil,
+                                positional_clear = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                                clear: POSITIONAL_ARGUMENT_NOT_GIVEN)
+        clear = ActiveScaffold.deprecated_positional_argument(
+          positional_clear, clear,
+          method_name: __method__, argument_name: :clear, default: false
+        )
         content_tag :dl, style: 'display: none' do
           content_tag(:dt, '') <<
             content_tag(:dd, form_hidden_field(column, record, scope, clear))
         end
       end
 
-      def form_hidden_field(column, record, scope, clear = false)
+      def form_hidden_field(column, record, scope,
+                            positional_clear = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                            clear: POSITIONAL_ARGUMENT_NOT_GIVEN)
+        clear = ActiveScaffold.deprecated_positional_argument(
+          positional_clear, clear,
+          method_name: __method__, argument_name: :clear, default: false
+        )
         options = active_scaffold_input_options(column, scope)
         value = record.send(column.name) unless clear
         if column.association&.collection?

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -93,7 +93,7 @@ module ActiveScaffold
           associated.collect!(&:to_i)
           method = ui_options[:label_method] || :to_label
           helper_method = association_helper_method(column.association, :sorted_association_options_find)
-          select_options = send(helper_method, column.association, nil, record).collect do |r|
+          select_options = send(helper_method, column.association, {}, record).collect do |r|
             [r.send(method), r.id]
           end
         else
@@ -119,7 +119,7 @@ module ActiveScaffold
           associated = associated.is_a?(Array) ? associated.map(&:to_i) : associated.to_i unless associated.nil?
           method = column.association.belongs_to? ? column.association.foreign_key : column.name
           helper_method = association_helper_method(column.association, :sorted_association_options_find)
-          select_options = send(helper_method, column.association, false, record)
+          select_options = send(helper_method, column.association, {}, record)
         else
           method = column.name
           select_options = active_scaffold_translated_enum_options(column, record, ui_options: ui_options)

data/lib/active_scaffold/helpers/view_helpers.rb

@@ -57,7 +57,12 @@ module ActiveScaffold
 
       # This is the template finder logic, keep it updated with however we find stuff in rails
       # currently this very similar to the logic in ActionBase::Base.render for options file
-      def template_exists?(template_name, partial = false)
+      def template_exists?(template_name, positional_partial = POSITIONAL_ARGUMENT_NOT_GIVEN,
+                           partial: POSITIONAL_ARGUMENT_NOT_GIVEN)
+        partial = ActiveScaffold.deprecated_positional_argument(
+          positional_partial, partial,
+          method_name: __method__, argument_name: :partial, default: false
+        )
         if @_view_paths
           restore_view_paths = lookup_context.view_paths
           lookup_context.view_paths = @_view_paths

data/lib/active_scaffold/version.rb

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

data/lib/active_scaffold.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveScaffold
+  POSITIONAL_ARGUMENT_NOT_GIVEN = Object.new.freeze
+
   autoload :ActiveRecordPermissions, 'active_scaffold/active_record_permissions'
   autoload :Assets, 'active_scaffold/assets'
   autoload :AttributeParams, 'active_scaffold/attribute_params'
@@ -260,7 +262,33 @@ module ActiveScaffold
   end
 
   def self.deprecator
-    @deprecator ||= ActiveSupport::Deprecation.new('4.3', 'ActiveScaffold')
+    @deprecator ||= ActiveSupport::Deprecation.new('4.5', 'ActiveScaffold')
+  end
+
+  def self.deprecated_positional_argument(positional, keyword, method_name:, argument_name:, default:)
+    if positional.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN)
+      keyword.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN) ? default : keyword
+    elsif keyword.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN)
+      deprecator.warn(
+        "Passing `#{argument_name}` positionally to `#{method_name}` is deprecated; " \
+        "use `#{argument_name}:` instead. Positional support will be removed in ActiveScaffold 4.5. " \
+        'Overrides must accept both forms during 4.4 and pass the argument to `super` as a keyword. ' \
+        'See https://github.com/activescaffold/active_scaffold/blob/4-4-stable/CHANGELOG.rdoc'
+      )
+      positional
+    else
+      raise ArgumentError, "#{argument_name} was given both positionally and as a keyword"
+    end
+  end
+
+  def self.positional_or_keyword_argument(positional, keyword, argument_name:, default:)
+    if positional.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN)
+      keyword.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN) ? default : keyword
+    elsif keyword.equal?(POSITIONAL_ARGUMENT_NOT_GIVEN)
+      positional
+    else
+      raise ArgumentError, "#{argument_name} was given both positionally and as a keyword"
+    end
   end
 
   def self.log_exception(exception, message)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_scaffold
 version: !ruby/object:Gem::Version
-  version: 4.4.1
+  version: 4.4.5
 platform: ruby
 authors:
 - Many, see README