react-manifest-rails 0.2.15 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 292c5ccc8f0c7465c5b4fc176d7b28ff5c53e11bad16689ce9ebfcf028fdc75c
-  data.tar.gz: c77bf1b90b135fccc39b7c27ae2739c36cb891fcf504f33be2a87d3d415928d0
+  metadata.gz: da69c627b8ff77a1d2aa520b4b034aea63c230045ed2dccfcb0175dd9bd71e60
+  data.tar.gz: bbd527c3f9fe99c4e2aa972d0cb8b0ddefef6c9bd61d5022e27b5619d7a3a19b
 SHA512:
-  metadata.gz: a7630b06c178a9d7433aaeef8eaec5c27a32319a8c6c191347cd614b1dde047ee8584cde6a2d16da4436975210479ef3cca12f62953562a6e1f49f3794829ef7
-  data.tar.gz: 28af64d5d5424b6a86b7c8d3b6be5e5b3dd865e500561adc2e4035bd1f38fbbb98ad2211c502003f604bb976967ae8a3eeb6e06c72ca470c06bd4800cef50e8d
+  metadata.gz: b064cc48119471dea358e9c1f428297b518df2b6861ee5b4d0876601a7f724c4d3da97bddfc3a86555a8219d3cfb28b8269671473cb6c3c543f4a3db13741714
+  data.tar.gz: 62c98dbf7a8d0b15fd9cdb8ffa05090bf0929a75bd0259e5b64d84630378cd80df8176f9f49340d607a98765572ce6c5d6ec8126702f3f1324fd259aa26fcec2

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

@@ -15,6 +15,7 @@ module ReactManifest
   #   and produces per-controller lists of referenced shared files.
   #
   # Phase 3 — emits non-fatal warnings.
+  # rubocop:disable Metrics/ClassLength
   class Scanner
     # Patterns to detect symbol definitions (CommonJS and ES module style)
     DEFINITION_PATTERNS = [
@@ -38,15 +39,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[
@@ -58,21 +57,24 @@ module ReactManifest
       Object Array String Number Boolean Symbol Map Set WeakMap
     ].freeze
 
-    Result = Struct.new(:symbol_index, :controller_usages, :warnings, keyword_init: true)
+    Result = Struct.new(:symbol_index, :controller_usages, :warnings, :shared_violations, keyword_init: true)
 
     def initialize(config = ReactManifest.configuration)
       @config = config
     end
 
+    # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
     def scan(classification)
       warnings      = []
       symbol_index  = {}
 
-      # Phase 1: index symbols from shared dirs
+      # Phase 1a: index symbols from shared dirs
+      shared_file_paths = {} # file_path => relative_require_path for all shared files
       classification.shared_dirs.each do |shared_dir|
         js_files_in(shared_dir[:path]).each do |file_path|
           relative = relative_require_path(file_path)
-          symbols  = extract_definitions(file_path)
+          shared_file_paths[file_path] = relative
+          symbols = extract_definitions(file_path)
           symbols.each do |sym|
             if symbol_index.key?(sym)
               warnings << "Duplicate symbol '#{sym}' in #{relative} (already from #{symbol_index[sym]})"
@@ -83,8 +85,41 @@ 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
+
+      # Phase 1d: build controller (app-dir) symbol index for violation detection
+      controller_symbol_index = {}
+      classification.controller_dirs.each do |ctrl|
+        js_files_in(ctrl[:path]).each do |file_path|
+          extract_definitions(file_path).each do |sym|
+            controller_symbol_index[sym] ||= {
+              file: relative_require_path(file_path),
+              controller: ctrl[:name]
+            }
+          end
+        end
+      end
+
       $stdout.puts "[ReactManifest] Shared symbol index: #{symbol_index.size} symbols indexed" if @config.verbose?
 
+      # Phase 1e: detect shared files that use app-dir (controller) symbols
+      shared_violations = detect_shared_violations(shared_file_paths, controller_symbol_index, warnings)
+
       # Phase 2: scan controller dirs for usage
       controller_usages = {}
 
@@ -111,9 +146,11 @@ module ReactManifest
       Result.new(
         symbol_index: symbol_index,
         controller_usages: controller_usages,
-        warnings: warnings
+        warnings: warnings,
+        shared_violations: shared_violations
       )
     end
+    # rubocop:enable Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
 
     private
 
@@ -162,8 +199,38 @@ module ReactManifest
                   "'#{ctrl_name}_<action>.js.jsx' naming convention"
     end
 
+    def detect_shared_violations(shared_file_paths, controller_symbol_index, warnings)
+      violations = []
+      shared_file_paths.each do |file_path, relative|
+        content = begin
+          File.read(file_path, encoding: "utf-8")
+        rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
+          next
+        end
+
+        local_syms = Set.new
+        DEFINITION_PATTERNS.each { |p| content.scan(p) { |m| local_syms << m[0] } }
+
+        [PASCAL_TOKEN_PATTERN, HOOK_TOKEN_PATTERN].each do |pattern|
+          content.scan(pattern) do |match|
+            sym = match[0]
+            next if local_syms.include?(sym)
+            next unless controller_symbol_index.key?(sym)
+
+            info = controller_symbol_index[sym]
+            violations << { shared_file: relative, symbol: sym,
+                            controller: info[:controller], app_file: info[:file] }
+            warnings << "Shared file '#{relative}' uses app-dir symbol '#{sym}' " \
+                        "(from ux/app/#{info[:controller]}). " \
+                        "Move '#{sym}' to a shared dir or the shared file will be incomplete."
+          end
+        end
+      end
+      violations
+    end
+
+    # Count how many controllers use each shared file
     def emit_fanout_warnings(controller_usages, warnings)
-      # Count how many controllers use each shared file
       fanout = Hash.new(0)
       controller_usages.each_value do |files|
         files.each { |f| fanout[f] += 1 }
@@ -190,16 +257,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 +315,12 @@ 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
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.15".freeze
+  VERSION = "0.2.17".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.17
 platform: ruby
 authors:
 - Oliver Noonan