active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/actions/create.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Create
     def self.included(base)
-      base.before_filter :create_authorized_filter, :only => [:new, :create]
+      base.before_action :create_authorized_filter, :only => %i[new create]
     end
 
     def new

data/lib/active_scaffold/actions/delete.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Delete
     def self.included(base)
-      base.before_filter :delete_authorized_filter, :only => [:destroy]
+      base.before_action :delete_authorized_filter, :only => [:destroy]
     end
 
     def destroy
@@ -14,7 +14,7 @@ module ActiveScaffold::Actions
     protected
 
     def destroy_respond_to_html
-      flash[:info] = as_(:deleted_model, :model => ERB::Util.h(@record.to_label)) if self.successful?
+      flash[:info] = as_(:deleted_model, :model => ERB::Util.h(@record.to_label)) if successful?
       return_to_main
     end
 
@@ -41,29 +41,32 @@ module ActiveScaffold::Actions
       record ||= destroy_find_record
       begin
         self.successful = record.destroy
-      rescue StandardError => ex
+      rescue StandardError => exception
         flash[:warning] = as_(:cant_destroy_record, :record => ERB::Util.h(record.to_label))
         self.successful = false
-        logger.debug ex.message
-        logger.debug ex.backtrace.join("\n")
+        logger.warn do
+          "\n\n#{exception.class} (#{exception.message}):\n    " +
+            Rails.backtrace_cleaner.clean(exception.backtrace).join("\n    ") +
+            "\n\n"
+        end
       end
     end
 
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def delete_authorized?(record = nil)
-      (!nested? || !nested.readonly?) && (record || self).authorized_for?(:crud_type => :delete)
+      (!nested? || !nested.readonly?) && (record || self).authorized_for?(crud_type: :delete, reason: true)
     end
 
     def delete_ignore?(record = nil)
-      (nested? && nested.readonly?) || !self.authorized_for?(:crud_type => :delete)
+      (nested? && nested.readonly?) || !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 send(link.security_method)
+      raise ActiveScaffold::ActionNotAllowed unless Array(send(link.security_method))[0]
     end
 
     def destroy_formats

data/lib/active_scaffold/actions/field_search.rb

@@ -1,9 +1,11 @@
 module ActiveScaffold::Actions
   module FieldSearch
     def self.included(base)
-      base.helper_method :field_search_params
-      base.send :include, ActiveScaffold::Actions::CommonSearch
-      base.send :include, InstanceMethods
+      base.class_eval do
+        helper_method :field_search_params, :grouped_search?, :search_group_column, :search_group_function
+        include ActiveScaffold::Actions::CommonSearch
+        include InstanceMethods
+      end
     end
 
     module InstanceMethods
@@ -30,6 +32,102 @@ module ActiveScaffold::Actions
         params[:search] = default_params.is_a?(Proc) ? instance_eval(&default_params) : default_params
       end
 
+      def grouped_search?
+        field_search_params.present? && field_search_params['active_scaffold_group'].present?
+      end
+
+      def setup_search_group
+        @_search_group_name, @_search_group_function = field_search_params['active_scaffold_group'].to_s.split('#')
+      end
+
+      def search_group_function
+        setup_search_group unless defined? @_search_group_function
+        @_search_group_function
+      end
+
+      def search_group_name
+        setup_search_group unless defined? @_search_group_name
+        @_search_group_name
+      end
+
+      def search_group_column
+        active_scaffold_config.columns[search_group_name] if search_group_name
+      end
+
+      def custom_finder_options
+        if grouped_search?
+          group_sql = calculation_for_group_by(search_group_column.try(: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.try(:select_columns))
+          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}
+        else
+          super
+        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)
+        end
+      end
+
+      def calculation_for_group_search(column)
+        sql_function column.calculate.to_s, column.active_record_class.arel_table[column.name]
+      end
+
+      def calculation_for_group_by(group_sql)
+        return group_sql unless search_group_function
+        group_sql = Arel::Nodes::SqlLiteral.new(group_sql)
+        case search_group_function
+        when 'year', 'month', 'quarter'
+          sql_function(search_group_function, group_sql)
+        when 'year_month'
+          sql_function('extract', sql_operator(Arel::Nodes::SqlLiteral.new('YEAR_MONTH'), 'FROM', group_sql))
+        when 'year_quarter'
+          sql_operator(sql_operator(sql_function('year', group_sql), '*', 10), '+', sql_function('quarter', group_sql))
+        else
+          raise "#{search_group_function} unsupported, override calculation_for_group_by in #{self.class.name}"
+        end
+      end
+
+      def sql_function(function, *args)
+        args.map! { |arg| quoted_arel_value(arg) }
+        Arel::Nodes::NamedFunction.new(function, args)
+      end
+
+      def sql_operator(arg1, operator, arg2)
+        Arel::Nodes::InfixOperation.new(operator, quoted_arel_value(arg1), quoted_arel_value(arg2))
+      end
+
+      def quoted_arel_value(value)
+        value.is_a?(Arel::Predications) ? value : Arel::Nodes::Quoted.new(value)
+      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
+      end
+
+      def grouped_columns
+        return if active_scaffold_config.field_search.grouped_columns.blank?
+        active_scaffold_config.field_search.grouped_columns.map do |col|
+          active_scaffold_config.columns[col]
+        end.compact
+      end
+
       def field_search_params
         search_params.is_a?(Hash) ? search_params : {}
       end
@@ -43,7 +141,7 @@ module ActiveScaffold::Actions
       end
 
       def do_search
-        if search_params.is_a?(Hash) && search_params.present?
+        if field_search_params.present?
           filtered_columns = []
           text_search = active_scaffold_config.field_search.text_search
           columns = active_scaffold_config.field_search.columns
@@ -54,7 +152,7 @@ module ActiveScaffold::Actions
             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)
+            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
@@ -62,7 +160,7 @@ module ActiveScaffold::Actions
             active_scaffold_conditions << search_condition
             filtered_columns << column
           end
-          unless filtered_columns.blank?
+          if filtered_columns.present? || grouped_search?
             @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
           end
 

data/lib/active_scaffold/actions/list.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module List
     def self.included(base)
-      base.before_filter :list_authorized_filter, :only => :index
+      base.before_action :list_authorized_filter, :only => :index
       base.helper_method :list_columns
     end
 
@@ -22,7 +22,7 @@ module ActiveScaffold::Actions
     end
 
     def list
-      if %w(index list).include? action_name
+      if %w[index list].include? action_name
         do_list
       else
         do_refresh_list
@@ -43,6 +43,7 @@ module ActiveScaffold::Actions
         render(:partial => 'list_with_header')
       else
         @auto_pagination = params[:auto_pagination]
+        @popstate = params.delete(:_popstate)
         render :partial => 'refresh_list', :formats => [:js]
       end
     end
@@ -73,21 +74,20 @@ module ActiveScaffold::Actions
           active_scaffold_config.send(action).columns.collect_visible(:flatten => true)
         end
       joins_cols, preload_cols = columns.select { |c| c.includes.present? }.partition do |col|
-        includes_need_join?(col, sorting)
+        includes_need_join?(col, sorting) && !grouped_search?
       end
       active_scaffold_references.concat joins_cols.map(&:includes).flatten.uniq
       active_scaffold_preload.concat preload_cols.map(&:includes).flatten.uniq
-      set_includes_for_sorting(columns, sorting) if Rails::VERSION::MAJOR >= 4 && sorting.sorts_by_sql?
+      set_includes_for_sorting(columns, sorting) if sorting.sorts_by_sql?
     end
 
     def set_includes_for_sorting(columns, sorting)
       sorting.each do |col, _|
-        if col.includes.present? && !columns.include?(col)
-          if active_scaffold_config.model.connection.needs_order_expressions_in_select?
-            active_scaffold_references << col.includes
-          else
-            active_scaffold_outer_joins << col.includes
-          end
+        next unless col.includes.present? && !columns.include?(col)
+        if active_scaffold_config.model.connection.needs_order_expressions_in_select?
+          active_scaffold_references << col.includes
+        else
+          active_scaffold_outer_joins << col.includes
         end
       end
     end
@@ -97,8 +97,8 @@ module ActiveScaffold::Actions
     end
 
     def scoped_habtm?(column)
-      assoc = column.association if column.plural_association?
-      assoc && assoc.macro == :has_and_belongs_to_many && assoc.respond_to?(:scope) && assoc.scope
+      assoc = column.association if column.association.try :collection?
+      assoc && assoc.habtm? && assoc.scope
     end
 
     def get_row(crud_type_or_security_options = :read)
@@ -108,17 +108,18 @@ module ActiveScaffold::Actions
 
     # 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
 
       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.merge!(
-          :per_page => active_scaffold_config.list.user.per_page,
-          :page => active_scaffold_config.list.user.page
-        )
+        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]]
@@ -140,7 +141,10 @@ module ActiveScaffold::Actions
 
     def do_refresh_list
       params.delete(:id)
-      do_search if respond_to? :do_search, true
+      if respond_to? :do_search, true
+        store_search_params_into_session if search_params.blank?
+        do_search
+      end
       do_list
     end
 
@@ -172,7 +176,7 @@ module ActiveScaffold::Actions
     end
 
     def action_update_respond_to_js
-      do_refresh_list unless @record.present?
+      do_refresh_list if @record.blank?
       super
     end
 
@@ -197,10 +201,10 @@ module ActiveScaffold::Actions
     def list_formats
       (default_formats + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
     end
-    alias_method :index_formats, :list_formats
+    alias index_formats list_formats
 
     def row_formats
-      ([:html, :js] + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
+      (%i[html js] + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
     end
 
     def action_update_formats

data/lib/active_scaffold/actions/mark.rb

@@ -1,8 +1,8 @@
 module ActiveScaffold::Actions
   module Mark
     def self.included(base)
-      base.before_filter :mark_authorized?, :only => :mark
-      base.before_filter :assign_marked_records_to_model
+      base.before_action :mark_authorized_filter, :only => :mark
+      base.before_action :assign_marked_records_to_model
       base.helper_method :marked_records
     end
 
@@ -45,7 +45,11 @@ module ActiveScaffold::Actions
     end
 
     def mark?
-      @mark ||= [true, 'true', 1, '1', 'T', 't'].include?(params[:value].class == String ? params[:value].downcase : params[:value])
+      @mark ||= begin
+        value = params.delete :value
+        value.downcase! if value.is_a? String
+        [true, 'true', 1, '1', 't'].include? value
+      end
     end
 
     def mark_all_scope_forced?
@@ -80,7 +84,11 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def mark_authorized?
-      authorized_for?(:crud_type => :read)
+      authorized_for?(crud_type: :read)
+    end
+
+    def mark_authorized_filter
+      raise ActiveScaffold::ActionNotAllowed unless mark_authorized?
     end
 
     def mark_formats

data/lib/active_scaffold/actions/nested.rb

@@ -4,11 +4,11 @@ module ActiveScaffold::Actions
     def self.included(base)
       super
       base.module_eval do
-        before_filter :set_nested
-        before_filter :configure_nested
+        before_action :set_nested
+        before_action :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 }
       end
-      base.before_filter :include_habtm_actions
+      base.before_action :include_habtm_actions
       base.helper_method :nested
       base.helper_method :nested_parent_record
     end
@@ -25,6 +25,7 @@ module ActiveScaffold::Actions
     end
 
     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?
@@ -33,7 +34,10 @@ module ActiveScaffold::Actions
     def configure_nested
       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
+      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
     end
 
     def nested_label
@@ -44,8 +48,8 @@ module ActiveScaffold::Actions
       end
     end
 
-    def nested_default_sorting
-      {:table_name => active_scaffold_config.model.model_name, :default_sorting => nested.default_sorting}
+    def nested_default_sorting(chain)
+      {:table_name => active_scaffold_config._table_name, :default_sorting => nested.default_sorting(chain)}
     end
 
     def nested_authorized?(record = nil)
@@ -59,7 +63,7 @@ module ActiveScaffold::Actions
         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']
+            active_scaffold_config.action_links.delete('destroy') if active_scaffold_config.action_links['destroy']
           end
         end
       else
@@ -69,7 +73,7 @@ module ActiveScaffold::Actions
         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['delete']
+            active_scaffold_config.action_links.add(active_scaffold_config.delete.link) unless active_scaffold_config.action_links['destroy']
           end
         end
       end
@@ -79,22 +83,14 @@ module ActiveScaffold::Actions
       if nested? && nested.association
         if nested.association.collection?
           nested_parent_record.send(nested.association.name)
-        elsif nested.association.options[:through] # has_one :through
+        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.child_association.nil? # without child_association is not possible to add conditions
-          active_scaffold_config.model
-        elsif nested.child_association.belongs_to?
+        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?
-          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, [])
-              join_associations = Rails.version >= '4.1.0' ? dependency.join_root.children : dependency.join_associations
-              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)
+          nested_belongs_to_chain
+        else # never should get here
+          active_scaffold_config.model
         end
       elsif nested? && nested.scope
         nested_parent_record.send(nested.scope)
@@ -103,6 +99,11 @@ 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))
+    end
+
     def nested_parent_record(crud = :read)
       @nested_parent_record ||= find_if_allowed(nested.parent_id, crud, nested.parent_model)
     end
@@ -111,11 +112,10 @@ module ActiveScaffold::Actions
       # 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
+      if nested.child_association.singular?
         record.send("#{nested.child_association.name}=", parent)
-      when :has_many, :has_and_belongs_to_many
-        record.send("#{nested.child_association.name}").send(:<<, parent)
+      else
+        record.send(nested.child_association.name) << parent
       end
     end
 
@@ -210,7 +210,7 @@ module ActiveScaffold::Actions::Nested
     end
 
     def delete_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), :reason => true)
     end
 
     def after_create_save(record)