react-manifest-rails 0.2.33 → 0.2.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03532c58c1ba02316a423460c591adf2b8caa7d6366ff89abfc5c344d1e3a8fc
-  data.tar.gz: 3ab9a668ad0196bec652c804535307f788a7b6a9abea8418bb3c206d6f6ddba6
+  metadata.gz: 0076f3ffaf1c303d4ac14a8345477b3851045267b0cba8f823f49ce5f17efa4f
+  data.tar.gz: 579d04e786fe515e46d9c56c5c755efcf616cfd49289fcef8ccda0cc4cce7fa8
 SHA512:
-  metadata.gz: 6ff77f4444719e08a35032a2b07bc2d6e0621d49a5db73e2b77880bbddd0172f8c3f2aea1b38b3ce40ff7feaad8d59a141fa7edabe0ce8430091f89656904a42
-  data.tar.gz: d683a77dbcb098e2f5b08c74b1b36dac9d53e56587bf6ec7e958b5f0af25701d98fb9f70a305ceeff2ee0e2656bb81112fddf60cb61f33f21029bf6b445b8291
+  metadata.gz: 6d221314836bc176da1378824e2ab7a55232d5977db2ca46b353d98f499b8e49d31b7999d0787953944db9c8b1c8652f3f17422918ee59d0fd5b78f5d46dca65
+  data.tar.gz: 3eeaba00d80ad2e7c73b1320026ea4b3ed0ed989b5a3c33513a2e45f6e63f7b632b466c2cb192e163b42892f4bce76b2dc59b87b90d90869c4eaa5137f4a8a86

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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

@@ -31,6 +31,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.
@@ -88,6 +104,7 @@ module ReactManifest
       @shared_bundle     = "ux_shared"
       @always_include    = []
       @ignore            = []
+      @isolated_app_dirs = []
       @exclude_paths     = %w[react react_dev vendor]
       @size_threshold_kb = 500
       @extensions        = %w[js jsx]
@@ -150,7 +167,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

data/lib/react_manifest/generator.rb

@@ -150,11 +150,18 @@ module ReactManifest
         files = js_files_in(ctrl[:path])
         bundle_files[bundle_name] = files
 
+        isolated = @config.isolated_app_dirs.include?(ctrl[:name])
+
         files.each do |file_path|
           extract_defined_symbols(file_path).each do |sym|
             next unless sym.match?(/\A[A-Z][A-Za-z0-9_]*\z/)
 
-            symbol_to_bundle[sym] ||= bundle_name
+            # Isolated dirs never register into the shared symbol index, so
+            # no other bundle can ever be inferred to depend on them —
+            # regardless of what their own symbol names happen to collide
+            # with (regex-based usage detection can't tell a real component
+            # reference from an unrelated word appearing as plain JSX text).
+            symbol_to_bundle[sym] ||= bundle_name unless isolated
             bundle_own_symbols[bundle_name] << sym
           end
         end
@@ -388,18 +395,14 @@ module ReactManifest
 
     def extract_defined_symbols(file_path)
       content = File.read(file_path, encoding: "utf-8")
-      symbols = []
-      ReactManifest::Scanner::DEFINITION_PATTERNS.each do |pattern|
-        content.scan(pattern) { |m| symbols << m[0] }
-      end
-      symbols.uniq
+      SymbolExtractor.extract_definitions(content, file_path: file_path)
     rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
       []
     end
 
     def extract_used_component_symbols(file_path)
       content = File.read(file_path, encoding: "utf-8")
-      SymbolExtractor.extract_usages(content)
+      SymbolExtractor.extract_usages(content, file_path: file_path)
     rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
       []
     end

data/lib/react_manifest/scanner.rb

@@ -166,7 +166,7 @@ module ReactManifest
       cache = self.class.file_symbol_cache
       return cache[file_path] if cache.key?(file_path)
 
-      cache[file_path] = parse_definitions(content)
+      cache[file_path] = parse_definitions(content, file_path: file_path)
     end
 
     def scan_file_definitions(file_path)
@@ -175,17 +175,13 @@ module ReactManifest
       rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
         return []
       end
-      parse_definitions(content)
+      parse_definitions(content, file_path: file_path)
     end
 
-    def parse_definitions(content)
+    def parse_definitions(content, file_path: nil)
       return [] unless content
 
-      symbols = []
-      DEFINITION_PATTERNS.each do |pattern|
-        content.scan(pattern) { |m| symbols << m[0] }
-      end
-      symbols.uniq
+      SymbolExtractor.extract_definitions(content, file_path: file_path)
     end
 
     def relative_require_path(abs_path)
@@ -201,7 +197,7 @@ module ReactManifest
         content = shared_file_content[file_path]
         next unless content
 
-        SymbolExtractor.extract_usages(content).each do |sym|
+        SymbolExtractor.extract_usages(content, file_path: file_path).each do |sym|
           next unless controller_symbol_index.key?(sym)
 
           info = controller_symbol_index[sym]
@@ -224,7 +220,7 @@ module ReactManifest
           next
         end
 
-        SymbolExtractor.extract_usages(content).each do |sym|
+        SymbolExtractor.extract_usages(content, file_path: file_path).each do |sym|
           next unless controller_symbol_index.key?(sym)
 
           info = controller_symbol_index[sym]

data/lib/react_manifest/symbol_extractor.rb

@@ -30,9 +30,44 @@ module ReactManifest
 
     module_function
 
-    def extract_definitions(content)
+    # Uses the AST engine (mini_racer) when available; falls back to regex
+    # extraction for this content on any AST failure (unavailable engine,
+    # parse error, unsupported syntax such as TypeScript).
+    def extract_definitions(content, file_path: nil)
       return [] unless content
 
+      if ast_engine_available?
+        result = AstExtractor.extract_definitions(content, file_path: file_path)
+        return result if result
+      end
+
+      regex_extract_definitions(content)
+    end
+
+    def extract_usages(content, file_path: nil)
+      return [] unless content
+
+      if ast_engine_available?
+        result = AstExtractor.extract_usages(content, file_path: file_path)
+        return result if result
+      end
+
+      regex_extract_usages(content)
+    end
+
+    # Decided once per process: does `require "mini_racer"` succeed?
+    def ast_engine_available?
+      return @ast_engine_available if defined?(@ast_engine_available)
+
+      @ast_engine_available = begin
+        require_relative "ast_extractor"
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+    def regex_extract_definitions(content)
       symbols = []
       DEFINITION_PATTERNS.each do |pattern|
         content.scan(pattern) { |m| symbols << m[0] }
@@ -40,9 +75,7 @@ module ReactManifest
       symbols.uniq
     end
 
-    def extract_usages(content)
-      return [] unless content
-
+    def regex_extract_usages(content)
       local_syms = Set.new
       DEFINITION_PATTERNS.each { |p| content.scan(p) { |m| local_syms << m[0] } }