active_scaffold 3.5.3 → 3.6.0.rc2

data/lib/active_scaffold/actions/search.rb

@@ -19,7 +19,7 @@ module ActiveScaffold::Actions
       def do_search
         if search_params.is_a?(String) && search_params.present?
           query = search_params.to_s.strip
-          columns = active_scaffold_config.search.columns
+          columns = active_scaffold_config.search.columns.visible_columns
           text_search = active_scaffold_config.search.text_search
           query = query.split(active_scaffold_config.search.split_terms) if active_scaffold_config.search.split_terms
           search_conditions = self.class.conditions_for_columns(query, columns, text_search)

data/lib/active_scaffold/actions/show.rb

@@ -19,11 +19,11 @@ module ActiveScaffold::Actions
     protected
 
     def show_respond_to_json
-      render :json => response_object, :only => show_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(show_columns_names), :methods => virtual_columns(show_columns_names), :status => response_status
+      response_to_api(:json, show_columns_names)
     end
 
     def show_respond_to_xml
-      render :xml => response_object, :only => show_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(show_columns_names), :methods => virtual_columns(show_columns_names), :status => response_status
+      response_to_api(:xml, show_columns_names)
     end
 
     def show_respond_to_js
@@ -35,7 +35,7 @@ module ActiveScaffold::Actions
     end
 
     def show_columns_names
-      active_scaffold_config.show.columns.names
+      active_scaffold_config.show.columns.visible_columns_names
     end
 
     # A simple method to retrieve and prepare a record for showing.
@@ -58,7 +58,7 @@ module ActiveScaffold::Actions
     private
 
     def show_authorized_filter
-      link = active_scaffold_config.show.link || active_scaffold_config.show.class.link
+      link = active_scaffold_config.show.link || self.class.active_scaffold_config.show.class.link
       raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
     end
 

data/lib/active_scaffold/actions/subform.rb

@@ -2,37 +2,38 @@ module ActiveScaffold::Actions
   module Subform
     def edit_associated
       do_edit_associated
-      render :action => 'edit_associated', :formats => [:js], :readonly => @column.association.readonly?
+      respond_to do |format|
+        format.js { render :action => 'edit_associated', :formats => [:js], :readonly => @column.association.readonly? }
+      end
     end
 
     protected
 
-    def do_edit_associated
-      @parent_record = params[:id].nil? ? new_model : find_if_allowed(params[:id], :update)
-      if @parent_record.new_record?
-        apply_constraints_to_record @parent_record
-        create_association_with_parent @parent_record if nested?
+    def new_parent_record
+      parent_record = new_model
+      # don't apply if scope, subform inside subform, because constraints won't apply to parent_record
+      apply_constraints_to_record parent_record unless @scope
+      if nested? && nested.match_model?(active_scaffold_config.model)
+        create_association_with_parent parent_record
       end
+      parent_record
+    end
 
-      generate_temporary_id(@parent_record, params[:generated_id]) if @parent_record.new_record? && params[:generated_id]
+    def do_edit_associated
+      @scope = params[:scope]
+      @parent_record = params[:id].nil? ? new_parent_record : find_if_allowed(params[:id], :update)
+
+      cache_generated_id(@parent_record, params[:generated_id]) if @parent_record.new_record?
       @column = active_scaffold_config.columns[params[:child_association]]
 
-      # NOTE: we don't check whether the user is allowed to update this record, because if not, we'll still let them associate the record. we'll just refuse to do more than associate, is all.
-      if params[:associated_id]
-        @record = @column.association.klass.find(params[:associated_id])
-        if (reverse = @column.association.reverse_association)
-          if reverse.collection?
-            @record.send(reverse.name) << @parent_record
-          elsif @column.association.belongs_to?
-            @parent_record.send("#{@column.name}=", @record)
-          else
-            @record.send("#{reverse.name}=", @parent_record)
-          end
-        end
-      else
-        @record = build_associated(@column.association, @parent_record)
+      @record = find_associated_record if params[:associated_id]
+      @record ||= build_associated(@column.association, @parent_record)
+    end
+
+    def find_associated_record
+      @column.association.klass.find(params[:associated_id]).tap do |record|
+        save_record_to_association(record, @column.association.reverse_association, @parent_record, @column.association)
       end
-      @scope = params[:scope]
     end
   end
 end

data/lib/active_scaffold/actions/update.rb

@@ -35,54 +35,63 @@ module ActiveScaffold::Actions
       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
+      end
+    end
+
     def update_respond_to_html
-      if params[:iframe] == 'true' # was this an iframe post ?
-        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
-        end
-      else # just a regular post
-        if successful?
-          message = as_(:updated_model, :model => ERB::Util.h(@record.to_label))
-          if params[:dont_close]
-            flash.now[:info] = message
-            render(:action => 'update')
-          else
-            flash[:info] = message
-            return_to_main
-          end
-        else
+      if successful? # just a regular post
+        message = as_(:updated_model, :model => ERB::Util.h(@record.to_label))
+        if params[:dont_close]
+          flash.now[:info] = message
           render(:action => 'update')
+        else
+          flash[:info] = message
+          return_to_main
         end
+      else
+        render(:action => 'update')
       end
     end
 
+    def record_to_refresh_on_update
+      if update_refresh_list?
+        do_refresh_list
+      else
+        reload_record_on_update
+      end
+    end
+
+    def reload_record_on_update
+      @updated_record = @record
+      # get_row so associations are cached like in list action
+      # if record doesn't fullfil current conditions remove it from list
+      @record = get_row
+    rescue ActiveRecord::RecordNotFound
+      nil
+    end
+
     def update_respond_to_js
       if successful?
-        if !render_parent? && active_scaffold_config.actions.include?(:list)
-          if update_refresh_list?
-            do_refresh_list
-          else
-            @updated_record = @record
-            # get_row so associations are cached like in list action
-            @record = get_row rescue nil # if record doesn't fullfil current conditions remove it from list
-          end
-        end
+        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
       end
       render :action => 'on_update'
     end
 
     def update_respond_to_xml
-      render :xml => response_object, :only => update_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(update_columns_names), :methods => virtual_columns(update_columns_names), :status => response_status
+      response_to_api(:xml, update_columns_names)
     end
 
     def update_respond_to_json
-      render :json => response_object, :only => update_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(update_columns_names), :methods => virtual_columns(update_columns_names), :status => response_status
+      response_to_api(:json, update_columns_names)
     end
 
     def update_columns_names
-      active_scaffold_config.update.columns.names
+      active_scaffold_config.update.columns.visible_columns_names
     end
 
     # A simple method to find and prepare a record for editing
@@ -91,45 +100,47 @@ module ActiveScaffold::Actions
       @record = find_if_allowed(params[:id], :update)
     end
 
-    # A complex method to update a record. The complexity comes from the support for subforms, and saving associated records.
+    # A complex method to update a record. The complexity comes from the support for subforms,
+    # and saving associated records.
     # If you want to customize this algorithm, consider using the +before_update_save+ callback
     def do_update
       do_edit
       update_save
     end
 
-    def update_save(options = {})
-      attributes = options[:attributes] || params[:record]
-      begin
-        active_scaffold_config.model.transaction do
-          @record = update_record_from_params(@record, active_scaffold_config.update.columns, attributes) unless options[:no_record_param_update]
-          before_update_save(@record)
-          # errors to @record can be added by update_record_from_params when association fails to set and ActiveRecord::RecordNotSaved is raised
-          self.successful = [@record.keeping_errors { @record.valid? }, @record.associated_valid?].all? # this syntax avoids a short-circuit
-          if successful?
-            @record.save! && @record.save_associated!
-            after_update_save(@record)
-          else
-            # some associations such as habtm are saved before saved is called on parent object
-            # we have to revert these changes if validation fails
-            raise ActiveRecord::Rollback, "don't save habtm associations unless record is valid"
-          end
+    def update_save(attributes: params[:record], no_record_param_update: false)
+      active_scaffold_config.model.transaction do
+        unless no_record_param_update
+          @record = update_record_from_params(@record, active_scaffold_config.update.columns, attributes)
         end
-      rescue ActiveRecord::StaleObjectError
-        @record.errors.add(:base, as_(:version_inconsistency))
-        self.successful = false
-      rescue ActiveRecord::RecordNotSaved => exception
-        logger.warn do
-          "\n\n#{exception.class} (#{exception.message}):\n    " +
-            Rails.backtrace_cleaner.clean(exception.backtrace).join("\n    ") +
-            "\n\n"
+        before_update_save(@record)
+        # errors to @record can be added by update_record_from_params when association fails
+        # to set and ActiveRecord::RecordNotSaved is raised
+        # this syntax avoids a short-circuit, so we run validations on record and associations
+        self.successful = [@record.keeping_errors { @record.valid? }, @record.associated_valid?].all?
+
+        unless successful?
+          # some associations such as habtm are saved before saved is called on parent object
+          # we have to revert these changes if validation fails
+          raise ActiveRecord::Rollback, "don't save habtm associations unless record is valid"
         end
-        @record.errors.add(:base, as_(:record_not_saved)) if @record.errors.empty?
-        self.successful = false
-      rescue ActiveRecord::ActiveRecordError => ex
-        flash[:error] = ex.message
-        self.successful = false
+        @record.save! && @record.save_associated!
+        after_update_save(@record)
       end
+    rescue ActiveRecord::StaleObjectError
+      @record.errors.add(:base, as_(:version_inconsistency))
+      self.successful = false
+    rescue ActiveRecord::RecordNotSaved => exception
+      logger.warn do
+        "\n\n#{exception.class} (#{exception.message}):\n    " +
+          Rails.backtrace_cleaner.clean(exception.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
+      self.successful = false
     end
 
     def do_update_column
@@ -139,25 +150,10 @@ module ActiveScaffold::Actions
       params.delete(:original_html)
       params.delete(:original_value)
       @column = active_scaffold_config.columns[column]
-      @record = value_record = find_if_allowed(params[:id], :read)
-      return unless @record.authorized_for?(:crud_type => :update, :column => column)
-      if @column.delegated_association
-        value_record = @record.send(@column.delegated_association.name)
-        value_record ||= @record.association(@column.delegated_association.name).build
-        return unless value_record.authorized_for?(:crud_type => :update, :column => column)
-      end
-
-      value ||=
-        unless @column.column.nil? || @column.column.null
-          default_val = @column.column.default
-          default_val = ActiveScaffold::Core.column_type_cast default_val, @column.column if Rails.version >= '4.2.0'
-          default_val == true ? false : default_val
-        end
-      unless @column.nil?
-        value = column_value_from_param_value(value_record, @column, value)
-        value = [] if value.nil? && @column.form_ui && @column.association.try(:collection?)
-      end
+      value_record = record_for_update_column
+      return unless value_record
 
+      value = value_for_update_column(value, @column, value_record)
       value_record.send("#{@column.name}=", value)
       before_update_save(@record)
       self.successful = value_record.save
@@ -174,6 +170,29 @@ module ActiveScaffold::Actions
       after_update_save(@record)
     end
 
+    def record_for_update_column
+      @record = find_if_allowed(params[:id], :read)
+      return 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
+        value_record if value_record.authorized_for?(:crud_type => :update, :column => @column.name)
+      else
+        @record
+      end
+    end
+
+    def value_for_update_column(param_value, column, record)
+      unless param_value
+        param_value = ActiveScaffold::Core.column_type_cast @column.default_for_empty_value, @column.column
+        param_value = false if param_value == true
+      end
+      value = column_value_from_param_value(record, @column, param_value)
+      value = [] if value.nil? && @column.form_ui && @column.association&.collection?
+      value
+    end
+
     # override this method if you want to inject data in the record (or its associated objects) before the save
     def before_update_save(record); end
 
@@ -198,7 +217,7 @@ module ActiveScaffold::Actions
     private
 
     def update_authorized_filter
-      link = active_scaffold_config.update.link || active_scaffold_config.update.class.link
+      link = active_scaffold_config.update.link || self.class.active_scaffold_config.update.class.link
       raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
     end
 

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)