active_scaffold 3.5.4 → 3.6.0

data/lib/active_scaffold/active_record_permissions.rb

@@ -37,7 +37,7 @@ module ActiveScaffold
         # because the object may change (someone may log in or out). So we give ActiveRecord a proc that ties to the
         # current_user_method on this ApplicationController.
         def assign_current_user_to_models
-          ActiveRecord::Base.current_user_proc = proc { send(ActiveRecordPermissions.current_user_method) }
+          ActiveScaffold::Registry.current_user_proc = proc { send(ActiveRecordPermissions.current_user_method) }
         end
       end
 
@@ -48,18 +48,9 @@ module ActiveScaffold
         end
 
         module ClassMethods
-          # The proc to call that retrieves the current_user from the ApplicationController.
-          def current_user_proc
-            Thread.current[:current_user_proc]
-          end
-
-          def current_user_proc=(proc_value)
-            Thread.current[:current_user_proc] = proc_value
-          end
-
           # Class-level access to the current user
           def current_user
-            ActiveRecord::Base.current_user_proc.call if ActiveRecord::Base.current_user_proc
+            ActiveScaffold::Registry.current_user_proc&.call
           end
         end
 

data/lib/active_scaffold/attribute_params.rb

@@ -41,13 +41,8 @@ module ActiveScaffold
       difference = value.select(&:persisted?).size - parent_record.send(counter_attr)
 
       if parent_record.new_record?
-        if Rails.version >= '4.2.0'
-          parent_record.send "#{column.name}=", value
-          parent_record.send "#{counter_attr}_will_change!"
-        else # < 4.2
-          parent_record.send "#{counter_attr}=", difference
-          parent_record.send "#{column.name}=", value
-        end
+        parent_record.send "#{column.name}=", value
+        parent_record.send "#{counter_attr}_will_change!"
       else
         # don't decrement counter for deleted records, on destroy they will update counter
         difference += (parent_record.send(column.name) - value).size
@@ -57,7 +52,7 @@ module ActiveScaffold
       # update counters on old parents if belongs_to is changed
       value.select(&:persisted?).each do |record|
         key = record.send(column.association.foreign_key)
-        parent_record.class.decrement_counter counter_attr, key if key && key != parent_record.id
+        parent_record.class.decrement_counter counter_attr, key if key && key != parent_record.id # rubocop:disable Rails/SkipsModelValidations
       end
       parent_record.send "#{column.name}=", value if parent_record.persisted?
     end
@@ -76,6 +71,15 @@ module ActiveScaffold
       !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]
+      end
+    end
+
     # Takes attributes (as from params[:record]) and applies them to the parent_record. Also looks for
     # association attributes and attempts to instantiate them as associated objects.
     #
@@ -85,28 +89,22 @@ module ActiveScaffold
       crud_type = parent_record.new_record? ? :create : :update
       return parent_record unless parent_record.authorized_for?(:crud_type => crud_type)
 
-      multi_parameter_attributes = {}
-      attributes.each do |k, v|
-        next unless k.include? '('
-        column_name = k.split('(').first
-        multi_parameter_attributes[column_name] ||= []
-        multi_parameter_attributes[column_name] << [k, v]
-      end
+      multi_parameter_attrs = multi_parameter_attributes(attributes)
 
-      columns.each :for => parent_record, :crud_type => crud_type, :flatten => true do |column|
+      columns.each_column(for: parent_record, crud_type: crud_type, flatten: true) do |column|
         begin
           # Set any passthrough parameters that may be associated with this column (ie, file column "keep" and "temp" attributes)
-          unless column.params.empty?
-            column.params.each { |p| parent_record.send("#{p}=", attributes[p]) if attributes.key? p }
-          end
+          column.params.select { |p| attributes.key? p }.each { |p| parent_record.send("#{p}=", attributes[p]) }
 
-          if multi_parameter_attributes.key? column.name.to_s
-            parent_record.send(:assign_multiparameter_attributes, multi_parameter_attributes[column.name.to_s])
+          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
-            value = update_column_from_params(parent_record, column, attributes[column.name], avoid_changes)
+            update_column_from_params(parent_record, column, attributes[column.name], avoid_changes)
           end
-        rescue => e
-          Rails.logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} for #{parent_record.inspect}#{" with value #{value}" if value}"
+        rescue StandardError => e
+          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
         end
       end
@@ -116,38 +114,45 @@ module ActiveScaffold
 
     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 avoid_changes && column.association
-        parent_record.association(column.name).target = value
-        parent_record.send("#{column.association.foreign_key}=", value.try(:id)) if column.association.belongs_to?
-      elsif column.association && counter_cache_hack?(column.association, attribute)
-        parent_record.send "#{column.association.foreign_key}=", value.try(:id)
+      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
+      else
+        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? }
+      end
+      value
+    end
+
+    def update_column_association(parent_record, column, attribute, value)
+      if counter_cache_hack?(column.association, attribute)
+        parent_record.send "#{column.association.foreign_key}=", value&.id
         parent_record.association(column.name).target = value
-      elsif column.association.try(:collection?) && column.association.through? && !column.association.through_reflection.collection?
+      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
+      elsif hack_for_has_many_counter_cache?(parent_record, column)
+        hack_for_has_many_counter_cache(parent_record, column, value)
       else
-        begin
-          if column.association && hack_for_has_many_counter_cache?(parent_record, column)
-            hack_for_has_many_counter_cache(parent_record, column, value)
-          else
-            parent_record.send "#{column.name}=", value
-          end
-        rescue ActiveRecord::RecordNotSaved
-          parent_record.errors.add column.name, :invalid
-          parent_record.association(column.name).target = value if column.association
-        end
+        parent_record.send "#{column.name}=", value
       end
-      if column.association.try(:reverse_association).try(:belongs_to?)
-        Array(value).each { |v| v.send("#{column.association.reverse}=", parent_record) if v.new_record? }
-      end
-      value
+    rescue ActiveRecord::RecordNotSaved
+      parent_record.errors.add column.name, :invalid
+      parent_record.association(column.name).target = value
     end
 
     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.try(:type)
+      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)
       elsif params_hash? value
@@ -177,27 +182,24 @@ module ActiveScaffold
       Date.parse("#{value}-01")
     end
 
-    def column_value_from_param_simple_value(parent_record, column, value)
-      if column.association.try :singular?
-        if value.present?
-          if column.association.polymorphic?
-            class_name = parent_record.send(column.association.foreign_type)
-            class_name.constantize.find(value) if class_name.present?
-          else
-            # it's a single id
-            column.association.klass.find(value)
-          end
-        end
-      elsif column.association.try :collection?
+    def association_value_from_param_simple_value(parent_record, column, value)
+      if column.association.singular?
+        column.association.klass(parent_record)&.find(value) if value.present?
+      else # column.association.collection?
         column_plural_assocation_value_from_value(column, Array(value))
-      elsif column.number? && column.options[:format] && column.form_ui != :number
+      end
+    end
+
+    def column_value_from_param_simple_value(parent_record, column, value)
+      if column.association
+        association_value_from_param_simple_value(parent_record, column, value)
+      elsif column.convert_to_native?
         column.number_to_native(value)
-      else
+      elsif value.is_a?(String) && value.empty? && !column.virtual?
         # convert empty strings into nil. this works better with 'null => true' columns (and validations),
         # for 'null => false' columns is just converted to default value from column
-        if value.is_a?(String) && value.empty? && !column.column.nil?
-          value = column.column.null ? nil : column.column.default
-        end
+        column.default_for_empty_value
+      else
         value
       end
     end
@@ -213,9 +215,9 @@ module ActiveScaffold
     end
 
     def column_value_from_param_hash_value(parent_record, column, value, avoid_changes = false)
-      if column.association.try :singular?
+      if column.association&.singular?
         manage_nested_record_from_params(parent_record, column, value, avoid_changes)
-      elsif column.association.try :collection?
+      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
@@ -228,7 +230,7 @@ module ActiveScaffold
       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(column.association.klass).subform.columns
+        record_columns = active_scaffold_config_for(record.class).subform.columns
         prev_constraints = record_columns.constraint_columns
         record_columns.constraint_columns = [column.association.reverse].compact
         update_record_from_params(record, record_columns, attributes, avoid_changes)
@@ -240,8 +242,9 @@ module ActiveScaffold
 
     def build_record_from_params?(params, column, record)
       current = record.send(column.name)
-      klass = column.association.klass
-      (column.association.collection? && !column.show_blank_record?(current)) || !attributes_hash_is_empty?(params, klass)
+      return true if column.association.collection? && !column.show_blank_record?(current)
+      klass = column.association.klass(record)
+      klass && !attributes_hash_is_empty?(params, klass)
     end
 
     # Attempts to create or find an instance of the klass of the association in parent_column from the
@@ -249,21 +252,26 @@ module ActiveScaffold
     # otherwise it will build a new one.
     def find_or_create_for_params(params, parent_column, parent_record)
       current = parent_record.send(parent_column.name)
-      klass = parent_column.association.klass
+      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)
-        parent_column.association.klass.new
+        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)
+        end
+        record
       end
     end
 
     # 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)
-      if current && current.is_a?(ActiveRecord::Base) && current.id.to_s == id
+      if current.is_a?(ActiveRecord::Base) && current.id.to_s == id
         # modifying the current object of a singular association
         current
-      elsif current && current.respond_to?(:any?) && current.any? { |o| o.id.to_s == id }
+      elsif current.respond_to?(:any?) && current.any? { |o| o.id.to_s == id }
         # modifying one of the current objects in a plural association
         current.detect { |o| o.id.to_s == id }
       else # attaching an existing but not-current object
@@ -271,36 +279,20 @@ module ActiveScaffold
       end
     end
 
-    def save_record_to_association(record, association, value)
-      if association.try(:collection?)
-        record.send(association.name) << value
-      elsif association
-        record.send("#{association.name}=", value)
-      end
-    end
-
     # Determines whether the given attributes hash is "empty".
     # 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)
-      # old style date form management... ignore them too
-      part_ignore_column_types = [:datetime, :date, :time, Time, Date]
-
       hash.all? do |key, value|
         # convert any possible multi-parameter attributes like 'created_at(5i)' to simply 'created_at'
-        parts = key.to_s.split('(')
-        column_name = parts.first
-        column = ActiveScaffold::OrmChecks.columns_hash(klass)[column_name]
-        column_type = ActiveScaffold::OrmChecks.column_type(klass, column_name) if column
+        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 column && parts.length > 1 && part_ignore_column_types.include?(column_type)
+        next true if mulitpart_ignored?(key, klass)
 
         # 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
-        default_value = column_default_value(column_name, klass, column)
-        casted_value = column ? ActiveScaffold::Core.column_type_cast(value, column) : value
-        next true if casted_value == default_value
+        next true if default_value?(column_name, klass, value)
 
         if params_hash? value
           attributes_hash_is_empty?(value, klass)
@@ -312,14 +304,30 @@ module ActiveScaffold
       end
     end
 
-    def column_default_value(column_name, klass, column)
+    # old style date form management... ignore them
+    MULTIPART_IGNORE_TYPES = [:datetime, :date, :time, Time, Date].freeze
+
+    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
+
+    def default_value?(column_name, klass, value)
+      column = ActiveScaffold::OrmChecks.columns_hash(klass)[column_name]
+      default_value = column_default_value(column_name, klass)
+      casted_value = ActiveScaffold::Core.column_type_cast(value, column)
+      casted_value == default_value
+    end
+
+    def column_default_value(column_name, klass)
+      column = ActiveScaffold::OrmChecks.columns_hash(klass)[column_name]
       return unless column
       if ActiveScaffold::OrmChecks.mongoid? klass
         column.default_val
       elsif ActiveScaffold::OrmChecks.active_record? klass
-        if Rails.version < '4.2'
-          column.default
-        elsif Rails.version < '5.0'
+        if Rails.version < '5.0'
           column.type_cast_from_database(column.default)
         else
           column_type = ActiveScaffold::OrmChecks.column_type(klass, column_name)

data/lib/active_scaffold/bridges.rb

@@ -11,7 +11,7 @@ module ActiveScaffold
     self.bridges = {}
 
     def self.register(file)
-      match = file.match(/(active_scaffold\/bridges\/(.*))\.rb\Z/)
+      match = file.match(%r{(active_scaffold/bridges/(.*))\.rb\Z})
       bridges[match[2].to_sym] = match[1] if match
     end
 
@@ -34,18 +34,18 @@ module ActiveScaffold
 
     def self.run_all
       return false if bridges_run
-      bridges.keys.each do |bridge_name|
-        bridge = self[bridge_name]
-        bridge.run if bridge
+      bridges.each_key do |bridge_name|
+        self[bridge_name]&.run
       end
+      ActiveScaffold::Config::Core.freeze if ActiveScaffold.threadsafe
       self.bridges_run = true
     end
 
     def self.prepare_all
       return false if bridges_prepared
-      bridges.keys.each do |bridge_name|
+      bridges.each_key do |bridge_name|
         bridge = self[bridge_name]
-        bridge.prepare if bridge && bridge.install?
+        bridge.prepare if bridge&.install?
       end
       self.bridges_prepared = true
     end
@@ -53,14 +53,14 @@ module ActiveScaffold
     def self.all_stylesheets
       bridges.keys.collect do |bridge_name|
         bridge = self[bridge_name]
-        bridge.stylesheets if bridge && bridge.install?
+        bridge.stylesheets if bridge&.install?
       end.compact.flatten
     end
 
     def self.all_javascripts
       bridges.keys.collect do |bridge_name|
         bridge = self[bridge_name]
-        bridge.javascripts if bridge && bridge.install?
+        bridge.javascripts if bridge&.install?
       end.compact.flatten
     end
   end

data/lib/active_scaffold/bridges/active_storage.rb

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

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

@@ -0,0 +1,34 @@
+module ActiveScaffold
+  module Bridges
+    class ActiveStorage
+      module ActiveStorageBridge
+        def initialize(model_id)
+          super
+          return unless ActiveScaffold::Bridges::ActiveStorage::ActiveStorageBridgeHelpers.klass_has_active_storage_fields?(model)
+
+          model.send :extend, ActiveScaffold::Bridges::ActiveStorage::ActiveStorageBridgeHelpers
+
+          # include the "delete" helpers for use with active scaffold, unless they are already included
+          model.generate_delete_helpers
+
+          update.multipart = true
+          create.multipart = true
+
+          model.active_storage_has_one_fields.each { |field| configure_active_storage_field(field.to_sym, :has_one) }
+          model.active_storage_has_many_fields.each { |field| configure_active_storage_field(field.to_sym, :has_many) }
+        end
+
+        private
+
+        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[field].params.add "delete_#{field}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module ActiveScaffold
+  module Bridges
+    class ActiveStorage
+      module ActiveStorageBridgeHelpers
+        mattr_accessor :thumbnail_variant
+        self.thumbnail_variant = {resize_to_limit: [nil, 30]}
+
+        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] } || []
+          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] } || []
+          end
+
+          def klass_has_active_storage_fields?(klass)
+            active_storage_has_one_fields(klass).present? || active_storage_has_many_fields(klass).present?
+          end
+
+          def generate_delete_helpers(klass)
+            (active_storage_has_one_fields(klass) | active_storage_has_many_fields(klass)).each do |field|
+              klass.send :class_eval, <<-CODE, __FILE__, __LINE__ + 1 unless klass.method_defined?(:"#{field}_with_delete=")
+                attr_reader :delete_#{field}
+
+                def delete_#{field}=(value)
+                  value = (value=="true") if String===value
+                  return unless value
+
+                  # passing nil to the file column causes the file to be deleted.
+                  self.#{field}.purge
+                end
+              CODE
+            end
+          end
+        end
+
+        def active_storage_has_one_fields
+          @active_storage_has_one_fields ||= ActiveStorageBridgeHelpers.active_storage_has_one_fields(self)
+        end
+
+        def active_storage_has_many_fields
+          @active_storage_has_many_fields ||= ActiveStorageBridgeHelpers.active_storage_has_many_fields(self)
+        end
+
+        def generate_delete_helpers
+          ActiveStorageBridgeHelpers.generate_delete_helpers(self)
+        end
+      end
+    end
+  end
+end