upload_d_n_d 0.9.1

data/lib/generators/upload_d_n_d/templates/validators/file_validator.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# Validateur de fichiers pour ActiveStorage
+# Utilise Marcel pour la détection MIME et vérifie le contenu réel des fichiers
+#
+# @example Utilisation avec has_one_attached
+#   class User < ApplicationRecord
+#     has_one_attached :avatar
+#
+#     validates :avatar, file: {
+#       content_type: ['image/png', 'image/jpeg'],
+#       max_size: 5.megabytes
+#     }
+#   end
+#
+# @example Utilisation avec has_many_attached
+#   class Project < ApplicationRecord
+#     has_many_attached :documents
+#
+#     validates :documents, file: {
+#       content_type: ['application/pdf', 'application/msword'],
+#       max_size: 10.megabytes,
+#       max_files: 5
+#     }
+#   end
+#
+class FileValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return unless value.attached?
+
+    Array(value).each do |file|
+      validate_content_type(record, attribute, file)
+      validate_size(record, attribute, file)
+      validate_mime_type(record, attribute, file) if options[:strict_mime_check]
+    end
+
+    validate_file_count(record, attribute, value) if value.respond_to?(:count)
+  end
+
+  private
+
+  # Valide le content_type déclaré
+  def validate_content_type(record, attribute, file)
+    return unless options[:content_type].present?
+
+    unless file.content_type.in?(Array(options[:content_type]))
+      record.errors.add(
+        attribute,
+        :content_type,
+        message: options[:message] || "n'est pas un type de fichier valide"
+      )
+    end
+  end
+
+  # Valide la taille du fichier
+  def validate_size(record, attribute, file)
+    return unless options[:max_size].present?
+
+    if file.byte_size > options[:max_size]
+      max_size_in_mb = options[:max_size] / 1.megabyte
+      record.errors.add(
+        attribute,
+        :max_size,
+        message: options[:message] || "doit être inférieur à #{max_size_in_mb}MB"
+      )
+    end
+  end
+
+  # Valide le nombre de fichiers (pour has_many_attached)
+  def validate_file_count(record, attribute, value)
+    return unless options[:max_files].present?
+
+    if value.count > options[:max_files]
+      record.errors.add(
+        attribute,
+        :max_files,
+        message: options[:message] || "ne peut pas avoir plus de #{options[:max_files]} fichiers"
+      )
+    end
+  end
+
+  # Détecte le vrai type MIME en analysant le contenu du fichier
+  # Protège contre le spoofing de fichiers (ex: .exe renommé en .jpg)
+  def validate_mime_type(record, attribute, file)
+    return unless options[:content_type].present?
+
+    begin
+      # Marcel analyse le contenu réel du fichier pour détecter son type
+      detected_content_type = detect_content_type(record, attribute, file)
+
+      declared_content_type = file.content_type
+
+      # Vérifie que le type détecté est dans la liste des types autorisés
+      unless detected_content_type.in?(Array(options[:content_type]))
+        record.errors.add(
+          attribute,
+          :spoofed_content_type,
+          message: options[:spoofing_message] ||
+                  "Le type de fichier détecté (#{detected_content_type}) ne correspond pas aux types autorisés"
+        )
+      end
+
+      # Vérifie que le type détecté correspond au type déclaré
+      if detected_content_type != declared_content_type
+        record.errors.add(
+          attribute,
+          :mime_type_mismatch,
+          message: options[:spoofing_message] ||
+                  "Le type de fichier détecté (#{detected_content_type}) " \
+                  "ne correspond pas au type déclaré (#{declared_content_type})"
+        )
+      end
+    rescue StandardError => e
+      record.errors.add(
+        attribute,
+        :mime_type_detection_failed,
+        message: "Impossible de vérifier le type de fichier : #{e.message}"
+      )
+    end
+  end
+
+  # Marcel a besoin des octets du fichier. Avec un champ fichier classique, le
+  # fichier part avec le formulaire et n'est envoyé au stockage qu'après le
+  # `save` : à la validation, `file.download` lèverait
+  # `ActiveStorage::FileNotFoundError`. On lit alors la source encore en attente
+  # (`attachment_changes`) sans la consommer pour l'envoi au stockage. Avec un
+  # blob déjà stocké (zone de dépôt), on retombe sur `file.download`.
+  def detect_content_type(record, attribute, file)
+    io = pending_upload_io(record, attribute, file)
+    return Marcel::MimeType.for(file.download, name: file.filename.to_s) unless io
+
+    io.rewind if io.respond_to?(:rewind)
+    Marcel::MimeType.for(io, name: file.filename.to_s)
+  ensure
+    io.rewind if io.respond_to?(:rewind)
+  end
+
+  def pending_upload_io(record, attribute, file)
+    return unless record.respond_to?(:attachment_changes)
+
+    change = record.attachment_changes[attribute.to_s]
+    return unless change
+
+    blob = file.respond_to?(:blob) ? file.blob : file
+    attachable = pending_attachables_by_key(change)[blob&.key]
+    attachable && readable_io(attachable)
+  end
+
+  # { blob.key => attachable } des sources non encore stockées. has_one :
+  # CreateOne (blob + attachable). has_many : CreateMany (blobs + attachables,
+  # même ordre). La `key` est fiable avant le save (l'id du blob est encore nil).
+  def pending_attachables_by_key(change)
+    if change.respond_to?(:blobs) && change.respond_to?(:attachables)
+      change.blobs.map(&:key).zip(change.attachables).to_h
+    elsif change.respond_to?(:blob) && change.respond_to?(:attachable)
+      { change.blob&.key => change.attachable }
+    else
+      {}
+    end
+  end
+
+  def readable_io(attachable)
+    if attachable.respond_to?(:tempfile) # UploadedFile (ActionDispatch / Rack::Test)
+      attachable.tempfile
+    elsif attachable.is_a?(Hash)
+      attachable[:io]
+    elsif attachable.respond_to?(:read) # IO, File, StringIO...
+      attachable
+    end
+  end
+end

data/lib/tasks/upload_d_n_d_storage.rake

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+namespace :upload_d_n_d do
+  desc "Liste les blobs orphelins (sans rattachement, > min_age, non cités dans un texte). Simulation sauf APPLY=1"
+  task purge_orphans: :environment do
+    apply = ENV["APPLY"] == "1"
+    results = UploadDND::OrphanBlobs.call
+
+    results.each do |result|
+      blob = result.blob
+      puts "blob ##{blob.id} | #{blob.created_at.to_date} | #{blob.filename} | " \
+           "#{ActiveSupport::NumberHelper.number_to_human_size(blob.byte_size)} | service=#{blob.service_name}"
+      if result.purgeable?
+        blob.purge if apply
+        puts "    → #{apply ? "supprimé" : "à supprimer"}"
+      else
+        puts "    → cité dans #{result.citations.join(", ")} : conservé"
+      end
+    end
+
+    purgeable = results.select(&:purgeable?)
+    size = ActiveSupport::NumberHelper.number_to_human_size(purgeable.sum { |result| result.blob.byte_size })
+    puts "#{apply ? "APPLIQUÉ" : "SIMULATION (APPLY=1 pour appliquer)"} : " \
+         "#{purgeable.size} blob(s) #{apply ? "supprimé(s)" : "à supprimer"} (#{size}), " \
+         "#{results.size - purgeable.size} cité(s) dans un texte et conservé(s)."
+  end
+end

data/lib/tasks/upload_d_n_d_tasks.rake

@@ -0,0 +1,20 @@
+namespace :upload_d_n_d do
+  desc "Link gem JS into node_modules for jsbundling compatibility"
+  task :link_js do
+    gem_spec = Gem.loaded_specs["upload_d_n_d"]
+    next unless gem_spec
+
+    gem_path  = gem_spec.gem_dir
+    link_path = Rails.root.join("node_modules", "upload_d_n_d")
+
+    unless link_path.exist?
+      FileUtils.mkdir_p(link_path.dirname)
+      FileUtils.ln_s(gem_path, link_path.to_s)
+      puts "upload_d_n_d: linked JS #{link_path} → #{gem_path}"
+    end
+  end
+end
+
+if Rake::Task.task_defined?("javascript:build")
+  Rake::Task["javascript:build"].enhance([ "upload_d_n_d:link_js" ])
+end

data/lib/upload_d_n_d/attachment_lookup.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Résout un attachment ActiveStorage à partir d'un nom d'attribut venu du
+  # client (paramètre de requête, ou attribute_name stocké dans un
+  # TemporaryAttachment).
+  #
+  # SÉCURITÉ : seule la réflexion du modèle fait foi. Un nom qui ne désigne pas
+  # un attachment déclaré (has_one_attached / has_many_attached) n'est jamais
+  # appelé sur le record — `respond_to?` + `send` laisserait passer `destroy`,
+  # `delete`, `touch`...
+  module AttachmentLookup
+    # @return [ActiveStorage::Attached::One, ActiveStorage::Attached::Many, nil]
+    def self.find(record, attribute_name)
+      return if record.nil? || attribute_name.blank?
+      return unless record.class.respond_to?(:reflect_on_attachment)
+
+      name = attribute_name.to_s
+      return unless record.class.reflect_on_attachment(name)
+
+      record.public_send(name)
+    end
+  end
+end

data/lib/upload_d_n_d/authorization/can_can_can_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Authorization
+    # Adaptateur CanCanCan : `authorize! :action, sujet` sur le contrôleur.
+    # Les sujets génériques sont des symboles, à autoriser dans l'Ability :
+    #   can :create, :upload_d_n_d_attachment
+    # Sans règle, CanCanCan refuse : il n'y a pas de RuleMissing.
+    module CanCanCanAdapter
+      module_function
+
+      def authorize!(controller, subject, action, namespace: nil) # rubocop:disable Lint/UnusedMethodArgument
+        unless defined?(::CanCan::AccessDenied) && controller.respond_to?(:authorize!, true)
+          raise ConfigurationError,
+                "authorization_adapter is :cancancan but #{controller.class} cannot call authorize! " \
+                "(CanCanCan missing)"
+        end
+
+        call(controller, subject, action)
+      end
+
+      def call(controller, subject, action)
+        controller.send(:authorize!, action, subject)
+      rescue ::CanCan::AccessDenied
+        raise Denied
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/authorization/no_authorization.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Authorization
+    # authorization_adapter = :none — opt-out explicite : seule
+    # l'authentification est vérifiée. Signalé au démarrage.
+    module NoAuthorization
+      module_function
+
+      def authorize!(_controller, _subject, _action, namespace: nil); end
+    end
+  end
+end

data/lib/upload_d_n_d/authorization/pundit_adapter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Authorization
+    # Adaptateur Pundit : `authorize sujet, :action?` sur le contrôleur, qui
+    # doit inclure Pundit::Authorization (verify_authorized reste satisfait).
+    module PunditAdapter
+      module_function
+
+      def authorize!(controller, subject, action, namespace: nil)
+        unless defined?(::Pundit) && controller.respond_to?(:authorize, true)
+          raise ConfigurationError,
+                "authorization_adapter is :pundit but #{controller.class} cannot call authorize " \
+                "(Pundit missing or Pundit::Authorization not included)"
+        end
+
+        call(controller, subject, :"#{action}?", namespace)
+      end
+
+      # Avec un namespace, la policy namespacée (authorize [:admin, record] ->
+      # Admin::RecordPolicy) est essayée d'abord, puis la policy top-level : un
+      # namespace de contrôleur (module: dans les routes) ne reflète pas
+      # forcément celui des policies.
+      def call(controller, subject, query, namespace)
+        if namespace.present?
+          begin
+            return controller.send(:authorize, [ *namespace, subject ], query)
+          rescue ::Pundit::NotDefinedError
+            nil # repli sur la policy top-level
+          end
+        end
+
+        controller.send(:authorize, subject, query)
+      rescue ::Pundit::NotAuthorizedError
+        raise Denied
+      rescue ::Pundit::NotDefinedError
+        raise RuleMissing
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/authorization/unconfigured.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Authorization
+    # Aucun adaptateur utilisable (nil, valeur inconnue) : tout est refusé.
+    module Unconfigured
+      module_function
+
+      def authorize!(_controller, subject, action, namespace: nil) # rubocop:disable Lint/UnusedMethodArgument
+        Rails.logger.warn "UploadDND: #{action} on #{subject.class} refused - no authorization adapter configured"
+        raise Denied
+      end
+    end
+  end
+end

data/lib/upload_d_n_d/authorization.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module UploadDND
+  # Port d'autorisation : la question que la gem pose — « l'utilisateur
+  # courant peut-il faire <action> sur <sujet> ? » — indépendamment de la
+  # librairie qui y répond. Chaque librairie est un adaptateur, choisi par
+  # config.authorization_adapter.
+  #
+  # Fail-closed : un adaptateur absent (nil) ou inconnu refuse tout.
+  # L'absence d'autorisation ne s'obtient qu'explicitement, avec :none.
+  module Authorization
+    # Refus. `cause` porte l'exception native de la librairie, s'il y en a une.
+    class Denied < UploadDND::Error; end
+
+    # Aucune règle pour ce sujet (Pundit : policy absente). L'appelant décide
+    # du repli ; à défaut, l'erreur remonte (500).
+    class RuleMissing < UploadDND::Error; end
+
+    # Adaptateur déclaré mais inutilisable (librairie absente, contrôleur sans
+    # la méthode d'autorisation).
+    class ConfigurationError < UploadDND::Error; end
+
+    class << self
+      # @param controller [ActionController::Base] contrôleur de la requête
+      # @param subject [Object, Symbol] record, ou symbole d'une policy générique
+      # @param action [Symbol] :create, :update, :destroy...
+      # @param namespace [Array<Symbol>, nil] namespace de policy à essayer d'abord
+      # @raise [Denied, RuleMissing, ConfigurationError]
+      def authorize!(controller, subject, action, namespace: nil)
+        adapter.authorize!(controller, subject, action, namespace: namespace)
+      end
+
+      def adapter(name = UploadDND.configuration.authorization_adapter)
+        key = name.respond_to?(:to_sym) ? name.to_sym : name
+        adapters.fetch(key, Unconfigured)
+      end
+
+      # Avertit au démarrage quand les uploads ne sont pas protégés par une
+      # librairie d'autorisation.
+      def report(logger = Rails.logger)
+        configured = UploadDND.configuration.authorization_adapter
+        current = adapter(configured)
+
+        if current == NoAuthorization
+          logger.warn "UploadDND: authorization disabled (authorization_adapter = :none) - " \
+                      "uploads and deletions are only checked for authentication"
+        elsif current == Unconfigured
+          logger.warn "UploadDND: no usable authorization adapter (authorization_adapter = #{configured.inspect}) - " \
+                      "all uploads and deletions are refused. Set config.authorization_adapter " \
+                      "to :pundit, :cancancan or :none."
+        end
+      end
+
+      private
+
+      def adapters
+        { pundit: PunditAdapter, cancancan: CanCanCanAdapter, none: NoAuthorization }
+      end
+    end
+  end
+end
+
+require "upload_d_n_d/authorization/pundit_adapter"
+require "upload_d_n_d/authorization/can_can_can_adapter"
+require "upload_d_n_d/authorization/no_authorization"
+require "upload_d_n_d/authorization/unconfigured"

data/lib/upload_d_n_d/configuration.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module UploadDND
+  class Configuration
+    attr_accessor :max_size,
+                  :accepted_types,
+                  :strict_mime_check,
+                  :main_color,
+                  :allow_anonymous_uploads,
+                  :require_authentication,
+                  :temporary_files_retention,
+                  :rejected_blob_purge_window,
+                  :orphan_blob_min_age,
+                  :orphan_scan_columns,
+                  :orphan_scan_patterns,
+                  :orphan_scan_excluded_tables,
+                  :authorization_adapter,
+                  :validator_class,
+                  :active_storage_service,
+                  :on_upload_success,
+                  :on_upload_error,
+                  :on_file_removed,
+                  :delete_route,
+                  :rate_limit_enabled,
+                  :rate_limit_max_requests,
+                  :rate_limit_period
+
+    def initialize
+      # Valeurs par défaut
+      @max_size = 10.megabytes
+      @accepted_types = ".pdf,.doc,.docx,.jpg,.jpeg,.png,.gif"
+      @strict_mime_check = false
+      @main_color = "#E97451"
+      @allow_anonymous_uploads = false
+      @require_authentication = true # Par défaut, authentification requise
+      @temporary_files_retention = 7 # jours
+      # Un blob refusé n'est purgé que s'il a été créé dans cette fenêtre
+      # (envoi en cours) : un blob plus ancien peut être cité dans un HTML
+      # stocké. nil désactive la purge des blobs refusés.
+      @rejected_blob_purge_window = 1.hour
+      # Nettoyage des blobs orphelins (opt-in via UploadDND::PurgeOrphanBlobsJob
+      # ou la tâche rake upload_d_n_d:purge_orphans) :
+      # - âge minimal avant qu'un blob sans rattachement soit candidat ;
+      # - liste blanche des colonnes à scanner ("table.colonne"), nil = toutes
+      #   les colonnes texte/JSON (borne la mémoire sur une grosse base) ;
+      # - motifs LIKE supplémentaires (hôte/bucket du service de stockage) ;
+      # - tables à exclure en plus des tables système.
+      @orphan_blob_min_age = 2.days
+      @orphan_scan_columns = nil
+      @orphan_scan_patterns = nil
+      @orphan_scan_excluded_tables = []
+      @authorization_adapter = detect_authorization_adapter
+      @validator_class = "FileValidator"
+      @active_storage_service = nil # Utilise le service par défaut de Rails
+      @on_upload_success = nil
+      @on_upload_error = nil
+      @on_file_removed = nil
+      # :engine (défaut) : la suppression passe par le moteur de la gem,
+      #   aucune route requise côté app (symétrique de l'upload).
+      # :host (legacy) : la suppression passe par la route membre remove_file
+      #   de l'app (concern Controllers::Uploadable) — nécessite une route
+      #   polymorphique pour le record (cf. README, "Records imbriqués").
+      @delete_route = :engine
+      @rate_limit_enabled = false
+      @rate_limit_max_requests = 10
+      @rate_limit_period = 60 # secondes
+    end
+
+    private
+
+    # Détecte l'adaptateur d'autorisation disponible. nil si aucun : tout
+    # est alors refusé (UploadDND::Authorization), sauf :none explicite.
+    def detect_authorization_adapter
+      return :pundit if defined?(::Pundit)
+      return :cancancan if defined?(::CanCan::Ability)
+
+      nil
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    # Reset de la configuration (utile pour les tests)
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end