active_scaffold 3.7.12 → 4.0.0.rc1

data/lib/active_scaffold/actions/list.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module List
     def self.included(base)
-      base.before_action :list_authorized_filter, :only => :index
+      base.before_action :list_authorized_filter, only: :index
       base.helper_method :list_columns, :count_on_association_class?
     end
 
@@ -32,19 +32,19 @@ module ActiveScaffold::Actions
 
     def list_respond_to_html
       if loading_embedded?
-        render :action => 'list', :layout => false
+        render action: 'list', layout: false
       else
-        render :action => 'list'
+        render action: 'list'
       end
     end
 
     def list_respond_to_js
       if params[:adapter] || loading_embedded?
-        render(:partial => 'list_with_header')
+        render partial: 'list_with_header'
       else
         @auto_pagination = params[:auto_pagination]
         @popstate = params.delete(:_popstate)
-        render :partial => 'refresh_list', :formats => [:js]
+        render partial: 'refresh_list', formats: [:js]
       end
     end
 
@@ -57,22 +57,17 @@ module ActiveScaffold::Actions
     end
 
     def row_respond_to_html
-      render(:partial => 'row', :locals => {:record => @record})
+      render partial: 'row', locals: {record: @record}
     end
 
     def row_respond_to_js
-      render :action => 'row'
+      render action: 'row'
     end
 
     # The actual algorithm to prepare for the list view
     def set_includes_for_columns(action = :list, sorting = active_scaffold_config.list.user.sorting)
       @cache_associations = true
-      columns =
-        if respond_to?(:"#{action}_columns", true)
-          send(:"#{action}_columns")
-        else
-          active_scaffold_config.send(action).columns.visible_columns(flatten: true)
-        end
+      columns = columns_for_action(action)
       joins_cols, preload_cols = columns.select { |c| c.includes.present? }.partition do |col|
         includes_need_join?(col, sorting) && !grouped_search?
       end
@@ -81,10 +76,19 @@ module ActiveScaffold::Actions
       set_includes_for_sorting(columns, sorting) if sorting.sorts_by_sql?
     end
 
+    def columns_for_action(action)
+      if respond_to?(:"#{action}_columns", true)
+        send(:"#{action}_columns")
+      else
+        active_scaffold_config.send(action).columns.visible_columns(flatten: true)
+      end
+    end
+
     def set_includes_for_sorting(columns, sorting)
       sorting.each_column do |col|
         next if sorting.constraint_columns.include? col.name
-        next unless col.includes.present? && !columns.include?(col)
+        next unless col.includes.present? && columns.exclude?(col)
+
         if active_scaffold_config.model.connection.needs_order_expressions_in_select?
           active_scaffold_references << col.includes
         else
@@ -130,11 +134,7 @@ module ActiveScaffold::Actions
     end
 
     def columns_to_cache_counts
-      list_columns.select do |col|
-        col.association&.collection? && col.includes.blank? && col.associated_number? &&
-          !ActiveScaffold::OrmChecks.tableless?(col.association.klass) &&
-          !col.association.reverse_association&.counter_cache
-      end
+      list_columns.select(&:cache_count?)
     end
 
     def cache_column_counts(records)
@@ -166,18 +166,18 @@ module ActiveScaffold::Actions
       if column.association.as
         query.where!(column.association.reverse_association.foreign_type => active_scaffold_config.model.name)
       end
-      if column.association.scope
-        query = query.instance_exec(&column.association.scope)
-      end
+      query = query.instance_exec(&column.association.scope) if column.association.scope
       query.group(column.association.foreign_key)
     end
 
     def count_query_with_join(column, records)
       klass = column.association.klass
       query = active_scaffold_config.model.where(active_scaffold_config.primary_key => records.map(&:id))
-                                    .joins(column.name).group(active_scaffold_config.primary_key)
-                                    .select("#{klass.quoted_table_name}.#{klass.quoted_primary_key}")
-      query = query.distinct if column.association.scope && klass.instance_exec(&column.association.scope).values[:distinct]
+                .joins(column.name).group(active_scaffold_config.primary_key)
+                .select("#{klass.quoted_table_name}.#{klass.quoted_primary_key}")
+      if column.association.scope && klass.instance_exec(&column.association.scope).values[:distinct]
+        query = query.distinct
+      end
       query
     end
 
@@ -195,8 +195,8 @@ module ActiveScaffold::Actions
 
     def find_page_options
       options = {
-        :sorting => active_scaffold_config.list.user.sorting,
-        :count_includes => active_scaffold_config.list.user.count_includes
+        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])
@@ -208,7 +208,7 @@ module ActiveScaffold::Actions
 
       if active_scaffold_config.list.auto_select_columns
         auto_select_columns = list_columns + [active_scaffold_config.columns[active_scaffold_config.model.primary_key]]
-        options[:select] = auto_select_columns.map { |c| quoted_select_columns(c.select_columns) }.compact.flatten
+        options[:select] = auto_select_columns.filter_map { |c| quoted_select_columns(c.select_columns) }.flatten
       end
 
       options
@@ -227,12 +227,12 @@ module ActiveScaffold::Actions
       do_list
     end
 
-    def each_record_in_page
-      page_items.each { |record| yield record }
+    def each_record_in_page(&block)
+      page_items.each(&block)
     end
 
-    def each_record_in_scope
-      scoped_query.each { |record| yield record }
+    def each_record_in_scope(&block)
+      scoped_query.each(&block)
     end
 
     def page_items
@@ -257,7 +257,7 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def list_authorized?
-      authorized_for?(:crud_type => :read)
+      authorized_for?(crud_type: :read)
     end
 
     def action_update_respond_to_js
@@ -271,7 +271,7 @@ module ActiveScaffold::Actions
           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}
+            {etag: active_scaffold_config.list.user.sorting.clause}
           end
         end
       objects.presence || super

data/lib/active_scaffold/actions/mark.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Mark
     def self.included(base)
-      base.before_action :mark_authorized_filter, :only => :mark
+      base.before_action :mark_authorized_filter, only: :mark
       base.before_action :assign_marked_records_to_model
       base.helper_method :marked_records
     end
@@ -14,7 +14,7 @@ module ActiveScaffold::Actions
       end
       if marked_records.any?
         count = marked_records.length
-        flash[:info] = as_(:records_marked, :count => count, :model => active_scaffold_config.label(:count => count))
+        flash[:info] = as_(:records_marked, count: count, model: active_scaffold_config.label(count: count))
       end
       respond_to_action(:mark)
     end
@@ -30,11 +30,11 @@ module ActiveScaffold::Actions
       if params.delete(:id) # so find_page doesn't filter by :id
         do_search if respond_to? :do_search, true
         set_includes_for_columns if active_scaffold_config.actions.include? :list
-        @page = find_page(:pagination => active_scaffold_config.mark.mark_all_mode != :page)
-        render :action => 'on_mark'
+        @page = find_page(pagination: active_scaffold_config.mark.mark_all_mode != :page)
+        render action: 'on_mark'
       else
         @include_checkboxes = true
-        render :action => 'on_mark', :locals => {:checked => mark?}
+        render action: 'on_mark', locals: {checked: mark?}
       end
     end
 

data/lib/active_scaffold/actions/nested.rb

@@ -8,9 +8,8 @@ module ActiveScaffold::Actions
       base.module_eval do
         before_action :set_nested
         before_action :configure_nested
-        include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.columns.map(&:association).compact.any?(&:habtm?)
+        include ActiveScaffold::Actions::Nested::ChildMethods if active_scaffold_config.columns.filter_map(&:association).any?(&:habtm?)
       end
-      base.before_action :include_habtm_actions
       base.helper_method :nested
       base.helper_method :nested_parent_record
     end
@@ -29,65 +28,39 @@ module ActiveScaffold::Actions
     def set_nested
       @nested = nil
       return unless params[:parent_scaffold] && (params[:association] || params[:named_scope])
+
       @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
       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
       if nested.belongs_to?
-        as_(:nested_of_model, :nested_model => active_scaffold_config.model.model_name.human, :parent_model => ERB::Util.h(nested_parent_record.to_label))
+        as_(:nested_of_model, nested_model: active_scaffold_config.model.model_name.human, parent_model: ERB::Util.h(nested_parent_record.to_label))
       else
-        as_(:nested_for_model, :nested_model => active_scaffold_config.list.label, :parent_model => ERB::Util.h(nested_parent_record.to_label))
+        as_(:nested_for_model, nested_model: active_scaffold_config.list.label, parent_model: ERB::Util.h(nested_parent_record.to_label))
       end
     end
 
     def nested_default_sorting(chain)
-      {:table_name => active_scaffold_config._table_name, :default_sorting => nested.default_sorting(chain)}
+      {table_name: active_scaffold_config._table_name, default_sorting: nested.default_sorting(chain)}
     end
 
     def nested_authorized?(record = nil)
       true
     end
 
-    def include_habtm_actions
-      if nested&.habtm?
-        # Production mode is ok with adding a link everytime the scaffold is nested - we are not ok with that.
-        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
       # 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)
@@ -118,24 +91,26 @@ module ActiveScaffold::Actions
       @nested_parent_record ||= find_if_allowed(nested.parent_id, crud, nested.parent_model)
     end
 
-    def create_association_with_parent?(check_match = false)
+    def create_association_with_parent?(check_match: false)
       # has_many is done by beginning_of_chain and rails if direct association, not in through associations
       return false unless nested.create_with_parent?
       return false if check_match && !nested.match_model?(active_scaffold_config.model)
+
       nested_parent_record.present?
     end
 
-    def create_association_with_parent(record, check_match = false)
-      return unless create_association_with_parent?(check_match)
+    def create_association_with_parent(record, check_match: false)
+      return unless create_association_with_parent?(check_match: check_match)
+
       if nested.child_association&.singular?
-        record.send("#{nested.child_association.name}=", nested_parent_record)
+        record.send(:"#{nested.child_association.name}=", nested_parent_record)
       elsif nested.create_through_singular?
         through = nested_parent_record.send(nested.association.through_reflection.name) ||
-                  nested_parent_record.send("build_#{nested.association.through_reflection.name}")
+                  nested_parent_record.send(:"build_#{nested.association.through_reflection.name}")
         if nested.source_reflection.reverse_association.collection?
           record.send(nested.source_reflection.reverse) << through
         else
-          record.send("#{nested.source_reflection.reverse}=", through)
+          record.send(:"#{nested.source_reflection.reverse}=", through)
         end
       else
         record.send(nested.child_association.name) << nested_parent_record
@@ -154,6 +129,25 @@ module ActiveScaffold::Actions::Nested
   module ChildMethods
     def self.included(base)
       super
+      include_habtm_actions base.active_scaffold_config
+    end
+
+    def self.include_habtm_actions(config)
+      # Production mode is ok with adding a link everytime the scaffold is nested - we are not ok with that.
+      unless config.action_links['new_existing']
+        config.action_links.add('new_existing', label: :add_existing, type: :collection,
+                                                security_method: :add_existing_authorized?,
+                                                ignore_method: :add_existing_ignore?)
+      end
+      return unless config.nested.shallow_delete
+
+      unless config.action_links['destroy_existing']
+        config.action_links.add('destroy_existing', label: :remove, type: :member, confirm: :are_you_sure_to_delete,
+                                                    method: :delete, position: false,
+                                                    security_method: :add_existing_authorized?,
+                                                    ignore_method: :add_existing_ignore?)
+      end
+      config.action_links['destroy'].ignore_method = :habtm_delete_ignore? if config.actions.include?(:delete)
     end
 
     def new_existing
@@ -167,7 +161,8 @@ module ActiveScaffold::Actions::Nested
     end
 
     def destroy_existing
-      return redirect_to(params.merge(:action => :delete, :only_path => true)) if request.get? || request.head?
+      return redirect_to(params.merge(action: :delete, only_path: true)) if request.get? || request.head?
+
       do_destroy_existing
       respond_to_action(:destroy_existing)
     end
@@ -176,68 +171,81 @@ module ActiveScaffold::Actions::Nested
 
     def new_existing_respond_to_html
       if successful?
-        render(:action => 'add_existing_form')
+        render action: 'add_existing_form'
       else
         return_to_main
       end
     end
 
     def new_existing_respond_to_js
-      render(:partial => 'add_existing_form')
+      render partial: 'add_existing_form'
     end
 
     def add_existing_respond_to_html
       if successful?
-        flash[:info] = as_(:created_model, :model => ERB::Util.h(@record.to_label))
+        flash[:info] = as_(:created_model, model: ERB::Util.h(@record.to_label))
         return_to_main
       else
-        render(:action => 'add_existing_form')
+        render action: 'add_existing_form'
       end
     end
 
     def add_existing_respond_to_js
       if successful?
-        render :action => 'add_existing'
+        render action: 'add_existing'
       else
-        render :action => 'form_messages'
+        render action: 'form_messages'
       end
     end
 
     def add_existing_respond_to_xml
-      render :xml => response_object, :only => active_scaffold_config.list.columns.visible_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.visible_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
-      flash[:info] = as_(:deleted_model, :model => ERB::Util.h(@record.to_label))
+      flash[:info] = as_(:deleted_model, model: ERB::Util.h(@record.to_label))
       return_to_main
     end
 
     def destroy_existing_respond_to_js
-      render(:action => 'destroy')
+      render action: 'destroy'
     end
 
     def destroy_existing_respond_to_xml
-      render :xml => successful? ? '' : response_object, :only => active_scaffold_config.list.columns.visible_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.visible_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)
-      nested_parent_record.authorized_for?(:crud_type => :update, :column => nested.association.try(:name))
+      nested_parent_record.authorized_for?(crud_type: :update, column: nested.association.try(:name))
     end
 
     def delete_existing_authorized?(record = nil)
-      nested_parent_record.authorized_for?(:crud_type => :update, :column => nested.association.try(:name), :reason => true)
+      nested_parent_record.authorized_for?(crud_type: :update, column: nested.association.try(:name), reason: true)
+    end
+
+    def add_existing_ignore?(record = nil)
+      !nested&.habtm?
+    end
+
+    def delete_existing_ignore?(record = nil)
+      !nested&.habtm?
+    end
+
+    def habtm_delete_ignore?(record = nil)
+      !delete_existing_ignore?(record) || delete_ignore?(record)
     end
 
     def after_create_save(record)
       return unless params[:association_macro] == :has_and_belongs_to_many
+
       params[:associated_id] = record
       do_add_existing
     end

data/lib/active_scaffold/actions/search.rb

@@ -9,11 +9,11 @@ module ActiveScaffold::Actions
       protected
 
       def search_respond_to_html
-        render(:action => 'search')
+        render action: 'search'
       end
 
       def search_respond_to_js
-        render(:partial => 'search')
+        render partial: 'search'
       end
 
       def do_search

data/lib/active_scaffold/actions/show.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Show
     def self.included(base)
-      base.before_action :show_authorized_filter, :only => :show
+      base.before_action :show_authorized_filter, only: :show
     end
 
     def show
@@ -27,11 +27,11 @@ module ActiveScaffold::Actions
     end
 
     def show_respond_to_js
-      render :partial => 'show'
+      render partial: 'show'
     end
 
     def show_respond_to_html
-      render :action => 'show'
+      render action: 'show'
     end
 
     def show_columns_names
@@ -52,14 +52,14 @@ module ActiveScaffold::Actions
     end
 
     def show_ignore?(record = nil)
-      !send(:authorized_for?, :crud_type => :read)
+      !send(:authorized_for?, crud_type: :read)
     end
 
     private
 
     def show_authorized_filter
       link = active_scaffold_config.show.link || self.class.active_scaffold_config.show.class.link
-      raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
+      raise ActiveScaffold::ActionNotAllowed unless action_link_authorized?(link)
     end
 
     def show_formats

data/lib/active_scaffold/actions/subform.rb

@@ -3,7 +3,7 @@ module ActiveScaffold::Actions
     def edit_associated
       do_edit_associated
       respond_to do |format|
-        format.js { render :action => 'edit_associated', :formats => [:js], :readonly => @column.association.readonly? }
+        format.js { render action: 'edit_associated', formats: [:js], readonly: @column.association.readonly? }
       end
     end
 
@@ -13,7 +13,7 @@ module ActiveScaffold::Actions
       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
-      create_association_with_parent parent_record, true if nested?
+      create_association_with_parent parent_record, check_match: true if nested?
       parent_record
     end
 
@@ -24,8 +24,19 @@ module ActiveScaffold::Actions
       cache_generated_id(@parent_record, params[:generated_id]) if @parent_record.new_record?
       @column = active_scaffold_config.columns[params[:child_association]]
 
-      @record = find_associated_record if params[:associated_id]
-      @record ||= build_associated(@column.association, @parent_record)
+      @record = (find_associated_record if params[:associated_id]) ||
+                build_associated(@column.association, @parent_record) do |blank_record|
+                  if params[:tabbed_by] && params[:value]
+                    assign_tabbed_by(blank_record, @column, params[:tabbed_by], params[:value], params[:value_type])
+                  end
+                end
+    end
+
+    def assign_tabbed_by(record, parent_column, tabbed_by, value, value_type)
+      if (association = tabbed_by_association(parent_column, tabbed_by))
+        klass = value_type&.constantize || association.klass
+      end
+      record.send :"#{tabbed_by}=", klass&.find(value) || value
     end
 
     def find_associated_record