active_scaffold 3.7.13 → 4.0.0.rc1

data/lib/active_scaffold/actions/update.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Update
     def self.included(base)
-      base.before_action :update_authorized_filter, :only => %i[edit update]
+      base.before_action :update_authorized_filter, only: %i[edit update]
       base.helper_method :update_refresh_list?
     end
 
@@ -25,35 +25,35 @@ module ActiveScaffold::Actions
 
     def edit_respond_to_html
       if successful?
-        render(:action => 'update')
+        render action: 'update'
       else
         return_to_main
       end
     end
 
     def edit_respond_to_js
-      render(:partial => 'update_form')
+      render partial: 'update_form'
     end
 
     def update_respond_on_iframe
       do_refresh_list if successful? && active_scaffold_config.update.refresh_list && !render_parent?
       responds_to_parent do
-        render :action => 'on_update', :formats => [:js], :layout => false
+        render action: 'on_update', formats: [:js], layout: false
       end
     end
 
     def update_respond_to_html
       if successful? # just a regular post
-        message = as_(:updated_model, :model => ERB::Util.h(@record.to_label))
+        message = as_(:updated_model, model: ERB::Util.h(@record.to_label))
         if params[:dont_close]
           flash.now[:info] = message
-          render(:action => 'update')
+          render action: 'update'
         else
           flash[:info] = message
           return_to_main
         end
       else
-        render(:action => 'update')
+        render action: 'update'
       end
     end
 
@@ -77,9 +77,9 @@ module ActiveScaffold::Actions
     def update_respond_to_js
       if successful?
         record_to_refresh_on_update if !render_parent? && active_scaffold_config.actions.include?(:list)
-        flash.now[:info] = as_(:updated_model, :model => ERB::Util.h((@updated_record || @record).to_label)) if active_scaffold_config.update.persistent
+        flash.now[:info] = as_(:updated_model, model: ERB::Util.h((@updated_record || @record).to_label)) if active_scaffold_config.update.persistent
       end
-      render :action => 'on_update'
+      render action: 'on_update'
     end
 
     def update_respond_to_xml
@@ -124,6 +124,7 @@ module ActiveScaffold::Actions
           # we have to revert these changes if validation fails
           raise ActiveRecord::Rollback, "don't save habtm associations unless record is valid"
         end
+
         @record.save! && @record.save_associated!
         after_update_save(@record)
       end
@@ -131,16 +132,14 @@ module ActiveScaffold::Actions
       @record.errors.add(:base, as_(:version_inconsistency))
       self.successful = false
       on_stale_object_error(@record)
-    rescue ActiveRecord::RecordNotSaved => exception
+    rescue ActiveRecord::RecordNotSaved => e
       logger.warn do
-        "\n\n#{exception.class} (#{exception.message}):\n    " +
-          Rails.backtrace_cleaner.clean(exception.backtrace).join("\n    ") +
-          "\n\n"
+        "\n\n#{e.class} (#{e.message}):\n    #{Rails.backtrace_cleaner.clean(e.backtrace).join("\n    ")}\n\n"
       end
       @record.errors.add(:base, as_(:record_not_saved)) if @record.errors.empty?
       self.successful = false
-    rescue ActiveRecord::ActiveRecordError => ex
-      flash[:error] = ex.message
+    rescue ActiveRecord::ActiveRecordError => e
+      flash[:error] = e.message
       self.successful = false
     end
 
@@ -154,7 +153,7 @@ module ActiveScaffold::Actions
 
       value_record = record_for_update_column
       value = value_for_update_column(value, @column, value_record)
-      value_record.send("#{@column.name}=", value)
+      value_record.send(:"#{@column.name}=", value)
       before_update_save(@record)
       self.successful = value_record.save
       if !successful?
@@ -174,12 +173,13 @@ module ActiveScaffold::Actions
 
     def record_for_update_column
       @record = find_if_allowed(params[:id], :read)
-      raise ActiveScaffold::ActionNotAllowed 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
-        raise ActiveScaffold::ActionNotAllowed unless 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
@@ -217,14 +217,14 @@ module ActiveScaffold::Actions
     end
 
     def update_ignore?(record = nil)
-      !authorized_for?(:crud_type => :update)
+      !authorized_for?(crud_type: :update)
     end
 
     private
 
     def update_authorized_filter
       link = active_scaffold_config.update.link || self.class.active_scaffold_config.update.class.link
-      raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
+      raise ActiveScaffold::ActionNotAllowed unless action_link_authorized?(link)
     end
 
     def edit_formats

data/lib/active_scaffold/active_record_permissions.rb

@@ -66,8 +66,7 @@ module ActiveScaffold
         base.extend SecurityMethods
         base.send :include, SecurityMethods
         class << base
-          attr_accessor :class_security_methods
-          attr_accessor :instance_security_methods
+          attr_accessor :class_security_methods, :instance_security_methods
         end
       end
 
@@ -88,12 +87,13 @@ module ActiveScaffold
         # options[:action] is the name of a method
         # options[:reason] if returning reason is expected, it will return array with authorized and reason, or nil if no reason
         def authorized_for?(options = {})
-          raise ArgumentError, "unknown crud type #{options[:crud_type]}" if options[:crud_type] && !%i[create read update delete].include?(options[:crud_type])
+          raise ArgumentError, "unknown crud type #{options[:crud_type]}" if options[:crud_type] && %i[create read update delete].exclude?(options[:crud_type])
 
           not_authorized_reason = ActiveRecordPermissions.not_authorized_reason
           # collect other possibly-related methods that actually exist
           methods = cached_authorized_for_methods(options)
           return ActiveRecordPermissions.default_permission if methods.empty?
+
           if methods.one?
             result = send(methods.first)
             # if not_authorized_reason enabled interpret String as reason for not authorized
@@ -108,6 +108,7 @@ module ActiveScaffold
             # if not_authorized_reason enabled interpret String as reason for not authorized
             authorized, reason = not_authorized_reason && result.is_a?(String) ? [false, result] : [result, nil]
             next if authorized
+
             # return array with reason only if requested with options[:reason]
             return options[:reason] ? [authorized, reason] : authorized
           end

data/lib/active_scaffold/attribute_params.rb

@@ -33,16 +33,10 @@ module ActiveScaffold
   module AttributeParams
     protected
 
-    # workaround for updating counters twice bug on rails4 (https://github.com/rails/rails/pull/14849)
-    # rails 5 needs this hack for belongs_to, when selecting record, not creating new one (value is Hash)
-    # TODO: remove when rails5 support is removed
-    def belongs_to_counter_cache_hack?(association, value)
-      !params_hash?(value) && association.belongs_to? && association.counter_cache_hack?
-    end
-
     def multi_parameter_attributes(attributes)
       params_hash(attributes).each_with_object({}) do |(k, v), result|
         next unless k.include? '('
+
         column_name = k.split('(').first
         result[column_name] ||= []
         result[column_name] << [k, v]
@@ -52,6 +46,7 @@ module ActiveScaffold
     def assign_locking_column(parent_record, attributes)
       return unless parent_record.persisted? && parent_record.locking_enabled? &&
                     attributes.include?(parent_record.class.locking_column)
+
       parent_record.write_attribute parent_record.class.locking_column, attributes[parent_record.class.locking_column]
     end
 
@@ -60,25 +55,24 @@ 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, avoid_changes = false)
       crud_type = parent_record.new_record? ? :create : :update
-      return parent_record unless parent_record.authorized_for?(:crud_type => crud_type)
+      return parent_record unless parent_record.authorized_for?(crud_type: crud_type)
 
       multi_parameter_attrs = multi_parameter_attributes(attributes)
       assign_locking_column(parent_record, attributes)
 
       columns.each_column(for: parent_record, crud_type: crud_type, flatten: true) do |column|
         # Set any passthrough parameters that may be associated with this column (ie, file column "keep" and "temp" attributes)
-        column.params.select { |p| attributes.key? p }.each { |p| parent_record.send("#{p}=", attributes[p]) }
+        assign_column_params(parent_record, column, attributes)
 
         if multi_parameter_attrs.key? column.name.to_s
           parent_record.send(:assign_multiparameter_attributes, multi_parameter_attrs[column.name.to_s])
         elsif attributes.key? column.name
-          next if search_attributes && params_hash?(attributes[column.name])
           update_column_from_params(parent_record, column, attributes[column.name], avoid_changes)
         end
       rescue StandardError => e
-        message = "on the ActiveScaffold column = :#{column.name} for #{parent_record.inspect} "\
+        message = "on the ActiveScaffold column = :#{column.name} for #{parent_record.inspect} " \
                   "(value from params #{attributes[column.name].inspect})"
         Rails.logger.error "#{e.class.name}: #{e.message} -- #{message}"
         raise
@@ -87,36 +81,39 @@ module ActiveScaffold
       parent_record
     end
 
+    def assign_column_params(parent_record, column, attributes)
+      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)
       value = column_value_from_param_value(parent_record, column, attribute, avoid_changes)
       if column.association
-        if avoid_changes
-          parent_record.association(column.name).target = value
-          parent_record.send("#{column.association.foreign_key}=", value&.id) if column.association.belongs_to?
-        else
-          update_column_association(parent_record, column, attribute, value)
-        end
+        update_column_association(parent_record, column, attribute, value, avoid_changes)
       else
-        parent_record.send "#{column.name}=", value
+        parent_record.send :"#{column.name}=", value
       end
       # needed? probably done on find_or_create_for_params, need more testing
       if column.association&.reverse_association&.belongs_to?
-        Array(value).each { |v| v.send("#{column.association.reverse}=", parent_record) if v.new_record? }
+        Array(value).each { |v| v.send(:"#{column.association.reverse}=", parent_record) if v.new_record? }
       end
       value
     end
 
-    def update_column_association(parent_record, column, attribute, value)
-      if belongs_to_counter_cache_hack?(column.association, attribute)
-        parent_record.send "#{column.association.foreign_key}=", value&.id
-        parent_record.association(column.name).target = value
+    def assign_column_association(parent_record, column, attribute, value)
+      parent_record.association(column.name).target = value
+      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)
+      if avoid_changes
+        assign_column_association(parent_record, column, attribute, value)
       elsif column.association.collection? && column.association.through_singular?
         through = column.association.through_reflection.name
         through_record = parent_record.send(through)
-        through_record ||= parent_record.send "build_#{through}"
-        through_record.send "#{column.association.source_reflection.name}=", value
+        through_record ||= parent_record.send :"build_#{through}"
+        through_record.send :"#{column.association.source_reflection.name}=", value
       else
-        parent_record.send "#{column.name}=", value
+        parent_record.send :"#{column.name}=", value
       end
     rescue ActiveRecord::RecordNotSaved
       parent_record.errors.add column.name, :invalid
@@ -126,8 +123,8 @@ module ActiveScaffold
     def column_value_from_param_value(parent_record, column, value, avoid_changes = 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)
-        send("column_value_for_#{form_ui}_type", parent_record, column, value)
+      if form_ui && respond_to?(:"column_value_for_#{form_ui}_type", true)
+        send(:"column_value_for_#{form_ui}_type", parent_record, column, value)
       elsif params_hash? value
         column_value_from_param_hash_value(parent_record, column, params_hash(value), avoid_changes)
       else
@@ -144,10 +141,8 @@ module ActiveScaffold
     end
 
     def column_value_for_datetime_type(parent_record, column, value)
-      new_value = self.class.condition_value_for_datetime(column, value, datetime_conversion_for_value(column))
-      if new_value.nil? && value.present?
-        parent_record.errors.add column.name, :invalid
-      end
+      new_value = self.class.condition_value_for_datetime(column, value, datetime_conversion_for_value(column), ui_method: :form_ui)
+      parent_record.errors.add column.name, :invalid if new_value.nil? && value.present?
       new_value
     end
 
@@ -184,7 +179,7 @@ module ActiveScaffold
     def column_plural_assocation_value_from_value(column, value)
       # it's an array of ids
       if value.present?
-        ids = value.select(&:present?)
+        ids = value.compact_blank
         ids.empty? ? [] : column.association.klass.find(ids)
       else
         []
@@ -196,8 +191,8 @@ module ActiveScaffold
         manage_nested_record_from_params(parent_record, column, value, avoid_changes)
       elsif column.association&.collection?
         # HACK: to be able to delete all associated records, hash will include "0" => ""
-        values = value.values.reject(&:blank?)
-        values.collect { |val| manage_nested_record_from_params(parent_record, column, val, avoid_changes) }.compact
+        value.values.compact_blank
+          .filter_map { |val| manage_nested_record_from_params(parent_record, column, val, avoid_changes) }
       else
         value
       end
@@ -205,6 +200,7 @@ module ActiveScaffold
 
     def manage_nested_record_from_params(parent_record, column, attributes, avoid_changes = false)
       return nil unless build_record_from_params?(attributes, column, parent_record)
+
       record = find_or_create_for_params(attributes, column, parent_record)
       if record
         record_columns = active_scaffold_config_for(record.class).subform.columns
@@ -220,6 +216,7 @@ module ActiveScaffold
     def build_record_from_params?(params, column, record)
       current = record.send(column.name)
       return true if column.association.collection? && !column.show_blank_record?(current)
+
       klass = column.association.klass(record)
       klass && !attributes_hash_is_empty?(params, klass)
     end
@@ -232,11 +229,11 @@ module ActiveScaffold
       klass = parent_column.association.klass(parent_record)
       if params.key? klass.primary_key
         record_from_current_or_find(klass, params[klass.primary_key], current)
-      elsif klass.authorized_for?(:crud_type => :create)
+      elsif klass.authorized_for?(crud_type: :create)
         association = parent_column.association
         record = klass.new
         if association.reverse_association&.belongs_to? && (association.collection? || current.nil?)
-          record.send("#{parent_column.association.reverse}=", parent_record)
+          record.send(:"#{parent_column.association.reverse}=", parent_record)
         end
         record
       end
@@ -260,24 +257,27 @@ module ActiveScaffold
     # This isn't a literal emptiness - it's an attempt to discern whether the user intended it to be empty or not.
     def attributes_hash_is_empty?(hash, klass)
       hash.all? do |key, value|
-        # convert any possible multi-parameter attributes like 'created_at(5i)' to simply 'created_at'
-        column_name = key.to_s.split('(', 2)[0]
-
         # datetimes will always have a value. so we ignore them when checking whether the hash is empty.
         # this could be a bad idea. but the current situation (excess record entry) seems worse.
         next true if mulitpart_ignored?(key, klass)
 
+        # convert any possible multi-parameter attributes like 'created_at(5i)' to simply 'created_at'
+        column_name = key.to_s.split('(', 2)[0]
+        attribute_is_empty?(column_name, klass, value)
+      end
+    end
+
+    def attribute_is_empty?(column_name, klass, value)
+      if default_value?(column_name, klass, value)
         # defaults are pre-filled on the form. we can't use them to determine if the user intends a new row.
         # booleans always have value, so they are ignored if not changed from default
-        next true if default_value?(column_name, klass, value)
-
-        if params_hash? value
-          attributes_hash_is_empty?(value, klass)
-        elsif value.is_a?(Array)
-          value.all?(&:blank?)
-        else
-          value.respond_to?(:empty?) ? value.empty? : false
-        end
+        true
+      elsif params_hash? value
+        attributes_hash_is_empty?(value, klass)
+      elsif value.is_a?(Array)
+        value.all?(&:blank?)
+      else
+        value.respond_to?(:empty?) ? value.empty? : false
       end
     end
 
@@ -287,6 +287,7 @@ module ActiveScaffold
     def mulitpart_ignored?(param_name, klass)
       column_name, multipart = param_name.to_s.split('(', 2)
       return false unless multipart
+
       column_type = ActiveScaffold::OrmChecks.column_type(klass, column_name)
       MULTIPART_IGNORE_TYPES.include?(column_type) if column_type
     end

data/lib/active_scaffold/bridges/active_storage/active_storage_bridge.rb

@@ -22,10 +22,10 @@ module ActiveScaffold
 
         def configure_active_storage_field(field, field_type)
           columns << field
-          columns.exclude "#{field}_attachment#{'s' if field_type == :has_many}".to_sym
-          columns.exclude "#{field}_blob#{'s' if field_type == :has_many}".to_sym
-          columns[field].includes ||= ["#{field}_attachment#{'s' if field_type == :has_many}".to_sym, "#{field}_blob#{'s' if field_type == :has_many}".to_sym]
-          columns[field].form_ui ||= "active_storage_#{field_type}".to_sym
+          columns.exclude :"#{field}_attachment#{'s' if field_type == :has_many}"
+          columns.exclude :"#{field}_blob#{'s' if field_type == :has_many}"
+          columns[field].includes ||= [:"#{field}_attachment#{'s' if field_type == :has_many}", :"#{field}_blob#{'s' if field_type == :has_many}"]
+          columns[field].form_ui ||= :"active_storage_#{field_type}"
           columns[field].params.add "delete_#{field}"
         end
       end

data/lib/active_scaffold/bridges/active_storage/active_storage_helpers.rb

@@ -5,12 +5,16 @@ module ActiveScaffold
         class << self
           # has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: false
           def active_storage_has_one_fields(klass)
-            klass.reflect_on_all_associations(:has_one)&.select { |reflection| reflection.class_name == 'ActiveStorage::Attachment' } &.collect { |association| association.name[0..-12] } || []
+            klass.reflect_on_all_associations(:has_one)
+              &.select { |reflection| reflection.class_name == 'ActiveStorage::Attachment' }
+              &.collect { |association| association.name[0..-12] } || []
           end
 
           # has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: false do
           def active_storage_has_many_fields(klass)
-            klass.reflect_on_all_associations(:has_many)&.select { |reflection| reflection.class_name == 'ActiveStorage::Attachment' } &.collect { |association| association.name[0..-13] } || []
+            klass.reflect_on_all_associations(:has_many)
+              &.select { |reflection| reflection.class_name == 'ActiveStorage::Attachment' }
+              &.collect { |association| association.name[0..-13] } || []
           end
 
           def klass_has_active_storage_fields?(klass)

data/lib/active_scaffold/bridges/active_storage.rb

@@ -4,6 +4,6 @@ class ActiveScaffold::Bridges::ActiveStorage < ActiveScaffold::DataStructures::B
 
   def self.install
     Dir[File.join(__dir__, 'active_storage', '*.rb')].each { |file| require file }
-    ActiveScaffold::Config::Core.send :prepend, ActiveScaffold::Bridges::ActiveStorage::ActiveStorageBridge
+    ActiveScaffold::Config::Core.prepend ActiveScaffold::Bridges::ActiveStorage::ActiveStorageBridge
   end
 end

data/lib/active_scaffold/bridges/ancestry/ancestry_bridge.rb

@@ -2,7 +2,7 @@ module ActiveScaffold::Bridges
   class Ancestry
     module AncestryBridge
       def initialize(model_id)
-        super(model_id)
+        super
 
         return unless model.respond_to? :ancestry_column
 
@@ -18,7 +18,7 @@ module ActiveScaffold::Bridges
       def active_scaffold_input_ancestry(column, options, ui_options: column.options)
         record = options[:object]
         select_options = []
-        select_control_options = {:selected => record.parent_id}
+        select_control_options = {selected: record.parent_id}
         select_control_options[:include_blank] = as_(:_select_) if record.parent_id.nil?
         method = ui_options[:label_method] || :to_label
         traverse_ancestry = proc do |key, value|
@@ -37,4 +37,4 @@ end
 ActionView::Base.class_eval do
   include ActiveScaffold::Bridges::Ancestry::FormColumnHelpers
 end
-ActiveScaffold::Config::Core.send :prepend, ActiveScaffold::Bridges::Ancestry::AncestryBridge
+ActiveScaffold::Config::Core.prepend ActiveScaffold::Bridges::Ancestry::AncestryBridge

data/lib/active_scaffold/bridges/bitfields/bitfields_bridge.rb

@@ -17,10 +17,13 @@ module ActiveScaffold
 
         def _setup_bitfields
           return unless model.respond_to?(:bitfields) && model.bitfields.present?
+
+          supported_actions = %i[create update show subform]
           model.bitfields.each do |column_name, options|
             columns = options.keys.sort_by { |column| self.columns[column].weight }
-            %i[create update show subform].each do |action|
+            supported_actions.each do |action|
               next unless actions.include? action
+
               if send(action).columns.include? column_name
                 send(action).columns.exclude column_name
                 send(action).columns.add_subgroup(column_name) { |group| group.add(*columns) }

data/lib/active_scaffold/bridges/bitfields.rb

@@ -1,7 +1,7 @@
 class ActiveScaffold::Bridges::Bitfields < ActiveScaffold::DataStructures::Bridge
   def self.install
     Dir[File.join(__dir__, 'bitfields', '*.rb')].each { |file| require file }
-    ActiveScaffold::Config::Core.send :prepend, ActiveScaffold::Bridges::Bitfields::BitfieldsBridge
+    ActiveScaffold::Config::Core.prepend ActiveScaffold::Bridges::Bitfields::BitfieldsBridge
     ActiveScaffold::Config::Core.after_config_callbacks << :_setup_bitfields
   end
 end

data/lib/active_scaffold/bridges/cancan/cancan_bridge.rb

@@ -10,9 +10,9 @@
 module CanCan
   module Ability
     def as_action_aliases
-      alias_action :list, :show_search, :render_field, :to => :read
-      alias_action :update_column, :edit_associated, :new_existing, :add_existing, :to => :update
-      alias_action :delete, :destroy_existing, :to => :destroy
+      alias_action :list, :show_search, :render_field, to: :read
+      alias_action :update_column, :edit_associated, :new_existing, :add_existing, to: :update
+      alias_action :delete, :destroy_existing, to: :destroy
     end
   end
 end
@@ -26,8 +26,8 @@ module ActiveScaffold::Bridges
       def active_scaffold(model_id = nil, &block)
         super
         authorize_resource(
-          :class => active_scaffold_config.model,
-          :instance => :record
+          class: active_scaffold_config.model,
+          instance: :record
         )
       end
     end
@@ -101,19 +101,20 @@ module ActiveScaffold::Bridges
         class InvalidArgument < StandardError; end
 
         # is usually called with :crud_type and :column, or :action
-        #     {:crud_type=>:update, :column=>"some_colum_name"}
-        #     {:action=>"edit"}
+        #     {crud_type: :update, column: 'some_colum_name'}
+        #     {action: 'edit'}
         # to allow access cancan must allow both :crud_type and :action
         # if cancan says "no", it delegates to default AS behavior
         def authorized_for?(options = {})
           raise InvalidArgument if options[:crud_type].blank? && options[:action].blank?
+
           if current_ability.present?
             crud_type_result = options[:crud_type].nil? ? true : current_ability.can?(options[:crud_type], self)
             action_result = options[:action].nil? ? true : current_ability.can?(options[:action].to_sym, self)
           else
             crud_type_result = action_result = false
           end
-          result = (crud_type_result && action_result) || super(options.merge(:reason => nil))
+          result = (crud_type_result && action_result) || super(options.merge(reason: nil))
           # return array with nil reason if requested with options[:reason], we don't have reason but caller expects array
           options[:reason] ? [result, nil] : result
         end

data/lib/active_scaffold/bridges/cancan.rb

@@ -2,16 +2,16 @@ class ActiveScaffold::Bridges::Cancan < ActiveScaffold::DataStructures::Bridge
   def self.install
     require File.join(File.dirname(__FILE__), 'cancan', 'cancan_bridge.rb')
 
-    ActiveScaffold::Core::ClassMethods.send :prepend, ActiveScaffold::Bridges::Cancan::ClassMethods
-    ActiveScaffold::Actions::Core.send :prepend, ActiveScaffold::Bridges::Cancan::Actions::Core
-    ActiveScaffold::Actions::Nested.send :prepend, ActiveScaffold::Bridges::Cancan::Actions::Core
-    ActionController::Base.send :include, ActiveScaffold::Bridges::Cancan::ModelUserAccess::Controller
-    ActionView::Base.send :include, ActiveScaffold::Bridges::Cancan::AssociationHelpers
-    ::ActiveRecord::Base.send :include, ActiveScaffold::Bridges::Cancan::ModelUserAccess::Model
-    ::ActiveRecord::Base.send :include, ActiveScaffold::Bridges::Cancan::ActiveRecord
+    ActiveScaffold::Core::ClassMethods.prepend ActiveScaffold::Bridges::Cancan::ClassMethods
+    ActiveScaffold::Actions::Core.prepend ActiveScaffold::Bridges::Cancan::Actions::Core
+    ActiveScaffold::Actions::Nested.prepend ActiveScaffold::Bridges::Cancan::Actions::Core
+    ActiveSupport.on_load(:action_controller) { include ActiveScaffold::Bridges::Cancan::ModelUserAccess::Controller }
+    ActiveSupport.on_load(:action_view) { include ActiveScaffold::Bridges::Cancan::AssociationHelpers }
+    ActiveSupport.on_load(:active_record) { include ActiveScaffold::Bridges::Cancan::ModelUserAccess::Model }
+    ActiveSupport.on_load(:active_record) { include ActiveScaffold::Bridges::Cancan::ActiveRecord }
   end
 
   def self.install?
-    Object.const_defined? 'CanCan'
+    Object.const_defined? :CanCan
   end
 end

data/lib/active_scaffold/bridges/carrierwave/form_ui.rb

@@ -8,7 +8,7 @@ module ActiveScaffold
         active_scaffold_file_with_remove_link(column, options, content, 'remove_', 'carrierwave_controls', ui_options: ui_options) do
           cache_field_options = {
             name: options[:name].gsub(/\[#{column.name}\]$/, "[#{column.name}_cache]"),
-            id: options[:id] + '_cache'
+            id: "#{options[:id]}_cache"
           }
           hidden_field(:record, "#{column.name}_cache", cache_field_options)
         end

data/lib/active_scaffold/bridges/carrierwave/list_ui.rb

@@ -4,14 +4,15 @@ module ActiveScaffold
       def active_scaffold_column_carrierwave(record, column, ui_options: column.options)
         carrierwave = record.send(column.name.to_s)
         return nil if carrierwave.file.blank?
+
         thumbnail_style = ActiveScaffold::Bridges::Carrierwave::CarrierwaveBridgeHelpers.thumbnail_style
         content =
-          if carrierwave.versions.keys.include?(thumbnail_style)
-            image_tag(carrierwave.url(thumbnail_style), :border => 0)
+          if carrierwave.versions.key?(thumbnail_style)
+            image_tag(carrierwave.url(thumbnail_style), border: 0)
           else
             record.send(record.send(:_mounter, column.name).send(:serialization_column))
           end
-        link_to(content, carrierwave.url, :target => '_blank', rel: 'noopener noreferrer')
+        link_to(content, carrierwave.url, target: '_blank', rel: 'noopener noreferrer')
       end
     end
   end

data/lib/active_scaffold/bridges/carrierwave.rb

@@ -4,10 +4,10 @@ class ActiveScaffold::Bridges::Carrierwave < ActiveScaffold::DataStructures::Bri
     require File.join(File.dirname(__FILE__), 'carrierwave/list_ui')
     require File.join(File.dirname(__FILE__), 'carrierwave/carrierwave_bridge_helpers')
     require File.join(File.dirname(__FILE__), 'carrierwave/carrierwave_bridge')
-    ActiveScaffold::Config::Core.send :prepend, ActiveScaffold::Bridges::Carrierwave::CarrierwaveBridge
+    ActiveScaffold::Config::Core.prepend ActiveScaffold::Bridges::Carrierwave::CarrierwaveBridge
   end
 
   def self.install?
-    Object.const_defined? 'CarrierWave'
+    Object.const_defined? :CarrierWave
   end
 end

data/lib/active_scaffold/bridges/chosen.rb

@@ -3,15 +3,11 @@ class ActiveScaffold::Bridges::Chosen < ActiveScaffold::DataStructures::Bridge
     require File.join(File.dirname(__FILE__), 'chosen/helpers.rb')
   end
 
-  def self.install?
-    super && %i[jquery prototype].include?(ActiveScaffold.js_framework)
-  end
-
   def self.stylesheets
     'chosen'
   end
 
   def self.javascripts
-    ["chosen-#{ActiveScaffold.js_framework}", "#{ActiveScaffold.js_framework}/active_scaffold_chosen"]
+    ['chosen-jquery', 'jquery/active_scaffold_chosen']
   end
 end