upload_d_n_d 0.9.1

data/lib/generators/upload_d_n_d/mime_type_helper.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Generators
+    module MimeTypeHelper
+      # Mapping des extensions vers MIME types
+      EXTENSION_TO_MIME = {
+        # Images
+        "jpg" => "image/jpeg",
+        "jpeg" => "image/jpeg",
+        "png" => "image/png",
+        "gif" => "image/gif",
+        "webp" => "image/webp",
+        "svg" => "image/svg+xml",
+        "bmp" => "image/bmp",
+        "ico" => "image/x-icon",
+        "tiff" => "image/tiff",
+        "tif" => "image/tiff",
+
+        # Documents
+        "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",
+        "ppt" => "application/vnd.ms-powerpoint",
+        "pptx" => "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "odt" => "application/vnd.oasis.opendocument.text",
+        "ods" => "application/vnd.oasis.opendocument.spreadsheet",
+        "odp" => "application/vnd.oasis.opendocument.presentation",
+
+        # Texte
+        "txt" => "text/plain",
+        "csv" => "text/csv",
+        "html" => "text/html",
+        "htm" => "text/html",
+        "xml" => "text/xml",
+        "json" => "application/json",
+        "md" => "text/markdown",
+
+        # Archives
+        "zip" => "application/zip",
+        "rar" => "application/x-rar-compressed",
+        "7z" => "application/x-7z-compressed",
+        "tar" => "application/x-tar",
+        "gz" => "application/gzip",
+
+        # Audio
+        "mp3" => "audio/mpeg",
+        "wav" => "audio/wav",
+        "ogg" => "audio/ogg",
+        "flac" => "audio/flac",
+        "m4a" => "audio/mp4",
+
+        # Vidéo
+        "mp4" => "video/mp4",
+        "avi" => "video/x-msvideo",
+        "mov" => "video/quicktime",
+        "wmv" => "video/x-ms-wmv",
+        "flv" => "video/x-flv",
+        "webm" => "video/webm",
+        "mkv" => "video/x-matroska"
+      }.freeze
+
+      # Convertit une liste d'extensions ou de MIME types en MIME types
+      # @param types [Array<String>] Liste d'extensions (ex: ['jpg', 'png']) ou MIME types
+      # @return [Array<String>] Liste de MIME types
+      def convert_to_mime_types(types)
+        types.map do |type|
+          type = type.to_s.strip.downcase
+
+          # Si ça commence par un point, on l'enlève
+          type = type.delete_prefix(".")
+
+          # Si c'est déjà un MIME type (contient un /), on le garde tel quel
+          if type.include?("/")
+            type
+          # Sinon, on cherche dans notre mapping
+          elsif EXTENSION_TO_MIME.key?(type)
+            EXTENSION_TO_MIME[type]
+          else
+            # Si on ne trouve pas, on affiche un warning et on garde tel quel
+            say "  ⚠️  Extension inconnue '#{type}', utilisée telle quelle", :yellow
+            type
+          end
+        end.uniq
+      end
+
+      # Retourne une liste lisible des extensions supportées
+      def supported_extensions
+        EXTENSION_TO_MIME.keys.sort
+      end
+
+      # Retourne des exemples d'extensions par catégorie
+      def extension_examples
+        {
+          "Images" => %w[jpg png gif webp svg],
+          "Documents" => %w[pdf doc docx xls xlsx ppt pptx],
+          "Archives" => %w[zip rar 7z tar gz],
+          "Audio" => %w[mp3 wav ogg flac],
+          "Vidéo" => %w[mp4 avi mov webm]
+        }
+      end
+    end
+  end
+end

data/lib/generators/upload_d_n_d/model_generator.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+require_relative "mime_type_helper"
+
+module UploadDND
+  module Generators
+    class ModelGenerator < Rails::Generators::NamedBase
+      include MimeTypeHelper
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Configure un modèle pour utiliser UploadDND avec drag & drop"
+
+      class_option :attribute,
+                   type: :string,
+                   aliases: "-a",
+                   desc: "Nom de l'attribut uploadable (ex: avatar, documents)",
+                   required: true
+
+      class_option :multiple,
+                   type: :boolean,
+                   default: false,
+                   desc: "Upload multiple fichiers (has_many_attached)"
+
+      class_option :content_type,
+                   type: :array,
+                   default: [ "jpg", "png" ],
+                   desc: "Extensions de fichiers acceptées (ex: jpg png pdf) ou MIME types"
+
+      class_option :max_size,
+                   type: :string,
+                   default: "5",
+                   desc: "Taille max en MB"
+
+      class_option :max_files,
+                   type: :string,
+                   default: nil,
+                   desc: "Nombre max de fichiers (pour multiple)"
+
+      class_option :controller,
+                   type: :boolean,
+                   default: true,
+                   desc: "Générer/mettre à jour le controller"
+
+      class_option :views,
+                   type: :boolean,
+                   default: true,
+                   desc: "Générer/mettre à jour les vues"
+
+      def validate_options
+        unless options[:attribute].present?
+          say "❌ L'option --attribute est requise", :red
+          say "Exemple: rails g upload_d_n_d:model User --attribute=avatar", :yellow
+          exit(1)
+        end
+      end
+
+      def check_model_exists
+        unless model_exists?
+          say "❌ Le modèle #{model_path} n'existe pas", :red
+          say "Créez d'abord le modèle avec: rails g model #{class_name}", :yellow
+          exit(1)
+        end
+      end
+
+      def add_uploadable_to_model
+        say "📝 Configuration du modèle (instructions)", :green
+
+        model_content = File.read(model_path)
+
+        already_has_concern = model_content.include?("include UploadDND::Uploadable")
+        already_has_uploadable = model_content.match?(/uploadable\s+:#{attribute_name}/)
+
+        if already_has_concern && already_has_uploadable
+          say "  ✓ Le modèle semble déjà configuré pour :#{attribute_name}", :yellow
+          return
+        end
+
+        say "Ajoutez (ou vérifiez) ces lignes dans #{model_path} :", :yellow
+        say ""
+
+        unless already_has_concern
+          say "  include UploadDND::Uploadable", :cyan
+        end
+        unless already_has_uploadable
+          uploadable_attribute_code.each_line { |l| say l.rstrip, :cyan }
+        end
+
+        say ""
+        say "  Note: uploadable déclare automatiquement has_one_attached / has_many_attached.", :yellow
+        say "  Inutile de le déclarer séparément.", :yellow
+        say ""
+      end
+
+      def add_active_storage_association
+        # Non-invasif: inclus dans add_uploadable_to_model (instructions), on garde la méthode
+        # pour compatibilité de flow / messages.
+      end
+
+      def update_controller
+        return unless options[:controller]
+
+        if controller_exists?
+          say "🎮 Controller existant détecté (instructions)", :green
+          show_controller_instructions
+        else
+          say "🎮 Génération du controller...", :green
+          generate_controller
+        end
+      end
+
+      def add_routes_for_uploads
+        say "🛣️  Routes (instructions)", :green
+
+        say "Ajoutez ces routes dans config/routes.rb (dans le bon scope/namespace) :", :yellow
+        say ""
+
+        if namespaced?
+          say "  # Exemple si votre ressource est dans un namespace (adaptez au vôtre)", :cyan
+          say "  namespace :#{namespace_path.underscore} do", :cyan
+          say "    resources :#{plural_name} do", :cyan
+          say "      member do", :cyan
+          say "        post :attach_file", :cyan
+          say "        delete :remove_file", :cyan
+          say "      end", :cyan
+          say "    end", :cyan
+          say "  end", :cyan
+        else
+          say "  resources :#{plural_name} do", :cyan
+          say "    member do", :cyan
+          say "      post :attach_file", :cyan
+          say "      delete :remove_file", :cyan
+          say "    end", :cyan
+          say "  end", :cyan
+        end
+
+        say ""
+      end
+
+      def update_views
+        return unless options[:views]
+
+        say "👁️  Instructions pour les vues", :green
+        show_view_instructions
+      end
+
+      def add_uploadable_concern_to_controller
+        # Non-invasif: on n'injecte plus dans les controllers existants.
+      end
+
+      def add_actions_to_before_action
+        # Non-invasif: instructions via show_controller_instructions
+      end
+
+      def show_summary
+        extensions = normalized_content_types
+        mime_types = convert_to_mime_types(extensions)
+
+        say "\n✅ Configuration terminée!", :green
+        say "\n📋 Résumé:", :cyan
+        say "  Modèle: #{class_name}"
+        say "  Namespace: #{namespace_path}" if namespaced?
+        say "  Attribut: #{attribute_name}"
+        say "  Type: #{options[:multiple] ? 'multiple' : 'simple'}"
+        say "  Extensions: #{extensions.join(', ')}"
+        say "  MIME types: #{mime_types.join(', ')}"
+        say "  Taille max: #{options[:max_size]}MB"
+        say "  Fichiers max: #{options[:max_files]}" if options[:max_files]
+
+        say "\n📝 Prochaines étapes:", :yellow
+        say "  1. Copiez/collez les snippets affichés (modèle/routes/controller si applicable)"
+        say "  2. Lancez la migration si nécessaire: rails db:migrate"
+        say "  3. Vérifiez #{model_path}"
+        say "  4. Vérifiez #{controller_path}" if options[:controller]
+        say "  5. Vérifiez les vues dans #{views_path}" if options[:views]
+        say "\n💡 Utilisez dans vos vues:", :cyan
+        say "  <%= upload_field :#{attribute_name}, record: @#{singular_name} %>"
+      end
+
+      private
+
+      def model_exists?
+        File.exist?(model_path)
+      end
+
+      def controller_exists?
+        File.exist?(controller_path)
+      end
+
+      def model_path
+        @model_path ||= File.join("app/models", "#{file_path}.rb")
+      end
+
+      def controller_path
+        @controller_path ||= File.join("app/controllers", namespace_path, "#{plural_name}_controller.rb")
+      end
+
+      def views_path
+        @views_path ||= File.join("app/views", namespace_path, plural_name)
+      end
+
+      def namespace_path
+        @namespace_path ||= class_path.join("/")
+      end
+
+
+      def model_class_name
+        class_name.split("::").last
+      end
+
+      def attribute_name
+        options[:attribute]
+      end
+
+      def singular_name
+        file_name.split("/").last
+      end
+
+      def uploadable_attribute_code
+        max_files_option = options[:max_files] ? ",\n             max_files: #{options[:max_files]}" : ""
+        multiple_option = options[:multiple] ? ",\n             multiple: true" : ""
+
+        # Utilise accept: avec symboles (nouvelle API v0.4.0)
+        extensions = normalized_content_types.map { |ext| ":#{ext.delete_prefix('.')}" }
+
+        <<~RUBY.indent(2)
+
+          uploadable :#{attribute_name},
+                     accept: [#{extensions.join(', ')}],
+                     max_size: #{options[:max_size]}.megabytes#{multiple_option}#{max_files_option},
+                     strict_mime_check: true
+        RUBY
+      end
+
+      def update_existing_controller
+        # Non-invasif: on ne modifie plus le controller existant.
+      end
+
+      def generate_controller
+        # Génère un controller basique si il n'existe pas
+        template "controller.rb.tt", controller_path
+      end
+
+      def show_view_instructions
+        say ""
+        say "Dans votre formulaire new.html.erb (création avec uploads temporaires) :", :yellow
+        say ""
+        say "  <%= form_with model: @#{singular_name} do |form| %>", :cyan
+        say "    <%# Champ caché pour lier les uploads temporaires %>", :cyan
+        say "    <%= upload_session_field %>", :cyan
+        say ""
+        say "    <%# Vos autres champs... %>", :cyan
+        say ""
+        say "    <%# Ajoutez le champ d'upload %>", :cyan
+        say "    <%= upload_field :#{attribute_name}, record: @#{singular_name} %>", :cyan
+        say ""
+        say "    <%= form.submit %>", :cyan
+        say "  <% end %>", :cyan
+        say ""
+        say "Dans votre formulaire edit.html.erb (édition, pas besoin de upload_session_field) :", :yellow
+        say ""
+        say "  <%= form_with model: @#{singular_name} do |form| %>", :cyan
+        say "    <%# Vos autres champs... %>", :cyan
+        say "    <%= upload_field :#{attribute_name}, record: @#{singular_name} %>", :cyan
+        say "    <%= form.submit %>", :cyan
+        say "  <% end %>", :cyan
+        say ""
+        say "Dans votre vue show.html.erb (pour afficher les fichiers) :", :yellow
+        say ""
+        say "  <%# Si vous voulez afficher la liste des fichiers : %>", :cyan
+        say "  <%= render 'upload_d_n_d/shared/files_list',", :cyan
+        say "             record: @#{singular_name},", :cyan
+        say "             attribute_name: :#{attribute_name} %>", :cyan
+        say ""
+      end
+
+      def show_controller_instructions
+        say "Ajoutez (ou vérifiez) ces éléments dans #{controller_path} :", :yellow
+        say ""
+        say "  # 1. Incluez le concern", :cyan
+        say "  include UploadDND::Controllers::Uploadable", :cyan
+        say ""
+        say "  # 2. Ajoutez :attach_file et :remove_file dans le before_action", :cyan
+        say "  before_action :set_#{singular_name}, only: [:show, :edit, :update, :destroy, :attach_file, :remove_file]", :cyan
+        say ""
+        say "  # 3. Les actions attach_file et remove_file sont fournies par le concern", :cyan
+        say "  # Elles utilisent @#{singular_name} automatiquement", :cyan
+        say ""
+        say "  # 4. Pour les uploads temporaires (formulaire new/create) :", :cyan
+        say "  def create", :cyan
+        say "    @#{singular_name} = #{class_name}.new(#{singular_name}_params)", :cyan
+        say "    wire_temporary_uploads(@#{singular_name})", :cyan
+        say "    # ...", :cyan
+        say "  end", :cyan
+        say ""
+      end
+
+      # Accepte:
+      # - --content_type=pdf docx pptx
+      # - --content_type=pdf,docx,pptx
+      # - mixte (espaces + virgules)
+      def normalized_content_types
+        Array(options[:content_type])
+          .flat_map { |v| v.to_s.split(/[,\s]+/) }
+          .map(&:strip)
+          .reject(&:empty?)
+          .uniq
+      end
+    end
+  end
+end

data/lib/generators/upload_d_n_d/policy_generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Generators
+    class PolicyGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Generate Pundit policies for UploadDND (temporary + permanent attachments)"
+
+      def create_temporary_attachment_policy
+        template "policies/upload_d_n_d_temporary_attachment_policy.rb",
+                 "app/policies/upload_d_n_d_temporary_attachment_policy.rb"
+      end
+
+      def create_attachment_policy
+        template "policies/upload_d_n_d_attachment_policy.rb",
+                 "app/policies/upload_d_n_d_attachment_policy.rb"
+      end
+
+      def show_readme
+        readme "POLICY_README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/upload_d_n_d/templates/POST_INSTALL

@@ -0,0 +1,62 @@
+===============================================================================
+
+  UploadDND v0.5.0 installé avec succès !
+
+===============================================================================
+
+Prochaines étapes :
+
+  1. Exécuter les migrations :
+
+     rails db:migrate
+
+  2. (Si pas déjà fait) Installer ActiveStorage :
+
+     rails active_storage:install
+     rails db:migrate
+
+  3. Ajouter l'import JavaScript dans votre application.js :
+
+     import "upload_d_n_d"
+
+     Les contrôleurs Stimulus sont auto-enregistrés depuis la gem.
+
+  4. Ajouter le CSS dans votre layout :
+
+     <%= stylesheet_link_tag "upload_d_n_d/application", media: "all" %>
+
+  5. (Optionnel) Configurer les policies Pundit :
+
+     rails generate upload_d_n_d:policy
+
+     Ceci génère les deux policies :
+       - app/policies/upload_d_n_d_temporary_attachment_policy.rb
+       - app/policies/upload_d_n_d_attachment_policy.rb
+
+  6. Utiliser le générateur de modèle (recommandé) :
+
+     rails g upload_d_n_d:model User --attribute=avatar
+     rails g upload_d_n_d:model Project --attribute=documents --multiple --content_type=pdf docx xlsx
+
+  7. Utiliser dans vos vues :
+
+     <%= upload_field :avatar, record: @user %>
+
+  8. Architecture v0.5.0 :
+
+     Tout est servi directement depuis la gem :
+       - UploadDND::Uploadable          (model concern)
+       - UploadDND::Controllers::Uploadable (controller concern)
+       - UploadDND::FileValidator        (file validation)
+       - Contrôleurs Stimulus            (auto-enregistrés via importmap)
+       - CSS                             (servi via asset pipeline)
+       - ViewComponent                   (servi depuis la gem)
+
+     Un simple `bundle update` suffit pour tout mettre à jour.
+
+     Fichiers personnalisables (copiés dans votre app) :
+       - app/controllers/concerns/upload_d_n_d/upload_authorization.rb
+       - app/helpers/upload_d_n_d/upload_helper.rb
+       - config/initializers/upload_d_n_d.rb
+
+===============================================================================

data/lib/generators/upload_d_n_d/templates/concerns/controllers_uploadable.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module UploadDND
+  module Controllers
+    module Uploadable
+      extend ActiveSupport::Concern
+
+      # Action pour attacher un fichier à un record existant
+      # POST /:resource/:id/attach_file
+      def attach_file
+        record = instance_variable_get("@#{controller_name.singularize}")
+        attribute_name = params[:attribute_name]
+        blob_id = params[:blob_id]
+
+        unless record
+          render json: { error: "Enregistrement non trouvé" }, status: :not_found
+          return
+        end
+
+        unless attribute_name.present? && blob_id.present?
+          render json: { error: "Paramètres manquants" }, status: :bad_request
+          return
+        end
+
+        # Récupère le blob ActiveStorage
+        begin
+          blob = ActiveStorage::Blob.find(blob_id)
+        rescue ActiveRecord::RecordNotFound
+          render json: { error: "Fichier non trouvé" }, status: :not_found
+          return
+        end
+
+        # Attache le blob au record
+        attachment = record.send(attribute_name)
+        if attachment.respond_to?(:attach)
+          attachment.attach(blob)
+        else
+          record.send("#{attribute_name}=", blob)
+        end
+
+        if record.save
+          render_file_list(record, attribute_name)
+        else
+          render json: { error: record.errors.full_messages.join(", ") }, status: :unprocessable_entity
+        end
+      end
+
+      # Action pour supprimer un fichier d'un record
+      # DELETE /:resource/:id/remove_file
+      def remove_file
+        record = instance_variable_get("@#{controller_name.singularize}")
+        attribute_name = params[:attribute_name]
+        file_id = params[:file_id]
+
+        unless record
+          render json: { error: "Enregistrement non trouvé" }, status: :not_found
+          return
+        end
+
+        unless attribute_name.present? && file_id.present?
+          render json: { error: "Paramètres manquants" }, status: :bad_request
+          return
+        end
+
+        # Sécurité : vérifie que l'attribut existe et est un attachement
+        unless record.respond_to?(attribute_name)
+          render json: { error: "Attribut inexistant" }, status: :unprocessable_entity
+          return
+        end
+
+        # Trouve et supprime l'attachment
+        begin
+          attachment = ActiveStorage::Attachment.find(file_id)
+
+          # Sécurité : vérifie que l'attachment appartient bien à ce record
+          unless attachment.record_id == record.id && attachment.name == attribute_name
+            render json: { error: "Accès refusé" }, status: :forbidden
+            return
+          end
+
+          attachment.purge
+          render_file_list(record, attribute_name)
+        rescue ActiveRecord::RecordNotFound
+          render json: { error: "Fichier non trouvé" }, status: :not_found
+        end
+      end
+
+      # Lie les uploads temporaires (session) au record avant save
+      # Utiliser dans l'action create :
+      #   wire_temporary_uploads(@record)
+      def wire_temporary_uploads(record)
+        sid = params[:temp_upload_session_id]
+        if sid.present? && sid == UploadDND::SessionId.for(session)
+          record.temp_upload_session_id = sid
+        end
+      end
+
+      private
+
+      def render_file_list(record, attribute_name)
+        respond_to do |format|
+          format.turbo_stream do
+            render turbo_stream: turbo_stream.replace(
+              "udnd_files_list_#{attribute_name}",
+              partial: "upload_d_n_d/shared/files_list",
+              locals: { record: record, attribute_name: attribute_name }
+            )
+          end
+          format.json { render json: { status: "ok" }, status: :ok }
+          format.html { redirect_back fallback_location: root_path, notice: "Fichier mis à jour" }
+        end
+      end
+    end
+  end
+end