inline_forms 8.1.47 → 8.1.53

data/app/models/inline_forms/file_trash_sweep.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+
+# One row per run of the retention sweep (`rake inline_forms:file_trash:
+# purge_expired`): the heartbeat the global trash page shows, so a cron job
+# that silently stopped is visible to a human.
+class InlineForms::FileTrashSweep < ActiveRecord::Base
+  self.table_name = "inline_forms_file_trash_sweeps"
+
+  # A sweep older than this is reported as overdue (daily cron + slack).
+  OVERDUE_AFTER = 48.hours
+
+  def self.last_run
+    order(ran_at: :desc, id: :desc).first
+  end
+
+  def self.overdue?
+    return false if InlineForms.file_trash_retention.nil?
+
+    last = last_run
+    last.nil? || last.ran_at < OVERDUE_AFTER.ago
+  end
+
+  # Runs the sweep and records it. Re-raises after recording a failure, so
+  # the rake task exits non-zero and cron mails it.
+  def self.run!
+    purged = InlineForms::TrashedFile.purge_expired!
+    create!(ran_at: Time.current, purged_count: purged)
+    purged
+  rescue StandardError => e
+    begin
+      create!(ran_at: Time.current, purged_count: 0, error: "#{e.class}: #{e.message}".truncate(1000))
+    rescue StandardError
+      nil
+    end
+    raise
+  end
+end

data/app/models/inline_forms/trashed_file.rb

@@ -0,0 +1,205 @@
+# -*- encoding : utf-8 -*-
+
+require "digest"
+
+# One row per file event on a declared file slot (InlineForms::StoredFiles).
+#
+# Trash rows (reason removed / replaced / record_destroyed / orphaned) hold the
+# bytes of a file that left its slot, so it can be restored (undo) or purged
+# (bytes deleted for good, metadata kept as a tombstone = history). Event rows
+# (reason uploaded) never hold bytes; they only record who put a file in a
+# slot, because the slot columns are kept out of PaperTrail.
+#
+# States of a trash row:
+#   trashed   data present, not restored, not purged, not expired
+#   restored  bytes went back to the record; data NULLed, row kept as history
+#   purged    data NULLed by a user or the retention sweep; tombstone kept
+#   expired   purge_after passed but the sweep has not run yet: treated as
+#             purged by every read path (no download, no restore)
+#
+# Every state change is a conditional UPDATE (WHERE still trashed) whose row
+# count is checked, so a restore racing a purge, a replayed POST or a second
+# click never acts twice. Lock order everywhere: the owner record's row first,
+# then this table's row.
+#
+# Lists must never load the bytes: use +without_data+.
+class InlineForms::TrashedFile < ActiveRecord::Base
+  self.table_name = "inline_forms_trashed_files"
+
+  class NotRestorable < StandardError; end
+  class RecordGone < NotRestorable; end
+
+  TRASH_REASONS = %w[removed replaced record_destroyed orphaned].freeze
+  EVENT_REASONS = %w[uploaded].freeze
+  REASONS = (TRASH_REASONS + EVENT_REASONS).freeze
+
+  validates :record_type, :record_id, :attribute_name, :reason, presence: true
+  validates :reason, inclusion: { in: REASONS }
+
+  scope :without_data, -> { select(column_names - [ "data" ]) }
+  scope :trash_entries, -> { where(reason: TRASH_REASONS) }
+  scope :events, -> { where(reason: EVENT_REASONS) }
+  scope :for_record, ->(record) { where(record_type: record.class.base_class.name, record_id: record.id) }
+  scope :for_slot, ->(record, attribute) { for_record(record).where(attribute_name: attribute.to_s) }
+  scope :unexpired, -> { where("purge_after IS NULL OR purge_after > ?", Time.current) }
+  scope :expired, -> { where("purge_after IS NOT NULL AND purge_after <= ?", Time.current) }
+  scope :still_trashed, -> { trash_entries.where(restored_at: nil, purged_at: nil) }
+  scope :restorable, -> { still_trashed.unexpired }
+  scope :newest_first, -> { order(trashed_at: :desc, id: :desc) }
+
+  # ---- writing --------------------------------------------------------------
+
+  # Moves +data+ (the bytes that just left +attribute+ on +record+) into the
+  # trash. Called from inside the record's transaction.
+  def self.trash!(record:, attribute:, data:, filename:, content_type:, reason:, by: nil, at: Time.current)
+    retention = InlineForms.file_trash_retention
+    create!(
+      record_type: record.class.base_class.name,
+      record_id: record.id,
+      attribute_name: attribute.to_s,
+      filename: filename,
+      content_type: content_type,
+      byte_size: data&.bytesize,
+      checksum: data && Digest::SHA256.hexdigest(data),
+      data: data,
+      reason: reason.to_s,
+      trashed_by_id: by,
+      trashed_at: at,
+      purge_after: retention && at + retention
+    )
+  end
+
+  # Metadata-only "a file was put in this slot" event.
+  def self.record_upload!(record:, attribute:, filename:, content_type:, byte_size:, checksum:, by: nil, at: Time.current)
+    create!(
+      record_type: record.class.base_class.name,
+      record_id: record.id,
+      attribute_name: attribute.to_s,
+      filename: filename,
+      content_type: content_type,
+      byte_size: byte_size,
+      checksum: checksum,
+      reason: "uploaded",
+      trashed_by_id: by,
+      trashed_at: at
+    )
+  end
+
+  # Purges every trash row whose retention has passed. Returns the number
+  # purged. Idempotent; safe to run while users work.
+  def self.purge_expired!
+    ids = still_trashed.expired.pluck(:id)
+    ids.count { |id| find_by(id: id)&.purge!(by: nil) }
+  end
+
+  # ---- state ----------------------------------------------------------------
+
+  def trash_entry?
+    TRASH_REASONS.include?(reason)
+  end
+
+  def event?
+    EVENT_REASONS.include?(reason)
+  end
+
+  def restored?
+    restored_at.present?
+  end
+
+  def purged?
+    purged_at.present?
+  end
+
+  def expired?
+    purge_after.present? && purge_after <= Time.current
+  end
+
+  # Still holds bytes that may be downloaded, restored or purged.
+  def trashed?
+    trash_entry? && !restored? && !purged? && !expired?
+  end
+
+  # May still be purged: trashed, or expired but not yet swept.
+  def purgeable?
+    trash_entry? && !restored? && !purged?
+  end
+
+  # :trashed, :restored, :purged, :expired or :event
+  def state
+    return :event if event?
+    return :restored if restored?
+    return :purged if purged?
+    return :expired if expired?
+
+    :trashed
+  end
+
+  # The record this file belongs to, or nil when it was destroyed (or its
+  # class is gone). Never constantizes anything but a stored record_type.
+  #
+  # Loaded without the slots' byte columns (it is used for authorization and
+  # labels; reading a file goes through the slot API, which queries fresh).
+  def owner
+    klass = owner_class
+    return nil unless klass
+
+    scope = klass.unscoped
+    if klass.respond_to?(:inline_forms_file_slots)
+      blob_columns = klass.inline_forms_file_slots.values.map { |slot| slot[:data] }
+      scope = scope.select(klass.column_names - blob_columns)
+    end
+    scope.find_by(klass.primary_key => record_id)
+  end
+
+  def owner_class
+    klass = record_type.safe_constantize
+    klass.is_a?(Class) && klass < ActiveRecord::Base ? klass : nil
+  end
+
+  # The bytes, loaded on demand (lists select without them).
+  def file_data
+    self.class.where(id: id).pick(:data)
+  end
+
+  # ---- actions --------------------------------------------------------------
+
+  # Permanently deletes the bytes. Returns true when this call purged the row,
+  # false when it was already restored or purged (stale page, replayed POST).
+  def purge!(by:)
+    changes = { data: nil, purged_at: Time.current, purged_by_id: by, updated_at: Time.current }
+    if InlineForms.file_trash_redact_on_purge
+      changes[:filename] = nil
+      changes[:redacted] = true
+    end
+    count = self.class.where(id: id).still_trashed.update_all(changes)
+    reload if count == 1
+    count == 1
+  end
+
+  # Puts the bytes back into the slot. If the slot holds a file now (someone
+  # uploaded since), that file goes to the trash first (reason replaced) —
+  # never a silent overwrite. Raises RecordGone when the record was destroyed
+  # (restore the record instead; its files come back with it) and
+  # NotRestorable when the entry is no longer trashed.
+  def restore!(by:)
+    record_class = owner_class
+    raise RecordGone, "the record was deleted" unless record_class
+
+    record_class.transaction do
+      record = record_class.unscoped.lock.find_by(record_class.primary_key => record_id)
+      raise RecordGone, "the record was deleted" unless record
+
+      payload = self.class.lock.where(id: id).restorable.pick(:data, :filename, :content_type)
+      raise NotRestorable, "this file can no longer be restored" unless payload
+
+      now = Time.current
+      count = self.class.where(id: id).restorable.update_all(data: nil, restored_at: now, restored_by_id: by, updated_at: now)
+      raise NotRestorable, "this file can no longer be restored" unless count == 1
+
+      data, filename, content_type = payload
+      record.inline_forms_put_file!(attribute_name, data: data, filename: filename, content_type: content_type, by: by)
+      reload
+      record
+    end
+  end
+end

data/app/views/inline_forms/_file_slot.html.erb

@@ -0,0 +1,39 @@
+<%# A declared file slot (InlineForms::StoredFiles) inside its field frame.
+    Present: download link + replace (pencil) / remove (trash) by permission.
+    Empty: the usual plus link to upload, and, when the slot's last file is
+    still in the trash, an undo link to put it back. -%>
+<% frame_id = inline_forms_file_field_frame_id(object, attribute) -%>
+<% filename = object[attribute.to_s] -%>
+<% slots_param = inline_forms_file_trash_slots(object).join(",") -%>
+<span class="inline_forms-file">
+<% if object.inline_forms_file_present?(attribute) %>
+  <%= link_to filename,
+        polymorphic_path(object, action: :download_file, attribute: attribute),
+        class: "inline_forms-file-name", data: { turbo: false } -%>
+  <span class="inline_forms-file-actions">
+    <% if inline_forms_file_can?(:update, object, attribute) && inline_forms_file_can?(:replace_file, object, attribute) %>
+      <%= inline_forms_file_icon_link "fi-pencil", t("inline_forms.files.replace"),
+            edit_polymorphic_path(object, attribute: attribute.to_s, form_element: "simple_file_field", update: frame_id),
+            data: { turbo: true, turbo_frame: (@inline_forms_turbo_field ? "_self" : frame_id) } -%>
+    <% end %>
+    <% if inline_forms_file_can?(:remove_file, object, attribute) %>
+      <% days = inline_forms_file_retention_days -%>
+      <% confirm = days ? t("inline_forms.files.confirm_remove", filename: filename, count: days) : t("inline_forms.files.confirm_remove_no_expiry", filename: filename) -%>
+      <%= inline_forms_file_icon_link "fi-trash", t("inline_forms.files.remove"),
+            polymorphic_path(object, action: :remove_file, attribute: attribute, update: frame_id, slots: slots_param),
+            inline_forms_file_post_data(frame_id, confirm: confirm) -%>
+    <% end %>
+  </span>
+<% else %>
+  <%= link_to_inline_edit object, attribute, "<i class='fi-plus'></i>".html_safe, from_callee: :simple_file_field_show -%>
+  <%# Right after a remove the notice below carries the undo; don't offer it twice. -%>
+  <% if @file_notice != :removed && inline_forms_file_can?(:restore_file, object, attribute) && inline_forms_file_can?(:update, object, attribute) %>
+    <% entry = inline_forms_restorable_file_entries(object, [ attribute.to_s ])[attribute.to_s] -%>
+    <% if entry %>
+      <%= link_to t("inline_forms.files.restore_previous", filename: inline_forms_file_entry_name(entry)),
+            polymorphic_path(object, action: :restore_file, attribute: attribute, trash_id: entry.id, update: frame_id, slots: slots_param),
+            inline_forms_file_post_data(frame_id).deep_merge(class: "inline_forms-file-undo") -%>
+    <% end %>
+  <% end %>
+<% end %>
+</span>

data/app/views/inline_forms/_header.html.erb

@@ -29,6 +29,9 @@
         <li>
           <a href="#"><%= current_user.name %></a>
           <ul class="menu">
+            <% if (trash_link = link_to_inline_forms_file_trash) %>
+              <li><%= trash_link %></li>
+            <% end %>
             <li>
               <%= link_to( t("common.logout"), destroy_user_session_path, :method => :delete) if current_user  %>
             </li>

data/app/views/inline_forms/_model_top_bar.html.erb

@@ -9,10 +9,9 @@
             </a>
           </h1>
         </li>
-        <% if respond_to?(:inline_forms_schema_new_path) %>
-          <li class="menu-text">
-            <%= link_to "+ field", inline_forms_schema_new_path, data: { turbo: false }, title: "Add a field to a model (dev only)" %>
-          </li>
+        <%# Hook for app-specific items next to the title (none by default). %>
+        <% if lookup_context.exists?("inline_forms/model_top_bar_left", [], true) %>
+          <%= render "inline_forms/model_top_bar_left" %>
         <% end %>
       </ul>
     </div>

data/app/views/inline_forms/_show.html.erb

@@ -89,6 +89,12 @@
         <% end %>
       <% end %>
     <% end %>
+    <% file_trash_slots = inline_forms_file_trash_slots(@object, attributes) -%>
+    <% if file_trash_slots.any? && inline_forms_file_can?(:read_file_trash, @object) %>
+      <%= render template: "inline_forms/file_trash_panel",
+            locals: { object: @object, update_span: inline_forms_file_trash_turbo_frame_id(@object),
+                      slots: file_trash_slots, open: false } %>
+    <% end %>
     <% if cancan_disabled? || can?(:list_versions, @object) %>
       <% css_class_id = inline_forms_versions_turbo_frame_id(@object) -%>
       <turbo-frame id="<%= css_class_id -%>">

data/app/views/inline_forms/_versions.html.erb

@@ -1,13 +1,13 @@
 <% object = local_assigns[:object] || @object -%>
 <% css_class_id = inline_forms_versions_turbo_frame_id(object) -%>
-<%# Count the same merged set the open list does (`inline_forms_versions_for`
-    sums the parent's PaperTrail versions and the versions of any associated
-    ActionText::RichText records). Using `object.versions.length` here meant
+<%# Count the same merged set the open list does (`inline_forms_history_for`:
+    the parent's PaperTrail versions, the versions of any associated
+    ActionText::RichText records, and file events of declared file slots). Using `object.versions.length` here meant
     the closed header showed N (parent only) and the open header showed N+M
     (parent + rich_text), flickering as the user toggled the panel. -%>
 <div class="row form_element_header associated_auto_header callout">
   <div class='medium-11 large-11 column' >
-    <%= "Versions (#{inline_forms_versions_for(object).length})" %>
+    <%= "Versions (#{inline_forms_history_for(object).length})" %>
   </div>
   <div class='medium-1 large-1 column'>
       <%= link_to_versions_list(

data/app/views/inline_forms/_versions_file_entry.html.erb

@@ -0,0 +1,36 @@
+<%# One file event in the versions list (kind :file, from the trash table):
+    uploaded / removed / replaced / record_destroyed / restored / purged.
+    Its restore link is "restore file" (restore_file, not revert), offered
+    only on the slot's newest still-restorable trash entry. -%>
+<% row = entry[:entry] -%>
+<% attribute = row.attribute_name -%>
+<% field_frame = inline_forms_file_field_frame_id(object, attribute) -%>
+<div class="row <%= cycle('odd', 'even') %> inline_forms-versions-file">
+  <div class="small-1 column">
+    <% if restorable[attribute]&.id == row.id && entry[:file_event] == row.reason.to_sym &&
+          inline_forms_file_can?(:restore_file, object, attribute) &&
+          inline_forms_file_can?(object.inline_forms_file_present?(attribute) ? :replace_file : :update, object, attribute) %>
+      <%= link_to t("inline_forms.files.restore_file"),
+            polymorphic_path(object, action: :restore_file, attribute: attribute, trash_id: row.id,
+                             update: field_frame, slots: inline_forms_file_trash_slots(object).join(",")),
+            inline_forms_file_post_data(field_frame,
+              confirm: (object.inline_forms_file_present?(attribute) ? t("inline_forms.files.confirm_restore_swap", current: object[attribute], filename: inline_forms_file_entry_name(row)) : nil)) %>
+    <% else %>
+      &nbsp;
+    <% end %>
+  </div>
+  <div class="small-1 column">
+    <%= t("inline_forms.files.event.#{entry[:file_event]}") %>
+  </div>
+  <div class="small-2 column">
+    <%= entry[:at] %>
+  </div>
+  <div class="small-2 column">
+    <%= inline_forms_file_user_name(entry[:by]) %>
+  </div>
+  <div class="small-6 column">
+    <strong><%= object.class.human_attribute_name(attribute) %></strong>:
+    <%= inline_forms_file_entry_name(row) %>
+    <span class="inline_forms-file-meta"><%= inline_forms_file_size(row.byte_size) %></span>
+  </div>
+</div>

data/app/views/inline_forms/_versions_list.html.erb

@@ -1,6 +1,7 @@
 <% path_to_object = @object.class.to_s.underscore + '_path' %>
 <% css_class_id = inline_forms_versions_turbo_frame_id(@object) -%>
-<% entries = inline_forms_versions_for(@object) -%>
+<% entries = inline_forms_history_for(@object) -%>
+<% restorable_files = inline_forms_restorable_file_entries(@object, entries.filter_map { |e| e[:entry]&.attribute_name }.uniq) -%>
 <div class="row form_element_header associated_auto_header callout">
   <div class='medium-11 large-11 column' >
     <%= "Versions (#{entries.length})" %>
@@ -33,14 +34,22 @@
   <div class="small-1 column">
     <strong>Event</strong>
   </div>
+  <div class="small-2 column">
+    <strong>When</strong>
+  </div>
   <div class="small-2 column">
     <strong>Done by</strong>
   </div>
-  <div class="small-8 column">
+  <div class="small-6 column">
     <strong>Changeset</strong>
   </div>
 </div>
 <% entries.reverse.each do |entry| %>
+  <% if entry[:kind] == :file %>
+    <%= render partial: "inline_forms/versions_file_entry",
+          locals: { entry: entry, object: @object, restorable: restorable_files } %>
+    <% next %>
+  <% end %>
   <% version = entry[:version] -%>
   <% rich_text_name = entry[:rich_text_name] -%>
   <div class="row <%= cycle('odd', 'even') %>">

data/app/views/inline_forms/file_field_frame.html.erb

@@ -0,0 +1,22 @@
+<%# A file slot's field frame after a file action (FileSlotsConcern), with a
+    one-line status notice; after a remove the notice carries the undo. -%>
+<% frame_id = local_assigns[:frame_id] || @update_span -%>
+<turbo-frame id="<%= frame_id %>">
+  <%= simple_file_field_show(@object, @attribute) %>
+  <% if @file_notice %>
+    <p class="inline_forms-file-notice" role="status">
+      <% if @file_notice == :removed %>
+        <%= t("inline_forms.files.notice_removed", filename: inline_forms_file_entry_name(@file_entry)) %>
+        <% if @file_entry&.trashed? && inline_forms_file_can?(:restore_file, @object, @attribute) && inline_forms_file_can?(:update, @object, @attribute) %>
+          &middot;
+          <%= link_to t("inline_forms.files.undo"),
+                polymorphic_path(@object, action: :restore_file, attribute: @attribute, trash_id: @file_entry.id,
+                                 update: frame_id, slots: inline_forms_file_trash_slots_param),
+                inline_forms_file_post_data(frame_id) %>
+        <% end %>
+      <% else %>
+        <%= t("inline_forms.files.notice_#{@file_notice}") %>
+      <% end %>
+    </p>
+  <% end %>
+</turbo-frame>

data/app/views/inline_forms/file_trash/index.html.erb

@@ -0,0 +1,112 @@
+<%# Global file trash (InlineForms::FileTrashController#index). -%>
+<div class="row inline_forms-file-trash-page">
+  <div class="small-12 column">
+    <h2><%= t("inline_forms.files.global.title") %></h2>
+
+    <% if @sweep_overdue %>
+      <div class="callout warning" role="alert">
+        <%= @last_sweep ? t("inline_forms.files.global.sweep_overdue") : t("inline_forms.files.global.sweep_never") %>
+      </div>
+    <% end %>
+    <p class="inline_forms-file-meta">
+      <% if @last_sweep.nil? %>
+        <%# (reported above when retention is on) %>
+      <% elsif @last_sweep.error.present? %>
+        <%= t("inline_forms.files.global.sweep_failed", error: @last_sweep.error) %>
+      <% else %>
+        <%= t("inline_forms.files.global.sweep_last", at: l(@last_sweep.ran_at, format: :short), count: @last_sweep.purged_count) %>
+      <% end %>
+    </p>
+
+    <%= form_with url: inline_forms_file_trash_path, method: :get, local: true, class: "inline_forms-file-trash-filter" do %>
+      <div class="row">
+        <div class="small-12 medium-4 column">
+          <label><%= t("inline_forms.files.global.model") %>
+            <%= select_tag :model, options_for_select([ [ t("inline_forms.files.global.all"), "" ] ] + @models.map { |m| [ (m.safe_constantize&.model_name&.human || m), m ] }, @model) %>
+          </label>
+        </div>
+        <div class="small-12 medium-4 column">
+          <label><%= t("inline_forms.files.global.state") %>
+            <%= select_tag :state, options_for_select(InlineForms::FileTrashController::STATES.map { |s| [ (s == "all" ? t("inline_forms.files.global.all") : t("inline_forms.files.global.states.#{s}")), s ] }, @state) %>
+          </label>
+        </div>
+        <div class="small-12 medium-4 column">
+          <label>&nbsp;<%= submit_tag t("inline_forms.files.global.filter"), class: "button", name: nil %></label>
+        </div>
+      </div>
+    <% end %>
+
+    <% if @entries.empty? %>
+      <p><%= t("inline_forms.files.global.empty") %></p>
+    <% else %>
+      <% purgeable = @entries.any?(&:purgeable?) -%>
+      <%= form_with url: inline_forms_file_trash_purge_path(model: @model, state: @state, page: params[:page]), method: :post, local: true do %>
+        <table class="inline_forms-file-trash-table">
+          <thead>
+            <tr>
+              <% if purgeable %><th></th><% end %>
+              <th><%= t("inline_forms.files.global.record") %></th>
+              <th><%= t("inline_forms.files.global.slot") %></th>
+              <th><%= t("inline_forms.files.global.file") %></th>
+              <th><%= t("inline_forms.files.global.trashed") %></th>
+              <th><%= t("inline_forms.files.global.state") %></th>
+              <th><%= t("inline_forms.files.global.actions") %></th>
+            </tr>
+          </thead>
+          <tbody>
+            <% @entries.each do |entry| %>
+              <% klass = entry.owner_class -%>
+              <% record = entry.owner -%>
+              <tr class="<%= 'inline_forms-file-trash-history' unless entry.trashed? %>">
+                <% if purgeable %>
+                  <td>
+                    <% if entry.purgeable? %>
+                      <%= check_box_tag "ids[]", entry.id, false, id: "trash_entry_#{entry.id}", "aria-label": inline_forms_file_entry_name(entry) %>
+                    <% end %>
+                  </td>
+                <% end %>
+                <td>
+                  <% if record %>
+                    <%= "#{klass.model_name.human} ##{entry.record_id}" %>
+                    <% if record.respond_to?(:_presentation) %><span class="inline_forms-file-meta"><%= record._presentation %></span><% end %>
+                  <% else %>
+                    <%= t("inline_forms.files.global.record_gone", model: (klass&.model_name&.human || entry.record_type), id: entry.record_id) %>
+                  <% end %>
+                </td>
+                <td><%= klass ? klass.human_attribute_name(entry.attribute_name) : entry.attribute_name %></td>
+                <td>
+                  <span class="inline_forms-file-name"><%= inline_forms_file_entry_name(entry) %></span>
+                  <span class="inline_forms-file-meta"><%= inline_forms_file_size(entry.byte_size) %> &middot; <%= t("inline_forms.files.reason.#{entry.reason}") %></span>
+                </td>
+                <td><%= t("inline_forms.files.by_on", user: inline_forms_file_user_name(entry.trashed_by_id), at: l(entry.trashed_at, format: :short)) %></td>
+                <td>
+                  <% if entry.state == :restored %><%= t("inline_forms.files.state_restored", user: inline_forms_file_user_name(entry.restored_by_id), at: l(entry.restored_at, format: :short)) %>
+                  <% elsif entry.state == :purged %><%= t("inline_forms.files.state_purged", user: inline_forms_file_user_name(entry.purged_by_id), at: l(entry.purged_at, format: :short)) %>
+                  <% elsif entry.state == :expired %><%= t("inline_forms.files.state_expired") %>
+                  <% else %>
+                    <% if entry.purge_after %><%= t("inline_forms.files.expires_in", count: ((entry.purge_after - Time.current) / 1.day).ceil, date: l(entry.purge_after.to_date)) %><% else %><%= t("inline_forms.files.global.states.trashed") %><% end %>
+                  <% end %>
+                </td>
+                <td class="inline_forms-file-actions">
+                  <% if entry.trashed? %>
+                    <%= link_to t("inline_forms.files.download"), inline_forms_file_trash_download_path(entry), data: { turbo: false } %>
+                    <% if record %>
+                      <%= link_to t("inline_forms.files.restore"),
+                            inline_forms_file_trash_restore_path(entry, model: @model, state: @state, page: params[:page]),
+                            data: { turbo_method: :post } %>
+                    <% end %>
+                  <% end %>
+                </td>
+              </tr>
+            <% end %>
+          </tbody>
+        </table>
+        <% if purgeable %>
+          <%= submit_tag t("inline_forms.files.global.purge_selected"), class: "button alert",
+                data: { turbo_confirm: t("inline_forms.files.global.confirm_purge_selected") } %>
+        <% end %>
+      <% end %>
+      <%= will_paginate @entries %>
+    <% end %>
+  </div>
+</div>

data/app/views/inline_forms/file_trash_panel.html.erb

@@ -0,0 +1,90 @@
+<%# Per-record trash panel ("Removed files (n)"), beside Versions. Lists the
+    trash rows of the slots shown on this page (a Client tab only its own),
+    newest first; restored and purged rows stay as greyed history. The frame
+    is always rendered, empty or not, so a file action can stream into it.
+    Never loads file bytes (without_data). -%>
+<% object = local_assigns[:object] || @object -%>
+<% update_span = local_assigns[:update_span] || @update_span -%>
+<% slots = local_assigns.key?(:slots) ? local_assigns[:slots] : @file_trash_slots -%>
+<% open = local_assigns.key?(:open) ? local_assigns[:open] : @file_trash_open -%>
+<% slots = Array(slots) -%>
+<% entries = slots.empty? ? [] : InlineForms::TrashedFile.without_data.trash_entries.for_record(object).where(attribute_name: slots).newest_first.to_a -%>
+<% slots_param = slots.join(",") -%>
+<turbo-frame id="<%= update_span %>">
+<% if entries.any? %>
+  <% in_trash = entries.count(&:trashed?) -%>
+  <% toggle_path = polymorphic_path(object, action: :file_trash, update: update_span, slots: slots_param, close: (open ? true : nil)) -%>
+  <div class="row form_element_header associated_auto_header callout inline_forms-file-trash">
+    <div class='medium-11 large-11 column' >
+      <%= t("inline_forms.files.trash_header", count: in_trash) %>
+    </div>
+    <div class='medium-1 large-1 column'>
+      <%= inline_forms_file_icon_link (open ? "fi-x" : "fi-list"),
+            (open ? t("inline_forms.files.close_trash") : t("inline_forms.files.open_trash")),
+            toggle_path,
+            { class: "button #{open ? 'close_button' : 'new_button'}", data: { turbo: true, turbo_frame: update_span } } %>
+    </div>
+  </div>
+  <% if open %>
+    <% if (stale = entries.select(&:expired?).reject { |e| e.purged? || e.restored? }).any? %>
+      <div class="row"><div class="small-12 column inline_forms-file-meta"><%= t("inline_forms.files.expired_pending", count: stale.size) %></div></div>
+    <% end %>
+    <% entries.each do |entry| %>
+      <% attribute = entry.attribute_name -%>
+      <% field_frame = inline_forms_file_field_frame_id(object, attribute) -%>
+      <div class="row <%= cycle('odd', 'even') %> inline_forms-file-trash-row<%= ' inline_forms-file-trash-history' unless entry.trashed? %>">
+        <div class="small-12 medium-3 column">
+          <strong><%= object.class.human_attribute_name(attribute) %></strong>
+        </div>
+        <div class="small-12 medium-5 column">
+          <span class="inline_forms-file-name"><%= inline_forms_file_entry_name(entry) %></span>
+          <span class="inline_forms-file-meta">
+            <%= inline_forms_file_size(entry.byte_size) %> &middot;
+            <%= t("inline_forms.files.reason.#{entry.reason}") %>
+            <%= t("inline_forms.files.by_on", user: inline_forms_file_user_name(entry.trashed_by_id), at: l(entry.trashed_at, format: :short)) %>
+          </span>
+          <span class="inline_forms-file-meta">
+            <% if entry.state == :restored %>
+              <%= t("inline_forms.files.state_restored", user: inline_forms_file_user_name(entry.restored_by_id), at: l(entry.restored_at, format: :short)) %>
+            <% elsif entry.state == :purged %>
+              <%= t("inline_forms.files.state_purged", user: inline_forms_file_user_name(entry.purged_by_id), at: l(entry.purged_at, format: :short)) %>
+            <% elsif entry.state == :expired %>
+              <%= t("inline_forms.files.state_expired") %>
+            <% else %>
+              <% if entry.purge_after %>
+                <% days_left = ((entry.purge_after - Time.current) / 1.day).ceil -%>
+                <span class="<%= 'inline_forms-file-expiring' if days_left <= 7 %>"><%= t("inline_forms.files.expires_in", count: days_left, date: l(entry.purge_after.to_date)) %></span>
+              <% end %>
+            <% end %>
+          </span>
+        </div>
+        <div class="small-12 medium-4 column inline_forms-file-actions">
+          <% if entry.trashed? %>
+            <% if inline_forms_file_can?(:download_trashed_file, object, attribute) %>
+              <%= link_to t("inline_forms.files.download"),
+                    polymorphic_path(object, action: :trashed_file, attribute: attribute, trash_id: entry.id),
+                    data: { turbo: false } %>
+            <% end %>
+            <% if inline_forms_file_can?(:restore_file, object, attribute) %>
+              <% occupied = object.inline_forms_file_present?(attribute) -%>
+              <% if inline_forms_file_can?(occupied ? :replace_file : :update, object, attribute) %>
+                <% confirm = occupied ? t("inline_forms.files.confirm_restore_swap", current: object[attribute], filename: inline_forms_file_entry_name(entry)) : nil -%>
+                <%= link_to t("inline_forms.files.restore"),
+                      polymorphic_path(object, action: :restore_file, attribute: attribute, trash_id: entry.id,
+                                       update: field_frame, slots: slots_param, panel: "open"),
+                      inline_forms_file_post_data(update_span, confirm: confirm) %>
+              <% end %>
+            <% end %>
+            <% if inline_forms_file_can?(:purge_file, object, attribute) %>
+              <%= link_to t("inline_forms.files.purge"),
+                    polymorphic_path(object, action: :purge_file, attribute: attribute, trash_id: entry.id,
+                                     update: field_frame, slots: slots_param, panel: "open"),
+                    inline_forms_file_post_data(update_span, confirm: t("inline_forms.files.confirm_purge", filename: inline_forms_file_entry_name(entry))).deep_merge(class: "alert") %>
+            <% end %>
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  <% end %>
+<% end %>
+</turbo-frame>

data/app/views/layouts/inline_forms.html.erb

@@ -3,7 +3,11 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title><%= t('application_name') + " v" + InlineForms::VERSION -%></title>
+    <%# A missing translation must not reach <title>: a bare t() returns an %>
+    <%# html_safe <span class="translation_missing"> that shows up as markup. %>
+    <%# The `default:` (the host's ApplicationHelper#application_name, which %>
+    <%# the header partial needs anyway) makes t() return plain, escaped text. %>
+    <title><%= t('application_name', default: application_name) %> v<%= InlineForms::VERSION %></title>
     <%= stylesheet_link_tag "application" %>
     <%= stylesheet_link_tag "inline_forms_fonts" %>
     <%= stylesheet_link_tag "inline_forms/inline_forms" %>