active_scaffold 4.4.4 → 4.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b212c764ce6307b7968f811cd89c2042b8cb5d1f79b448ddd838360efc8375ab
-  data.tar.gz: 4f44ea2e0e00189d67f4027e95decea8b3589e5f3d372d1c53cd289ca70188c7
+  metadata.gz: 53bf726d56ef1da11ee5ecdf4bc039b59ef10e74dd1ac9d31e2723e3e27716e1
+  data.tar.gz: 625f6798df882567a08bac210c6af4c9dbb246364ba739fc0a68bdad695c7b94
 SHA512:
-  metadata.gz: 264149ca1905e0bae13b93a71a3720d9e09d3b2bae57b15a702474dfb40d2d8fad33ea04a8708991d6c983ef6c45159a5fd7133ad143cf95e3d5c74f5b830a34
-  data.tar.gz: b8bf1c62d6fc8e9063ccb46df88709630a0ce6d1eb9edebcb3058df8e43535f7e0420a4781614bd479197f00f5cdcce423bf1298b15ddd264515701fa7c83b03
+  metadata.gz: 1948177220ec25858dc4d4a19e0313db67f8cafc544ab6bfdf5129bbd418918c9d6f4e4af1f134213e39cc97fb2da485972feca80628547f7fcbc9ad1687e2b9
+  data.tar.gz: 21308ad93ecc7bed4293d82dc4b011eb516e43171d9283ea26fdf24fd67f3283f280ba2c11033c3fdd1008194fef34821a9b134b2c672c8159611eb1b73eac59

data/CHANGELOG.rdoc

@@ -1,3 +1,49 @@
+= 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

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/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/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 = 4
+    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.4
+  version: 4.4.5
 platform: ruby
 authors:
 - Many, see README