react-manifest-rails 0.2.10 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22469e4a0a5114411640201194bae46bdb549f365a7bb7064eeb95bfd4ddb24e
-  data.tar.gz: 6b85f5dec1cf64f9132fd7cf1267f66d021a00f3058400b1644a7ac8f04bb534
+  metadata.gz: 9c85309337765f3f24fae46e4cf3895e11e4a3a59b5cbfb96fa90f296f3ba48e
+  data.tar.gz: b0f320a6ebf2a4210a4fac89d04f5609bd3d261a458f2db26fb92dd814b45465
 SHA512:
-  metadata.gz: f9501224f4fe519573393612a126f6bedaeea60ece7a44c6adce4e6c143f90db6ec948075ac228b93e1f7ca944195a5645e621d932ec3d1ce7c4890f208a46a4
-  data.tar.gz: e68251a96c1beb886969b2bc479babddd2fedf471d110f861bec99410c3dbbd4a72bf3961bd4088abe887857acdb72f9bd4b84de541c8d108d3f36adcb49c19c
+  metadata.gz: 85edbe32bf32f739097e60779a34874d1c792db5ea40ed41e671e8b0552718d4549dfddb9b120d74bcce42a15bbc598ed0384c7e609cb6f0d4044fb80900098c
+  data.tar.gz: d2728828f1fd930cd702aa35fb4ab5ab88b4219dff1fe996fa5cdb8491888b15bb25b0fd1d44c84aa9c0707cd80b87d3d3c2554b15f0723fd979bf484db4b3f1

data/README.md

@@ -88,6 +88,8 @@ Generation is **directory-based** — deterministic and conservative by design.
 
 Namespace fallback for nested controllers: `admin/reports/summary` tries `ux_admin_reports_summary`, then `ux_admin_reports`, then `ux_admin`, then `ux_summary`. The most specific match wins.
 
+When using `react-rails`, `react_component("ComponentName")` is also component-aware: the helper infers the matching controller bundle from the component symbol and includes it at render time. This provides a fallback when controller naming and bundle naming do not align perfectly.
+
 The gem's scanner uses regex to detect which shared symbols are referenced in each controller directory (for the `react_manifest:analyze` report). Generation itself stays directory-based to avoid brittle runtime misses from dynamic component references.
 
 ## What Gets Generated
@@ -204,6 +206,16 @@ Check in order:
 - Restart the Rails server.
 - Without `listen`, run `react_manifest:generate` manually after making changes.
 
+### `ComponentName is not defined` from `react_component`
+
+If you see errors like `UserSignInForm is not defined` (often from `eval` inside `react-rails`), ensure your layout does **not** defer the bundle tag:
+
+```erb
+<%= react_bundle_tag %>
+```
+
+Using `defer: true` can cause `react_component` inline scripts to run before your `ux_*.js` bundles are executed.
+
 ## Compatibility
 
 - Ruby: 3.2+

data/lib/react_manifest/generator.rb

@@ -1,5 +1,4 @@
 require "digest"
-require "time"
 require "tmpdir"
 
 module ReactManifest
@@ -26,7 +25,7 @@ module ReactManifest
   class Generator
     HEADER = <<~JS.freeze
       // AUTO-GENERATED — DO NOT EDIT
-      // react-manifest-rails %<version>s | %<timestamp>s
+      // react-manifest-rails %<version>s
       // Run `rails react_manifest:generate` to regenerate.
     JS
 
@@ -82,8 +81,6 @@ module ReactManifest
 
     def build_controller(ctrl)
       lines = header_lines
-      lines << "//= require #{@config.shared_bundle}"
-      lines << ""
 
       files = js_files_in(ctrl[:path])
       if files.empty?
@@ -167,7 +164,7 @@ module ReactManifest
 
     def header_lines
       [
-        format(HEADER, version: ReactManifest::VERSION, timestamp: Time.now.utc.iso8601),
+        format(HEADER, version: ReactManifest::VERSION),
         ""
       ].flatten
     end
@@ -206,7 +203,7 @@ module ReactManifest
       # Build relative to output_dir (configurable) rather than a hardcoded path.
       base = @config.abs_output_dir + File::SEPARATOR
       rel  = abs_path.sub(base, "")
-      # Strip Sprockets-understood extensions: .js.jsx → "", .jsx → "", .js → ""
+      # Strip Sprockets-understood extensions: .js.jsx/.jsx/.js -> logical path.
       rel.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
     end
 

data/lib/react_manifest/layout_patcher.rb

@@ -10,8 +10,8 @@ module ReactManifest
   #   ReactManifest::LayoutPatcher.new(config).patch!
   class LayoutPatcher
     LAYOUTS_GLOB   = "app/views/layouts/*.html.{erb,haml,slim}".freeze
-    BUNDLE_TAG_ERB = "<%= react_bundle_tag defer: true %>\n".freeze
-    BUNDLE_TAG_HAML = "= react_bundle_tag defer: true\n".freeze
+    BUNDLE_TAG_ERB = "<%= react_bundle_tag %>\n".freeze
+    BUNDLE_TAG_HAML = "= react_bundle_tag\n".freeze
 
     Result = Struct.new(:file, :status, :detail, keyword_init: true)
 

data/lib/react_manifest/railtie.rb

@@ -43,6 +43,22 @@ module ReactManifest
       manifest_dir = ReactManifest.configuration.abs_manifest_dir
       app.config.assets.paths.delete(manifest_dir)
       app.config.assets.paths.unshift(manifest_dir)
+
+      app.config.assets.configure do |env|
+        next unless defined?(React::JSX::Processor)
+
+        begin
+          env.register_mime_type("application/jsx", extensions: [".jsx", ".js.jsx", ".es.jsx", ".es6.jsx"])
+        rescue StandardError
+          nil
+        end
+
+        begin
+          env.register_transformer("application/jsx", "application/javascript", React::JSX::Processor)
+        rescue StandardError
+          nil
+        end
+      end
     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
@@ -177,7 +149,7 @@ module ReactManifest
       # Build relative to output_dir (configurable) rather than a hardcoded path.
       base = @config.abs_output_dir + File::SEPARATOR
       rel  = abs_path.sub(base, "")
-      # Strip Sprockets-understood extensions: .js.jsx → "", .jsx → "", .js → ""
+      # Strip Sprockets-understood extensions: .js.jsx/.jsx/.js -> logical path.
       rel.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
     end
 
@@ -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.10".freeze
+  VERSION = "0.2.14".freeze
 end

data/lib/react_manifest/view_helpers.rb

@@ -2,7 +2,7 @@ module ReactManifest
   # Provides the `react_bundle_tag` view helper, included in ActionView::Base.
   #
   # Usage in layouts:
-  #   <%= react_bundle_tag defer: true %>
+  #   <%= react_bundle_tag %>
   #
   # Resolves which ux_*.js bundles to include based on controller_path:
   #   1. Always includes config.shared_bundle (e.g. "ux_shared")
@@ -21,7 +21,33 @@ module ReactManifest
       bundles = ReactManifest.resolve_bundles(ctrl)
       return "".html_safe if bundles.empty?
 
-      javascript_include_tag(*bundles, **html_options)
+      asset_names = bundles.map { |bundle| "#{bundle}.js" }
+      javascript_include_tag(*asset_names, extname: false, **html_options)
+    end
+
+    # react-rails integration:
+    # If a component-specific controller bundle can be inferred from the component
+    # symbol, include that bundle at the call site before delegating to react-rails.
+    # This avoids strict dependence on controller_path -> bundle naming alignment.
+    def react_component(*args, **kwargs, &block)
+      html = super
+
+      component_name = args.first
+      bundles = ReactManifest.resolve_bundles_for_component(component_name)
+      return html if bundles.empty?
+
+      emitted = (@_react_manifest_emitted_bundles ||= [])
+
+      new_tags = bundles.filter_map do |bundle|
+        next if emitted.include?(bundle)
+
+        emitted << bundle
+        javascript_include_tag("#{bundle}.js", extname: false)
+      end
+
+      return html if new_tags.empty?
+
+      safe_join(new_tags + [html])
     end
   end
 end

data/lib/react_manifest.rb

@@ -1,4 +1,5 @@
 require "fileutils"
+require "set"
 
 require "react_manifest/version"
 require "react_manifest/configuration"
@@ -58,8 +59,127 @@ module ReactManifest
       bundles
     end
 
+    # Resolve a controller bundle from a React component symbol.
+    #
+    # This is primarily used to support react-rails `react_component` calls,
+    # where the requested component name is known and may not align 1:1 with
+    # controller_path-derived bundle names.
+    def resolve_bundle_for_component(component_name)
+      resolve_bundles_for_component(component_name).last
+    end
+
+    # Resolve all controller bundles needed for a React component symbol.
+    # Includes transitive controller-bundle dependencies inferred from
+    # component symbol usage across ux/app/* directories.
+    def resolve_bundles_for_component(component_name)
+      name = component_name.to_s
+      return [] if name.empty?
+
+      config = configuration
+      maps = component_maps(config)
+      root_bundle = maps[:symbol_to_bundle][name]
+      return [] unless root_bundle
+
+      ordered = []
+      visiting = Set.new
+      visited = Set.new
+
+      walk = lambda do |bundle_name|
+        return if visited.include?(bundle_name) || visiting.include?(bundle_name)
+
+        visiting << bundle_name
+        maps[:bundle_dependencies].fetch(bundle_name, Set.new).each { |dep| walk.call(dep) }
+        visiting.delete(bundle_name)
+
+        visited << bundle_name
+        ordered << bundle_name
+      end
+
+      walk.call(root_bundle)
+
+      ordered.filter_map { |bundle_name| resolve_bundle_reference(config, bundle_name) }
+    end
+
     private
 
+    def component_bundle_map(config)
+      component_maps(config)[:symbol_to_bundle]
+    end
+
+    def component_maps(config)
+      controller_dirs = TreeClassifier.new(config).classify.controller_dirs
+      symbol_to_bundle = {}
+      bundle_files = Hash.new { |h, k| h[k] = [] }
+      bundle_dependencies = Hash.new { |h, k| h[k] = Set.new }
+
+      controller_dirs.each do |ctrl|
+        bundle_name = ctrl[:bundle_name]
+        files = js_files_in_controller(ctrl[:path], config)
+        bundle_files[bundle_name].concat(files)
+
+        files.each do |file_path|
+          extract_defined_symbols(file_path).each do |symbol|
+            next unless symbol.match?(/\A[A-Z][A-Za-z0-9_]*\z/)
+
+            # Keep first writer to ensure deterministic behavior if a symbol is duplicated.
+            symbol_to_bundle[symbol] ||= 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 |symbol|
+            dep_bundle = symbol_to_bundle[symbol]
+            next unless dep_bundle && dep_bundle != bundle_name
+
+            bundle_dependencies[bundle_name] << dep_bundle
+          end
+        end
+      end
+
+      {
+        symbol_to_bundle: symbol_to_bundle,
+        bundle_dependencies: bundle_dependencies
+      }
+    end
+
+    def js_files_in_controller(dir, config)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "**", config.extensions_glob))
+         .reject { |f| File.directory?(f) }
+         .sort
+    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 resolve_bundle_reference(config, bundle_name)
       manifest_path = File.join(config.abs_manifest_dir, "#{bundle_name}.js")
       return bundle_name if File.exist?(manifest_path)

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.14
 platform: ruby
 authors:
 - Oliver Noonan
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-16 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -161,7 +160,6 @@ metadata:
   changelog_uri: https://github.com/olivernoonan/react-manifest-rails/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/olivernoonan/react-manifest-rails/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -176,8 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Zero-touch Sprockets manifest generation for react-rails apps
 test_files: []