active_scaffold 4.0.13 → 4.1.0

data/lib/active_scaffold/actions/core.rb

@@ -88,14 +88,13 @@ module ActiveScaffold::Actions
       @columns += [@column.name] if @column.options[:refresh_link] && @columns.exclude?(@column.name)
       process_render_field_params
 
-      @record =
+      @record = find_from_scope(setup_parent, @scope) if main_form_controller && @scope
+      @record ||=
         if @column.send_form_on_update_column
           updated_record_with_form(@main_columns, params[:record] || params[:search], @scope)
         else
           updated_record_with_column(@column, params.delete(:value), @scope)
         end
-      # if @scope has more than 2 ] then it's subform inside subform, and assign parent would fail (found associotion may be through association)
-      setup_parent(@record) if main_form_controller && @scope && @scope.scan(']').size == 2
       after_render_field(@record, @column)
     end
 
@@ -146,21 +145,15 @@ module ActiveScaffold::Actions
       "#{params[:parent_controller].camelize}Controller"
     end
 
-    def setup_parent(record)
+    def setup_parent
       cfg = main_form_controller.active_scaffold_config
-      association = cfg.columns[subform_child_association]&.association&.reverse_association
-      return if association.nil?
-
       parent_model = cfg.model
       parent = parent_model.new
       copy_attributes(find_if_allowed(params[:parent_id], :read, parent_model), parent) if params[:parent_id]
       parent.id = params[:parent_id]
       apply_constraints_to_record(parent) unless params[:parent_id]
-      parent = update_record_from_params(parent, cfg.send(params[:parent_id] ? :update : :create).columns, params[:record], true) if @column.send_form_on_update_column
-      if association.collection?
-        record.send(association.name) << parent
-      else
-        record.send(:"#{association.name}=", parent)
+      if @column.send_form_on_update_column
+        parent = update_record_from_params(parent, cfg.send(params[:parent_id] ? :update : :create).columns, params[:record], true)
       end
 
       if params[:nested] # form in nested scaffold, set nested parent_record to parent
@@ -172,6 +165,27 @@ module ActiveScaffold::Actions
       parent
     end
 
+    def find_from_scope(parent, scope)
+      parts = scope[1..-2].split('][')
+      record = parent
+
+      while parts.present?
+        part = parts.shift
+        return unless record.respond_to?(part)
+
+        association = record.class.reflect_on_association(part)
+        id = parts.shift.to_i if association&.collection?
+        record = record.send(part)
+        if id
+          record = record.find { |child| child.id == id }
+          record ||= @new_records&.dig(association.klass, id.to_s)
+        end
+        return if record.nil?
+      end
+
+      record
+    end
+
     def copy_attributes(orig, dst = nil)
       dst ||= orig.class.new
       orig.attributes.each { |attr, value| dst.send :write_attribute, attr, value }
@@ -203,8 +217,8 @@ module ActiveScaffold::Actions
       cookies[params[:_dl_cookie]] = {value: Time.now.to_i, expires: 1.day.since} if params[:_dl_cookie]
     end
 
-    def each_marked_record(&block)
-      active_scaffold_config.model.as_marked.each(&block)
+    def each_marked_record(&)
+      active_scaffold_config.model.as_marked.each(&)
     end
 
     def marked_records
@@ -276,6 +290,10 @@ module ActiveScaffold::Actions
       redirect_to options.is_a?(Hash) ? url_for(options) : options
     end
 
+    def filtered_query
+      beginning_of_chain
+    end
+
     # Overide this method on your controller to provide model with named scopes
     def beginning_of_chain
       active_scaffold_config.model
@@ -352,7 +370,7 @@ module ActiveScaffold::Actions
     end
 
     def get_row(crud_type_or_security_options = :read)
-      klass = beginning_of_chain
+      klass = filtered_query
       klass = klass.preload(active_scaffold_preload) unless active_scaffold_config.mongoid?
       @record = find_if_allowed(params[:id], crud_type_or_security_options, klass)
     end
@@ -369,7 +387,7 @@ module ActiveScaffold::Actions
     end
 
     def set_vary_accept_header
-      response.headers['Vary'] = 'Accept'
+      response.set_header 'vary', 'Accept'
     end
 
     def check_input_device

data/lib/active_scaffold/actions/field_search.rb

@@ -65,16 +65,22 @@ module ActiveScaffold::Actions
 
       def grouped_search_finder_options
         select_query = grouped_search_select
+        group_by = calculation_for_group_by(search_group_column&.group_by || [search_group_name], search_group_function)
+
         if search_group_function
-          group_sql = calculation_for_group_by(search_group_column&.field || search_group_name, search_group_function)
-          group_by = group_sql.to_sql
-          select_query += [group_sql.as(search_group_column.name.to_s)]
+          select_query += [group_by.as(search_group_name)]
+          group_by = group_by.to_sql
           order = grouped_sorting(group_by)
         else
-          group_by = quoted_select_columns(search_group_column&.select_columns || [search_group_name])
-          select_query += group_by
+          if search_group_column&.group_by
+            sql_with_names = search_group_column.group_by.map.with_index { |part, i| [part, "#{search_group_name}_#{i}"] }
+            select_query += quoted_select_columns(sql_with_names)
+          else
+            select_query += group_by
+          end
           order = grouped_sorting
         end
+
         {group: group_by, select: select_query, reorder: order}
       end
 
@@ -103,11 +109,13 @@ module ActiveScaffold::Actions
       end
 
       def calculation_for_group_search(column)
-        sql_function column.calculate.to_s, column.active_record_class.arel_table[column.name]
+        sql_function column.calculate.to_s, column.grouped_select
       end
 
       def calculation_for_group_by(group_sql, group_function)
-        group_sql = Arel::Nodes::SqlLiteral.new(group_sql)
+        return quoted_select_columns(group_sql) unless group_function
+
+        group_sql = Arel.sql(group_sql.join(', '))
         case group_function
         when 'year', 'month', 'quarter'
           extract_sql_fn(group_function, group_sql)
@@ -121,7 +129,7 @@ module ActiveScaffold::Actions
       end
 
       def extract_sql_fn(part, column)
-        sql_function('extract', sql_operator(Arel::Nodes::SqlLiteral.new(part), 'FROM', column))
+        sql_function('extract', sql_operator(Arel.sql(part), 'FROM', column))
       end
 
       def sql_function(function, *args)
@@ -206,11 +214,16 @@ module ActiveScaffold::Actions
       def setup_joins_for_filtered_columns(filtered_columns)
         if grouped_search? || active_scaffold_config.list.user.count_includes.present?
           active_scaffold_outer_joins.concat filtered_columns.map(&:search_joins).flatten.uniq.compact
+          active_scaffold_joins << search_group_column.search_joins if grouped_column_needs_joins?(filtered_columns)
         else
           set_outer_joins_for_search filtered_columns
         end
       end
 
+      def grouped_column_needs_joins?(filtered_columns)
+        grouped_search? && search_group_column&.search_joins.present? && filtered_columns.exclude?(search_group_column)
+      end
+
       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

@@ -215,7 +215,10 @@ module ActiveScaffold::Actions
     end
 
     def quoted_select_columns(columns)
-      columns&.map { |c| active_scaffold_config.columns[c]&.field || c }
+      columns&.map do |col, name|
+        sql_column = active_scaffold_config.columns[col]&.field || col
+        name ? Arel.sql(sql_column).as(name) : sql_column
+      end
     end
 
     def do_refresh_list
@@ -227,12 +230,12 @@ module ActiveScaffold::Actions
       do_list
     end
 
-    def each_record_in_page(&block)
-      page_items.each(&block)
+    def each_record_in_page(&)
+      page_items.each(&)
     end
 
-    def each_record_in_scope(&block)
-      scoped_query.each(&block)
+    def each_record_in_scope(&)
+      scoped_query.each(&)
     end
 
     def page_items
@@ -245,6 +248,38 @@ module ActiveScaffold::Actions
       end
     end
 
+    def filtered_query
+      apply_filters beginning_of_chain
+    end
+
+    def filters_enabled?
+      active_scaffold_config.list.filters.present? && params[:id].nil?
+    end
+
+    def apply_filters(query)
+      return query unless filters_enabled?
+
+      active_scaffold_config.list.refresh_with_header = true
+
+      active_scaffold_config.list.filters.inject(query) do |q, filter|
+        next q unless filter.security_method.nil? || send(filter.security_method)
+
+        default_option = filter[filter.default_option]
+        apply_filter q, params[filter.name] ? filter[params[filter.name]] : default_option, default_option
+      end
+    end
+
+    def apply_filter(query, filter_option, default_option)
+      return query if filter_option.nil? || (filter_option.security_method_set? && !send(filter_option.security_method))
+
+      @applied_filters ||= []
+      @applied_filters << filter_option unless filter_option == default_option
+      case filter_option.conditions
+      when Proc then instance_exec query, &filter_option.conditions
+      else query.where(filter_option.conditions)
+      end
+    end
+
     def scoped_query
       @scoped_query ||= begin
         do_search if respond_to? :do_search, true

data/lib/active_scaffold/actions/nested.rb

@@ -147,7 +147,7 @@ module ActiveScaffold::Actions::Nested
                                                     security_method: :delete_existing_authorized?,
                                                     ignore_method: :delete_existing_ignore?)
       end
-      config.action_links['destroy'].ignore_method = :habtm_delete_ignore? if config.actions.include?(:delete)
+      config.action_links['destroy']&.ignore_method = :habtm_delete_ignore? if config.actions.include?(:delete)
     end
 
     def new_existing

data/lib/active_scaffold/actions/subform.rb

@@ -26,7 +26,8 @@ module ActiveScaffold::Actions
       @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])
+                    @tab_id = params.delete(:value)
+                    assign_tabbed_by(blank_record, @column, params.delete(:tabbed_by), @tab_id, params.delete(:value_type))
                   end
                 end
     end

data/lib/active_scaffold/attribute_params.rb

@@ -195,13 +195,23 @@ module ActiveScaffold
         manage_nested_record_from_params(parent_record, column, value, avoid_changes)
       elsif column.association&.collection?
         # HACK: to be able to delete all associated records, hash will include "0" => ""
-        value.values.compact_blank
-          .filter_map { |val| manage_nested_record_from_params(parent_record, column, val, avoid_changes) }
+        value.compact_blank.filter_map do |id, attributes|
+          manage_nested_record_from_params(parent_record, column, attributes, avoid_changes).tap do |record|
+            track_new_record(record, id)
+          end
+        end
       else
         value
       end
     end
 
+    def track_new_record(record, id)
+      return unless record&.new_record?
+
+      @new_records ||= Hash.new { |h, k| h[k] = {} }
+      @new_records[record.class][id] = record
+    end
+
     def manage_nested_record_from_params(parent_record, column, attributes, avoid_changes = false)
       return nil unless build_record_from_params?(attributes, column, parent_record)
 

data/lib/active_scaffold/bridges/cancan/cancan_bridge.rb

@@ -23,7 +23,7 @@ module ActiveScaffold::Bridges
     # As already has callbacks to ensure authorization at controller method via "authorization_method"
     # but let's include this too, just in case, no sure how performance is affected tough :TODO benchmark
     module ClassMethods
-      def active_scaffold(model_id = nil, &block)
+      def active_scaffold(model_id = nil, &)
         super
         authorize_resource(
           class: active_scaffold_config.model,

data/lib/active_scaffold/bridges/paper_trail/helper.rb

@@ -3,7 +3,7 @@ module ActiveScaffold::Bridges
     module Helper
       def filter_action_links_for_deleted(action_links, record, options); end
 
-      def display_action_links(action_links, record, options, &block)
+      def display_action_links(action_links, record, options, &)
         if action_name == 'deleted'
           action_links = filter_action_links_for_deleted(action_links, record, options)
           return unless action_links

data/lib/active_scaffold/bridges/record_select/helpers.rb

@@ -15,7 +15,7 @@ class ActiveScaffold::Bridges::RecordSelect
         if column.association&.singular?
           multiple = ui_options.dig(:html_options, :multiple)
           html = active_scaffold_record_select(record, column, options, record.send(column.name), multiple, ui_options: ui_options)
-          html << active_scaffold_new_record_subform(column, record, options, ui_options: ui_options) if ui_options[:add_new]
+          html << active_scaffold_add_new(column, record, options, ui_options: ui_options) if ui_options[:add_new]
           html
         elsif column.association&.collection?
           active_scaffold_record_select(record, column, options, record.send(column.name), true, ui_options: ui_options)

data/lib/active_scaffold/config/core.rb

@@ -197,9 +197,13 @@ module ActiveScaffold::Config
     def _cache_lazy_values
       action_links.collection # ensure the collection group exist although it's empty
       action_links.member # ensure the collection group exist although it's empty
-      action_links.each(&:name_to_cache) if cache_action_link_urls
+      if cache_action_link_urls
+        action_links.each(&:name_to_cache)
+        list.filters.each { |filter| filter.each(&:name_to_cache) } if actions.include?(:list)
+      end
       columns.select(&:sortable?).each(&:sort)
       columns.select(&:searchable?).each(&:search_sql)
+      columns.each(&:field)
       actions.each do |action_name|
         action = send(action_name)
         Array(action.class.columns_collections).each { |method| action.send(method) }

data/lib/active_scaffold/config/list.rb

@@ -7,6 +7,7 @@ module ActiveScaffold::Config
       # inherit from global scope
       # full configuration path is: defaults => global table => local table
       @per_page = self.class.per_page
+      @filters = ActiveScaffold::DataStructures::Filters.new
       @page_links_inner_window = self.class.page_links_inner_window
       @page_links_outer_window = self.class.page_links_outer_window
 
@@ -20,7 +21,10 @@ module ActiveScaffold::Config
       @pagination = self.class.pagination
       @auto_pagination = self.class.auto_pagination
       @show_search_reset = self.class.show_search_reset
+      @show_filter_reset = self.class.show_filter_reset
+      @filter_human_message = self.class.filter_human_message
       @reset_link = self.class.reset_link.clone
+      @reset_filter_link = self.class.reset_filter_link.clone
       @wrap_tag = self.class.wrap_tag
       @always_show_search = self.class.always_show_search
       @always_show_create = self.class.always_show_create
@@ -77,10 +81,23 @@ module ActiveScaffold::Config
     cattr_accessor :show_search_reset, instance_accessor: false
     @@show_search_reset = true
 
+    # show a link to reset the filter next to filter human message
+    cattr_accessor :show_filter_reset, instance_accessor: false
+    @@show_filter_reset = true
+
+    # filter human message
+    # you may show the user a humanized applied filters, not the default ones
+    cattr_accessor :filter_human_message, instance_accessor: false
+    @@filter_human_message = false
+
     # the ActionLink to reset search
     cattr_reader :reset_link, instance_reader: false
     @@reset_link = ActiveScaffold::DataStructures::ActionLink.new('index', label: :click_to_reset, type: :collection, position: false, parameters: {search: ''})
 
+    # the ActionLink to reset the filters
+    cattr_reader :reset_filter_link, instance_reader: false
+    @@reset_filter_link = ActiveScaffold::DataStructures::ActionLink.new('index', label: :click_to_reset, type: :collection, position: false, dynamic_parameters: -> { clear_filters_params })
+
     # wrap normal cells (not inplace editable columns or with link) with a tag
     # it allows for more css styling
     cattr_accessor :wrap_tag, instance_accessor: false
@@ -103,6 +120,10 @@ module ActiveScaffold::Config
     cattr_accessor :calculate_etag, instance_accessor: false
     @@calculate_etag = false
 
+    def self.filters
+      ActiveScaffold::DataStructures::Filters
+    end
+
     # instance-level configuration
     # ----------------------------
 
@@ -143,9 +164,22 @@ module ActiveScaffold::Config
     # show a link to reset the search next to filtered message
     attr_accessor :show_search_reset
 
+    # show a link to reset the filter next to filter human message
+    attr_accessor :show_filter_reset
+
+    # filter human message
+    # you may show the user a humanized applied filters, not the default ones
+    attr_accessor :filter_human_message
+
     # the ActionLink to reset search
     attr_reader :reset_link
 
+    # the ActionLink to reset the filters
+    attr_reader :reset_filter_link
+
+    # the filters for this controller
+    attr_reader :filters
+
     # the default sorting.
     # should be a hash of {column_name => direction}, e.g. {a: 'desc', b: 'asc'}.
     # for backwards compatibility, it may be an array of hashes of {column_name => direction}, e.g. [{a: 'desc'}, {b: 'asc'}].
@@ -229,7 +263,7 @@ module ActiveScaffold::Config
       user_attr :page_links_inner_window, :page_links_outer_window, :refresh_with_header, :empty_field_text,
                 :association_join_text, :messages_above_header, :wrap_tag, :auto_select_columns, :calculate_etag,
                 :no_entries_message, :filtered_message, :show_search_reset, :always_show_create, :always_show_search,
-                :hide_nested_column, :pagination, :auto_pagination
+                :hide_nested_column, :pagination, :auto_pagination, :filter_human_message, :show_filter_reset
 
       def initialize(conf, storage, params)
         super(conf, storage, params, :list)

data/lib/active_scaffold/constraints.rb

@@ -87,7 +87,9 @@ module ActiveScaffold
           # regular column constraints
           elsif column.searchable? && params[column.name] != v
             active_scaffold_references.concat column.references if column.includes.present?
-            conditions << [column.search_sql.collect { |search_sql| "#{search_sql} = ?" }.join(' OR '), *([v] * column.search_sql.size)]
+            condition = column.search_sql.collect { |search_sql| "#{search_sql} = ?" }.join(' OR ')
+            condition = ([condition] * v.size).join(' OR ') if Array(v).many?
+            conditions << [condition, *(Array(v) * column.search_sql.size)]
           end
         # unknown-to-activescaffold-but-real-database-column constraint
         elsif active_scaffold_config._columns_hash[k.to_s] && params[column.name] != v
@@ -101,7 +103,7 @@ module ActiveScaffold
 
     def join_from_association_constraint(column)
       if column.association.habtm?
-        active_scaffold_habtm_joins.concat column.includes
+        active_scaffold_joins.concat column.includes
       elsif !column.association.polymorphic?
         if column.association.belongs_to?
           active_scaffold_preload.concat column.includes

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -40,11 +40,11 @@ module ActiveScaffold::DataStructures
     attr_accessor :collapsed
 
     # nests a subgroup in the column set
-    def add_subgroup(label, &proc)
+    def add_subgroup(label, &)
       columns = ActiveScaffold::DataStructures::ActionColumns.new
       columns.label = label
       columns.action = action
-      columns.configure(&proc)
+      columns.configure(&)
       exclude columns.collect_columns
       add columns
     end

data/lib/active_scaffold/data_structures/action_link.rb

@@ -95,10 +95,7 @@ module ActiveScaffold::DataStructures
     attr_accessor :image
 
     # if the action requires confirmation
-    def confirm=(value)
-      @dhtml_confirm = nil if value
-      @confirm = value
-    end
+    attr_writer :confirm
 
     def confirm(label = '')
       return @confirm if !confirm? || @confirm.is_a?(String)
@@ -110,16 +107,24 @@ module ActiveScaffold::DataStructures
       @confirm.present?
     end
 
-    # if the action uses a DHTML based (i.e. 2-phase) confirmation
-    attr_reader :dhtml_confirm
+    # if the action requires prompting a value, only for inline links
+    attr_writer :prompt
+
+    def prompt(label = '')
+      return @prompt if !prompt? || @prompt.is_a?(String)
 
-    def dhtml_confirm=(value)
-      @confirm = nil if value
-      @dhtml_confirm = value
+      ActiveScaffold::Registry.cache(:translations, @prompt) { as_(@prompt) } % {label: label}
     end
 
-    def dhtml_confirm?
-      @dhtml_confirm.present?
+    def prompt?
+      @prompt.present?
+    end
+
+    # if the prompt is required, empty value or cancel will prevent running the action
+    attr_writer :prompt_required
+
+    def prompt_required?
+      @prompt_required
     end
 
     # what method to call on the controller to see if this action_link should be visible

data/lib/active_scaffold/data_structures/action_links.rb

@@ -160,9 +160,9 @@ module ActiveScaffold::DataStructures
       end
     end
 
-    def method_missing(name, *args, &block)
+    def method_missing(name, *args, &)
       return super if name.match?(/[=!?]$/)
-      return subgroup(name.to_sym, args.first, &block) if frozen?
+      return subgroup(name.to_sym, args.first, &) if frozen?
 
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{name}(label = nil)                     # def group_name(label = nil)
@@ -171,7 +171,7 @@ module ActiveScaffold::DataStructures
           @#{name}                                   #   @group_name
         end                                          # end
       METHOD
-      send(name, args.first, &block)
+      send(name, args.first, &)
     end
 
     def respond_to_missing?(name, *)

data/lib/active_scaffold/data_structures/actions.rb

@@ -16,8 +16,8 @@ class ActiveScaffold::DataStructures::Actions
   end
   alias << add
 
-  def each(&block)
-    @set.each(&block)
+  def each(&)
+    @set.each(&)
   end
 
   def include?(val)

data/lib/active_scaffold/data_structures/column.rb

@@ -44,6 +44,9 @@ module ActiveScaffold::DataStructures
         # send all the form instead of only new value when this column changes
         attr_accessor :send_form_on_update_column
 
+        # disable the form while the request to refresh other columns is sent
+        attr_accessor :disable_on_update_column
+
         # add a custom attr_accessor that can contain a Proc (or boolean or symbol)
         # that will be called when the column renders, such that we can dynamically
         # hide or show the column with an element that can be replaced by
@@ -57,6 +60,9 @@ module ActiveScaffold::DataStructures
         # config.columns[:my_column].hide_form_column_if = :hide_tractor_fields?
         attr_accessor :hide_form_column_if
 
+        # text to display when the column is empty, defaults nil, so list.empty_field_text is used
+        attr_accessor :empty_field_text
+
         # a collection of columns to load from the association when eager loading is disabled, if it's nil all columns will be loaded
         attr_accessor :select_associated_columns
 
@@ -480,6 +486,7 @@ module ActiveScaffold::DataStructures
       if @column.nil? && active_record? && active_record_class._default_attributes.key?(name.to_s)
         @column = active_record_class._default_attributes[name.to_s]
       end
+      @disable_on_update_column = true
       @db_default_value = ActiveScaffold::OrmChecks.default_value active_record_class, name if @column
       @delegated_association = delegated_association
       @cache_key = [@active_record_class.name, name].compact.map(&:to_s).join('#')
@@ -551,6 +558,20 @@ module ActiveScaffold::DataStructures
       @field ||= quoted_field(field_name)
     end
 
+    def group_by=(value)
+      @group_by = value ? Array(value) : nil
+    end
+
+    def group_by
+      @group_by || select_columns || [field]
+    end
+
+    attr_writer :grouped_select
+
+    def grouped_select
+      Arel.sql(@grouped_select&.to_s || field)
+    end
+
     def quoted_foreign_type
       quoted_field(quoted_field_name(association.foreign_type))
     end

data/lib/active_scaffold/data_structures/columns.rb

@@ -78,8 +78,8 @@ module ActiveScaffold::DataStructures
     end
     alias [] find_by_name
 
-    def each(&block)
-      @set.each_value(&block)
+    def each(&)
+      @set.each_value(&)
     end
 
     def _inheritable