react-manifest-rails 0.2.33 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03532c58c1ba02316a423460c591adf2b8caa7d6366ff89abfc5c344d1e3a8fc
-  data.tar.gz: 3ab9a668ad0196bec652c804535307f788a7b6a9abea8418bb3c206d6f6ddba6
+  metadata.gz: 42ca130740decc2c19123ab8e2d0b368925f0bd988736d84a9087d4016e1836c
+  data.tar.gz: e9e23a7c0eb8dea12f4eb8498f08bff0ea11fe56f168833ae3ef13e090b4d59a
 SHA512:
-  metadata.gz: 6ff77f4444719e08a35032a2b07bc2d6e0621d49a5db73e2b77880bbddd0172f8c3f2aea1b38b3ce40ff7feaad8d59a141fa7edabe0ce8430091f89656904a42
-  data.tar.gz: d683a77dbcb098e2f5b08c74b1b36dac9d53e56587bf6ec7e958b5f0af25701d98fb9f70a305ceeff2ee0e2656bb81112fddf60cb61f33f21029bf6b445b8291
+  metadata.gz: d73c047a2257f229e26682658c2644c0645fd362ba30f2f2ef34fceb15ecf83cf282b2c7899472e3eb25351b30512b5a3e8dbe456e1057502453876f2ce1868d
+  data.tar.gz: 78ebfd5b3390fa6204d6a59a46d94f1aef87c87359b499049f745da68d493f2dab3dd4fefe1f46667ca1be40f66c02e17fa1b977f3fc5b67370a9ba37a9b0566

data/CHANGELOG.md

@@ -7,6 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-07-15
+
+### Fixed
+- `always_include` no longer double-declares. Its bundles are delivered on every page
+  by their own `<script>` tag (both `react_bundle_tag`/`resolve_bundles` and
+  `react_component` now emit them), and their files are no longer inlined into each
+  controller manifest. Previously the separate tag plus the inline loaded an
+  always_include bundle's **private** files twice on any other controller's page, and a
+  **collided** symbol whose definer lives in an always_include bundle could pull a
+  second definer into the consumer — both causing "Identifier X has already been
+  declared". Controller dependency resolution now treats symbols provided by an
+  always_include bundle as already satisfied, and skips those bundles when inlining
+  dependencies (legacy `auto_shared = false` path included). The "already provided"
+  set is computed from the exact files the always_include `<script>` tag actually
+  carries (its own non-promoted files plus the canonical dependency files it inlines),
+  not from whole dependency bundles — so a consumer never drops a definer for a symbol
+  that lives in a sibling file the tag does not load. Symbol availability that the
+  previous inlining protected (added in 0.2.24) is preserved by the tag `react_component`
+  now emits.
+- One case remains inherently unresolvable by dependency arithmetic: when an
+  `always_include` bundle *consumes* a collided symbol, its tag inlines the
+  first-writer definer, which also lives in that definer's own bundle manifest, so on
+  the definer's own page the file loads twice. `react_manifest:generate` now emits a
+  warning naming the always_include bundle, the duplicated file/symbol, and the owning
+  bundle, with the fix (rename or relocate the collided symbol). Detected in both the
+  default and legacy (`auto_shared = false`) modes.
+
+### Added
+- Auto-promotion: a component defined under `ux/app/<controller>/` but used by any
+  other bundle is now emitted into `ux_shared` (loaded once per page) instead of being
+  inlined into each consumer. This eliminates duplicate top-level `const` declarations
+  ("Identifier X has already been declared") — and the cascading `X is not defined`
+  errors that follow when a SyntaxError aborts a concatenated bundle — for components
+  shared across controllers (e.g. a navbar component pulled in via `always_include`).
+  Files never move; only the `//= require` line's destination changes. Promotion is
+  transitive. `react_manifest:analyze` now lists what was promoted and why. Set
+  `config.auto_shared = false` to restore the previous inline behavior.
+
+### Changed
+- Generated `ux_manifests/*.js` are now treated as build artifacts. `react_manifest:setup`
+  and the development boot step add them to `.gitignore` (idempotently) and keep a
+  committed `.keep` so the directory always exists; setup prints a one-time
+  `git rm --cached` to untrack previously-committed manifests. Production is unaffected
+  (manifests regenerate during `assets:precompile`). Opt out with
+  `config.manage_gitignore = false`. Upgrading an existing app requires no manual step:
+  the first dev boot regenerates manifests and ensures the ignore entry.
+
+## [0.2.34] - 2026-07-02
+
+### Added
+- Optional AST-based symbol extraction: add `gem "mini_racer"` to opt in. Definitions and usages are derived from a real JS/JSX AST (Acorn + acorn-jsx) instead of regex when available, fixing false positives where an unrelated word (e.g. plain JSX text like "Show More") is indistinguishable from a real component reference to a regex scanner. Falls back to regex extraction per-file on any parse failure, always with a line-numbered warning. No behavior change for apps that don't add `mini_racer`.
+- New `config.isolated_app_dirs` option. A listed controller dir's own manifest is generated as usual, but its files/symbols are never inferred as a dependency of any *other* controller's manifest. Without the AST extraction above (i.e. no `mini_racer`), symbol usage detection is regex-based, so a generic component name can collide with an unrelated word appearing as plain JSX text elsewhere (e.g. a `Show` component vs. a "Show More" button label in a completely different controller) and get wrongly inlined into every other bundle. Use this as a manual, always-available fallback for self-contained dirs — e.g. a page-builder tool bundling its own vendored library — that should never leak into other pages, whether or not `mini_racer` is installed.
+
 ## [0.2.33] - 2026-07-01
 
 ### Fixed

data/README.md

@@ -131,6 +131,7 @@ ReactManifest.configure do |config|
   config.extensions       = %w[js jsx]     # add ts tsx for TypeScript
   config.always_include   = []             # extra shared files always added to every bundle
   config.ignore           = []             # controller dir names to skip entirely
+  config.isolated_app_dirs = []            # controller dir names that must never leak into other bundles
   config.exclude_paths    = ["react", "react_dev", "vendor"]  # path segments to exclude
   config.size_threshold_kb = 500           # warn if a bundle exceeds this
   config.dry_run          = false          # never write; only print what would change
@@ -142,11 +143,13 @@ end
 ### Key option notes
 
 - **`ignore`**: skips entire controller dirs under `ux/app/`. `ignore = ["admin"]` excludes `ux/app/admin/`.
+- **`isolated_app_dirs`**: a controller dir's own `ux_<name>.js` is generated as usual, but its files/symbols are never inferred as a dependency of any *other* controller. Without the optional AST engine below (i.e. no `mini_racer`), symbol usage detection is regex-based, so a generic component name can collide with an unrelated word appearing as plain JSX text elsewhere (e.g. a `Show` component vs. a "Show More" button label in a different controller) and get wrongly inlined everywhere. Use this as a manual, always-available fallback for self-contained dirs — e.g. a page-builder tool bundling its own vendored library — that should never leak into other pages, whether or not `mini_racer` is installed. `isolated_app_dirs = ["rvb"]` isolates `ux/app/rvb/`.
 - **`exclude_paths`**: excludes files whose path contains any listed segment. Not based on `application.js`.
 - **`dry_run`**: also honoured by `DRY_RUN=1` environment variable at runtime.
 - **`extensions`**: add `ts` and `tsx` to enable TypeScript source detection.
 - **`external_roots` / `external_providers`**: do not point these at files already inside shared `ux/` dirs (`components/`, `hooks/`, `lib/`, etc.). The generator now skips those overlaps to prevent duplicate declarations in browser runtime.
 - **`stdout_logging`**: `Rails.logger` always receives status lines regardless of this flag. Turn this on only if your `Rails.logger` does *not* already print to your terminal in development — if it does (common with `RAILS_LOG_TO_STDOUT`, Docker, or `bin/dev`/Foreman setups), enabling this prints every line twice.
+- **AST-based symbol extraction**: add `gem "mini_racer"` to your Gemfile to opt in. When present, definitions and usages are derived from a real JS/JSX AST (Acorn) instead of regex, which fixes false positives like a `Show` component colliding with unrelated text such as a "Show More" button label. Falls back to regex extraction per-file on any parse failure (always logged via `Rails.logger.warn` with file/line/column when available) — generation never breaks because of this. Without `mini_racer`, behavior is unchanged from today.
 
 ## Commands
 

data/lib/react_manifest/ast_extractor.rb

@@ -0,0 +1,70 @@
+require "mini_racer"
+require "json"
+require_relative "logging"
+
+module ReactManifest
+  # AST-based symbol extraction backed by an embedded V8 (mini_racer).
+  # Mirrors SymbolExtractor's public interface exactly. Never raises — any
+  # parse or runtime failure returns nil (after logging a warning) so the
+  # caller (SymbolExtractor's dispatcher) can fall back to regex extraction
+  # for that one file.
+  module AstExtractor
+    VENDOR_SCRIPT = File.expand_path("vendor/ast_extractor.js", __dir__)
+
+    GLUE = <<~JS.freeze
+      function __reactManifestExtractDefinitions(content) {
+        return JSON.stringify(__astExtractor.extractDefinitions(content));
+      }
+      function __reactManifestExtractUsages(content) {
+        return JSON.stringify(__astExtractor.extractUsages(content));
+      }
+    JS
+
+    class << self
+      include ReactManifest::Logging
+
+      def extract_definitions(content, file_path: nil)
+        result = call_js("__reactManifestExtractDefinitions", content)
+        return result["definitions"] if result["success"]
+
+        report_error(file_path, result["error"])
+        nil
+      end
+
+      def extract_usages(content, file_path: nil)
+        result = call_js("__reactManifestExtractUsages", content)
+        return result["usages"] if result["success"]
+
+        report_error(file_path, result["error"])
+        nil
+      end
+
+      private
+
+      def context
+        @context ||= begin
+          ctx = MiniRacer::Context.new
+          ctx.eval(File.read(VENDOR_SCRIPT))
+          ctx.eval(GLUE)
+          ctx
+        end
+      end
+
+      def call_js(function_name, content)
+        JSON.parse(context.call(function_name, content))
+      rescue MiniRacer::Error => e
+        @context = nil
+        { "success" => false, "error" => { "message" => e.message, "line" => nil, "column" => nil } }
+      rescue StandardError => e
+        { "success" => false, "error" => { "message" => e.message, "line" => nil, "column" => nil } }
+      end
+
+      def report_error(file_path, error)
+        location = file_path || "unknown file"
+        location = "#{location} at line #{error['line']}, column #{error['column']}" if error && error["line"]
+        message = error ? error["message"] : "unknown error"
+        log_warn "AST parse failed for #{location}: #{message} — falling back to regex extraction for this file."
+      end
+    end
+  end
+end

data/lib/react_manifest/configuration.rb

@@ -21,9 +21,18 @@ module ReactManifest
     # Keeping generated files out of output_dir root avoids clutter.
     attr_accessor :manifest_subdir
 
+    # When true (default), the gem ensures the generated manifest dir is gitignored
+    # (adds the entry on dev boot if missing). Set false to manage .gitignore yourself.
+    attr_accessor :manage_gitignore
+
     # Bundle name for auto-generated shared bundle (all non-app/ dirs)
     attr_accessor :shared_bundle
 
+    # When true (default), a component defined under app_dir but used by any other
+    # bundle is emitted into the shared bundle (loaded once per page) instead of
+    # being inlined into each consumer. Set false to restore legacy inlining.
+    attr_accessor :auto_shared
+
     # Bundles always prepended by react_bundle_tag (e.g. ["ux_main"])
     attr_accessor :always_include
 
@@ -31,6 +40,22 @@ module ReactManifest
     # Example: ignore = ["admin"] skips ux/app/admin/* when building ux_<controller>.js.
     attr_accessor :ignore
 
+    # Controller directory names (under ux_root/app_dir) whose files must never
+    # be inlined into any OTHER controller's manifest via inferred cross-app
+    # dependency detection. Their own ux_<name>.js manifest is unaffected —
+    # still includes all of their own files as usual.
+    #
+    # Symbol usage detection is pure regex (no AST), so a generic component
+    # name can collide with an unrelated word appearing as plain JSX text
+    # elsewhere (e.g. a "Show" component vs a "Show More" button label in a
+    # completely different controller) and get wrongly inlined everywhere.
+    # Use this for self-contained dirs (e.g. a page-builder tool bundling its
+    # own vendored library) that should truly never leak into other bundles.
+    #
+    # Example:
+    #   config.isolated_app_dirs = ["rvb"]
+    attr_accessor :isolated_app_dirs
+
     # Path segments to exclude while scanning files under ux_root.
     # This is segment matching (not full path matching), so "vendor" excludes
     # ux/vendor/foo.js and ux/app/users/vendor/bar.jsx, but not ux/vendor_custom/x.js.
@@ -85,9 +110,12 @@ module ReactManifest
       @app_dir           = "app"
       @output_dir        = "app/assets/javascripts"
       @manifest_subdir   = "ux_manifests"
+      @manage_gitignore  = true
       @shared_bundle     = "ux_shared"
+      @auto_shared       = true
       @always_include    = []
       @ignore            = []
+      @isolated_app_dirs = []
       @exclude_paths     = %w[react react_dev vendor]
       @size_threshold_kb = 500
       @extensions        = %w[js jsx]
@@ -102,6 +130,10 @@ module ReactManifest
       !!@dry_run
     end
 
+    def auto_shared?
+      !!@auto_shared
+    end
+
     def verbose?
       !!@verbose
     end
@@ -110,6 +142,10 @@ module ReactManifest
       !!@stdout_logging
     end
 
+    def manage_gitignore?
+      !!@manage_gitignore
+    end
+
     # Glob fragment used by Dir.glob, e.g. "*.{js,jsx}" or "*.{js,jsx,ts,tsx}"
     def extensions_glob
       "*.{#{extensions.join(',')}}"
@@ -150,7 +186,7 @@ module ReactManifest
     end
 
     def cache_key
-      [ux_root, app_dir, extensions, always_include, exclude_paths, external_providers].hash
+      [ux_root, app_dir, extensions, always_include, exclude_paths, external_providers, isolated_app_dirs].hash
     end
   end
 end