upload_d_n_d 0.9.1

data/app/javascript/upload_d_n_d/controllers/preview_controller.js

@@ -0,0 +1,217 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = {
+    url: String,
+    filename: String,
+    contentType: String
+  }
+
+  disconnect() {
+    this.close()
+  }
+
+  // Ouvrir la modale avec prévisualisation
+  open(event) {
+    event.preventDefault()
+
+    const dataset = event.currentTarget.dataset
+    const url = dataset.previewUrl
+    const filename = dataset.previewFilename
+    const contentType = dataset.previewContentType
+
+    // Libellés i18n fournis par les partials (fallback français)
+    this.i18n = {
+      unavailable: dataset.previewI18nUnavailable || 'Aperçu non disponible pour ce type de fichier',
+      download: dataset.previewI18nDownload || 'Télécharger le fichier',
+      close: dataset.previewI18nClose || 'Fermer'
+    }
+
+    this.showPreview(url, filename, contentType)
+  }
+
+  // Afficher la prévisualisation selon le type de fichier
+  showPreview(url, filename, contentType) {
+    if (this.modal) this.close()
+
+    this.previousFocus = document.activeElement
+    this.modal = this.createModal(filename)
+
+    const content = this.modal.querySelector('.udnd-preview-body')
+    content.appendChild(this.buildContent(url, filename, contentType))
+
+    document.body.appendChild(this.modal)
+    document.body.style.overflow = 'hidden'
+
+    // Gestion clavier (Escape + focus trap) et fermeture sur navigation Turbo
+    this.keydownHandler = (e) => this.handleKeydown(e)
+    this.beforeVisitHandler = () => this.close()
+    document.addEventListener('keydown', this.keydownHandler)
+    document.addEventListener('turbo:before-visit', this.beforeVisitHandler)
+
+    this.modal.querySelector('.udnd-preview-close').focus()
+
+    // Animation d'entrée
+    requestAnimationFrame(() => this.modal.classList.add('show'))
+  }
+
+  // Contenu de la modale selon le type de fichier (DOM APIs, jamais d'innerHTML
+  // avec des données utilisateur : filename est contrôlé par l'uploadeur)
+  buildContent(url, filename, contentType) {
+    if (this.isImage(contentType)) {
+      const img = document.createElement('img')
+      img.className = 'udnd-preview-image'
+      img.setAttribute('src', url)
+      img.setAttribute('alt', filename)
+      return img
+    }
+
+    if (this.isPDF(contentType)) {
+      // <object> plutôt qu'<iframe> : fallback natif quand le navigateur
+      // ne sait pas afficher le PDF (Safari mobile notamment)
+      const object = document.createElement('object')
+      object.className = 'udnd-preview-pdf'
+      object.setAttribute('type', 'application/pdf')
+      object.setAttribute('data', url)
+      object.appendChild(this.buildUnsupported(url, filename))
+      return object
+    }
+
+    return this.buildUnsupported(url, filename)
+  }
+
+  buildUnsupported(url, filename) {
+    const wrapper = document.createElement('div')
+    wrapper.className = 'udnd-preview-unsupported'
+
+    const icon = document.createElement('span')
+    icon.innerHTML = this.fileIcon() // SVG statique, sans donnée utilisateur
+    wrapper.appendChild(icon.firstElementChild)
+
+    const message = document.createElement('p')
+    message.textContent = this.i18n.unavailable
+    wrapper.appendChild(message)
+
+    const link = document.createElement('a')
+    link.className = 'udnd-btn-download'
+    link.setAttribute('href', url)
+    link.setAttribute('download', filename)
+    link.textContent = this.i18n.download
+    wrapper.appendChild(link)
+
+    return wrapper
+  }
+
+  // Créer la structure HTML de la modale (DOM APIs)
+  createModal(filename) {
+    const modal = document.createElement('div')
+    modal.className = 'udnd-preview-modal'
+
+    const overlay = document.createElement('div')
+    overlay.className = 'udnd-preview-overlay'
+    overlay.addEventListener('click', () => this.close())
+    modal.appendChild(overlay)
+
+    const container = document.createElement('div')
+    container.className = 'udnd-preview-container'
+    container.setAttribute('role', 'dialog')
+    container.setAttribute('aria-modal', 'true')
+    container.setAttribute('aria-labelledby', 'udnd-preview-title')
+
+    const header = document.createElement('div')
+    header.className = 'udnd-preview-header'
+
+    const title = document.createElement('h3')
+    title.className = 'udnd-preview-title'
+    title.id = 'udnd-preview-title'
+    title.textContent = filename
+    header.appendChild(title)
+
+    const closeButton = document.createElement('button')
+    closeButton.type = 'button'
+    closeButton.className = 'udnd-preview-close'
+    closeButton.setAttribute('aria-label', this.i18n.close)
+    closeButton.innerHTML = this.closeIcon() // SVG statique, sans donnée utilisateur
+    closeButton.addEventListener('click', () => this.close())
+    header.appendChild(closeButton)
+
+    const body = document.createElement('div')
+    body.className = 'udnd-preview-body'
+
+    container.appendChild(header)
+    container.appendChild(body)
+    modal.appendChild(container)
+
+    return modal
+  }
+
+  // Fermer la modale
+  close() {
+    if (!this.modal) return
+
+    const modal = this.modal
+    this.modal = null
+
+    document.removeEventListener('keydown', this.keydownHandler)
+    document.removeEventListener('turbo:before-visit', this.beforeVisitHandler)
+
+    modal.classList.remove('show')
+    setTimeout(() => {
+      modal.remove()
+      document.body.style.overflow = ''
+    }, 300)
+
+    if (this.previousFocus && document.contains(this.previousFocus)) {
+      this.previousFocus.focus()
+    }
+    this.previousFocus = null
+  }
+
+  // Escape ferme la modale, Tab reste piégé dedans
+  handleKeydown(event) {
+    if (event.key === 'Escape') {
+      this.close()
+      return
+    }
+
+    if (event.key === 'Tab' && this.modal) {
+      const focusables = this.modal.querySelectorAll('button, a[href], object')
+      if (focusables.length === 0) return
+
+      const first = focusables[0]
+      const last = focusables[focusables.length - 1]
+
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault()
+        last.focus()
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault()
+        first.focus()
+      }
+    }
+  }
+
+  // Helpers de détection de type
+  isImage(contentType) {
+    return contentType && (
+      contentType.startsWith('image/jpeg') ||
+      contentType.startsWith('image/jpg') ||
+      contentType.startsWith('image/png') ||
+      contentType.startsWith('image/webp') ||
+      contentType.startsWith('image/gif')
+    )
+  }
+
+  isPDF(contentType) {
+    return contentType && contentType.includes('pdf')
+  }
+
+  // SVG statiques (contenu fixe, aucune interpolation)
+  fileIcon() {
+    return '<svg class="udnd-icon udnd-icon-xl" xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z"/><path d="M14 2v5a1 1 0 0 0 1 1h5"/></svg>'
+  }
+
+  closeIcon() {
+    return '<svg class="udnd-icon" xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M18 6 6 18"/><path d="m6 6 12 12"/></svg>'
+  }
+}

data/app/javascript/upload_d_n_d/controllers/uploads_controller.js

@@ -0,0 +1,396 @@
+import { Controller } from "@hotwired/stimulus"
+import { DirectUpload } from "@rails/activestorage"
+
+export default class extends Controller {
+  static targets = ["progressBar"]
+  static values = {
+    attachUrl: String,
+    attributeName: String,
+    recordId: String,
+    recordGid: String,
+    multiple: Boolean,
+    maxSize: Number,
+    acceptedTypes: String,
+    mimeTypes: String,
+    fieldRef: String,
+    i18n: Object
+  }
+
+  connect() {
+    this.dropzone = this.element.querySelector('.udnd-dropzone')
+  }
+
+  // --- Handlers Drag & Drop ---
+  handleDragEnter(e) {
+    e.preventDefault()
+    this.dropzone.classList.add('dragover')
+  }
+
+  handleDragOver(e) {
+    e.preventDefault()
+    this.dropzone.classList.add('dragover')
+  }
+
+  handleDragLeave(e) {
+    this.dropzone.classList.remove('dragover')
+  }
+
+  handleDrop(e) {
+    e.preventDefault()
+    this.dropzone.classList.remove('dragover')
+    const files = Array.from(e.dataTransfer.files)
+    this.processFiles(files)
+  }
+
+  previewFiles(e) {
+    const files = Array.from(e.target.files)
+    this.processFiles(files)
+  }
+
+  // --- Logique d'Upload ---
+  async processFiles(files) {
+    // VALIDATION UX : Si multiple: false, n'accepter qu'un seul fichier
+    if (!this.multipleValue && files.length > 1) {
+      const msg = this.i18nValue.alerts.singleFileOnly
+      this.showAlert(msg.title, msg.text, "warning")
+      // Ne traiter que le premier fichier
+      files = [files[0]]
+    }
+
+    for (const file of files) {
+      if (!this.validateFile(file)) continue
+
+      // État UI "upload en cours"
+      this.element.classList.add('upload-active')
+      this.dropzone?.classList.add('upload-active')
+      const upload = new DirectUpload(file, '/rails/active_storage/direct_uploads', this)
+
+      upload.create((error, blob) => {
+        if (error) {
+          const msg = this.i18nValue.alerts.uploadError
+          this.showAlert(msg.title, msg.text, "error")
+          this.element.classList.remove('upload-active')
+          this.dropzone?.classList.remove('upload-active')
+        } else {
+          this.attachBlob(blob)
+        }
+      })
+    }
+  }
+
+  validateFile(file) {
+    // Validation de la taille
+    if (file.size > this.maxSizeValue) {
+      const msg = this.i18nValue.alerts.fileTooLarge
+      const maxSizeMB = this.maxSizeValue / 1048576
+      this.showAlert(msg.title, msg.text.replace('%{max_size}', maxSizeMB), "error")
+      return false
+    }
+
+    // Validation fichier vide
+    if (file.size === 0) {
+      const msg = this.i18nValue.alerts.emptyFile
+      this.showAlert(msg.title, msg.text, "error")
+      return false
+    }
+
+    // Validation de l'extension — comparaison exacte sur la liste,
+    // pas en substring (".jpe" ne doit pas passer parce que ".jpeg" est accepté)
+    const ext = "." + file.name.split('.').pop().toLowerCase()
+    const acceptedExts = this.acceptedTypesValue.split(',').map(e => e.trim().toLowerCase())
+    if (!acceptedExts.includes(ext)) {
+      const msg = this.i18nValue.alerts.invalidFormat
+      this.showAlert(msg.title, msg.text.replace('%{accepted_types}', this.acceptedTypesValue), "error")
+      return false
+    }
+
+    // Validation du MIME type (sécurité supplémentaire)
+    // Note: file.type peut être trompé mais c'est une première barrière
+    if (file.type && this.hasAcceptedMimeTypesValue) {
+      // mimeTypes : types calculés par le serveur (pas hasMimeTypesValue,
+      // l'attribut est toujours rendu, éventuellement vide)
+      const acceptedMimes = this.mimeTypesValue
+        ? this.mimeTypesValue.split(',').map(m => m.trim())
+        : this.getAcceptedMimeTypes(this.acceptedTypesValue)
+      if (!acceptedMimes.includes(file.type)) {
+        const msg = this.i18nValue.alerts.suspiciousType
+        this.showAlert(msg.title, msg.text, "error")
+        return false
+      }
+    }
+
+    return true
+  }
+
+  // Repli si le serveur n'a pas fourni les types MIME (ancien rendu)
+  // Mapping extensions → MIME types communs
+  getAcceptedMimeTypes(extensions) {
+    const mimeMap = {
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.png': 'image/png',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+      '.pdf': 'application/pdf',
+      '.doc': 'application/msword',
+      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      '.xls': 'application/vnd.ms-excel',
+      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      '.csv': 'text/csv',
+      '.txt': 'text/plain',
+      '.zip': 'application/zip',
+      '.mp4': 'video/mp4',
+      '.mp3': 'audio/mpeg'
+    }
+
+    const exts = extensions.split(',').map(e => e.trim().toLowerCase())
+    return exts.flatMap(ext => mimeMap[ext] || [])
+  }
+
+  get hasAcceptedMimeTypesValue() {
+    return this.acceptedTypesValue && this.acceptedTypesValue.trim().length > 0
+  }
+
+  attachBlob(blob) {
+    const payload = {
+      signed_blob_id: blob.signed_id,
+      attribute_name: this.attributeNameValue,
+      multiple: this.multipleValue
+    }
+
+    // Référence signée du champ : le serveur applique les limites du modèle
+    if (this.fieldRefValue) {
+      payload.field_ref = this.fieldRefValue
+    }
+
+    // Si on a un record existant, on passe son GlobalID
+    if (this.hasRecordGidValue && this.recordGidValue) {
+      payload.record_gid = this.recordGidValue
+    }
+
+    fetch(this.attachUrlValue, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content,
+        'Accept': 'text/vnd.turbo-stream.html'
+      },
+      body: JSON.stringify(payload)
+    })
+    .then(response => {
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`)
+      }
+      return response.text()
+    })
+    .then(html => {
+      Turbo.renderStreamMessage(html)
+      this.element.classList.remove('upload-active')
+      this.dropzone?.classList.remove('upload-active')
+    })
+    .catch(error => {
+      console.error('Upload failed:', error)
+      const msg = this.i18nValue.alerts.attachError
+      this.showAlert(msg.title, msg.text, "error")
+      this.element.classList.remove('upload-active')
+      this.dropzone?.classList.remove('upload-active')
+    })
+  }
+
+  async confirmDelete(e) {
+    e.preventDefault()
+    const url = e.currentTarget.dataset.url
+
+    const msg = this.i18nValue.confirms.deleteFile
+    const confirmed = await this.askConfirmation(
+      msg.title,
+      msg.text,
+      msg.confirmButton,
+      msg.cancelButton
+    )
+
+    if (confirmed) {
+      fetch(url, {
+        method: 'DELETE',
+        headers: {
+          'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]').content,
+          'Accept': 'text/vnd.turbo-stream.html'
+        }
+      })
+      .then(response => {
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`)
+        }
+        return response.text()
+      })
+      .then(html => Turbo.renderStreamMessage(html))
+      .catch(error => {
+        console.error('Delete failed:', error)
+        const errorMsg = this.i18nValue.alerts.deleteError
+        this.showAlert(errorMsg.title, errorMsg.text, "error")
+      })
+    }
+  }
+
+  // --- Helpers UI ---
+  showAlert(title, text, icon) {
+    // Utilise le système de modales natif
+    this.createModal(title, text, icon, false)
+  }
+
+  async askConfirmation(title, text, confirmButtonText, cancelButtonText) {
+    // Utilise le système de modales natif pour la confirmation
+    return this.createModal(title, text, 'warning', true, confirmButtonText, cancelButtonText)
+  }
+
+  // Crée une modale (alert ou confirm) via DOM APIs (pas d'innerHTML)
+  createModal(title, message, type, isConfirm, confirmText = "OK", cancelText = "Cancel") {
+    return new Promise((resolve) => {
+      // Overlay
+      // Listeners directs obligatoires : la modale est appendue à document.body,
+      // hors du scope de ce controller Stimulus — les data-action n'y sont jamais bindés
+      const overlay = document.createElement('div')
+      overlay.className = 'udnd-modal-overlay'
+      overlay.addEventListener('click', (e) => {
+        if (e.target === overlay) this.cancelModal()
+      })
+      overlay.setAttribute('role', 'dialog')
+      overlay.setAttribute('aria-modal', 'true')
+
+      // Modal
+      const modal = document.createElement('div')
+      modal.className = 'udnd-modal'
+
+      // Header + icon
+      const header = document.createElement('div')
+      header.className = 'udnd-modal-header'
+      const iconDiv = document.createElement('div')
+      iconDiv.className = `udnd-modal-icon udnd-modal-icon--${type}`
+      iconDiv.innerHTML = this.getIcon(type) // SVG icons are safe (static content)
+      header.appendChild(iconDiv)
+
+      // Body
+      const body = document.createElement('div')
+      body.className = 'udnd-modal-body'
+      const h3 = document.createElement('h3')
+      h3.className = 'udnd-modal-title'
+      h3.textContent = title
+      const p = document.createElement('p')
+      p.className = 'udnd-modal-message'
+      p.textContent = message
+      body.appendChild(h3)
+      body.appendChild(p)
+
+      // Footer
+      const footer = document.createElement('div')
+      footer.className = 'udnd-modal-footer'
+
+      if (isConfirm) {
+        const cancelBtn = document.createElement('button')
+        cancelBtn.type = 'button'
+        cancelBtn.className = 'udnd-modal-button udnd-modal-button--cancel'
+        cancelBtn.addEventListener('click', () => this.cancelModal())
+        cancelBtn.textContent = cancelText
+
+        const confirmBtn = document.createElement('button')
+        confirmBtn.type = 'button'
+        confirmBtn.className = 'udnd-modal-button udnd-modal-button--confirm'
+        confirmBtn.addEventListener('click', () => this.confirmModal())
+        confirmBtn.textContent = confirmText
+
+        footer.appendChild(cancelBtn)
+        footer.appendChild(confirmBtn)
+      } else {
+        const okBtn = document.createElement('button')
+        okBtn.type = 'button'
+        okBtn.className = 'udnd-modal-button udnd-modal-button--primary'
+        okBtn.addEventListener('click', () => this.closeModal())
+        okBtn.textContent = confirmText
+        footer.appendChild(okBtn)
+      }
+
+      modal.appendChild(header)
+      modal.appendChild(body)
+      modal.appendChild(footer)
+      overlay.appendChild(modal)
+
+      const container = document.createElement('div')
+      container.appendChild(overlay)
+      container._resolveFunction = resolve
+      this.currentModalContainer = container
+
+      document.body.appendChild(container)
+
+      // Anime l'ouverture
+      requestAnimationFrame(() => {
+        overlay.classList.add('udnd-modal-overlay--active')
+      })
+
+      // Gestion Escape
+      this.modalKeydownHandler = (e) => {
+        if (e.key === 'Escape') {
+          this.cancelModal()
+        }
+      }
+      document.addEventListener('keydown', this.modalKeydownHandler)
+    })
+  }
+
+  getIcon(type) {
+    const icons = {
+      info: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>',
+      success: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/></svg>',
+      warning: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg>',
+      error: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/></svg>'
+    }
+    return icons[type] || icons.info
+  }
+
+  confirmModal() {
+    if (this.currentModalContainer?._resolveFunction) {
+      this.currentModalContainer._resolveFunction(true)
+    }
+    this.closeModal()
+  }
+
+  cancelModal() {
+    if (this.currentModalContainer?._resolveFunction) {
+      this.currentModalContainer._resolveFunction(false)
+    }
+    this.closeModal()
+  }
+
+  closeModal() {
+    if (!this.currentModalContainer) return
+
+    // Résout la Promise pour les alertes simples
+    if (this.currentModalContainer._resolveFunction) {
+      this.currentModalContainer._resolveFunction(true)
+    }
+
+    const overlay = this.currentModalContainer.querySelector('.udnd-modal-overlay')
+    overlay.classList.remove('udnd-modal-overlay--active')
+
+    // Supprime du DOM après l'animation
+    setTimeout(() => {
+      this.currentModalContainer?.remove()
+      this.currentModalContainer = null
+    }, 300)
+
+    // Nettoie le listener Escape
+    if (this.modalKeydownHandler) {
+      document.removeEventListener('keydown', this.modalKeydownHandler)
+      this.modalKeydownHandler = null
+    }
+  }
+
+  // Callback obligatoire pour DirectUpload (ActiveStorage)
+  directUploadWillStoreFileWithXHR(xhr) {
+    xhr.upload.addEventListener("progress", event => {
+      const progress = (event.loaded / event.total) * 100
+      if (this.hasProgressBarTarget) {
+        this.progressBarTarget.style.width = `${progress}%`
+      }
+    })
+  }
+}

data/app/javascript/upload_d_n_d/index.js

@@ -0,0 +1,13 @@
+import UploadsController from "./controllers/uploads_controller.js"
+import PreviewController from "./controllers/preview_controller.js"
+
+// Export nommés pour usage manuel
+export { UploadsController, PreviewController }
+
+// Auto-enregistrement des controllers Stimulus
+// L'app hôte doit juste ajouter : import "upload_d_n_d"
+const application = window.Stimulus
+if (application) {
+  application.register("upload-d-n-d--uploads", UploadsController)
+  application.register("upload-d-n-d--preview", PreviewController)
+}

data/app/jobs/upload_d_n_d/application_job.rb

@@ -0,0 +1,4 @@
+module UploadDND
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/upload_d_n_d/cleanup_temporary_attachments_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Purge les fichiers temporaires expirés (au-delà de
+  # temporary_files_retention jours, 7 par défaut).
+  #
+  # La gem fournit le job mais ne le planifie pas : brancher la récurrence
+  # côté app hôte (solid_queue recurring, sidekiq-cron, whenever...).
+  # Voir la section "Nettoyage automatique" du README.
+  class CleanupTemporaryAttachmentsJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      TemporaryAttachment.cleanup_expired!
+    end
+  end
+end

data/app/jobs/upload_d_n_d/purge_orphan_blobs_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Nettoie les blobs orphelins listés par UploadDND::OrphanBlobs. Opt-in : la
+  # gem fournit le job, l'app hôte le planifie (voir README, "Nettoyage
+  # automatique"). apply: false (défaut) journalise un rapport sans supprimer ;
+  # l'app passe apply: true en connaissance de cause.
+  class PurgeOrphanBlobsJob < ApplicationJob
+    queue_as :default
+
+    def perform(apply: false)
+      results = UploadDND::OrphanBlobs.call
+      purgeable = results.select(&:purgeable?)
+
+      purgeable.each { |result| result.blob.purge } if apply
+
+      size = ActiveSupport::NumberHelper.number_to_human_size(purgeable.sum { |result| result.blob.byte_size })
+      Rails.logger.info(
+        "UploadDND::PurgeOrphanBlobsJob: #{purgeable.size} blob(s) orphelin(s) " \
+        "#{apply ? "purgé(s)" : "à purger (simulation)"} (#{size}), " \
+        "#{results.size - purgeable.size} cité(s) dans un texte et conservé(s)."
+      )
+    end
+  end
+end