upload_d_n_d 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c93f26a694496d5e6582aaeb7d7d2f723b58fd1684de65da9e6870f099d04b0
-  data.tar.gz: e23c03f1241c7f9488696230c73ebe56e0cf90cebebadaff5c4b76c40d9b77f3
+  metadata.gz: 2bc35467ae9c71f396f1168a6c900f8a828e87ad9491b99abd0f07c3ebfe49ab
+  data.tar.gz: 477cb07d1fda946dfccea4181327a4a5c8ce978998c2183a7fd7b38f1fd1ff6d
 SHA512:
-  metadata.gz: 5f0b4d1593e58c8f0ebec99a3828f5f5754bf38bf3f3e0d8540b6b1f0b3034a23e6667a68a4f0dbb6a37f074bc258764af46c60a3232c19056bd4dc9333edc2f
-  data.tar.gz: 2fe89e1d9d7d865a309d90e3ec4b80e9bbdb68d12edc0b2848de55c61d58d7a663d0cdc1b87de600242d5ece0e62cc16b2c27a775123efdd4ae102e10b4360fb
+  metadata.gz: '09adbe224dd2403b21da5e590e667686dea3c514f9c6c5a11f8cd2b528cf2506883cc283e99b916795afaf9a3278b7ff31c8aa9de41cb8a2ff3b403c5c947d29'
+  data.tar.gz: b5427eda02e120647c435f27df467126cbe24faa060260cd71833b02c57f4aa5adca316db0f6354606b20e632113eb1a48edeba72b8c5928aa94270ee44818fa

data/README.md

@@ -55,6 +55,8 @@ The installer adds `view_component` and `stimulus-rails` if missing, creates the
 
 Everything else (JS, CSS, components, concerns) is served from the gem: upgrading is a `bundle update`.
 
+With **jsbundling-rails** (bun/esbuild), the `upload_d_n_d:link_js` task copies the gem's JS/CSS into `node_modules/upload_d_n_d` so your bundler can resolve `import "upload_d_n_d"` and `@import "upload_d_n_d/styles"`. It is a real directory (not a symlink), so the gem's own imports of `@hotwired/stimulus` and `@rails/activestorage` resolve against your app's `node_modules`. The task runs automatically on `javascript:build` (so `assets:precompile` at deploy is always up to date). Note: a watch-mode dev server such as `bin/dev` calls the bundler directly and does **not** run the task, so after upgrading the gem run `bin/rails javascript:build` once locally to refresh the copy.
+
 ActiveStorage must be installed (`bin/rails active_storage:install`). With an external S3-like bucket and a strict CSP, serve files same-origin:
 
 ```ruby

data/docs/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.4] - 2026-10-29
+
+`link_js` copie le JS/CSS dans `node_modules` au lieu d'un lien symbolique, pour que les imports tiers de la gem se résolvent dans l'app (jsbundling/bun/esbuild). Patch, sans changement d'API.
+
+### Changed
+- **`upload_d_n_d:link_js` copie désormais le JS au lieu de créer un lien symbolique** — le JS de la gem importe `@hotwired/stimulus` et `@rails/activestorage`, que l'app hôte fournit dans ses propres `node_modules`. Avec un lien symbolique, le bundler (bun/esbuild) résolvait ces imports depuis le `realpath` du lien (le dossier de la gem, hors de l'app) et ne les trouvait pas — la compilation échouait (y compris à la construction de l'image de déploiement). La tâche copie maintenant `package.json` et les fichiers des `exports` dans `node_modules/upload_d_n_d` (vrai dossier), ce qui laisse la résolution remonter jusqu'aux dépendances de l'app. La copie est rafraîchie quand la version de la gem change ; un dossier ou fichier **non géré par la gem** (ex. paquet npm) n'est jamais supprimé (avertissement). Un ancien lien symbolique (gem ≤ 0.9.3) est remplacé par la copie au premier `rake upload_d_n_d:link_js` (ou `javascript:build`).
+
+### Migration
+- Les apps qui avaient ajouté `NODE_PATH=node_modules` à leur script de build pour contourner le problème en 0.9.3 peuvent **retirer ce réglage** après passage en 0.9.4 : la copie rend la résolution correcte sans configuration côté app.
+
 ## [0.9.3] - 2026-10-29
 
 Correctifs d'empaquetage pour la consommation de la gem via jsbundling (bun/esbuild) et Tailwind. Patch, sans changement d'API.

data/lib/tasks/upload_d_n_d_tasks.rake

@@ -1,21 +1,21 @@
 require "upload_d_n_d/js_link"
 
 namespace :upload_d_n_d do
-  desc "Link gem JS into node_modules for jsbundling compatibility"
+  desc "Copy 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")
+    gem_path = gem_spec.gem_dir
+    dest = Rails.root.join("node_modules", "upload_d_n_d")
 
-    case UploadDND::JsLink.reconcile(link_path: link_path, target: gem_path)
-    when :created then puts "upload_d_n_d: linked JS #{link_path} → #{gem_path}"
-    when :updated then puts "upload_d_n_d: relinked JS #{link_path} → #{gem_path}"
+    case UploadDND::JsLink.sync(source: gem_path, dest: dest)
+    when :created then puts "upload_d_n_d: copied JS → #{dest}"
+    when :updated then puts "upload_d_n_d: updated JS → #{dest}"
     when :conflict
-      warn "upload_d_n_d: #{link_path} existe et n'est pas un lien géré par la gem ; " \
+      warn "upload_d_n_d: #{dest} existe et n'est pas géré par la gem ; " \
            "laissé tel quel (rien supprimé). Retirez-le pour permettre à " \
-           "`rake upload_d_n_d:link_js` de créer le lien vers #{gem_path}."
+           "`rake upload_d_n_d:link_js` d'y copier le JS de la gem."
     end
   end
 end

data/lib/upload_d_n_d/js_link.rb

@@ -1,62 +1,114 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "json"
 
 module UploadDND
-  # Réconcilie le lien symbolique `node_modules/upload_d_n_d` utilisé par
-  # jsbundling (bun/esbuild) et Tailwind pour résoudre `upload_d_n_d` et
-  # `upload_d_n_d/styles` depuis le paquet de la gem.
+  # Synchronise `node_modules/upload_d_n_d` avec le JS/CSS de la gem
+  # (`package.json` + les fichiers de ses `exports`) en les **copiant**.
   #
-  # Idempotent, et corrige deux cas que la simple présence du lien masquait :
-  # un lien périmé pointant vers une version précédente de la gem (montée de
-  # version), et un lien cassé dont la cible a disparu (où `ln_s` échouerait,
-  # le lien existant déjà).
+  # Pourquoi une copie et non un lien symbolique : le JS de la gem importe des
+  # bibliothèques tierces (`@hotwired/stimulus`, `@rails/activestorage`) que
+  # l'app hôte fournit dans ses propres `node_modules`. Un lien symbolique est
+  # résolu vers son `realpath` (le dossier de la gem, hors de l'app) et la
+  # résolution de ces imports y échoue. Un vrai dossier sous les `node_modules`
+  # de l'app laisse la résolution remonter jusqu'aux dépendances de l'app.
   #
-  # Ne gère que les liens symboliques. Un vrai dossier ou fichier à cet
-  # emplacement (par ex. un paquet installé par npm) n'est jamais supprimé ni
-  # écrasé : la méthode signale un conflit (`:conflict`) et laisse l'appelant
-  # avertir.
+  # La copie est rafraîchie quand la version de la gem change. Un dossier ou
+  # fichier **non géré par la gem** (ex. paquet installé par npm) n'est jamais
+  # supprimé : la méthode signale un conflit et laisse l'appelant avertir.
   module JsLink
+    PACKAGE_NAME = "upload_d_n_d"
+
     module_function
 
-    # Crée ou met à jour le lien `link_path` vers `target`.
+    # Copie/rafraîchit le JS de la gem depuis `source` (gem_dir) vers `dest`
+    # (node_modules/upload_d_n_d).
     #
-    # @param link_path [String, Pathname] emplacement du lien (node_modules/upload_d_n_d)
-    # @param target [String, Pathname] répertoire cible (gem_dir de la gem courante)
+    # @param source [String, Pathname] répertoire de la gem (gem_dir)
+    # @param dest [String, Pathname] destination dans node_modules
     # @return [Symbol] :created, :updated, :unchanged ou :conflict
-    def reconcile(link_path:, target:)
-      link = link_path.to_s
-      target = target.to_s
+    def sync(source:, dest:)
+      source = source.to_s
+      dest = dest.to_s
 
-      if File.symlink?(link)
-        return :unchanged if resolves_to?(link, target)
+      if File.symlink?(dest)
+        replace(source, dest) # ancien lien symbolique (gem <= 0.9.3)
+        :updated
+      elsif File.directory?(dest)
+        return :conflict unless ours?(dest) # dossier étranger : on n'y touche jamais
+        return :unchanged if same_version?(source, dest)
 
-        File.unlink(link) # lien périmé, cassé, ou pointant ailleurs
-        link!(link, target)
+        replace(source, dest) # notre copie, version périmée
         :updated
-      elsif File.exist?(link)
-        :conflict # vrai dossier/fichier (ex. installé par npm) : on n'y touche jamais
+      elsif File.exist?(dest)
+        :conflict # fichier étranger
       else
-        link!(link, target)
+        copy(source, dest)
         :created
       end
     end
 
-    # Confronte la cible réelle du lien au dossier de la gem, après résolution
-    # des deux chemins (chemin relatif, lien intermédiaire) : un lien qui pointe
-    # déjà vers la bonne gem par un chemin indirect n'est pas remplacé. Un lien
-    # cassé ne résout pas (ENOENT) et n'est donc jamais considéré comme à jour.
-    def resolves_to?(link, target)
-      File.realpath(link) == File.realpath(target)
-    rescue Errno::ENOENT
+    # Le dossier est-il une copie gérée par la gem (et non un paquet étranger) ?
+    def ours?(dest)
+      pkg = File.join(dest, "package.json")
+      File.file?(pkg) && read_json(pkg)["name"] == PACKAGE_NAME
+    rescue JSON::ParserError
       false
     end
-    private_class_method :resolves_to?
+    private_class_method :ours?
+
+    def same_version?(source, dest)
+      read_json(File.join(source, "package.json"))["version"] ==
+        read_json(File.join(dest, "package.json"))["version"]
+    end
+    private_class_method :same_version?
+
+    def replace(source, dest)
+      FileUtils.remove_entry(dest)
+      copy(source, dest)
+    end
+    private_class_method :replace
+
+    # Copie `package.json` et les fichiers référencés par ses `exports`, en
+    # conservant leurs chemins relatifs (les `exports` les désignent ainsi).
+    def copy(source, dest)
+      package_files(source).each do |rel|
+        from = File.join(source, rel)
+        to = File.join(dest, rel)
+        FileUtils.mkdir_p(File.dirname(to))
+        FileUtils.cp(from, to)
+      end
+    end
+    private_class_method :copy
+
+    def package_files(source)
+      exports = read_json(File.join(source, "package.json"))["exports"] || {}
+      targets = []
+      collect = lambda do |value|
+        case value
+        when String then targets << value
+        when Hash then value.each_value(&collect)
+        end
+      end
+      exports.each_value(&collect)
+
+      files = [ "package.json" ]
+      targets.each do |target|
+        rel = target.sub(%r{\A\./}, "")
+        if rel.include?("*")
+          Dir.glob(File.join(source, rel)).each { |path| files << path.sub("#{source}/", "") }
+        else
+          files << rel
+        end
+      end
+      files.uniq
+    end
+    private_class_method :package_files
 
-    def link!(link, target)
-      FileUtils.mkdir_p(File.dirname(link))
-      FileUtils.ln_s(target, link)
+    def read_json(path)
+      JSON.parse(File.read(path))
     end
-    private_class_method :link!
+    private_class_method :read_json
   end
 end

data/lib/upload_d_n_d/version.rb

@@ -1,3 +1,3 @@
 module UploadDND
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

data/package.json

@@ -1,6 +1,6 @@
 {
     "name": "upload_d_n_d",
-    "version": "0.9.3",
+    "version": "0.9.4",
     "type": "module",
     "main": "app/javascript/upload_d_n_d/index.js",
     "exports": {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: upload_d_n_d
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Pierre Cherbero