react-manifest-rails 0.2.15 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 292c5ccc8f0c7465c5b4fc176d7b28ff5c53e11bad16689ce9ebfcf028fdc75c
-  data.tar.gz: c77bf1b90b135fccc39b7c27ae2739c36cb891fcf504f33be2a87d3d415928d0
+  metadata.gz: fe8b2c7c5aa432ddc840c97ed52cefc7672d5d46ee6abc07e37cf20d9f6032ab
+  data.tar.gz: 16448f82cee7e775111cc883820c14ff37065382452f90acd2b76abf33f807c7
 SHA512:
-  metadata.gz: a7630b06c178a9d7433aaeef8eaec5c27a32319a8c6c191347cd614b1dde047ee8584cde6a2d16da4436975210479ef3cca12f62953562a6e1f49f3794829ef7
-  data.tar.gz: 28af64d5d5424b6a86b7c8d3b6be5e5b3dd865e500561adc2e4035bd1f38fbbb98ad2211c502003f604bb976967ae8a3eeb6e06c72ca470c06bd4800cef50e8d
+  metadata.gz: 841fadadd182db285f3528d571bc0210178233d6da3854da67c3dc70b159110a08744e98bf52547c7f6358a3eed09d5a2ee78fed91103cdd5afa3707b0929f9b
+  data.tar.gz: 8352ee157c4288263bee93f86bcf01d718ef1794990f2dc76b441a9e0911b50311d12b9404eb9949f3353a2646dc350dc4a1b24e32a96b4802d6f64122dadbc1

data/lib/react_manifest/configuration.rb

@@ -54,6 +54,27 @@ module ReactManifest
     # Independent from Rails.logger output.
     attr_accessor :stdout_logging
 
+    # Explicit symbol-to-require-path mapping for external globals.
+    # Use for third-party libraries that export a PascalCase or camelCase symbol
+    # not located inside ux_root (e.g. MiniSearch, Chart.js wrappers).
+    #
+    # Keys are exact symbol names (case-sensitive); values are the Sprockets
+    # require path that should be emitted into the controller manifest.
+    #
+    # Example:
+    #   config.external_providers = { "MiniSearch" => "mini-search", "axios" => "vendor/axios" }
+    attr_accessor :external_providers
+
+    # Extra root directories (absolute or relative to Rails.root) to scan for
+    # symbol definitions outside of ux_root.  Symbols found here are added to
+    # the shared symbol index and will trigger an include when used by a
+    # controller.  Empty by default; files in these dirs are subject to the
+    # same +exclude_paths+ and +extensions+ filters.
+    #
+    # Example:
+    #   config.external_roots = ["app/assets/javascripts/vendor_components"]
+    attr_accessor :external_roots
+
     def initialize
       @ux_root           = "app/assets/javascripts/ux"
       @app_dir           = "app"
@@ -68,6 +89,8 @@ module ReactManifest
       @dry_run           = false
       @verbose           = false
       @stdout_logging    = true
+      @external_providers = {}
+      @external_roots     = []
     end
 
     def dry_run?

data/lib/react_manifest/generator.rb

@@ -84,10 +84,11 @@ module ReactManifest
     def build_controller(ctrl, controller_context)
       lines = header_lines
       dep_requires = controller_dependency_requires(ctrl[:bundle_name], controller_context)
+      ext_reqs = controller_context[:external_requires].fetch(ctrl[:bundle_name], Set.new).to_a.sort
 
       files = js_files_in(ctrl[:path])
       own_requires = files.map { |f| relative_require_path(f) }
-      all_requires = (dep_requires + own_requires).uniq
+      all_requires = (dep_requires + ext_reqs + own_requires).uniq
 
       if all_requires.empty?
         lines << "// (no JSX files found in #{ctrl[:name]}/)"
@@ -101,8 +102,11 @@ module ReactManifest
     def build_controller_context(controller_dirs)
       bundle_files = {}
       symbol_to_bundle = {}
+      external_symbol_to_require = {}
       dependencies = Hash.new { |h, k| h[k] = Set.new }
+      external_requires = Hash.new { |h, k| h[k] = Set.new }
 
+      # Index controller-defined symbols for cross-app detection
       controller_dirs.each do |ctrl|
         bundle_name = ctrl[:bundle_name]
         files = js_files_in(ctrl[:path])
@@ -117,20 +121,39 @@ module ReactManifest
         end
       end
 
+      # Index symbols from external_roots dirs
+      @config.external_roots.each do |root_path|
+        abs_root = abs_external_root(root_path)
+        external_js_files_in(abs_root).each do |file_path|
+          req_path = relative_require_path(file_path)
+          extract_defined_symbols(file_path).each do |sym|
+            external_symbol_to_require[sym] ||= req_path
+          end
+        end
+      end
+
+      # Explicit external_providers win over scanned roots on symbol conflicts
+      @config.external_providers.each do |sym, req_path|
+        external_symbol_to_require[sym] = req_path
+      end
+
+      # Compute per-bundle cross-app and external dependencies
       bundle_files.each do |bundle_name, files|
         files.each do |file_path|
           extract_used_component_symbols(file_path).each do |sym|
             dep_bundle = symbol_to_bundle[sym]
-            next unless dep_bundle && dep_bundle != bundle_name
+            dependencies[bundle_name] << dep_bundle if dep_bundle && dep_bundle != bundle_name
 
-            dependencies[bundle_name] << dep_bundle
+            req_path = external_symbol_to_require[sym]
+            external_requires[bundle_name] << req_path if req_path
           end
         end
       end
 
       {
         bundle_files: bundle_files,
-        dependencies: dependencies
+        dependencies: dependencies,
+        external_requires: external_requires
       }
     end
 
@@ -290,14 +313,19 @@ module ReactManifest
 
     def extract_used_component_symbols(file_path)
       content = File.read(file_path, encoding: "utf-8")
-      symbols = []
 
-      content.scan(ReactManifest::Scanner::JSX_ELEMENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::REACT_CREATE_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::JSX_PROP_COMPONENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::OBJECT_COMPONENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::ARRAY_COMPONENT_LIST_PATTERN) do |m|
-        m[0].split(/\s*,\s*/).each { |sym| symbols << sym }
+      # Collect locally-defined symbols to avoid self-reference false positives
+      local_syms = Set.new
+      ReactManifest::Scanner::DEFINITION_PATTERNS.each do |pattern|
+        content.scan(pattern) { |m| local_syms << m[0] }
+      end
+
+      symbols = []
+      content.scan(ReactManifest::Scanner::PASCAL_TOKEN_PATTERN) do |m|
+        symbols << m[0] unless local_syms.include?(m[0])
+      end
+      content.scan(ReactManifest::Scanner::HOOK_TOKEN_PATTERN) do |m|
+        symbols << m[0] unless local_syms.include?(m[0])
       end
 
       symbols.uniq
@@ -305,6 +333,21 @@ module ReactManifest
       []
     end
 
+    def external_js_files_in(dir)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "**", @config.extensions_glob))
+         .reject { |f| File.directory?(f) }
+         .reject { |f| excluded_path?(f) }
+         .sort
+    end
+
+    def abs_external_root(path)
+      return path if Pathname.new(path).absolute?
+
+      Rails.root.join(path).to_s
+    end
+
     def auto_generated?(path)
       # Avoid TOCTOU: don't check existence separately — just attempt the read
       # and treat a missing/unreadable file as not auto-generated.

data/lib/react_manifest/scanner.rb

@@ -38,15 +38,13 @@ module ReactManifest
       /^export\s+class\s+([A-Z][A-Za-z0-9_]*)\s*(?:extends|\{)/ # export class Foo
     ].freeze
 
-    # Patterns to detect usage in controller files
-    JSX_ELEMENT_PATTERN      = %r{<([A-Z][A-Za-z0-9_]*)[\s/>]}
-    REACT_CREATE_PATTERN     = /React\.createElement\(\s*([A-Z][A-Za-z0-9_]*)[\s,)]/
-    JSX_PROP_COMPONENT_PATTERN = /[A-Za-z_][A-Za-z0-9_]*\s*=\s*\{\s*([A-Z][A-Za-z0-9_]*)\s*\}/
-    OBJECT_COMPONENT_PATTERN = /:\s*([A-Z][A-Za-z0-9_]*)\b/
-    ARRAY_COMPONENT_LIST_PATTERN = /\[\s*([A-Z][A-Za-z0-9_]*(?:\s*,\s*[A-Z][A-Za-z0-9_]*)*\s*,?)\s*\]/
-    HOOK_CALL_PATTERN        = /\b(use[A-Z][A-Za-z0-9_]*)\s*\(/
+    # Patterns to detect usage in controller files.
+    # Token-based patterns match any identifier occurrence regardless of syntax
+    # context (JSX, constructor, assignment, array, function argument, etc.).
+    PASCAL_TOKEN_PATTERN = /\b([A-Z][A-Za-z0-9_]*)\b/
+    HOOK_TOKEN_PATTERN   = /\b(use[A-Z][A-Za-z0-9_]*)\b/
     # Lib calls matched against known lib symbols to reduce false positives
-    LIB_CALL_PATTERN         = /\b([a-z][A-Za-z0-9_]{2,})\s*\(/
+    LIB_CALL_PATTERN     = /\b([a-z][A-Za-z0-9_]{2,})\s*\(/
 
     # Common JS built-ins to exclude from lib-call matching
     JS_BUILTINS = %w[
@@ -68,7 +66,7 @@ module ReactManifest
       warnings      = []
       symbol_index  = {}
 
-      # Phase 1: index symbols from shared dirs
+      # Phase 1a: index symbols from shared dirs
       classification.shared_dirs.each do |shared_dir|
         js_files_in(shared_dir[:path]).each do |file_path|
           relative = relative_require_path(file_path)
@@ -83,6 +81,23 @@ module ReactManifest
         end
       end
 
+      # Phase 1b: index symbols from external_roots dirs
+      @config.external_roots.each do |root_path|
+        abs_root = abs_external_root(root_path)
+        js_files_in(abs_root).each do |file_path|
+          relative = relative_require_path(file_path)
+          symbols  = extract_definitions(file_path)
+          symbols.each do |sym|
+            symbol_index[sym] ||= relative
+          end
+        end
+      end
+
+      # Phase 1c: add explicit external_providers (highest precedence — wins on conflict)
+      @config.external_providers.each do |sym, require_path|
+        symbol_index[sym] = require_path
+      end
+
       $stdout.puts "[ReactManifest] Shared symbol index: #{symbol_index.size} symbols indexed" if @config.verbose?
 
       # Phase 2: scan controller dirs for usage
@@ -190,16 +205,37 @@ module ReactManifest
     def extract_used_shared_paths(content, symbol_index)
       used = Set.new
 
-      scan_component_usage(content, JSX_ELEMENT_PATTERN, symbol_index, used)
-      scan_component_usage(content, REACT_CREATE_PATTERN, symbol_index, used)
-      scan_component_usage(content, JSX_PROP_COMPONENT_PATTERN, symbol_index, used)
-      scan_component_usage(content, OBJECT_COMPONENT_PATTERN, symbol_index, used)
-      scan_array_component_usage(content, symbol_index, used)
-      scan_component_usage(content, HOOK_CALL_PATTERN, symbol_index, used)
+      # Collect locally-defined symbols so we don't count a file as "using"
+      # its own exports (avoid self-referencing false positives).
+      local_syms = Set.new
+      DEFINITION_PATTERNS.each do |pattern|
+        content.scan(pattern) { |m| local_syms << m[0] }
+      end
+
+      # PascalCase token scan: catches JSX elements, constructors (new Foo()),
+      # prop values, array entries, function arguments, assignments, etc.
+      content.scan(PASCAL_TOKEN_PATTERN) do |match|
+        sym = match[0]
+        next if local_syms.include?(sym)
+        next unless symbol_index.key?(sym)
+
+        used << symbol_index[sym]
+      end
+
+      # Hook token scan: catches useFoo(...) and bare useFoo references.
+      content.scan(HOOK_TOKEN_PATTERN) do |match|
+        sym = match[0]
+        next if local_syms.include?(sym)
+        next unless symbol_index.key?(sym)
 
+        used << symbol_index[sym]
+      end
+
+      # Lib call scan (lowercase): already filtered to symbol_index keys.
       content.scan(LIB_CALL_PATTERN) do |match|
         sym = match[0]
         next if JS_BUILTINS.include?(sym)
+        next if local_syms.include?(sym)
         next unless symbol_index.key?(sym)
 
         used << symbol_index[sym]
@@ -227,5 +263,11 @@ module ReactManifest
         end
       end
     end
+
+    def abs_external_root(path)
+      return path if Pathname.new(path).absolute?
+
+      Rails.root.join(path).to_s
+    end
   end
 end

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.15".freeze
+  VERSION = "0.2.16".freeze
 end

data/lib/react_manifest.rb

@@ -165,14 +165,19 @@ module ReactManifest
 
     def extract_used_component_symbols(file_path)
       content = File.read(file_path, encoding: "utf-8")
-      symbols = []
 
-      content.scan(ReactManifest::Scanner::JSX_ELEMENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::REACT_CREATE_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::JSX_PROP_COMPONENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::OBJECT_COMPONENT_PATTERN) { |m| symbols << m[0] }
-      content.scan(ReactManifest::Scanner::ARRAY_COMPONENT_LIST_PATTERN) do |m|
-        m[0].split(/\s*,\s*/).each { |sym| symbols << sym }
+      # Collect locally-defined symbols to avoid self-reference false positives
+      local_syms = Set.new
+      ReactManifest::Scanner::DEFINITION_PATTERNS.each do |pattern|
+        content.scan(pattern) { |m| local_syms << m[0] }
+      end
+
+      symbols = []
+      content.scan(ReactManifest::Scanner::PASCAL_TOKEN_PATTERN) do |m|
+        symbols << m[0] unless local_syms.include?(m[0])
+      end
+      content.scan(ReactManifest::Scanner::HOOK_TOKEN_PATTERN) do |m|
+        symbols << m[0] unless local_syms.include?(m[0])
       end
 
       symbols.uniq

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.16
 platform: ruby
 authors:
 - Oliver Noonan