active_scaffold 3.6.0.pre → 3.6.0.rc1

data/lib/active_scaffold/actions/delete.rb

@@ -65,7 +65,7 @@ module ActiveScaffold::Actions
     private
 
     def delete_authorized_filter
-      link = active_scaffold_config.delete.link || active_scaffold_config.delete.class.link
+      link = active_scaffold_config.delete.link || self.class.active_scaffold_config.delete.class.link
       raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
     end
 

data/lib/active_scaffold/actions/field_search.rb

@@ -23,11 +23,11 @@ module ActiveScaffold::Actions
       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?
+        init_field_search_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)
+      def init_field_search_params(default_params)
         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
@@ -57,23 +57,24 @@ module ActiveScaffold::Actions
       def custom_finder_options
         if grouped_search?
           group_sql = calculation_for_group_by(search_group_column&.field || search_group_name)
-          group_by = group_sql.respond_to?(:to_sql) ? group_sql.to_sql : group_sql
-
-          select_query = quoted_select_columns(search_group_column&.select_columns)
+          select_query = grouped_search_select
           select_query << group_sql.as(search_group_column.name.to_s) if search_group_column && group_sql.respond_to?(:to_sql)
-          if active_scaffold_config.model.columns_hash.include?(active_scaffold_config.model.inheritance_column)
-            select_query << active_scaffold_config.columns[active_scaffold_config.model.inheritance_column].field
-          end
-          grouped_columns_calculations.each do |name, part|
-            select_query << (part.respond_to?(:as) ? part : Arel::Nodes::SqlLiteral.new(part)).as(name.to_s)
-          end
-
-          {group: group_by, select: select_query}
+          {group: group_sql, select: select_query}
         else
           super
         end
       end
 
+      def grouped_search_select
+        select_query = quoted_select_columns(search_group_column&.select_columns || [search_group_name])
+        if active_scaffold_config.model.columns_hash.include?(active_scaffold_config.model.inheritance_column)
+          select_query << active_scaffold_config.columns[active_scaffold_config.model.inheritance_column].field
+        end
+        grouped_columns_calculations.each do |name, part|
+          select_query << (part.respond_to?(:as) ? part : Arel::Nodes::SqlLiteral.new(part)).as(name.to_s)
+        end
+      end
+
       def grouped_columns_calculations
         @grouped_columns_calculations ||= list_columns[1..-1].each_with_object({}) do |c, h|
           h[c.name] = calculation_for_group_search(c)
@@ -113,12 +114,13 @@ module ActiveScaffold::Actions
       end
 
       def list_columns
-        @list_columns ||= if grouped_search?
-                            columns = grouped_columns || super.select(&:calculation?)
-                            [search_group_column || search_group_name].concat columns
-        else
-          super
-        end
+        @list_columns ||=
+          if grouped_search?
+            columns = grouped_columns || super.select(&:calculation?)
+            columns.unshift(search_group_column || search_group_name)
+          else
+            super
+          end
       end
 
       def grouped_columns
@@ -142,34 +144,42 @@ module ActiveScaffold::Actions
 
       def do_search
         if field_search_params.present?
-          filtered_columns = []
-          text_search = active_scaffold_config.field_search.text_search
-          columns = active_scaffold_config.field_search.columns
-          count_includes = active_scaffold_config.list.user.count_includes
-          search_params.each do |key, value|
-            next unless columns.include? key
-            column = active_scaffold_config.columns[key]
-            search_condition = self.class.condition_for_column(column, value, text_search)
-            next if search_condition.blank?
-
-            if count_includes.nil? && column.includes.present? && list_columns.include?(column) && !grouped_search?
-              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
-          if filtered_columns.present? || grouped_search?
-            @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
-          end
-
-          active_scaffold_config.list.user.page = nil
+          do_field_search
         else
           super
         end
       end
 
+      def do_field_search
+        filtered_columns = []
+        text_search = active_scaffold_config.field_search.text_search
+        columns = active_scaffold_config.field_search.columns
+        count_includes = active_scaffold_config.list.user.count_includes
+        search_params.each do |key, value|
+          next unless columns.include? key
+          column = active_scaffold_config.columns[key]
+          search_condition = self.class.condition_for_column(column, value, text_search)
+          next if search_condition.blank?
+
+          joins_for_search_on_column(column, count_includes)
+          active_scaffold_conditions << search_condition
+          filtered_columns << column
+        end
+        if filtered_columns.present? || grouped_search?
+          @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
+        end
+
+        active_scaffold_config.list.user.page = nil
+      end
+
+      def joins_for_search_on_column(column, count_includes)
+        if count_includes.nil? && column.includes.present? && list_columns.include?(column) && !grouped_search?
+          active_scaffold_references << column.includes
+        elsif column.search_joins.present?
+          active_scaffold_outer_joins << column.search_joins
+        end
+      end
+
       def field_search_ignore?
         active_scaffold_config.list.always_show_search && active_scaffold_config.list.search_partial == 'field_search'
       end

data/lib/active_scaffold/actions/list.rb

@@ -2,7 +2,7 @@ module ActiveScaffold::Actions
   module List
     def self.included(base)
       base.before_action :list_authorized_filter, :only => :index
-      base.helper_method :list_columns
+      base.helper_method :list_columns, :count_on_association_class?
     end
 
     def index
@@ -49,11 +49,11 @@ module ActiveScaffold::Actions
     end
 
     def list_respond_to_xml
-      render :xml => response_object, :only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names), :status => response_status
+      response_to_api(:xml, list_columns_names)
     end
 
     def list_respond_to_json
-      render :json => response_object, :only => list_columns_names + [active_scaffold_config.model.primary_key], :include => association_columns(list_columns_names), :methods => virtual_columns(list_columns_names), :status => response_status
+      response_to_api(:json, list_columns_names)
     end
 
     def row_respond_to_html
@@ -82,7 +82,7 @@ module ActiveScaffold::Actions
     end
 
     def set_includes_for_sorting(columns, sorting)
-      sorting.each_key do |col|
+      sorting.each_column do |col|
         next unless col.includes.present? && !columns.include?(col)
         if active_scaffold_config.model.connection.needs_order_expressions_in_select?
           active_scaffold_references << col.includes
@@ -93,7 +93,7 @@ module ActiveScaffold::Actions
     end
 
     def includes_need_join?(column, sorting = active_scaffold_config.list.user.sorting)
-      sorting.sorts_on?(column) || scoped_habtm?(column)
+      (sorting.sorts_by_sql? && sorting.sorts_on?(column)) || scoped_habtm?(column)
     end
 
     def scoped_habtm?(column)
@@ -106,34 +106,111 @@ module ActiveScaffold::Actions
       super
     end
 
+    def current_page
+      set_includes_for_columns
+
+      page = find_page(find_page_options)
+      total_pages = page.pager.number_of_pages
+      if !page.pager.infinite? && !total_pages.zero? && page.number > total_pages
+        page = page.pager.last
+        active_scaffold_config.list.user.page = page.number
+      end
+      page
+    end
+
     # The actual algorithm to prepare for the list view
     def do_list
       # id: nil needed in params_for because rails reuse it even
       # if it was deleted from params (like do_refresh_list does)
       @remove_id_from_list_links = params[:id].blank?
-      set_includes_for_columns
+      @page = current_page
+      @records = @page.items
+      cache_column_counts
+    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
+    end
+
+    def cache_column_counts
+      @counts = columns_to_cache_counts.each_with_object({}) do |column, counts|
+        if ActiveScaffold::OrmChecks.active_record?(column.association.klass)
+          counts[column.name] = count_query_for_column(column).count
+        elsif ActiveScaffold::OrmChecks.mongoid?(column.association.klass)
+          counts[column.name] = mongoid_count_for_column(column)
+        end
+      end
+    end
+
+    def count_on_association_class?(column)
+      column.association.has_many? && !column.association.through? &&
+        (!column.association.as || column.association.reverse_association)
+    end
+
+    def count_query_for_column(column)
+      if count_on_association_class?(column)
+        count_query_on_association_class(column)
+      else
+        count_query_with_join(column)
+      end
+    end
+
+    def count_query_on_association_class(column)
+      key = column.association.primary_key || :id
+      query = column.association.klass.where(column.association.foreign_key => @records.map(&key))
+      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.group(column.association.foreign_key)
+    end
+
+    def count_query_with_join(column)
+      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.uniq if column.association.scope && klass.instance_exec(&column.association.scope).values[:distinct]
+      query
+    end
+
+    def mongoid_count_for_column(column)
+      matches = {column.association.foreign_key => {'$in': @records.map(&:id)}}
+      if column.association.as
+        matches[column.association.reverse_association.foreign_type] = {'$eq': active_scaffold_config.model.name}
+      end
+      group = {_id: "$#{column.association.foreign_key}", count: {'$sum' => 1}}
+      query = column.association.klass.collection.aggregate([{'$match' => matches}, {'$group' => group}])
+      query.each_with_object({}) do |row, hash|
+        hash[row['_id']] = row['count']
+      end
+    end
+
+    def find_page_options
+      options = {
+        :sorting => active_scaffold_config.list.user.sorting,
+        :count_includes => active_scaffold_config.list.user.count_includes
+      }
 
-      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])
+      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[:per_page] = active_scaffold_config.list.user.per_page
         options[:page] = active_scaffold_config.list.user.page
       end
+
       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
       end
 
-      page = find_page(options)
-      total_pages = page.pager.number_of_pages
-      if !page.pager.infinite? && !total_pages.zero? && page.number > total_pages
-        page = page.pager.last
-        active_scaffold_config.list.user.page = page.number
-      end
-      @page = page
-      @records = page.items
+      options
     end
 
     def quoted_select_columns(columns)
@@ -150,17 +227,23 @@ module ActiveScaffold::Actions
     end
 
     def each_record_in_page
-      current_page = active_scaffold_config.list.user.page
-      do_search if respond_to? :do_search, true
-      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 }
     end
 
+    def page_items
+      @page_items ||= begin
+        page_number = active_scaffold_config.list.user.page
+        do_search if respond_to? :do_search, true
+        active_scaffold_config.list.user.page = page_number
+        @page = current_page
+        @page.items
+      end
+    end
+
     def scoped_query
       @scoped_query ||= begin
         do_search if respond_to? :do_search, true
@@ -190,7 +273,7 @@ module ActiveScaffold::Actions
             {:etag => active_scaffold_config.list.user.sorting.clause}
           end
         end
-      objects.present? ? objects : super
+      objects.presence || super
     end
 
     private

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
@@ -33,11 +35,11 @@ module ActiveScaffold::Actions
     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)&.id)
-        elsif nested.association.has_one?
-          active_scaffold_config.model.where(nested.child_association.name => nested_parent_record)
-        elsif nested.association.belongs_to?
-          nested_belongs_to_chain
-        else # never should get here
-          raise 'missing condition for nested beginning_of_chain'
-        end
+      # only if nested is related to current controller, e.g. not when adding record in subform inside subform
+      if nested? && nested.association && nested.association.klass == 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