active_scaffold 3.4.17 → 3.4.18

data/lib/active_scaffold/actions/create.rb

@@ -15,8 +15,9 @@ module ActiveScaffold::Actions
     end
 
     protected
+
     def response_location
-      url_for(params_for(:action => "show", :id => @record.to_param)) if successful?
+      url_for(params_for(:action => 'show', :id => @record.to_param)) if successful?
     end
 
     def new_respond_to_html
@@ -26,13 +27,13 @@ module ActiveScaffold::Actions
         return_to_main
       end
     end
-    
+
     def new_respond_to_js
       render(:partial => 'create_form')
     end
 
     def create_respond_to_html
-      if params[:iframe]=='true' # was this an iframe post ?
+      if params[:iframe] == 'true' # was this an iframe post ?
         do_refresh_list if successful? && active_scaffold_config.create.refresh_list && !render_parent?
         responds_to_parent do
           render :action => 'on_create', :formats => [:js], :layout => false
@@ -40,10 +41,10 @@ module ActiveScaffold::Actions
       else
         if successful?
           flash[:info] = as_(:created_model, :model => @record.to_label)
-          if action = active_scaffold_config.create.action_after_create
+          if (action = active_scaffold_config.create.action_after_create)
             redirect_to params_for(:action => action, :id => @record.to_param)
           elsif params[:dont_close]
-            redirect_to params_for(:action => "new")
+            redirect_to params_for(:action => 'new')
           else
             return_to_main
           end
@@ -95,28 +96,25 @@ module ActiveScaffold::Actions
     # If you want to customize this behavior, consider using the +before_create_save+ and +after_create_save+ callbacks.
     def do_create(options = {})
       attributes = options[:attributes] || params[:record]
-      begin
-        active_scaffold_config.model.transaction do
-          @record = update_record_from_params(new_model, active_scaffold_config.create.columns, attributes)
-          apply_constraints_to_record(@record, :allow_autosave => true)
-          create_association_with_parent(@record) if nested?
-          before_create_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.errors.empty? && @record.valid?, @record.associated_valid?].all? # this syntax avoids a short-circuit
-          create_save(@record) unless options[:skip_save]
-        end
-      rescue ActiveRecord::ActiveRecordError => ex
-        flash[:error] = ex.message
-        self.successful = false
-        @record ||= new_model # ensure @record exists or display form will fail
+      active_scaffold_config.model.transaction do
+        @record = update_record_from_params(new_model, active_scaffold_config.create.columns, attributes)
+        apply_constraints_to_record(@record, :allow_autosave => true)
+        create_association_with_parent(@record) if nested?
+        before_create_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.errors.empty? && @record.valid?, @record.associated_valid?].all? # this syntax avoids a short-circuit
+        create_save(@record) unless options[:skip_save]
       end
+    rescue ActiveRecord::ActiveRecordError => ex
+      flash[:error] = ex.message
+      self.successful = false
+      @record ||= new_model # ensure @record exists or display form will fail
     end
 
     def create_save(record)
-      if successful?
-        record.save! and record.save_associated!
-        after_create_save(record)
-      end
+      return unless successful?
+      record.save! && record.save_associated!
+      after_create_save(record)
     end
 
     # override this method if you want to inject data in the record (or its associated objects) before the save
@@ -127,26 +125,29 @@ module ActiveScaffold::Actions
 
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
-    
+
     def create_ignore?
       active_scaffold_config.list.always_show_create
     end
-    
+
     def create_authorized?
       if nested?
-        nested_authorized = !nested.readonly? && !nested.readonly_through_association?(active_scaffold_config.create.columns)
-        return false unless nested_authorized
+        return false if nested.readonly? || nested.readonly_through_association?(active_scaffold_config.create.columns)
       end
       authorized_for?(:crud_type => :create)
     end
+
     private
+
     def create_authorized_filter
       link = active_scaffold_config.create.link || active_scaffold_config.create.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+      raise ActiveScaffold::ActionNotAllowed unless send(link.security_method)
     end
+
     def new_formats
       (default_formats + active_scaffold_config.formats).uniq
     end
+
     def create_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.create.formats).uniq
     end

data/lib/active_scaffold/actions/delete.rb

@@ -7,18 +7,14 @@ module ActiveScaffold::Actions
     def destroy
       params.delete :destroy_action
       process_action_link_action(:destroy) do |record|
-        do_destroy
+        do_destroy(record)
       end
     end
 
     protected
+
     def destroy_respond_to_html
-      if self.successful?
-        flash[:info] = as_(:deleted_model, :model => @record.to_label)
-      else
-        #error_message_for not available in controller...
-        #flash[:error] = active_scaffold_error_messages_for(@record, :object_name => "#{@record.class.model_name.human.downcase}#{@record.new_record? ? '' : ": #{@record.to_label}"}", :header_message => '', :message => "#{@record.class.model_name.human.downcase}#{@record.new_record? ? '' : ": #{@record.to_label}"}", :container_tag => nil, :list_type => :br)
-      end
+      flash[:info] = as_(:deleted_model, :model => @record.to_label) if self.successful?
       return_to_main
     end
 
@@ -28,15 +24,15 @@ module ActiveScaffold::Actions
     end
 
     def destroy_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+      render :xml => successful? ? '' : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
     end
 
     def destroy_respond_to_json
-      render :text => successful? ? "" : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+      render :text => successful? ? '' : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
     end
 
     def destroy_respond_to_yaml
-      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+      render :text => successful? ? '' : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
 
     def destroy_find_record
@@ -45,12 +41,12 @@ module ActiveScaffold::Actions
 
     # A simple method to handle the actual destroying of a record
     # May be overridden to customize the behavior
-    def do_destroy
-      @record ||= destroy_find_record
+    def do_destroy(record)
+      record ||= destroy_find_record
       begin
-        self.successful = @record.destroy
-      rescue Exception => ex
-        flash[:warning] = as_(:cant_destroy_record, :record => @record.to_label)
+        self.successful = record.destroy
+      rescue StandardError => ex
+        flash[:warning] = as_(:cant_destroy_record, :record => record.to_label)
         self.successful = false
         logger.debug ex.message
         logger.debug ex.backtrace.join("\n")
@@ -62,14 +58,18 @@ module ActiveScaffold::Actions
     def delete_authorized?(record = nil)
       (!nested? || !nested.readonly?) && (record || self).send(:authorized_for?, :crud_type => :delete)
     end
+
     def delete_ignore?(record = nil)
-      (nested? && nested.readonly?) || !self.send(:authorized_for?, :crud_type => :delete)
+      (nested? && nested.readonly?) || !send(:authorized_for?, :crud_type => :delete)
     end
+
     private
+
     def delete_authorized_filter
       link = active_scaffold_config.delete.link || active_scaffold_config.delete.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+      raise ActiveScaffold::ActionNotAllowed unless send(link.security_method)
     end
+
     def destroy_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.delete.formats).uniq
     end

data/lib/active_scaffold/actions/field_search.rb

@@ -5,9 +5,8 @@ module ActiveScaffold::Actions
       base.send :include, ActiveScaffold::Actions::CommonSearch
       base.send :include, InstanceMethods
     end
-    
-    module InstanceMethods
 
+    module InstanceMethods
       # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
       # This facilitates for example, textual searches against associations via .search_sql
       def show_search
@@ -20,28 +19,27 @@ module ActiveScaffold::Actions
       def search_partial
         super || :field_search
       end
-      
+
       def store_search_params_into_session
         set_field_search_default_params(active_scaffold_config.field_search.default_params) unless active_scaffold_config.field_search.default_params.nil?
         super
       end
-      
+
       def set_field_search_default_params(default_params)
-        if (params[:search].nil? && search_params.nil?) || (params[:search].is_a?(String) && params[:search].blank?)
-          params[:search] = default_params.is_a?(Proc) ? self.instance_eval(&default_params) : default_params
-        end
+        return unless (params[:search].is_a?(String) || search_params.nil?) && params[:search].blank?
+        params[:search] = default_params.is_a?(Proc) ? instance_eval(&default_params) : default_params
       end
-      
+
       def field_search_params
         search_params.is_a?(Hash) ? search_params : {}
       end
 
       def field_search_respond_to_html
-        render(:action => "field_search")
+        render(:action => 'field_search')
       end
-      
+
       def field_search_respond_to_js
-        render(:partial => "field_search")
+        render(:partial => 'field_search')
       end
 
       def do_search
@@ -53,15 +51,15 @@ module ActiveScaffold::Actions
             next unless columns.include? key
             column = active_scaffold_config.columns[key]
             search_condition = self.class.condition_for_column(column, value, text_search)
-            unless search_condition.blank?
-              if active_scaffold_config.list.user.count_includes.nil? && column.includes.present? && list_columns.include?(column)
-                self.active_scaffold_references << column.includes
-              elsif column.search_joins.present?
-                self.active_scaffold_outer_joins << column.search_joins
-              end
-              self.active_scaffold_conditions << search_condition
-              filtered_columns << column
+            next if search_condition.blank?
+
+            if active_scaffold_config.list.user.count_includes.nil? && column.includes.present? && list_columns.include?(column)
+              active_scaffold_references << column.includes
+            elsif column.search_joins.present?
+              active_scaffold_outer_joins << column.search_joins
             end
+            active_scaffold_conditions << search_condition
+            filtered_columns << column
           end
           unless filtered_columns.blank?
             @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
@@ -78,6 +76,7 @@ module ActiveScaffold::Actions
       end
 
       private
+
       def field_search_formats
         (default_formats + active_scaffold_config.formats + active_scaffold_config.field_search.formats).uniq
       end

data/lib/active_scaffold/actions/list.rb

@@ -14,6 +14,7 @@ module ActiveScaffold::Actions
     end
 
     protected
+
     # get just a single row
     def row
       get_row
@@ -36,6 +37,7 @@ module ActiveScaffold::Actions
         render :action => 'list'
       end
     end
+
     def list_respond_to_js
       if params[:adapter] || loading_embedded?
         render(:partial => 'list_with_header')
@@ -44,12 +46,15 @@ module ActiveScaffold::Actions
         render :partial => 'refresh_list', :formats => [:js]
       end
     end
+
     def list_respond_to_xml
       render :xml => response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::XML, :status => response_status
     end
+
     def list_respond_to_json
       render :text => response_object.to_json(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names)), :content_type => Mime::JSON, :status => response_status
     end
+
     def list_respond_to_yaml
       render :text => Hash.from_xml(response_object.to_xml(:only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names))).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
@@ -65,15 +70,16 @@ module ActiveScaffold::Actions
     # The actual algorithm to prepare for the list view
     def set_includes_for_columns(action = :list)
       @cache_associations = true
-      columns = if respond_to?(:"#{action}_columns", true)
-        send(:"#{action}_columns")
-      else
-        active_scaffold_config.send(action).columns.collect_visible(:flatten => true)
-      end
+      columns =
+        if respond_to?(:"#{action}_columns", true)
+          send(:"#{action}_columns")
+        else
+          active_scaffold_config.send(action).columns.collect_visible(:flatten => true)
+        end
       sorting = active_scaffold_config.list.user.sorting
-      columns_for_joins, columns_for_includes = columns.select{ |c| c.includes.present? }.partition {|c| sorting.sorts_on? c }
-      self.active_scaffold_preload.concat columns_for_includes.map(&:includes).flatten.uniq
-      self.active_scaffold_references.concat columns_for_joins.map(&:includes).flatten.uniq
+      columns_for_joins, columns_for_includes = columns.select { |c| c.includes.present? }.partition { |c| sorting.sorts_on? c }
+      active_scaffold_preload.concat columns_for_includes.map(&:includes).flatten.uniq
+      active_scaffold_references.concat columns_for_joins.map(&:includes).flatten.uniq
     end
 
     def get_row(crud_type_or_security_options = :read)
@@ -85,9 +91,9 @@ module ActiveScaffold::Actions
     def do_list
       set_includes_for_columns
 
-      options = { :sorting => active_scaffold_config.list.user.sorting,
-        :count_includes => active_scaffold_config.list.user.count_includes }
-      paginate = (params[:format].nil?) ? (accepts? :html, :js) : ['html', 'js'].include?(params[:format])
+      options = {:sorting => active_scaffold_config.list.user.sorting,
+                 :count_includes => active_scaffold_config.list.user.count_includes}
+      paginate = (params[:format].nil?) ? (accepts? :html, :js) : %w(html js).include?(params[:format])
       options[:pagination] = active_scaffold_config.list.pagination if paginate
       if options[:pagination]
         options.merge!(
@@ -120,15 +126,15 @@ module ActiveScaffold::Actions
     end
 
     def each_record_in_page
-      _page = active_scaffold_config.list.user.page
+      current_page = active_scaffold_config.list.user.page
       do_search if respond_to? :do_search, true
-      active_scaffold_config.list.user.page = _page
+      active_scaffold_config.list.user.page = current_page
       do_list
-      @page.items.each {|record| yield record}
+      @page.items.each { |record| yield record }
     end
 
     def each_record_in_scope
-      scoped_query.each {|record| yield record}
+      scoped_query.each { |record| yield record }
     end
 
     def scoped_query
@@ -150,19 +156,21 @@ module ActiveScaffold::Actions
       do_refresh_list unless @record.present?
       super
     end
-    
+
     def objects_for_etag
-      objects = if @list_columns
-        if active_scaffold_config.list.calculate_etag
-          @records.to_a
-        elsif active_scaffold_config.list.user.sorting
-          {:etag => active_scaffold_config.list.user.sorting.clause}
+      objects =
+        if @list_columns
+          if active_scaffold_config.list.calculate_etag
+            @records.to_a
+          elsif active_scaffold_config.list.user.sorting
+            {:etag => active_scaffold_config.list.user.sorting.clause}
+          end
         end
-      end
       objects.present? ? objects : super
     end
 
     private
+
     def list_authorized_filter
       raise ActiveScaffold::ActionNotAllowed unless list_authorized?
     end

data/lib/active_scaffold/actions/mark.rb

@@ -1,6 +1,5 @@
 module ActiveScaffold::Actions
   module Mark
-
     def self.included(base)
       base.before_filter :mark_authorized?, :only => :mark
       base.before_filter :assign_marked_records_to_model
@@ -19,6 +18,7 @@ module ActiveScaffold::Actions
       end
       respond_to_action(:mark)
     end
+
     protected
 
     def mark_respond_to_html

data/lib/active_scaffold/actions/nested.rb

@@ -1,13 +1,12 @@
 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).
   module Nested
-
     def self.included(base)
       super
       base.module_eval do
         before_filter :set_nested
         before_filter :configure_nested
-        include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.model.reflect_on_all_associations.any? {|a| a.macro == :has_and_belongs_to_many}
+        include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.model.reflect_on_all_associations.any? { |a| a.macro == :has_and_belongs_to_many }
       end
       base.before_filter :include_habtm_actions
       base.helper_method :nested
@@ -15,64 +14,68 @@ module ActiveScaffold::Actions
     end
 
     protected
+
     def nested
       set_nested unless defined? @nested
       @nested
     end
-    
+
     def nested?
       !nested.nil?
     end
-    
+
     def set_nested
-      if 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?
-      end
+      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?
     end
-    
+
     def configure_nested
-      if nested?
-        active_scaffold_config.list.user.label = if nested.belongs_to?
-          as_(:nested_of_model, :nested_model => active_scaffold_config.model.model_name.human, :parent_model => nested_parent_record.to_label)
-        else
-          as_(:nested_for_model, :nested_model => active_scaffold_config.list.label, :parent_model => nested_parent_record.to_label)
-        end
-        if nested.sorted? && !active_scaffold_config.nested.ignore_order_from_association
-          active_scaffold_config.list.user.nested_default_sorting = {:table_name => active_scaffold_config.model.model_name, :default_sorting => nested.default_sorting}
-        end
+      return unless nested?
+      active_scaffold_config.list.user.label = nested_label
+      active_scaffold_config.list.user.nested_default_sorting = nested_default_sorting if nested.sorted? && !active_scaffold_config.nested.ignore_order_from_association
+    end
+
+    def nested_label
+      if nested.belongs_to?
+        as_(:nested_of_model, :nested_model => active_scaffold_config.model.model_name.human, :parent_model => nested_parent_record.to_label)
+      else
+        as_(:nested_for_model, :nested_model => active_scaffold_config.list.label, :parent_model => nested_parent_record.to_label)
       end
     end
-    
+
+    def nested_default_sorting
+      {:table_name => active_scaffold_config.model.model_name, :default_sorting => nested.default_sorting}
+    end
+
     def nested_authorized?(record = nil)
       true
     end
 
     def include_habtm_actions
-      if nested?
-        if nested.habtm?
-          # Production mode is ok with adding a link everytime the scaffold is nested - we ar 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("delete") if active_scaffold_config.action_links['delete']
-            end
+      return unless nested?
+      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('delete') if active_scaffold_config.action_links['delete']
           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.action_links.add(ActiveScaffold::Config::Delete.link) unless active_scaffold_config.action_links['delete']
-            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.action_links.add(ActiveScaffold::Config::Delete.link) unless active_scaffold_config.action_links['delete']
           end
         end
       end
     end
-    
+
     def beginning_of_chain
       if nested? && nested.association
         if nested.association.collection?
@@ -85,10 +88,11 @@ module ActiveScaffold::Actions
           active_scaffold_config.model.where(nested.child_association.foreign_key => nested_parent_record.send(nested.association.association_primary_key))
         elsif nested.association.belongs_to?
           chain = active_scaffold_config.model.joins(nested.child_association.name)
-          table_name = if active_scaffold_config.model == nested.association.active_record
-            dependency = ActiveRecord::Associations::JoinDependency.new(chain.klass, chain.joins_values, [])
-            dependency.join_associations.find {|join| join.try(:reflection).try(:name) == nested.child_association.name}.try(:table).try(:right)
-          end
+          table_name =
+            if active_scaffold_config.model == nested.association.active_record
+              dependency = ActiveRecord::Associations::JoinDependency.new(chain.klass, chain.joins_values, [])
+              dependency.join_associations.find { |join| join.try(:reflection).try(:name) == nested.child_association.name }.try(:table).try(:right)
+            end
           table_name ||= nested.association.active_record.table_name
           chain.where(table_name => {nested.association.active_record.primary_key => nested_parent_record}).readonly(false)
         end
@@ -102,23 +106,21 @@ module ActiveScaffold::Actions
     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(record)
-      if nested?
-        # has_many is done by beginning_of_chain and rails
-        if (nested.belongs_to? || nested.has_one? || nested.habtm?) && nested.child_association
-          parent = nested_parent_record(:read)
-          case nested.child_association.macro
-          when :has_one, :belongs_to
-            record.send("#{nested.child_association.name}=", parent)
-          when :has_many, :has_and_belongs_to_many
-            record.send("#{nested.child_association.name}").send(:<<, parent)
-          end unless parent.nil?
-        end
+      # 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?
+      case nested.child_association.macro
+      when :has_one, :belongs_to
+        record.send("#{nested.child_association.name}=", parent)
+      when :has_many, :has_and_belongs_to_many
+        record.send("#{nested.child_association.name}").send(:<<, parent)
       end
     end
-    
+
     private
+
     def nested_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.nested.formats).uniq
     end
@@ -127,7 +129,6 @@ end
 
 module ActiveScaffold::Actions::Nested
   module ChildMethods
-
     def self.included(base)
       super
     end
@@ -147,8 +148,9 @@ module ActiveScaffold::Actions::Nested
       do_destroy_existing
       respond_to_action(:destroy_existing)
     end
-    
+
     protected
+
     def new_existing_respond_to_html
       if successful?
         render(:action => 'add_existing_form')
@@ -156,9 +158,11 @@ module ActiveScaffold::Actions::Nested
         return_to_main
       end
     end
+
     def new_existing_respond_to_js
       render(:partial => 'add_existing_form')
     end
+
     def add_existing_respond_to_html
       if successful?
         flash[:info] = as_(:created_model, :model => @record.to_label)
@@ -167,6 +171,7 @@ module ActiveScaffold::Actions::Nested
         render(:action => 'add_existing_form')
       end
     end
+
     def add_existing_respond_to_js
       if successful?
         render :action => 'add_existing'
@@ -174,15 +179,19 @@ module ActiveScaffold::Actions::Nested
         render :action => 'form_messages'
       end
     end
+
     def add_existing_respond_to_xml
       render :xml => response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
     end
+
     def add_existing_respond_to_json
       render :text => response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
     end
+
     def add_existing_respond_to_yaml
       render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
+
     def destroy_existing_respond_to_html
       flash[:info] = as_(:deleted_model, :model => @record.to_label)
       return_to_main
@@ -193,29 +202,29 @@ module ActiveScaffold::Actions::Nested
     end
 
     def destroy_existing_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
+      render :xml => successful? ? '' : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
     end
 
     def destroy_existing_respond_to_json
-      render :text => successful? ? "" : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
+      render :text => successful? ? '' : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
     end
 
     def destroy_existing_respond_to_yaml
-      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
+      render :text => successful? ? '' : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
     end
 
     def add_existing_authorized?(record = nil)
       true
     end
+
     def delete_existing_authorized?(record = nil)
       true
     end
- 
+
     def after_create_save(record)
-      if params[:association_macro] == :has_and_belongs_to_many
-        params[:associated_id] = record
-        do_add_existing
-      end
+      return unless params[:association_macro] == :has_and_belongs_to_many
+      params[:associated_id] = record
+      do_add_existing
     end
 
     # The actual "add_existing" algorithm
@@ -240,13 +249,17 @@ module ActiveScaffold::Actions::Nested
         do_destroy
       end
     end
+
     private
+
     def new_existing_formats
       (default_formats + active_scaffold_config.formats).uniq
     end
+
     def add_existing_formats
       (default_formats + active_scaffold_config.formats).uniq
     end
+
     def destroy_existing_formats
       (default_formats + active_scaffold_config.formats).uniq
     end