active_scaffold 3.5.4 → 3.6.0

data/lib/active_scaffold/actions/nested.rb

@@ -1,5 +1,7 @@
 module ActiveScaffold::Actions
-  # The Nested module basically handles automatically linking controllers together. It does this by creating column links with the right parameters, and by providing any supporting systems (like a /:controller/nested action for returning associated scaffolds).
+  # The Nested module basically handles automatically linking controllers together.
+  # It does this by creating column links with the right parameters, and by providing
+  # any supporting systems (like a /:controller/nested action for returning associated scaffolds).
   module Nested
     def self.included(base)
       super
@@ -27,17 +29,17 @@ module ActiveScaffold::Actions
     def set_nested
       @nested = nil
       return unless params[:parent_scaffold] && (params[:association] || params[:named_scope])
-      @nested = ActiveScaffold::DataStructures::NestedInfo.get(active_scaffold_config.model, params)
-      register_constraints_with_action_columns(@nested.constrained_fields) unless @nested.nil?
+      @nested = ActiveScaffold::DataStructures::NestedInfo.get(self.class.active_scaffold_config.model, params)
     end
 
     def configure_nested
       return unless nested?
+      register_constraints_with_action_columns(nested.constrained_fields)
+      return unless active_scaffold_config.actions.include? :list
       active_scaffold_config.list.user.label = nested_label
-      unless active_scaffold_config.nested.ignore_order_from_association
-        chain = beginning_of_chain
-        active_scaffold_config.list.user.nested_default_sorting = nested_default_sorting(chain) if nested.sorted?(chain)
-      end
+      return if active_scaffold_config.nested.ignore_order_from_association
+      chain = beginning_of_chain
+      active_scaffold_config.list.user.nested_default_sorting = nested_default_sorting(chain) if nested.sorted?(chain)
     end
 
     def nested_label
@@ -57,41 +59,39 @@ module ActiveScaffold::Actions
     end
 
     def include_habtm_actions
-      if nested? && nested.habtm?
+      if nested&.habtm?
         # Production mode is ok with adding a link everytime the scaffold is nested - we are not ok with that.
-        active_scaffold_config.action_links.add('new_existing', :label => :add_existing, :type => :collection, :security_method => :add_existing_authorized?) unless active_scaffold_config.action_links['new_existing']
-        if active_scaffold_config.nested.shallow_delete
-          active_scaffold_config.action_links.add('destroy_existing', :label => :remove, :type => :member, :confirm => :are_you_sure_to_delete, :method => :delete, :position => false, :security_method => :delete_existing_authorized?) unless active_scaffold_config.action_links['destroy_existing']
-          if active_scaffold_config.actions.include?(:delete)
-            active_scaffold_config.action_links.delete('destroy') if active_scaffold_config.action_links['destroy']
-          end
-        end
-      else
-        # Production mode is caching this link into a non nested scaffold
-        active_scaffold_config.action_links.delete('new_existing') if active_scaffold_config.action_links['new_existing']
-
-        if active_scaffold_config.nested.shallow_delete
-          active_scaffold_config.action_links.delete('destroy_existing') if active_scaffold_config.action_links['destroy_existing']
-          if active_scaffold_config.actions.include?(:delete) && active_scaffold_config.delete.link
-            active_scaffold_config.action_links.add(active_scaffold_config.delete.link) unless active_scaffold_config.action_links['destroy']
-          end
+        unless active_scaffold_config.action_links['new_existing']
+          active_scaffold_config.action_links.add('new_existing', :label => :add_existing, :type => :collection, :security_method => :add_existing_authorized?)
         end
+        add_shallow_links if active_scaffold_config.nested.shallow_delete
+      elsif !ActiveScaffold.threadsafe
+        # Production mode is caching this link into a non nested scaffold, when threadsafe is disabled
+        active_scaffold_config.action_links.delete('new_existing')
+        restore_shallow_links if active_scaffold_config.nested.shallow_delete
       end
     end
 
+    def add_shallow_links
+      unless active_scaffold_config.action_links['destroy_existing']
+        link_options = {:label => :remove, :type => :member, :confirm => :are_you_sure_to_delete, :method => :delete, :position => false, :security_method => :delete_existing_authorized?}
+        active_scaffold_config.action_links.add('destroy_existing', link_options)
+      end
+      active_scaffold_config.action_links.delete('destroy') if active_scaffold_config.actions.include?(:delete)
+    end
+
+    def restore_shallow_links
+      if active_scaffold_config.actions.include?(:delete) && active_scaffold_config.delete.link
+        link = active_scaffold_config.delete.link
+        active_scaffold_config.action_links.add(link) unless active_scaffold_config.action_links[link.action]
+      end
+      active_scaffold_config.action_links.delete('destroy_existing')
+    end
+
     def beginning_of_chain
-      if nested? && nested.association
-        if nested.association.collection?
-          nested_parent_record.send(nested.association.name)
-        elsif nested.association.through? # has_one :through
-          active_scaffold_config.model.where(active_scaffold_config.model.primary_key => nested_parent_record.send(nested.association.name).try(:id))
-        elsif nested.association.has_one?
-          active_scaffold_config.model.where(nested.child_association.foreign_key => nested_parent_record.send(nested.association.association_primary_key))
-        elsif nested.association.belongs_to?
-          nested_belongs_to_chain
-        else # never should get here
-          active_scaffold_config.model
-        end
+      # only if nested is related to current controller, e.g. not when adding record in subform inside subform
+      if nested? && nested.match_model?(active_scaffold_config.model)
+        nested_chain_with_association
       elsif nested? && nested.scope
         nested_parent_record.send(nested.scope)
       else
@@ -99,23 +99,40 @@ module ActiveScaffold::Actions
       end
     end
 
-    def nested_belongs_to_chain
-      primary_key = active_scaffold_config.mongoid? ? '_id' : active_scaffold_config.model.primary_key
-      active_scaffold_config.model.where(primary_key => nested_parent_record.send(nested.association.name))
+    def nested_chain_with_association
+      if nested.association.collection?
+        nested_parent_record.send(nested.association.name)
+      elsif nested.association.through? # has_one :through
+        active_scaffold_config.model.where(active_scaffold_config.model.primary_key => nested_parent_record.send(nested.association.name)&.id)
+      elsif nested.association.has_one?
+        active_scaffold_config.model.where(nested.child_association.name => nested_parent_record)
+      elsif nested.association.belongs_to?
+        primary_key = active_scaffold_config.mongoid? ? '_id' : active_scaffold_config.model.primary_key
+        active_scaffold_config.model.where(primary_key => nested_parent_record.send(nested.association.name))
+      else # never should get here
+        raise 'missing condition for nested beginning_of_chain'
+      end
     end
 
     def nested_parent_record(crud = :read)
       @nested_parent_record ||= find_if_allowed(nested.parent_id, crud, nested.parent_model)
     end
 
+    def create_association_with_parent?
+      # has_many is done by beginning_of_chain and rails if direct association, not in through associations
+      return false if nested.has_many? && !nested.association.through?
+      nested.child_association && nested_parent_record
+    end
+
     def create_association_with_parent(record)
-      # has_many is done by beginning_of_chain and rails
-      return unless (nested.belongs_to? || nested.has_one? || nested.habtm?) && nested.child_association
-      return if (parent = nested_parent_record).nil?
+      return unless create_association_with_parent?
       if nested.child_association.singular?
-        record.send("#{nested.child_association.name}=", parent)
+        record.send("#{nested.child_association.name}=", nested_parent_record)
+      elsif nested.association.through_singular? && nested.child_association.through_singular?
+        through = nested_parent_record.send(nested.association.through_reflection.name)
+        record.send("#{nested.child_association.through_reflection.name}=", through)
       else
-        record.send(nested.child_association.name) << parent
+        record.send(nested.child_association.name) << nested_parent_record
       end
     end
 
@@ -181,11 +198,11 @@ module ActiveScaffold::Actions::Nested
     end
 
     def add_existing_respond_to_xml
-      render :xml => response_object, :only => active_scaffold_config.list.columns.names, :status => response_status
+      render :xml => response_object, :only => active_scaffold_config.list.columns.visible_columns_names, :status => response_status
     end
 
     def add_existing_respond_to_json
-      render :json => response_object, :only => active_scaffold_config.list.columns.names, :status => response_status
+      render :json => response_object, :only => active_scaffold_config.list.columns.visible_columns_names, :status => response_status
     end
 
     def destroy_existing_respond_to_html
@@ -198,11 +215,11 @@ module ActiveScaffold::Actions::Nested
     end
 
     def destroy_existing_respond_to_xml
-      render :xml => successful? ? '' : response_object, :only => active_scaffold_config.list.columns.names, :status => response_status
+      render :xml => successful? ? '' : response_object, :only => active_scaffold_config.list.columns.visible_columns_names, :status => response_status
     end
 
     def destroy_existing_respond_to_json
-      render :json => successful? ? '' : response_object, :only => active_scaffold_config.list.columns.names, :status => response_status
+      render :json => successful? ? '' : response_object, :only => active_scaffold_config.list.columns.visible_columns_names, :status => response_status
     end
 
     def add_existing_authorized?(record = nil)

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