mensa 0.2.5 → 0.2.6

data/app/tables/mensa/base.rb

@@ -11,12 +11,11 @@ module Mensa
     attr_reader :params
 
     config_reader :model
+    config_reader :scope
     config_reader :link, call: false
     config_reader :supports_views?
     config_reader :supports_custom_views?
     config_reader :supports_filters?
-    config_reader :view_condensed?
-    config_reader :view_condensed_toggle?
     config_reader :view_columns_ordering?
     config_reader :show_header?
     config_reader :exportable?
@@ -25,10 +24,26 @@ module Mensa
     def initialize(config = {})
       @params = config.to_h.deep_symbolize_keys
       @config = self.class.definition.merge(@params || {})
+
+      ensure_internal_columns_for_joined_associations
+
+      params[:hidden_columns]&.each do |column_name|
+        c = columns.find { |c| c.name == column_name.to_sym }
+        c.config[:visible] = false
+      end
     end
 
     def column_order
-      config[:column_order] || config[:columns]&.keys
+      order = config[:column_order].presence || config[:columns]&.keys
+      order = order&.map(&:to_sym)
+      return order if order.nil?
+
+      # Internal columns are never shown in the column customizer UI, so they
+      # are absent from any URL-supplied column_order. Always append them so
+      # that columns and selected_scope include their attributes.
+      all_keys = (config[:columns]&.keys || []).map(&:to_sym)
+      internal_keys = all_keys.select { |key| config.dig(:columns, key, :internal) }
+      (order | internal_keys)
     end
 
     # Returns all columns
@@ -42,9 +57,15 @@ module Mensa
       columns.find { |c| c.name == name.to_sym }
     end
 
-    # Returns the columns to be displayed
+    # Returns the columns to be displayed, ordered by column_order.
     def display_columns
-      @display_columns ||= columns.select(&:visible?).reject(&:internal?)
+      @display_columns ||= begin
+        order = column_order || []
+        columns
+          .select(&:visible?)
+          .reject(&:internal?)
+          .sort_by { |col| order.index(col.name) || Float::INFINITY }
+      end
     end
 
     # Returns the rows to be displayed
@@ -57,8 +78,8 @@ module Mensa
     end
 
     def system_views
-      config[:views]&.key?(:default) ? [] : [Mensa::SystemView.new(:default, config: {name: I18n.t("mensa.views.default")}, table: self)] +
-        (config[:views] || {}).keys.map { |view_name| Mensa::SystemView.new(view_name, config: config.dig(:views, view_name), table: self) }
+      views = config[:views]&.key?(:default) ? [] : [Mensa::SystemView.new(:default, config: {name: I18n.t("mensa.views.default")}, table: self)]
+      views + (config[:views] || {}).keys.map { |view_name| Mensa::SystemView.new(view_name, config: config.dig(:views, view_name), table: self) }
     end
 
     # Returns true if the table has filters
@@ -66,9 +87,13 @@ module Mensa
       columns.any?(&:filter?)
     end
 
-    # Returns the active filters
+    # Returns the active filters, skipping any whose column no longer exists.
     def active_filters
-      (config[:filters] || {}).map { |column_name, filter_config| Mensa::Filter.new(column: column(column_name), config: filter_config, table: self) }
+      (config[:filters] || {}).filter_map do |column_name, filter_config|
+        col = column(column_name)
+        next unless col
+        Mensa::Filter.new(column: col, config: filter_config, table: self)
+      end
     end
 
     def actions?
@@ -81,10 +106,27 @@ module Mensa
       @actions ||= config[:actions].keys.map { |action_name| Mensa::Action.new(action_name, config: config.dig(:actions, action_name), table: self) }
     end
 
+    def batch_actions?
+      config[:batches].present?
+    end
+
+    def batch_actions
+      return @batch_actions if @batch_actions
+
+      @batch_actions ||= config[:batches].keys.map { |batch_name| Mensa::BatchAction.new(batch_name, config: config.dig(:batches, batch_name), table: self) }
+    end
+
     # Returns the current path with configuration
-    def path(order: {}, turbo_frame_id: nil, table_view_id: nil)
+    def path(order: {}, turbo_frame_id: nil, table_view_id: params[:table_view_id], column_order: params[:column_order], hidden_columns: params[:hidden_columns])
       # FIXME: if someone doesn't use as: :mensa in the routes, it breaks
-      original_view_context.mensa.table_path(name, order: order_hash(order), turbo_frame_id: turbo_frame_id, table_view_id: table_view_id)
+      original_view_context.mensa.table_path(
+        name,
+        order: order_hash(order),
+        turbo_frame_id: turbo_frame_id,
+        table_view_id: table_view_id,
+        column_order: column_order,
+        hidden_columns: hidden_columns
+      )
     end
 
     def menu
@@ -95,10 +137,18 @@ module Mensa
 
     def all_views
       views = system_views
-      views += TableView.where(table_name: name).where(user: [nil, Current.user])
+      views += TableView.where(table_name: name).where(user: [nil, current_user])
       views
     end
 
+    # The user that owns custom views. Returns nil when the host application has
+    # no current user, in which case views cannot be saved.
+    def current_user
+      return Current.user if defined?(Current) && Current.respond_to?(:user)
+
+      nil
+    end
+
     def table_id
       return @table_id if @table_id
 
@@ -108,5 +158,46 @@ module Mensa
     def original_view_context
       @original_view_context || component.original_view_context
     end
+
+    private
+
+    def ensure_internal_columns_for_joined_associations
+      config[:columns] ||= {}
+
+      auto_internal_column_names.each do |column_name|
+        config[:columns][column_name] ||= {internal: true}
+      end
+    end
+
+    def auto_internal_column_names
+      joined_association_names.filter_map do |association_name|
+        reflection = model.reflect_on_association(association_name)
+        reflection&.foreign_key&.to_sym
+      end.uniq
+    end
+
+    def joined_association_names
+      relation = scope
+      return [] unless relation.respond_to?(:joins_values) && relation.respond_to?(:left_outer_joins_values)
+
+      (relation.joins_values + relation.left_outer_joins_values).flat_map do |join_value|
+        association_names_from_join_value(join_value)
+      end.compact.uniq
+    end
+
+    def association_names_from_join_value(join_value)
+      case join_value
+      when Symbol, String
+        [join_value.to_sym]
+      when Array
+        join_value.flat_map { |value| association_names_from_join_value(value) }
+      when Hash
+        join_value.flat_map do |association_name, nested_join_values|
+          [association_name.to_sym, *association_names_from_join_value(nested_join_values)]
+        end
+      else
+        []
+      end
+    end
   end
 end

data/app/tables/mensa/batch_action.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mensa
+  # Represents a batch action that can be applied to multiple selected records.
+  #
+  # batch :archive do
+  #   title "Archive"
+  #   process { |records| records.update_all(archived: true) }
+  # end
+  class BatchAction
+    include ConfigReaders
+
+    defined_by Mensa::Config::BatchDsl
+
+    attr_reader :name, :table
+
+    def initialize(name, config:, table:)
+      @name = name
+      @table = table
+      @config = config
+    end
+
+    config_reader :title
+    config_reader :description
+    config_reader :process, call: false
+  end
+end

data/app/tables/mensa/cell.rb

@@ -46,5 +46,20 @@ module Mensa
         column.sanitize? ? sanitize(value.to_s) : value.to_s.html_safe
       end
     end
+
+    def to_csv
+      case value
+      when NilClass
+        ""
+      when TrueClass, FalseClass
+        value.to_s
+      when Date
+        respond_to?(:dt) ? dt(value) : value.strftime("%d.%m.%Y")
+      when Time, DateTime
+        respond_to?(:ln) ? ln(value) : value.strftime("%d-%m-%Y %H:%M:%S")
+      else
+        strip_tags(value.to_s)
+      end
+    end
   end
 end

data/app/tables/mensa/column.rb

@@ -21,7 +21,8 @@ module Mensa
     config_reader :method # When a method needs to be called on the model, slow!
 
     def sort_direction
-      table.config.dig(:order, name)&.to_sym
+      value = table.config.dig(:order, name)
+      value.present? ? value.to_sym : nil
     end
 
     def next_sort_direction
@@ -44,6 +45,18 @@ module Mensa
       end
     end
 
+    def active_record_column
+      @active_record_column ||= table.model&.columns&.find { _1.name == name.to_s }
+    end
+
+    def active_record_column_type
+      active_record_column&.type
+    end
+
+    def type
+      config[:type] || active_record_column_type
+    end
+
     def attribute_for_condition
       return @attribute_for_condition if @attribute_for_condition
 
@@ -77,7 +90,7 @@ module Mensa
       Satis::Menus::Builder.build(:filter_menu, event: "click") do |m|
         if sortable?
           m.item :sort_ascending, icon: "fa-solid fa-arrow-up-short-wide", link: table.path(order: {name => :asc}), link_attributes: {"data-turbo-frame": "_self"}
-          m.item :sort_descending, icon: "fa-solid fa-arrow-down-wide-short", link: table.path(order: {name => :asc}), link_attributes: {"data-turbo-frame": "_self"}
+          m.item :sort_descending, icon: "fa-solid fa-arrow-down-wide-short", link: table.path(order: {name => :desc}), link_attributes: {"data-turbo-frame": "_self"}
         end
       end
     end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mensa::Config
+  class BatchDsl
+    include DslLogic
+
+    option :title, default: -> { name.to_s.humanize }
+    option :description, default: ""
+    option :process, default: ->(records) {}
+
+    delegate :t, to: :I18n
+  end
+end

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

@@ -15,6 +15,7 @@ module Mensa::Config
     # Mensa doesn't select the whole records, to only select what we need
     option :internal, default: false
     option :method
+    option :type
 
     option :visible, default: true
     option :render, dsl: Mensa::Config::RenderDsl

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

@@ -2,9 +2,12 @@ module Mensa::Config
   class FilterDsl
     include DslLogic
 
-    option :operator, default: :equals
+    option :operator, default: :is
     option :value
     option :collection
     option :scope
+    option :multiple, default: false
+    option :as
+    option :operators
   end
 end

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

@@ -3,6 +3,6 @@ module Mensa::Config
     include DslLogic
 
     option :html
-    option :xlsx
+    option :csv
   end
 end

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

@@ -5,7 +5,7 @@
 #     render do # default Standard components
 #       html # Mensa::TableComponent::Default
 #       json # Mensa::JsonRenderer::Default
-#       xlsx # Mensa::XlsxRenderer::Default
+#       csv # Mensa::CsvRenderer::Default
 #     end
 #
 #     column(:first_name) do
@@ -55,6 +55,7 @@ module Mensa::Config
         raise "No model found for #{self.class.name}"
       end
     }
+    option :scope, default: -> { model.all }
     option :column, dsl_hash: Mensa::Config::ColumnDsl
     option :link
 
@@ -70,6 +71,8 @@ module Mensa::Config
     # Actions
     option :action, dsl_hash: Mensa::Config::ActionDsl
 
+    option :batch, dsl_hash: Mensa::Config::BatchDsl
+
     option :render, dsl: Mensa::Config::RenderDsl
 
     option :supports_views, default: false
@@ -78,11 +81,15 @@ module Mensa::Config
     option :show_header, default: true
     # Whether the table allows to change column ordering
     option :view_columns_ordering, default: true
-    # Whether to show a condensed view by default
-    option :view_condensed, default: false
-    # Whether to show the toggle for condensed view
-    option :view_condensed_toggle, default: true
 
     option :view, dsl_hash: Mensa::Config::ViewDsl
+
+    # Syntactic sugar for `column :carrier_id do internal true end`.
+    def internal(name, &block)
+      column(name) do
+        internal true
+        instance_exec(&block) if block
+      end
+    end
   end
 end

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

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

data/app/tables/mensa/config_readers.rb

@@ -8,8 +8,27 @@ module Mensa
 
     class_methods do
       def defined_by(dsl_class)
+        # Lazily-built DSL instance that accumulates configuration.
+        define_singleton_method(:dsl_definition) do
+          @dsl_definition ||= dsl_class.new(name)
+        end
+
         define_singleton_method(:definition) do |&block|
-          @definition ||= dsl_class.new(name, &block).config
+          dsl_definition.instance_eval(&block) if block
+          dsl_definition.config
+        end
+
+        # Forward unknown class-level calls to the DSL
+        define_singleton_method(:method_missing) do |method_name, *args, &block|
+          if dsl_definition.respond_to?(method_name)
+            dsl_definition.public_send(method_name, *args, &block)
+          else
+            super(method_name, *args, &block)
+          end
+        end
+
+        define_singleton_method(:respond_to_missing?) do |method_name, include_private = false|
+          dsl_definition.respond_to?(method_name, include_private) || super(method_name, include_private)
         end
       end
 

data/app/tables/mensa/filter.rb

@@ -11,6 +11,23 @@ module Mensa
     config_reader :operator, cast: :to_sym
     config_reader :value
     config_reader :scope
+    config_reader :multiple
+
+    class << self
+      def OPERATORS
+        [
+          [:is, I18n.t("mensa.operators.is"), true],
+          [:isnt, I18n.t("mensa.operators.isnt"), true],
+          [:matches, I18n.t("mensa.operators.matches"), true],
+          [:does_not_match, I18n.t("mensa.operators.does_not_match"), true],
+          [:gt, I18n.t("mensa.operators.gt"), true],
+          [:gteq, I18n.t("mensa.operators.gteq"), true],
+          [:lt, I18n.t("mensa.operators.lt"), true],
+          [:lteq, I18n.t("mensa.operators.lteq"), true],
+          [:is_current, I18n.t("mensa.operators.is_current"), false]
+        ].freeze
+      end
+    end
 
     def initialize(column:, config:, table:)
       @column = column
@@ -18,6 +35,10 @@ module Mensa
       @table = table
     end
 
+    def multiple?
+      !!multiple
+    end
+
     def collection
       return unless config&.key?(:collection)
 
@@ -28,8 +49,19 @@ module Mensa
       end
     end
 
+    # This defines how the filter should be displayed in the value popover
+    # :select => as a select input
+    # :checkbox => as a checkbox input
+    # :string => as a text input
+    def as
+      config[:as]
+    end
+
     def to_s
-      "#{column.human_name}: #{value}"
+      parts = [column.human_name, operator_label]
+      formatted_value = value.is_a?(Array) ? value.join(", ") : value
+      parts << formatted_value if formatted_value.present? && operator_with_value?
+      parts.join(" ")
     end
 
     def filter_scope(record_scope)
@@ -37,10 +69,26 @@ module Mensa
         record_scope.instance_exec(normalize(value), &scope)
       else
         case operator
+        when :is_current
+          record_scope.where("#{column.attribute_for_condition} = ?", Current.send(column.name))
         when :matches
           record_scope.where("#{column.attribute_for_condition} LIKE ?", "%#{normalize(value)}%")
-        when :equals
-          record_scope.where(column.attribute_for_condition => normalize(value))
+        when :does_not_match
+          record_scope.where("#{column.attribute_for_condition} NOT LIKE ?", "%#{normalize(value)}%")
+        when :is
+          val = value.is_a?(Array) ? value : normalize(value)
+          record_scope.where(column.attribute_for_condition => val)
+        when :isnt
+          val = value.is_a?(Array) ? value : normalize(value)
+          record_scope.where.not(column.attribute_for_condition => val)
+        when :gt
+          record_scope.where(column.table.model.arel_table[column.attribute_for_condition].gt(normalize(value)))
+        when :lt
+          record_scope.where(column.table.model.arel_table[column.attribute_for_condition].lt(normalize(value)))
+        when :gteq
+          record_scope.where(column.table.model.arel_table[column.attribute_for_condition].gteq(normalize(value)))
+        when :lteq
+          record_scope.where(column.table.model.arel_table[column.attribute_for_condition].lteq(normalize(value)))
         else
           # Ignore unknown operators
           record_scope
@@ -48,6 +96,41 @@ module Mensa
       end
     end
 
+    def operators
+      operators = Mensa::Filter.OPERATORS.dup
+      if config[:operators].present?
+        operators = operators.select { |op| config[:operators].include?(op[0]) }
+      else
+        operators.delete_if { |op| op[0] == :is_current } unless Current.method_defined?(column.name, false)
+        operators.delete_if { |op| [:matches, :does_not_match].include?(op[0]) } if collection.present?
+        operators.delete_if { |op| [:matches, :does_not_match].include?(op[0]) } if column.type == :integer || column.type == :date || column.type == :datetime
+        operators.delete_if { |op| [:is, :isnt].include?(op[0]) } if column.type == :date || column.type == :datetime
+        operators.delete_if { |op| [:gt, :lt, :gteq, :lteq].include?(op[0]) } if column.type == :string || column.type.blank?
+      end
+      operators
+    end
+
+    def operator_label
+      Mensa::Filter.OPERATORS.find { |op| op[0] == operator }[1]
+    end
+
+    def operator_with_value?
+      Mensa::Filter.OPERATORS.find { |op| op[0] == operator }[2]
+    end
+
+    def input_type
+      case column.type
+      when :integer
+        "number"
+      when :date
+        "date"
+      when :datetime
+        "datetime-local"
+      else
+        "text"
+      end
+    end
+
     private
 
     def normalize(query)

data/app/tables/mensa/scope.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
 module Mensa
+  # scope -> filtered_scope -> ordered_scope -> selected_scope ->
   module Scope
     extend ActiveSupport::Concern
 
     included do
     end
 
-    # Returns the records we want to display, using the Active Record Query Interface
-    # By default it returns all records
-    def scope
-      model.all
-    end
-
     # Returns the scope, but filtered
     def filtered_scope
       return @filtered_scope if @filtered_scope
@@ -20,7 +15,13 @@ module Mensa
       @filtered_scope = scope
       # See https://github.com/textacular/textacular
       # This has problems - not all table fields are searched
-      @filtered_scope = @filtered_scope.basic_search(params[:query]) if params[:query]
+      if params[:query].present?
+        @filtered_scope = if Mensa.config.search == :fuzzy
+          @filtered_scope.fuzzy_search(params[:query])
+        else
+          @filtered_scope.basic_search(params[:query])
+        end
+      end
 
       # Use inject
       active_filters.each do |filter|
@@ -35,7 +36,7 @@ module Mensa
       return @ordered_scope if @ordered_scope
 
       @ordered_scope = filtered_scope
-      @ordered_scope = @ordered_scope.reorder(order_hash)
+      @ordered_scope = @ordered_scope.reorder(effective_order)
 
       @ordered_scope
     end
@@ -68,11 +69,22 @@ module Mensa
       @pagy_details, @records = selected_scope.is_a?(Array) ? pagy(:offset, ordered_scope, anchor_string: 'data-turbo-frame="_self"') : pagy(:offset, selected_scope, anchor_string: 'data-turbo-frame="_self"')
     end
 
-    # Though this works, perhaps moving this in column(s) is nicer
+    # Effective ordering for SQL: when the request includes any order[] params
+    # (even with blank values), use only those — blank means "explicitly no sort".
+    # Falls back to the view/config default only when no order params were sent.
+    def effective_order
+      result = params.key?(:order) ? (params[:order] || {}) : (config[:order] || {})
+      result = result.symbolize_keys.compact_blank.transform_values(&:to_sym)
+      result.transform_keys { column(_1).attribute_for_condition }
+    end
+
+    # Builds an order hash for URL generation. Merges current order with overrides;
+    # nil values become "" so they appear in the URL as order[col]= (which tells
+    # the server the user explicitly cleared that column's sort direction).
     def order_hash(new_params = {})
-      (params[:order] || config[:order]).merge(new_params.symbolize_keys)
-        .compact_blank
-        .transform_values { |value| value.to_sym }
+      base = params[:order]&.symbolize_keys || config[:order]&.symbolize_keys || {}
+      merged = base.merge(new_params.symbolize_keys)
+      merged.transform_values { |v| v.nil? ? "" : v.to_sym }
     end
   end
 end

data/app/views/mensa/exports/_badge.html.slim

@@ -0,0 +1,5 @@
+/ Download counter shown on the export button. Hidden while there are no
+/ completed downloads. Replaced via Turbo stream when a job finishes.
+- count = Mensa::Export.completed_count(table_name, user)
+span id=Mensa::Export.badge_dom_id(table_name, user) class="mensa-table__control_bar__badge #{'hidden' unless count.positive?}" aria-hidden=(count.positive? ? "false" : "true")
+  = count

data/app/views/mensa/exports/_dialog.html.slim

@@ -0,0 +1,42 @@
+/ Export dialog rendered once per table inside the control bar. Opening it
+/ refreshes the downloads list; submitting the form creates a new export.
+- user = table.current_user
+- exports = Mensa::Export.for_table(table.name).for_user(user).recent
+dialog.mensa-table__export-dialog data-mensa-table-target="exportDialog" data-action="click->mensa-table#exportDialogBackdrop"
+  .mensa-table__export-dialog__panel
+    header.mensa-table__export-dialog__header
+      h2.mensa-table__export-dialog__title
+        = t("mensa.exports.title", default: "Export %{table}", table: table.name.to_s.humanize)
+      button.mensa-table__export-dialog__close type="button" data-action="mensa-table#cancelExport" aria-label=t("mensa.exports.close", default: "Close")
+        i.fa-solid.fa-xmark
+
+    .mensa-table__export-dialog__body
+      = render partial: "mensa/exports/list", locals: {table_name: table.name, user: user, exports: exports}
+
+      form.mensa-table__export-dialog__form data-action="submit->mensa-table#confirmExport"
+        fieldset.mensa-table__export-dialog__fieldset
+          legend.mensa-table__export-dialog__section-title
+            = t("mensa.exports.new_export", default: "New export")
+          label.mensa-table__export-dialog__option
+            input type="radio" name="scope" value="all" checked=true
+            span = t("mensa.exports.scope_all", default: "All records (matching current filters)")
+          label.mensa-table__export-dialog__option
+            input type="radio" name="scope" value="current_page"
+            span = t("mensa.exports.scope_current_page", default: "Current page")
+
+        fieldset.mensa-table__export-dialog__fieldset
+          legend.mensa-table__export-dialog__section-title
+            = t("mensa.exports.export_as", default: "Export as")
+          label.mensa-table__export-dialog__option
+            input type="radio" name="export_format" value="csv_excel" checked=true
+            span = t("mensa.exports.format_excel", default: "CSV for Excel, Numbers, or other spreadsheet programs")
+          label.mensa-table__export-dialog__option
+            input type="radio" name="export_format" value="plain_csv"
+            span = t("mensa.exports.format_plain", default: "Plain CSV file")
+
+        .mensa-table__export-dialog__actions
+          button.mensa-table__export-dialog__button.mensa-table__export-dialog__button--secondary type="button" data-action="mensa-table#cancelExport"
+            = t("mensa.exports.cancel", default: "Cancel")
+          button.mensa-table__export-dialog__button.mensa-table__export-dialog__button--primary type="submit"
+            i.fa-solid.fa-file-export
+            = t("mensa.exports.submit", default: "Export")

data/app/views/mensa/exports/_list.html.slim

@@ -0,0 +1,29 @@
+/ The list of a user's downloads for a table. Replaced via Turbo stream when a
+/ new export is created or finishes processing.
+div id=Mensa::Export.list_dom_id(table_name, user) class="mensa-table__export-dialog__downloads"
+  h3.mensa-table__export-dialog__section-title
+    = t("mensa.exports.available_downloads", default: "Available downloads")
+  - if exports.blank?
+    p.mensa-table__export-dialog__empty
+      = t("mensa.exports.empty", default: "You have no downloads yet. Create one below.")
+  - else
+    ul.mensa-table__export-dialog__list
+      - exports.each do |export|
+        li.mensa-table__export-dialog__item
+          .mensa-table__export-dialog__item-info
+            span.mensa-table__export-dialog__item-name
+              = export.filename.presence || t("mensa.exports.item_name", default: "%{table} export", table: export.table_name.to_s.humanize)
+            span.mensa-table__export-dialog__item-meta
+              = export.created_at.strftime("%Y-%m-%d %H:%M")
+          .mensa-table__export-dialog__item-action
+            - if export.downloadable?
+              = link_to mensa.download_table_export_path(export.table_name, export), class: "mensa-table__export-dialog__download", data: {turbo: false} do
+                i.fa-solid.fa-download
+                = t("mensa.exports.download", default: "Download")
+            - elsif export.failed?
+              span.mensa-table__export-dialog__status.mensa-table__export-dialog__status--failed
+                = t("mensa.exports.failed", default: "Failed")
+            - else
+              span.mensa-table__export-dialog__status.mensa-table__export-dialog__status--pending
+                i.fa-solid.fa-spinner.fa-spin
+                = t("mensa.exports.processing", default: "Preparing…")