react-manifest-rails 0.2.14 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c85309337765f3f24fae46e4cf3895e11e4a3a59b5cbfb96fa90f296f3ba48e
-  data.tar.gz: b0f320a6ebf2a4210a4fac89d04f5609bd3d261a458f2db26fb92dd814b45465
+  metadata.gz: fe8b2c7c5aa432ddc840c97ed52cefc7672d5d46ee6abc07e37cf20d9f6032ab
+  data.tar.gz: 16448f82cee7e775111cc883820c14ff37065382452f90acd2b76abf33f807c7
 SHA512:
-  metadata.gz: 85edbe32bf32f739097e60779a34874d1c792db5ea40ed41e671e8b0552718d4549dfddb9b120d74bcce42a15bbc598ed0384c7e609cb6f0d4044fb80900098c
-  data.tar.gz: d2728828f1fd930cd702aa35fb4ab5ab88b4219dff1fe996fa5cdb8491888b15bb25b0fd1d44c84aa9c0707cd80b87d3d3c2554b15f0723fd979bf484db4b3f1
+  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

@@ -22,6 +22,7 @@ module ReactManifest
   # to avoid partial reads from concurrent processes.
   #
   # Never touches application.js, application_dev.js, or files in exclude_paths.
+  # rubocop:disable Metrics/ClassLength
   class Generator
     HEADER = <<~JS.freeze
       // AUTO-GENERATED — DO NOT EDIT
@@ -41,11 +42,12 @@ module ReactManifest
     # written and others stale/missing.
     def run!
       classification = @classifier.classify
+      controller_context = build_controller_context(classification.controller_dirs)
 
       # Phase 1: build all content in memory — no I/O.
       manifests = []
       manifests << build_shared(classification.shared_dirs)
-      classification.controller_dirs.each { |ctrl| manifests << build_controller(ctrl) }
+      classification.controller_dirs.each { |ctrl| manifests << build_controller(ctrl, controller_context) }
 
       migrate_legacy_manifests!
 
@@ -79,19 +81,110 @@ module ReactManifest
 
     # --------------------------------------------------------------- controller
 
-    def build_controller(ctrl)
+    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])
-      if files.empty?
+      own_requires = files.map { |f| relative_require_path(f) }
+      all_requires = (dep_requires + ext_reqs + own_requires).uniq
+
+      if all_requires.empty?
         lines << "// (no JSX files found in #{ctrl[:name]}/)"
       else
-        files.each { |f| lines << "//= require #{relative_require_path(f)}" }
+        all_requires.each { |req| lines << "//= require #{req}" }
       end
 
       { filename: "#{ctrl[:bundle_name]}.js", content: "#{lines.join("\n")}\n" }
     end
 
+    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])
+        bundle_files[bundle_name] = files
+
+        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
+          end
+        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]
+            dependencies[bundle_name] << dep_bundle if dep_bundle && dep_bundle != bundle_name
+
+            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,
+        external_requires: external_requires
+      }
+    end
+
+    def controller_dependency_requires(bundle_name, controller_context)
+      deps = transitive_dependencies(bundle_name, controller_context[:dependencies])
+      deps.flat_map { |dep_bundle| controller_context[:bundle_files].fetch(dep_bundle, []) }
+          .map { |abs_path| relative_require_path(abs_path) }
+          .uniq
+          .sort
+    end
+
+    def transitive_dependencies(bundle_name, dependency_map)
+      ordered = []
+      visiting = Set.new
+      visited = Set.new
+
+      walk = lambda do |current|
+        return if visited.include?(current) || visiting.include?(current)
+
+        visiting << current
+        dependency_map.fetch(current, Set.new).each { |dep| walk.call(dep) }
+        visiting.delete(current)
+
+        visited << current
+        ordered << current unless current == bundle_name
+      end
+
+      walk.call(bundle_name)
+      ordered
+    end
+
     # --------------------------------------------------------------- write
 
     def write_manifest(filename, content)
@@ -207,6 +300,54 @@ module ReactManifest
       rel.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
     end
 
+    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
+    rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
+      []
+    end
+
+    def extract_used_component_symbols(file_path)
+      content = File.read(file_path, encoding: "utf-8")
+
+      # 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
+    rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
+      []
+    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.
@@ -238,4 +379,5 @@ module ReactManifest
                    "#{counts[:skipped_pinned] || 0} skipped (not auto-generated)"
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

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.14".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.14
+  version: 0.2.16
 platform: ruby
 authors:
 - Oliver Noonan