mensa 0.6.13 → 0.6.14

data/app/components/mensa/group_header/component_controller.js

@@ -0,0 +1,63 @@
+import ApplicationController from "mensa/controllers/application_controller";
+
+// Collapses and expands groups in a grouped table. Collapsed groups are
+// remembered per table and group column.
+export default class GroupsController extends ApplicationController {
+    static targets = ["header", "row"];
+    static values = { storageKey: String };
+
+    connect() {
+        super.connect();
+        this.collapsed = new Set(this._load());
+        this._apply();
+    }
+
+    toggle(event) {
+        const key = event.currentTarget.dataset.groupKey;
+        if (this.collapsed.has(key)) {
+            this.collapsed.delete(key);
+        } else {
+            this.collapsed.add(key);
+        }
+        this._save();
+        this._apply();
+    }
+
+    _apply() {
+        this.headerTargets.forEach((header) => {
+            header.setAttribute(
+                "aria-expanded",
+                (!this.collapsed.has(header.dataset.groupKey)).toString(),
+            );
+        });
+        this.rowTargets.forEach((row) => {
+            row.classList.toggle(
+                "hidden",
+                this.collapsed.has(row.dataset.groupKey),
+            );
+        });
+    }
+
+    _load() {
+        try {
+            return JSON.parse(
+                window.localStorage.getItem(this.storageKeyValue) || "[]",
+            );
+        } catch (e) {
+            return [];
+        }
+    }
+
+    _save() {
+        try {
+            if (this.collapsed.size > 0) {
+                window.localStorage.setItem(
+                    this.storageKeyValue,
+                    JSON.stringify([...this.collapsed]),
+                );
+            } else {
+                window.localStorage.removeItem(this.storageKeyValue);
+            }
+        } catch (e) {}
+    }
+}

data/app/components/mensa/table/component_controller.js

@@ -262,6 +262,8 @@ export default class TableComponentController extends ApplicationController {
                 order: state.order,
                 column_order: state.column_order,
                 hidden_columns: state.hidden_columns,
+                group_by: state.group_by,
+                aggregates: state.aggregates,
                 turbo_frame_id: this.hasTurboFrameTarget
                     ? this.turboFrameTarget.id
                     : null,
@@ -323,6 +325,8 @@ export default class TableComponentController extends ApplicationController {
                 order: state.order,
                 column_order: state.column_order,
                 hidden_columns: state.hidden_columns,
+                group_by: state.group_by,
+                aggregates: state.aggregates,
                 turbo_frame_id: this.hasTurboFrameTarget
                     ? this.turboFrameTarget.id
                     : null,
@@ -357,10 +361,34 @@ export default class TableComponentController extends ApplicationController {
             order: outlet.loadOrder(),
             column_order: outlet.loadColumnOrder(),
             hidden_columns: outlet.loadHiddenColumns(),
+            group_by: this.groupState?.group_by ?? "",
+            aggregates: this.groupState?.aggregates ?? {},
         };
     }
 
-    viewTargetConnected() {}
+    // The rendered view carries the grouping the server applied, keep the
+    // group-by popover in sync with it (e.g. after selecting a view).
+    viewTargetConnected(element) {
+        let aggregates = {};
+        try {
+            aggregates = JSON.parse(element.dataset.aggregates || "{}");
+        } catch (e) {}
+        this.groupState = {
+            group_by: element.dataset.groupBy || "",
+            aggregates,
+        };
+
+        const groupByElement = this.element.querySelector(
+            '[data-controller~="mensa-group-by"]',
+        );
+        const groupBy =
+            groupByElement &&
+            this.application.getControllerForElementAndIdentifier(
+                groupByElement,
+                "mensa-group-by",
+            );
+        if (groupBy) groupBy.sync(this.groupState.group_by, aggregates);
+    }
 
     filterListTargetConnected(element) {
         // The filter bar is always visible in the new design — nothing to toggle.
@@ -575,6 +603,7 @@ export default class TableComponentController extends ApplicationController {
                 order: state.order,
                 column_order: state.column_order,
                 hidden_columns: state.hidden_columns,
+                group_by: state.group_by,
             }),
             contentType: "application/json",
             responseKind: "turbo-stream",

data/app/components/mensa/table_row/component.html.erb

@@ -1,4 +1,4 @@
-<%= content_tag :tr, **row.link_attributes do %>
+<%= content_tag :tr, **row_attributes do %>
   <% if table.batch_actions? %>
     <td class="mensa-table__checkbox-col" data-action="click->mensa-selection#stopPropagation">
       <input class="mensa-table__select-all" type="checkbox" value="<%= row.record.id %>" data-action="change->mensa-selection#toggleRow" data-mensa-selection-target="rowCheckbox">

data/app/components/mensa/table_row/component.rb

@@ -9,10 +9,18 @@ module Mensa
 
       attr_reader :table
       attr_reader :row
+      attr_reader :group
 
-      def initialize(table:, row:)
+      def initialize(table:, row:, group: nil)
         @table = table
         @row = row
+        @group = group
+      end
+
+      def row_attributes
+        return row.link_attributes unless group
+
+        row.link_attributes.deep_merge(data: {mensa_groups_target: "row", group_key: group.key})
       end
     end
   end

data/app/components/mensa/view/component.html.erb

@@ -1,4 +1,6 @@
-<div data-mensa-table-target="view">
+<div data-mensa-table-target="view"
+     data-group-by="<%= table.group_column&.name %>"
+     data-aggregates="<%= table.current_aggregates.to_json %>">
   <div class="overflow-y-auto relative"
        data-mensa-table-target="scrollContainer"
        data-controller="mensa-selection"
@@ -16,7 +18,11 @@
         </div>
       </div>
     <% end %>
-    <table class="w-full">
+    <table class="w-full"
+           <% if table.grouped? %>
+             data-controller="mensa-groups"
+             data-mensa-groups-storage-key-value="<%= "mensa:collapsed_groups:#{table.storage_key}:#{table.group_column.name}" %>"
+           <% end %>>
       <% if table.show_header? %>
         <thead>
           <tr>
@@ -38,7 +44,15 @@
         </thead>
       <% end %>
       <tbody>
-        <%= render(Mensa::TableRow::Component.with_collection(table.rows, table: table)) %>
+        <% if table.grouped? %>
+          <% table.rows.chunk_while { |a, b| a.group_value == b.group_value }.each do |rows| %>
+            <% group = table.group_for(rows.first) %>
+            <%= render Mensa::GroupHeader::Component.new(table: table, group: group) %>
+            <%= render(Mensa::TableRow::Component.with_collection(rows, table: table, group: group)) %>
+          <% end %>
+        <% else %>
+          <%= render(Mensa::TableRow::Component.with_collection(table.rows, table: table)) %>
+        <% end %>
       </tbody>
     </table>
     <% if table.pagy_details&.count == 0 %>

data/app/controllers/mensa/tables/exports_controller.rb

@@ -128,6 +128,7 @@ module Mensa
           :query,
           :page,
           :table_view_id,
+          :group_by,
           order: {},
           filters: {},
           column_order: [],

data/app/controllers/mensa/tables/views_controller.rb

@@ -95,7 +95,7 @@ module Mensa
       # show (query, ordering and filters), so a saved view can be replayed by
       # merging this hash back into the request params.
       def view_config
-        config = params.permit(:query, order: {}, column_order: [], hidden_columns: []).to_h
+        config = params.permit(:query, :group_by, order: {}, column_order: [], hidden_columns: [], aggregates: {}).to_h
         config[:filters] = params[:filters]&.to_unsafe_h || {}
         config
       end

data/app/controllers/mensa/tables_controller.rb

@@ -2,8 +2,10 @@ module Mensa
   class TablesController < ApplicationController
     def show
       filters_provided = params.key?(:filters)
-      config = params.permit(:format, :query, :id, :page, :table_view_id, :turbo_frame_id, order: {}, column_order: [], hidden_columns: [], params: {}, filters: {}).to_h
+      config = params.permit(:format, :query, :id, :page, :table_view_id, :turbo_frame_id, :group_by, order: {}, column_order: [], hidden_columns: [], params: {}, filters: {}, aggregates: {}).to_h
       config[:filters] = {} if filters_provided && !config.key?(:filters)
+      # aggregates= (blank) means none, also when the view has some
+      config[:aggregates] = {} if params.key?(:aggregates) && !config.key?(:aggregates)
 
       @table = Mensa.for_name(params[:id], config)
 

data/app/javascript/mensa/controllers/index.js

@@ -30,6 +30,12 @@ application.register("mensa-selection", SelectionComponentController);
 import ColumnCustomizerController from "mensa/components/column_customizer/component_controller";
 application.register("mensa-column-customizer", ColumnCustomizerController);
 
+import GroupByComponentController from "mensa/components/group_by/component_controller";
+application.register("mensa-group-by", GroupByComponentController);
+
+import GroupHeaderComponentController from "mensa/components/group_header/component_controller";
+application.register("mensa-groups", GroupHeaderComponentController);
+
 import CopyableComponentController from "mensa/components/copyable/component_controller";
 application.register("mensa-copyable", CopyableComponentController);
 

data/app/tables/mensa/base.rb

@@ -147,7 +147,9 @@ module Mensa
         table_view_id: table_view_id,
         page: page,
         column_order: column_order,
-        hidden_columns: hidden_columns
+        hidden_columns: hidden_columns,
+        group_by: group_by_param,
+        aggregates: aggregates_param
       }.compact.to_query
 
       query.present? ? "#{path}?#{query}" : path
@@ -237,10 +239,21 @@ module Mensa
       context[:table_view_id] = current_table_view_id if config.key?(:table_view_id) && !current_table_view_id.nil?
       context[:column_order] = current_column_order if config.key?(:column_order) && !current_column_order.nil?
       context[:hidden_columns] = current_hidden_columns if config.key?(:hidden_columns) && !current_hidden_columns.nil?
+      context[:group_by] = current_group_by if grouped?
 
       context
     end
 
+    # Grouping in a URL, blank means "explicitly not grouped" so it overrides
+    # the view's default
+    def group_by_param
+      current_group_by.to_s unless config[:group_by].nil?
+    end
+
+    def aggregates_param
+      current_aggregates.presence || ("" unless config[:aggregates].nil?)
+    end
+
     private
 
     def ensure_internal_columns_for_joined_associations

data/app/tables/mensa/cell.rb

@@ -10,16 +10,45 @@ module Mensa
 
     attr_reader :column, :row
 
-    def initialize(row:, column:)
+    # Pass a value to format one that doesn't come from a row, e.g. a group's
+    def initialize(row:, column:, value: nil)
       @row = row
       @column = column
+      @value = value
+      @value_given = row.nil?
     end
 
     def value
-      @value ||= row.value(column)
+      return @value if @value_given
+
+      @value_given = true
+      @value = row.value(column)
+    end
+
+    # The value in the given format, without custom render blocks or a <td>
+    def formatted(format = :html)
+      send(:"to_#{format}")
     end
 
+    # Renders the cell's content in the given format. The :html format
+    # includes the surrounding <td>; when a custom html render block returns
+    # its own td (e.g. content_tag(:td, ..., class: ...)), that one is used.
     def render(format)
+      content = render_content(format)
+      return content unless format.to_sym == :html
+      return content if td?(content)
+
+      content_tag(:td, content)
+    end
+
+    private
+
+    # Only HTML-safe output counts, so plain strings are still escaped.
+    def td?(content)
+      content.html_safe? && content.to_s.lstrip.match?(/\A<td[\s>]/i)
+    end
+
+    def render_content(format)
       proc = column.config.dig(:render, format.to_sym)
       if proc
         row.table.original_view_context.instance_exec(row.record, &proc)
@@ -28,8 +57,6 @@ module Mensa
       end
     end
 
-    private
-
     def to_html
       case value
       when NilClass

data/app/tables/mensa/column.rb

@@ -21,6 +21,8 @@ module Mensa
     config_reader :method # When a method needs to be called on the model, slow!
     config_reader :format
 
+    AGGREGATE_FUNCTIONS = %i[count sum min max].freeze
+
     def sort_direction
       value = table.config.dig(:order, name)
       value.presence&.to_sym
@@ -78,6 +80,22 @@ module Mensa
       end
     end
 
+    # Grouping and aggregating happen in SQL, so the column needs an attribute
+    def groupable?
+      config[:groupable] == true && attribute_for_condition.present?
+    end
+
+    # The aggregate functions the user can choose for this column
+    def aggregates
+      return [] if attribute_for_condition.blank?
+
+      Array(config[:aggregates]).map(&:to_sym) & AGGREGATE_FUNCTIONS
+    end
+
+    def aggregatable?
+      aggregates.any?
+    end
+
     # Returns true if the column supports filtering
     def filter?
       config[:filter] != false

data/app/tables/mensa/config/column_dsl.rb

@@ -19,7 +19,17 @@ module Mensa::Config
     option :format, default: :long, dsl_single_hash: Mensa::Config::FormatDsl, name_attribute: :format
 
     option :visible, default: true
+    # Allows the user to group the table by this column (needs an SQL attribute)
+    option :groupable, default: false
+    # Aggregates the user can choose for this column in grouped tables,
+    # any of :count, :sum, :min and :max
+    option :aggregates, default: []
     option :render, dsl: Mensa::Config::RenderDsl
     option :filter, dsl: Mensa::Config::FilterDsl
+
+    #   aggregates :sum, :min, :max
+    def aggregates(*functions)
+      config[:aggregates] = functions.flatten.map(&:to_sym)
+    end
   end
 end

data/app/tables/mensa/config/table_dsl.rb

@@ -67,6 +67,11 @@ module Mensa::Config
     # Order of columns in the table
     option :column_order
 
+    # Group rows by this column, e.g. `group_by :status`
+    option :group_by
+    # Aggregates shown per group, e.g. `aggregates market_cap: :sum`
+    option :aggregates
+
     # Actions
     option :action, dsl_hash: Mensa::Config::ActionDsl
 

data/app/tables/mensa/config/view_dsl.rb

@@ -7,5 +7,7 @@ module Mensa::Config
     option :filter, dsl_hash: Mensa::Config::FilterDsl
     option :column_order
     option :hidden_columns
+    option :group_by
+    option :aggregates
   end
 end

data/app/tables/mensa/filter.rb

@@ -84,6 +84,9 @@ module Mensa
       else
         return apply_duplicate_filter(record_scope) if operator == :is_duplicate
 
+        # Nothing selected in a multi-select means no filter
+        return record_scope if value.is_a?(Array) && value.compact_blank.empty?
+
         query, hash = query_and_hash_for_operator
         record_scope = (column.filter.having? ? record_scope.having(query, hash) : record_scope.where(query, hash)) if query.present?
         record_scope
@@ -106,33 +109,33 @@ module Mensa
 
     # Used in the where clause
     def query_and_hash_for_operator
-      hash = {column: column.attribute_for_condition, value: normalize(value)}
+      col = "(#{column.attribute_for_condition})"
+      hash = {value: normalize(value)}
+      hash[:value] = hash[:value].compact_blank if hash[:value].is_a?(Array)
 
       query = case operator
       when :is_empty
-        (column.type == :string) ? ":column IS NULL OR :column = ''" : ":column IS NULL"
+        (column.type == :string) ? "#{col} IS NULL OR #{col} = ''" : "#{col} IS NULL"
       when :isnt_empty
-        (column.type == :string) ? ":column IS NOT NULL AND :column != ''" : ":column IS NOT NULL"
+        (column.type == :string) ? "#{col} IS NOT NULL AND #{col} != ''" : "#{col} IS NOT NULL"
       when :is_current
-        ":column = :value"
+        "#{col} = :value"
       when :matches
-        ":column LIKE :value"
+        "#{col} LIKE :value"
       when :does_not_match
-        ":column NOT LIKE :value"
+        "#{col} NOT LIKE :value"
       when :is
-        hash[:value] = value if hash[:value].is_a?(Array)
-        ":column = :value"
+        hash[:value].is_a?(Array) ? "#{col} IN (:value)" : "#{col} = :value"
       when :isnt
-        hash[:value] = value if hash[:value].is_a?(Array)
-        ":column != :value"
+        hash[:value].is_a?(Array) ? "#{col} NOT IN (:value)" : "#{col} != :value"
       when :gt
-        ":column > :value"
+        "#{col} > :value"
       when :lt
-        ":column < :value"
+        "#{col} < :value"
       when :gteq
-        ":column >= :value"
+        "#{col} >= :value"
       when :lteq
-        ":column <= :value"
+        "#{col} <= :value"
       else
         raise ArgumentError, "Unknown filter operator #{operator.inspect} for column :#{column.name}"
       end

data/app/tables/mensa/group.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Mensa
+  # A group of rows in a grouped table, see Mensa::Grouping
+  class Group
+    attr_reader :table, :value, :count, :aggregates
+
+    def initialize(table:, value:, count: nil, aggregates: {})
+      @table = table
+      @value = value
+      @count = count
+      @aggregates = aggregates
+    end
+
+    def column
+      table.group_column
+    end
+
+    # Stable identifier for the group, used to remember collapsed groups
+    def key
+      value.nil? ? "none" : Digest::SHA256.hexdigest(value.to_s)[0, 12]
+    end
+
+    def title
+      return I18n.t("mensa.groups.empty", column: column.human_name) if value.nil? || value == ""
+
+      Mensa::Cell.new(row: nil, column: column, value: value).formatted
+    end
+
+    # The aggregate for a column, formatted for display, nil when there is none
+    def aggregate(column)
+      return unless aggregates.key?(column.name)
+
+      value = aggregates[column.name]
+      return ActiveSupport::NumberHelper.number_to_delimited(value) if value.is_a?(Numeric)
+
+      Mensa::Cell.new(row: nil, column: column, value: value).formatted
+    end
+
+    def aggregate_label(column)
+      function = table.current_aggregates[column.name]
+      I18n.t("mensa.aggregates.#{function}") if function
+    end
+  end
+end

data/app/tables/mensa/grouping.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Mensa
+  # Shows rows in groups: rows are sorted by the group column and every group
+  # gets a header with its row count and the chosen aggregates. Counts and
+  # aggregates are calculated with SQL GROUP BY over all filtered rows, not
+  # just the current page.
+  module Grouping
+    extend ActiveSupport::Concern
+
+    GROUP_VALUE_ALIAS = "mensa_group_value"
+
+    # The column the rows are grouped by, nil when not grouped
+    def group_column
+      return @group_column if defined?(@group_column)
+
+      name = current_group_by
+      col = column(name) if name.present?
+      @group_column = (col if col&.groupable? && scope.is_a?(ActiveRecord::Relation))
+    end
+
+    def grouped?
+      group_column.present?
+    end
+
+    def current_group_by
+      config[:group_by].presence
+    end
+
+    # The chosen aggregates as {column_name => function}, skipping columns and
+    # functions that don't allow it, e.g. from browser state saved earlier.
+    def current_aggregates
+      @current_aggregates ||= (config[:aggregates].presence || {}).to_h.filter_map { |name, function|
+        col = column(name)
+        next unless col && !col.internal?
+
+        function = col.aggregates.find { |f| f.to_s == function.to_s }
+        [col.name, function] if function
+      }.to_h
+    end
+
+    # All groups, keyed by group value
+    def groups
+      return {} unless grouped?
+
+      @groups ||= calculate_groups
+    end
+
+    # The group a row belongs to
+    def group_for(row)
+      value = row.group_value
+      groups[value] || Mensa::Group.new(table: self, value: value)
+    end
+
+    private
+
+    def group_order_clause
+      direction = (group_column.sort_direction == :desc) ? "desc" : "asc"
+      "#{group_column.attribute_for_condition} #{direction} NULLS LAST"
+    end
+
+    def group_select
+      Arel.sql("#{group_column.attribute_for_condition} AS #{GROUP_VALUE_ALIAS}")
+    end
+
+    # Runs the GROUP BY on a subquery of the filtered rows, so it also works
+    # for scopes that have their own GROUP BY/HAVING and for aggregate
+    # expressions as column attributes.
+    def calculate_groups
+      aggregates = current_aggregates.to_a
+      relation = filtered_scope.except(:select, :order, :limit, :offset)
+
+      inner_selects = [group_select]
+      aggregates.each_with_index do |(name, _function), index|
+        inner_selects << Arel.sql("#{column(name).attribute_for_condition} AS mensa_aggregate_#{index}")
+      end
+
+      outer_selects = ["mensa_groups.#{GROUP_VALUE_ALIAS}", "COUNT(*)"]
+      aggregates.each_with_index do |(_name, function), index|
+        outer_selects << "#{function.to_s.upcase}(mensa_groups.mensa_aggregate_#{index})"
+      end
+
+      rows = relation.model.unscoped
+        .from(relation.select(*inner_selects), :mensa_groups)
+        .group(Arel.sql("mensa_groups.#{GROUP_VALUE_ALIAS}"))
+        .pluck(*outer_selects.map { |sql| Arel.sql(sql) })
+
+      rows.to_h do |value, count, *aggregate_values|
+        values = aggregates.map(&:first).zip(aggregate_values).to_h
+        [value, Mensa::Group.new(table: self, value: value, count: count, aggregates: values)]
+      end
+    end
+  end
+end

data/app/tables/mensa/row.rb

@@ -23,6 +23,11 @@ module Mensa
       end
     end
 
+    # The value of the group column, when the table is grouped
+    def group_value
+      record[Mensa::Grouping::GROUP_VALUE_ALIAS] if record.respond_to?(:has_attribute?) && record.has_attribute?(Mensa::Grouping::GROUP_VALUE_ALIAS)
+    end
+
     def link_attributes
       return {} unless link