react-manifest-rails 0.2.13 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78103a797d9951bb67d7e9cd4fcbb0fbf5a6589cd5995f52f745de079b3d6824
-  data.tar.gz: 229244d4844f0accdc1c23538f0a5ec8965a35e5246a62abc91dfae3ce16676d
+  metadata.gz: 292c5ccc8f0c7465c5b4fc176d7b28ff5c53e11bad16689ce9ebfcf028fdc75c
+  data.tar.gz: c77bf1b90b135fccc39b7c27ae2739c36cb891fcf504f33be2a87d3d415928d0
 SHA512:
-  metadata.gz: 43ba51a2daca72844e5d6606fa4e6c15dda1cef4b42582ab2db4d2a49037675157814a20030e41f60d9bc6c395dd2681f548f0244884b733104f37b66996c8a2
-  data.tar.gz: 01a71eda1dc257b0e0c151e34ac227323a2349c02c8d7709edd619975ba9051c9f759f89b440e317e6575d1e37edfba0c9da20ed2f306d57b587ddd239162ca1
+  metadata.gz: a7630b06c178a9d7433aaeef8eaec5c27a32319a8c6c191347cd614b1dde047ee8584cde6a2d16da4436975210479ef3cca12f62953562a6e1f49f3794829ef7
+  data.tar.gz: 28af64d5d5424b6a86b7c8d3b6be5e5b3dd865e500561adc2e4035bd1f38fbbb98ad2211c502003f604bb976967ae8a3eeb6e06c72ca470c06bd4800cef50e8d

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,87 @@ 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)
 
       files = js_files_in(ctrl[:path])
-      if files.empty?
+      own_requires = files.map { |f| relative_require_path(f) }
+      all_requires = (dep_requires + 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 = {}
+      dependencies = Hash.new { |h, k| h[k] = Set.new }
+
+      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
+
+      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
+          end
+        end
+      end
+
+      {
+        bundle_files: bundle_files,
+        dependencies: dependencies
+      }
+    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 +277,34 @@ 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")
+      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 }
+      end
+
+      symbols.uniq
+    rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
+      []
+    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 +336,5 @@ module ReactManifest
                    "#{counts[:skipped_pinned] || 0} skipped (not auto-generated)"
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/react_manifest/scanner.rb

@@ -41,6 +41,9 @@ module ReactManifest
     # 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*\(/
     # Lib calls matched against known lib symbols to reduce false positives
     LIB_CALL_PATTERN         = /\b([a-z][A-Za-z0-9_]{2,})\s*\(/
@@ -93,41 +96,10 @@ module ReactManifest
 
         files.each do |file_path|
           validate_naming(file_path, ctrl[:name], warnings)
-          begin
-            content = File.read(file_path, encoding: "utf-8")
-          rescue Errno::ENOENT, Errno::EACCES => e
-            warnings << "Skipping #{file_path}: #{e.message}"
-            next
-          rescue Encoding::InvalidByteSequenceError
-            warnings << "Skipping #{file_path}: not valid UTF-8"
-            next
-          end
-
-          # JSX element usage: <PrimaryButton (JSX tag syntax)
-          content.scan(JSX_ELEMENT_PATTERN) do |match|
-            sym = match[0]
-            used << symbol_index[sym] if symbol_index.key?(sym)
-          end
-
-          # React.createElement(PrimaryButton, ...) (non-JSX style)
-          content.scan(REACT_CREATE_PATTERN) do |match|
-            sym = match[0]
-            used << symbol_index[sym] if symbol_index.key?(sym)
-          end
-
-          # Hook calls: useFetch(
-          content.scan(HOOK_CALL_PATTERN) do |match|
-            sym = match[0]
-            used << symbol_index[sym] if symbol_index.key?(sym)
-          end
+          content = read_controller_file(file_path, warnings)
+          next unless content
 
-          # Lib function calls: formatDate( — filtered against lib symbol index
-          content.scan(LIB_CALL_PATTERN) do |match|
-            sym = match[0]
-            next if JS_BUILTINS.include?(sym)
-
-            used << symbol_index[sym] if symbol_index.key?(sym)
-          end
+          used.merge(extract_used_shared_paths(content, symbol_index))
         end
 
         controller_usages[ctrl[:name]] = used.to_a.sort
@@ -204,5 +176,56 @@ module ReactManifest
         end
       end
     end
+
+    def read_controller_file(file_path, warnings)
+      File.read(file_path, encoding: "utf-8")
+    rescue Errno::ENOENT, Errno::EACCES => e
+      warnings << "Skipping #{file_path}: #{e.message}"
+      nil
+    rescue Encoding::InvalidByteSequenceError
+      warnings << "Skipping #{file_path}: not valid UTF-8"
+      nil
+    end
+
+    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)
+
+      content.scan(LIB_CALL_PATTERN) do |match|
+        sym = match[0]
+        next if JS_BUILTINS.include?(sym)
+        next unless symbol_index.key?(sym)
+
+        used << symbol_index[sym]
+      end
+
+      used
+    end
+
+    def scan_component_usage(content, pattern, symbol_index, used)
+      content.scan(pattern) do |match|
+        sym = match[0]
+        next unless symbol_index.key?(sym)
+
+        used << symbol_index[sym]
+      end
+    end
+
+    def scan_array_component_usage(content, symbol_index, used)
+      content.scan(ARRAY_COMPONENT_LIST_PATTERN) do |match|
+        list = match[0]
+        list.split(/\s*,\s*/).each do |sym|
+          next unless symbol_index.key?(sym)
+
+          used << symbol_index[sym]
+        end
+      end
+    end
   end
 end

data/lib/react_manifest/version.rb

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

data/lib/react_manifest.rb

@@ -169,6 +169,11 @@ module ReactManifest
 
       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 }
+      end
 
       symbols.uniq
     rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError

metadata

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