inline_forms 8.1.47 → 8.1.55

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" %>

data/lib/generators/inline_forms/file_trash_generator.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module InlineForms
+  module Generators
+    # `rails g inline_forms:file_trash`
+    #
+    # Writes the migration for the file trash of declared file slots
+    # (InlineForms::StoredFiles): inline_forms_trashed_files (one row per
+    # removed / replaced / uploaded file event, bytes until purged) and
+    # inline_forms_file_trash_sweeps (the retention sweep's heartbeat). The
+    # installer runs it for new apps; existing apps run it once by hand.
+    class FileTrashGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def self.next_migration_number(dirname)
+        # Collision-free against migrations generated in the same second
+        # (same policy as inline_forms_addto since 8.1.41).
+        now = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        existing = Dir.glob(File.join(dirname, "*.rb")).map { |f| File.basename(f)[/\A\d+/] }.compact
+        [ now, *existing.map(&:to_s) ].max.then do |highest|
+          highest == now ? now : (highest.to_i + 1).to_s
+        end
+      end
+
+      def create_migration_file
+        migration_template "create_inline_forms_file_trash.rb.erb",
+                           "db/migrate/create_inline_forms_file_trash.rb"
+      end
+    end
+  end
+end

data/lib/generators/inline_forms/templates/create_inline_forms_file_trash.rb.erb

@@ -0,0 +1,41 @@
+# File trash for declared file slots (inline_forms, InlineForms::StoredFiles).
+class CreateInlineFormsFileTrash < ActiveRecord::Migration[8.1]
+  def change
+    # Trashed bytes can be as large as the slot's own column: LONGBLOB on
+    # MySQL (a plain BLOB stops at 64 KB); a plain binary elsewhere (SQLite
+    # and PostgreSQL have no size variants).
+    long_blob = connection.adapter_name.match?(/mysql|trilogy/i) ? { size: :long } : {}
+
+    create_table :inline_forms_trashed_files do |t|
+      t.string   :record_type, null: false
+      t.bigint   :record_id, null: false
+      t.string   :attribute_name, null: false
+      t.string   :filename
+      t.string   :content_type
+      t.bigint   :byte_size
+      t.string   :checksum, limit: 64
+      t.binary   :data, **long_blob
+      t.string   :reason, null: false
+      t.boolean  :redacted, null: false, default: false
+      t.bigint   :trashed_by_id
+      t.datetime :trashed_at, null: false
+      t.bigint   :restored_by_id
+      t.datetime :restored_at
+      t.bigint   :purged_by_id
+      t.datetime :purged_at
+      t.datetime :purge_after
+      t.timestamps
+    end
+    add_index :inline_forms_trashed_files, [ :record_type, :record_id, :attribute_name ],
+              name: "index_inline_forms_trashed_files_on_slot"
+    add_index :inline_forms_trashed_files, [ :purged_at, :restored_at, :purge_after ],
+              name: "index_inline_forms_trashed_files_on_state"
+
+    create_table :inline_forms_file_trash_sweeps do |t|
+      t.datetime :ran_at, null: false
+      t.integer  :purged_count, null: false, default: 0
+      t.text     :error
+      t.timestamps
+    end
+  end
+end

data/lib/generators/inline_forms_addto_generator.rb

@@ -117,6 +117,12 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
 
         if attribute.column_type == :belongs_to
           @migration_lines << "    add_reference :#{table_name}, :#{attribute.name}, foreign_key: true\n"
+        elsif attribute.type == :simple_file_field
+          # Declared file slot: filename + bytes (LONGBLOB on MySQL) + content type.
+          columns = InlineForms.file_slot_columns(attribute.name)
+          @migration_lines << "    add_column :#{table_name}, :#{columns[:filename]}, :string\n"
+          @migration_lines << "    add_column :#{table_name}, :#{columns[:data]}, :binary, **(connection.adapter_name.match?(/mysql|trilogy/i) ? { size: :long } : {})\n"
+          @migration_lines << "    add_column :#{table_name}, :#{columns[:content_type]}, :string\n"
         else
           commenter = attribute.attribute_type == :unknown ? "#" : " "
           @migration_lines << "#{commenter}    add_column :#{table_name}, :#{attribute.name}, :#{attribute.column_type}\n"
@@ -158,6 +164,8 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
           inject_class_line!("  has_and_belongs_to_many :#{attribute.name}\n")
         when :rich_text
           inject_class_line!("  has_rich_text :#{attribute.name}\n")
+        when :simple_file_field
+          add_file_slot!(attribute)
         end
 
         next unless attribute.attribute?
@@ -182,6 +190,45 @@ class InlineFormsAddtoGenerator < Rails::Generators::NamedBase
 
     private
 
+    # A :simple_file_field is a declared file slot: the model gets
+    # InlineForms::StoredFiles + `inline_forms_file :attr`, and the resource
+    # block in routes.rb gets InlineForms.file_routes(self) (when it can be
+    # found; otherwise a reminder).
+    def add_file_slot!(attribute)
+      content = File.read(File.join(destination_root, model_file_path))
+      include_line = "  include InlineForms::StoredFiles\n"
+      macro = "  inline_forms_file :#{attribute.name}\n"
+      return if content.include?(macro)
+
+      if content.include?(include_line)
+        inject_into_file model_file_path, macro, after: include_line
+      else
+        # One injection: inject_into_class puts each line right under the
+        # class line, so two calls would land the macro above the include.
+        inject_class_line!(include_line + macro)
+      end
+      add_file_routes!
+    end
+
+    def add_file_routes!
+      routes = "config/routes.rb"
+      path = File.join(destination_root, routes)
+      return unless File.exist?(path)
+
+      content = File.read(path)
+      opener = content[/^(\s*)resources :#{table_name} do\n/]
+      if opener.nil?
+        say_status :reminder, "add InlineForms.file_routes(self) inside `resources :#{table_name} do ... end` in #{routes}", :yellow
+        return
+      end
+      block = content[content.index(opener)..][/\A.*?^\s*end$/m]
+      return if block&.include?("InlineForms.file_routes")
+
+      indent = opener[/\A\s*/]
+      inject_into_file routes, "#{indent}  InlineForms.file_routes(self)\n", after: opener
+    end
+
+
     def model_file_name
       name.underscore
     end

data/lib/generators/inline_forms_generator.rb

@@ -66,6 +66,7 @@ module InlineForms
         @order                    = "\n"
         @list_scopes              = ""
         @carrierwave_mounters     = "\n"
+        @stored_files             = String.new
         @inline_forms_attribute_list  = String.new
 
         for attribute in attributes
@@ -94,6 +95,12 @@ module InlineForms
           if attribute.type == :rich_text
             @has_rich_text << '  has_rich_text :' + attribute.name + "\n"
           end
+          # Declared file slot: bytes + content type in the model's own table,
+          # replace/remove/undo through the file trash (InlineForms::StoredFiles).
+          if attribute.type == :simple_file_field
+            @stored_files << "  include InlineForms::StoredFiles\n" if @stored_files.empty?
+            @stored_files << '  inline_forms_file :' + attribute.name + "\n"
+          end
           if attribute.name == '_presentation'
             @presentation <<  "  def _presentation\n" +
               "    \"#{attribute.type.to_s}\"\n" +
@@ -142,10 +149,11 @@ module InlineForms
 
     def generate_resource_route
       if @flag_create_resource_route
+        file_routes = file_slot_attributes.any? ? "\n            InlineForms.file_routes(self)" : ""
         route <<-ROUTE.strip_heredoc
           resources :#{resource_name} do
             post 'revert', :on => :member
-            get 'list_versions', :on => :member
+            get 'list_versions', :on => :member#{file_routes}
           end
         ROUTE
       end
@@ -156,7 +164,12 @@ module InlineForms
         @columns = String.new
 
         for attribute in attributes
-          if attribute.column_type == :image
+          if attribute.type == :simple_file_field
+            columns = InlineForms.file_slot_columns(attribute.name)
+            @columns << '      t.string :' + columns[:filename] + "\n"
+            @columns << '      t.binary :' + columns[:data] + ", **(connection.adapter_name.match?(/mysql|trilogy/i) ? { size: :long } : {})\n"
+            @columns << '      t.string :' + columns[:content_type] + "\n"
+          elsif attribute.column_type == :image
             @columns << '      t.string    :' + attribute.name + "_file_name\n"
             @columns << '        t.string    :' + attribute.name + "_content_type\n"
             @columns << '        t.integer   :' + attribute.name + "_file_size\n"
@@ -230,6 +243,10 @@ module InlineForms
 
 
     private
+    def file_slot_attributes
+      attributes.select { |attribute| attribute.type == :simple_file_field }
+    end
+
     def model_file_name
       name.underscore
     end

data/lib/generators/templates/model.erb

@@ -6,6 +6,10 @@ class <%= name %> < ApplicationRecord
 <%= @habtm if @habtm.length > 1 -%>
 <%= @has_rich_text if @has_rich_text.length > 1 -%>
 <%= @has_attached_files if @has_attached_files.length > 1 -%>
+<% unless @stored_files.empty? -%>
+
+<%= @stored_files -%>
+<% end -%>
 <% if @list_scopes && !@list_scopes.empty? -%>
 
 <%= @list_scopes -%>

data/lib/inline_forms/form_element_from_callee.rb

@@ -8,4 +8,29 @@ module InlineForms
     s = s.sub(/\Ablock in /, "")
     s.delete_suffix("_show")
   end
+
+  # Form elements whose +*_show+ helper delegates to another element's, so
+  # their edit link carries the delegate's name (+__callee__+ of the inner
+  # helper) as +form_element+ instead of the declared one.
+  FORM_ELEMENT_DELEGATES = {
+    plain_text_area: :plain_text,
+    text_area: :rich_text
+  }.freeze
+
+  # The +inline_forms_attribute_list+ row for a single-field request, or nil
+  # when +attribute+/+form_element+ (both from params) do not name a row the
+  # UI could have linked to. The controller uses this as a whitelist before
+  # it dispatches +send("#{form_element}_update")+ or touches the attribute.
+  def self.attribute_list_row_for(attribute_list, attribute, form_element)
+    attribute = attribute.to_s
+    form_element = form_element.to_s
+    return nil if attribute.empty? || form_element.empty?
+
+    attribute_list.find do |listed_attribute, declared, *|
+      next false unless listed_attribute.to_s == attribute
+
+      declared.to_s == form_element ||
+        FORM_ELEMENT_DELEGATES[declared.to_s.to_sym].to_s == form_element
+    end
+  end
 end

data/lib/inline_forms/form_elements/simple_file_field_helper.rb

@@ -5,7 +5,15 @@ module InlineForms
       module_eval(<<~'INLINE_FORMS_FORM_ELEMENT', __FILE__, __LINE__ + 1)
     # -*- encoding : utf-8 -*-
     
+    # Two modes. A declared file slot (InlineForms::StoredFiles + routes from
+    # InlineForms.file_routes) renders the slot partial: download through the
+    # gem, replace / remove / undo icons by permission. Anything else keeps the
+    # legacy behaviour below: a link to the host's download route named in the
+    # values hash, and an edit link only while the field is empty.
     def simple_file_field_show(object, attribute)
+      if inline_forms_file_slot_active?(object, attribute)
+        return render(partial: "inline_forms/file_slot", locals: { object: object, attribute: attribute })
+      end
       o = object.send(attribute)
       attributes = @inline_forms_attribute_list || object.inline_forms_attribute_list
       values = attributes.assoc(attribute.to_sym)[2]
@@ -21,11 +29,31 @@ module InlineForms
     end
     
     def simple_file_field_edit(object, attribute)
-      file_field_tag attribute, :class => 'input_text_field'
+      field = file_field_tag attribute, :class => 'input_text_field'
+      return field unless object.class.respond_to?(:inline_forms_file_slot?) && object.class.inline_forms_file_slot?(attribute)
+
+      field = file_field_tag attribute, class: 'input_text_field', required: true
+      return field unless object.inline_forms_file_present?(attribute)
+
+      # Replacing: say which file goes, and where it goes.
+      hint = t("inline_forms.files.replace_hint", filename: object[attribute.to_s])
+      safe_join([ field, content_tag(:span, hint, class: "inline_forms-file-hint") ])
     end
     
     def simple_file_field_update(object, attribute)
-      object.send(attribute.to_s + '=', params[attribute.to_sym])
+      value = params[attribute.to_sym]
+      if object.class.respond_to?(:inline_forms_file_slot?) && object.class.inline_forms_file_slot?(attribute)
+        # A declared slot only takes an uploaded file from a request (a crafted
+        # string would set a filename without bytes). Nothing chosen is a
+        # validation error, not a silent success.
+        if value.respond_to?(:original_filename)
+          object.send(attribute.to_s + '=', value)
+        else
+          object.inline_forms_file_missing!(attribute)
+        end
+        return
+      end
+      object.send(attribute.to_s + '=', value)
     end
     
     # You need to add a route to your routes.rb file: 

data/lib/inline_forms/gem_files.rb

@@ -1,5 +1,8 @@
 # -*- encoding: utf-8 -*-
 
+require "delegate"
+require "rubygems/package"
+
 module InlineFormsGemFiles
   INSTALLER_FILE_PREFIXES = %w[
     bin/inline_forms
@@ -23,8 +26,13 @@ module InlineFormsGemFiles
   # ignores stuff/ is per-machine (present here, absent on the release box), so
   # the token leaked into `gem build` on the release machine. Exclude it hard,
   # independent of any ignore configuration.
+  #
+  # Same for local Claude Code files (untracked, per checkout): .claude/
+  # (launch.json, settings.local.json) and CLAUDE.md.
   EXCLUDED_FILE_PREFIXES = %w[
     stuff/
+    .claude/
+    CLAUDE.md
   ].freeze
 
   module_function
@@ -63,4 +71,33 @@ module InlineFormsGemFiles
       include_installer ? !installer_file : installer_file
     end
   end
+
+  # Mode a file gets inside the .gem: 0755 if the owner may execute it,
+  # else 0644. RubyGems packages each file's on-disk mode (File.lstat) and
+  # `gem install` restores it, and this checkout is group-only (rw-rw----),
+  # so 8.1.53 shipped every file as 0660: only the installing user and group
+  # could read the installed gem, `require "inline_forms"` failed silently
+  # for anyone else (Bundler swallows the LoadError), and a Docker image that
+  # installs as root and runs as another user could not boot.
+  def packaged_mode(mode)
+    (mode & 0o100).zero? ? 0o644 : 0o755
+  end
+
+  # Wraps the tar writer Gem::Package#add_files writes to, so every file
+  # goes in with packaged_mode instead of its on-disk mode.
+  class ReadableTar < SimpleDelegator
+    def add_file_simple(name, mode, size, &block)
+      __getobj__.add_file_simple(name, InlineFormsGemFiles.packaged_mode(mode), size, &block)
+    end
+  end
+
+  module ReadablePackage
+    def add_files(tar)
+      super(ReadableTar.new(tar))
+    end
+  end
 end
+
+# Loaded by every gemspec in this repo, so `gem build`, `rake build` and the
+# CI full gate all package world-readable files whatever the checkout's modes.
+Gem::Package.prepend(InlineFormsGemFiles::ReadablePackage) unless Gem::Package <= InlineFormsGemFiles::ReadablePackage

data/lib/inline_forms/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 module InlineForms
-  VERSION = "8.1.47"
+  VERSION = "8.1.55"
 end

data/lib/inline_forms.rb

@@ -1,5 +1,7 @@
 # -*- encoding : utf-8 -*-
 
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/numeric/time"
 require "inline_forms/version"
 require "inline_forms/attribute_list"
 require "inline_forms/schema_intent"
@@ -18,6 +20,59 @@ require "inline_forms/turbo_tabs_builder"
 module InlineForms
   class PlainTextColumnMissingError < StandardError; end
 
+  # ---- File slots and the file trash (InlineForms::StoredFiles) ------------
+  #
+  # How long a removed/replaced file stays restorable in the trash before the
+  # sweep (`rake inline_forms:file_trash:purge_expired`) deletes its bytes.
+  # nil = never expire (purge by hand only).
+  mattr_accessor :file_trash_retention, default: 30.days
+
+  # Purging also blanks the stored filename (rendered as "removed file").
+  # Off by default: the filename is kept as part of the history.
+  mattr_accessor :file_trash_redact_on_purge, default: false
+
+  # Largest accepted upload for a declared file slot, in bytes; nil = no
+  # limit beyond the web server's. Enforced as a validation error.
+  mattr_accessor :max_file_size, default: nil
+
+  # Column names of a :simple_file_field slot, from its attribute: `filename`
+  # -> data / content_type; `<base>_filename` and any other `<base>` ->
+  # `<base>_data` / `<base>_content_type`. Shared by InlineForms::StoredFiles
+  # (its defaults) and the generators (the columns they create).
+  def self.file_slot_columns(attribute)
+    attribute = attribute.to_s
+    base = attribute == "filename" ? nil : attribute.delete_suffix("_filename")
+    { filename: attribute, data: base ? "#{base}_data" : "data", content_type: base ? "#{base}_content_type" : "content_type" }
+  end
+
+  # Member routes for a resource whose model declares file slots. Call it
+  # inside the resource block (order-independent, unlike a routing concern):
+  #
+  #   resources :clients do
+  #     post 'revert', on: :member
+  #     get 'list_versions', on: :member
+  #     InlineForms.file_routes(self)
+  #   end
+  def self.file_routes(router)
+    router.member do
+      router.get  "download_file"
+      router.post "remove_file"
+      router.post "restore_file"
+      router.post "purge_file"
+      router.get  "trashed_file"
+      router.get  "file_trash"
+    end
+  end
+
+  # The cross-record trash page (superadmin). One line in routes.rb:
+  #   InlineForms.draw_file_trash_routes(self)
+  def self.draw_file_trash_routes(router)
+    router.get  "file_trash",              to: "inline_forms/file_trash#index",    as: :inline_forms_file_trash
+    router.post "file_trash/purge",        to: "inline_forms/file_trash#purge",    as: :inline_forms_file_trash_purge
+    router.post "file_trash/:id/restore",  to: "inline_forms/file_trash#restore",  as: :inline_forms_file_trash_restore
+    router.get  "file_trash/:id/download", to: "inline_forms/file_trash#download", as: :inline_forms_file_trash_download
+  end
+
   # DEFAULT_COLUMN_TYPES holds the standard ActiveRecord::Migration column types.
   # This list provides compatability with the standard types, but we add our own
   # later in 'Special Column Types'.

data/lib/locales/inline_forms.en.yml

@@ -31,6 +31,89 @@ en:
       trash: trash
       list_versions: List versions
       close_versions_list: Close versions list
+    files:
+      download: download
+      replace: replace file
+      remove: remove file
+      restore: restore
+      restore_file: restore file
+      purge: delete permanently
+      undo: undo
+      restore_previous: "restore removed file %{filename}"
+      replace_hint: "The current file %{filename} goes to the trash."
+      confirm_remove:
+        one: "Remove %{filename}? It goes to the trash and can be restored for 1 day."
+        other: "Remove %{filename}? It goes to the trash and can be restored for %{count} days."
+      confirm_remove_no_expiry: "Remove %{filename}? It goes to the trash and can be restored."
+      confirm_restore_swap: "The current file %{current} goes to the trash and %{filename} is put back. Continue?"
+      confirm_purge: "Delete %{filename} permanently? This cannot be undone."
+      notice_removed: "%{filename} removed"
+      notice_restored: File restored.
+      notice_purged: File deleted permanently.
+      notice_already_empty: There was no file to remove.
+      notice_not_restorable: This file can no longer be restored.
+      notice_not_purgeable: This file was already restored or deleted.
+      missing: This file has been removed.
+      trash_header:
+        zero: Removed files
+        one: Removed files (1)
+        other: Removed files (%{count})
+      open_trash: Show removed files
+      close_trash: Hide removed files
+      by_on: "by %{user} on %{at}"
+      by_system: the system
+      redacted_name: "[removed file]"
+      state_restored: "restored by %{user} on %{at}"
+      state_purged: "deleted permanently by %{user} on %{at}"
+      state_expired: expired, will be deleted
+      expired_pending:
+        one: 1 expired file waits for the nightly clean-up.
+        other: "%{count} expired files wait for the nightly clean-up."
+      expires_in:
+        one: "restorable until %{date} (1 day)"
+        other: "restorable until %{date} (%{count} days)"
+      reason:
+        removed: removed
+        replaced: replaced
+        record_destroyed: record deleted
+        orphaned: orphaned bytes
+        uploaded: uploaded
+      event:
+        uploaded: file uploaded
+        removed: file removed
+        replaced: file replaced
+        record_destroyed: file trashed (record deleted)
+        orphaned: orphaned file trashed
+        restored: file restored
+        purged: file deleted
+      global:
+        title: Removed files
+        model: Model
+        state: State
+        all: all
+        filter: filter
+        record: Record
+        record_gone: "%{model} #%{id} (deleted)"
+        slot: Field
+        file: File
+        trashed: Removed
+        actions: Actions
+        purge_selected: Delete selected permanently
+        confirm_purge_selected: Delete the selected files permanently? This cannot be undone.
+        purged_count:
+          one: 1 file deleted permanently.
+          other: "%{count} files deleted permanently."
+        nothing_selected: No files selected.
+        empty: No removed files.
+        sweep_last: "Last clean-up: %{at} (%{count} deleted)"
+        sweep_never: The nightly clean-up has never run.
+        sweep_overdue: The nightly clean-up has not run for more than 48 hours. Check the cron job.
+        sweep_failed: "Last clean-up failed: %{error}"
+        states:
+          trashed: in trash
+          restored: restored
+          purged: deleted
+          expired: expired
     pending_migration:
       notice: "pending migration \u2014 run rails db:migrate"
   succes: success.
@@ -41,3 +124,7 @@ en:
       client:
         first_name: first name
         last_name: last name
+  errors:
+    messages:
+      inline_forms_file_too_large: "is too large (maximum %{count} MB)"
+      inline_forms_file_missing: "no file chosen"