react-manifest-rails 0.2.34 → 0.3.1

data/lib/react_manifest/vendor/build/entry.js

@@ -52,6 +52,31 @@ function definitionsFromAst(ast) {
   return [...new Set(defs)];
 }
 
+// Top-level const/let/class binding names of any casing, including destructured
+// ones. Only these throw "Identifier already declared" when two classic scripts
+// share a global lexical scope; var/function redeclaration is legal, so skipped.
+function lexicalBindingsFromAst(ast) {
+  const names = [];
+  const collect = (p) => {
+    if (!p) return;
+    switch (p.type) {
+      case "Identifier": names.push(p.name); break;
+      case "ObjectPattern": p.properties.forEach((prop) => collect(prop.type === "RestElement" ? prop.argument : prop.value)); break;
+      case "ArrayPattern": p.elements.forEach(collect); break;
+      case "AssignmentPattern": collect(p.left); break;
+      case "RestElement": collect(p.argument); break;
+      default: break;
+    }
+  };
+  for (const node of ast.body) {
+    const decl = node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration : node;
+    if (!decl) continue;
+    if (decl.type === "VariableDeclaration" && decl.kind !== "var") decl.declarations.forEach((d) => collect(d.id));
+    else if (decl.type === "ClassDeclaration") collect(decl.id);
+  }
+  return [...new Set(names)];
+}
+
 // Real reference positions only: JSX element names, call/new callees, and
 // generic identifier references (prop values, array elements, assignments,
 // arguments) — explicitly excluding JSXText and StringLiteral content. This
@@ -124,6 +149,13 @@ globalThis.__astExtractor = {
       return { success: false, error: errorInfo(e) };
     }
   },
+  extractLexicalBindings(content) {
+    try {
+      return { success: true, bindings: lexicalBindingsFromAst(parse(content)) };
+    } catch (e) {
+      return { success: false, error: errorInfo(e) };
+    }
+  },
   extractUsages(content) {
     try {
       const ast = parse(content);

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.34".freeze
+  VERSION = "0.3.1".freeze
 end

data/lib/react_manifest/view_helpers.rb

@@ -10,25 +10,36 @@ module ReactManifest
   #   3. For namespaced controllers (admin/users): checks ux_admin_users, then ux_admin
   #   4. Returns "" for pure ERB/HAML pages with no matching bundle, or when
   #      called outside a controller context (mailers, engines, etc.)
+  #
+  # Rails renders the action template before the layout, so react_component
+  # tags land in the body first. react_bundle_tag hoists them into its own
+  # output (the layout's <head>) so Turbolinks never re-evaluates a body script.
   module ViewHelpers
+    INLINE_BUNDLE_TAG = %r{<script\b[^>]*\sdata-react-manifest="([^"]*)"[^>]*></script>}
+
     def react_bundle_tag(**html_options)
       # controller_path is not available in all view contexts (mailers, engines,
       # views rendered outside a request). Fall back gracefully rather than raising.
       ctrl = respond_to?(:controller_path, true) ? controller_path : nil
       return "".html_safe if ctrl.nil?
 
-      bundles = ReactManifest.resolve_bundles(ctrl)
+      emitted = emitted_bundles
+      hoisted = hoist_inline_bundle_tags
+      emitted.reject! { |e| hoisted.any? { |h| canonical_bundle_name(h) == canonical_bundle_name(e) } }
+
+      bundles = (ReactManifest.resolve_bundles(ctrl) + hoisted).uniq { |b| canonical_bundle_name(b) }
       return "".html_safe if bundles.empty?
 
       # Record emitted bundles so react_component doesn't re-emit them.
-      emitted = emitted_bundles
       fresh_bundles = bundles.reject { |b| emitted_bundle?(emitted, b) }
       return "".html_safe if fresh_bundles.empty?
 
       fresh_bundles.each { |b| emitted << b }
 
-      asset_names = fresh_bundles.map { |bundle| "#{bundle}.js" }
-      javascript_include_tag(*asset_names, extname: false, **html_options)
+      tags = fresh_bundles.map do |bundle|
+        javascript_include_tag("#{bundle}.js", extname: false, **bundle_tag_options(bundle, html_options))
+      end
+      safe_join(tags, "\n")
     end
 
     # react-rails integration:
@@ -48,7 +59,7 @@ module ReactManifest
         next if emitted_bundle?(emitted, bundle)
 
         emitted << bundle
-        javascript_include_tag("#{bundle}.js", extname: false)
+        javascript_include_tag("#{bundle}.js", extname: false, data: { react_manifest: bundle })
       end
 
       return html if new_tags.empty?
@@ -58,6 +69,32 @@ module ReactManifest
 
     private
 
+    # Turbolinks 5 full-reloads when the tracked head elements differ between pages.
+    # ux_shared is identical on every page, so tracking it forces one reload per deploy;
+    # tracking controller bundles would reload on every cross-controller visit.
+    def bundle_tag_options(bundle, html_options)
+      shared = canonical_bundle_name(ReactManifest.configuration.shared_bundle)
+      return html_options unless canonical_bundle_name(bundle) == shared
+
+      html_options.merge(data: (html_options[:data] || {}).merge(turbolinks_track: "reload"))
+    end
+
+    # Strips the inline tags react_component already wrote into the rendered
+    # template (and content_for) buffers; returns their bundle names in order.
+    def hoist_inline_bundle_tags
+      return [] unless respond_to?(:view_flow, true) && view_flow
+
+      names = []
+      view_flow.content.each_key do |key|
+        html = view_flow.get(key).to_s
+        next unless html.include?("data-react-manifest")
+
+        names.concat(html.scan(INLINE_BUNDLE_TAG).flatten)
+        view_flow.set(key, html.gsub(INLINE_BUNDLE_TAG, "").html_safe)
+      end
+      names
+    end
+
     def emitted_bundle?(emitted, bundle)
       canonical = canonical_bundle_name(bundle)
       emitted.any? { |existing| canonical_bundle_name(existing) == canonical }

data/lib/react_manifest.rb

@@ -7,6 +7,7 @@ require "react_manifest/configuration"
 require "react_manifest/path_utils"
 require "react_manifest/tree_classifier"
 require "react_manifest/symbol_extractor"
+require "react_manifest/component_index"
 require "react_manifest/scanner"
 require "react_manifest/dependency_map"
 require "react_manifest/generator"
@@ -14,11 +15,11 @@ require "react_manifest/application_analyzer"
 require "react_manifest/application_migrator"
 require "react_manifest/layout_patcher"
 require "react_manifest/sprockets_manifest_patcher"
+require "react_manifest/gitignore_patcher"
 require "react_manifest/watcher"
 require "react_manifest/reporter"
 require "react_manifest/view_helpers"
 
-# rubocop:disable Metrics/ModuleLength
 module ReactManifest
   class << self
     def configuration
@@ -55,10 +56,7 @@ module ReactManifest
       bundles << shared if shared
 
       # 2. always_include bundles (e.g. ux_main)
-      config.always_include.each do |b|
-        resolved = resolve_bundle_reference(config, b)
-        bundles << resolved if resolved && !bundles.include?(resolved)
-      end
+      append_always_include(config, bundles)
 
       # 3. Controller-specific bundle
       # Try fully-namespaced first: admin/users → ux_admin_users
@@ -74,6 +72,18 @@ module ReactManifest
       bundles
     end
 
+    # Ensure the manifest dir is gitignored (and .keep present). Honors
+    # config.manage_gitignore. Returns true if it appended the .gitignore entry.
+    # Best-effort: a filesystem error is logged and swallowed (never breaks boot).
+    def reconcile_gitignore!(config = configuration)
+      return false unless config.manage_gitignore?
+
+      GitignorePatcher.new(config).reconcile!
+    rescue StandardError => e
+      Rails.logger&.warn("[ReactManifest] gitignore reconcile skipped: #{e.message}")
+      false
+    end
+
     # Resolve a controller bundle from a React component symbol.
     #
     # This is primarily used to support react-rails `react_component` calls,
@@ -102,6 +112,12 @@ module ReactManifest
       shared = resolve_bundle_reference(config, config.shared_bundle)
       bundles << shared if shared
 
+      # always_include bundles are delivered on every page. react_component does
+      # NOT go through resolve_bundles, so it must emit them here too — this is
+      # what makes always_include symbols available without inlining them into
+      # controller manifests (which would double-declare, see Generator).
+      append_always_include(config, bundles)
+
       root = resolve_bundle_reference(config, root_bundle)
       bundles << root if root && !bundles.include?(root)
 
@@ -142,6 +158,15 @@ module ReactManifest
 
     private
 
+    # Append each configured always_include bundle (deduped) to +bundles+.
+    def append_always_include(config, bundles)
+      config.always_include.each do |b|
+        resolved = resolve_bundle_reference(config, b)
+        bundles << resolved if resolved && !bundles.include?(resolved)
+      end
+      bundles
+    end
+
     def component_bundle_map(config)
       component_maps(config)[:symbol_to_bundle]
     end
@@ -153,79 +178,11 @@ module ReactManifest
         return cached_maps if cached_key == key
       end
 
-      controller_dirs = TreeClassifier.new(config).classify.controller_dirs
-      symbol_to_bundle = {}
-      bundle_own_symbols = Hash.new { |h, k| h[k] = Set.new }
-      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)
-        isolated = config.isolated_app_dirs.include?(ctrl[:name])
-
-        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.
-            # Isolated dirs never register into the shared symbol index (see
-            # Generator#build_controller_context for the full rationale).
-            symbol_to_bundle[symbol] ||= bundle_name unless isolated
-            bundle_own_symbols[bundle_name] << symbol
-          end
-        end
-      end
-
-      bundle_files.each do |bundle_name, files|
-        own_symbols = bundle_own_symbols[bundle_name]
-
-        files.each do |file_path|
-          extract_used_component_symbols(file_path).each do |symbol|
-            # A symbol the bundle defines itself is always satisfied locally —
-            # never attribute it to another bundle just because that symbol
-            # name happens to collide with something defined elsewhere.
-            next if own_symbols.include?(symbol)
-
-            dep_bundle = symbol_to_bundle[symbol]
-            next unless dep_bundle && dep_bundle != bundle_name
-
-            bundle_dependencies[bundle_name] << dep_bundle
-          end
-        end
-      end
-
-      maps = {
-        symbol_to_bundle: symbol_to_bundle,
-        bundle_dependencies: bundle_dependencies
-      }
+      maps = ComponentIndex.maps(config)
       @component_maps_cache = [key, maps]
       maps
     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")
-      SymbolExtractor.extract_definitions(content, file_path: file_path)
-    rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
-      []
-    end
-
-    def extract_used_component_symbols(file_path)
-      content = File.read(file_path, encoding: "utf-8")
-      SymbolExtractor.extract_usages(content, file_path: file_path)
-    rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
-      []
-    end
-
     def resolve_bundle_reference(config, bundle_name)
       subdir = config.normalized_manifest_subdir
       manifest_path = File.join(config.abs_manifest_dir, "#{bundle_name}.js")
@@ -261,4 +218,3 @@ module ReactManifest
     end
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/tasks/react_manifest.rake

@@ -80,6 +80,22 @@ namespace :react_manifest do
       puts "   ✓ #{written} written, #{unchanged} unchanged"
     end
 
+    # 6. Ensure generated manifests are gitignored
+    puts "\n6) Gitignoring generated manifests..."
+    if config.manage_gitignore?
+      patcher = ReactManifest::GitignorePatcher.new(config)
+      result  = patcher.patch!
+      if result.appended
+        puts "   ✓ added #{patcher.pattern} to .gitignore"
+        puts "   → one-time cleanup for previously-committed manifests:"
+        puts "     git rm --cached #{File.dirname(patcher.pattern)}/*.js"
+      else
+        puts "   ✓ #{patcher.pattern} already ignored"
+      end
+    else
+      puts "   (skipped — config.manage_gitignore is false)"
+    end
+
     # Done
     puts "\n=== Setup #{'(dry-run) ' if config.dry_run?}complete ==="
     puts "Start your Rails server — react_bundle_tag will serve the right JS per controller." unless config.dry_run?
@@ -120,6 +136,19 @@ namespace :react_manifest do
     end
   end
 
+  desc "Fail (exit 1, warnings on stderr) if any bundle declares the same top-level binding twice; writes nothing"
+  task check: :environment do
+    config = ReactManifest.configuration
+    next unless Dir.exist?(config.abs_ux_root)
+
+    clashes = ReactManifest::Generator.new(config).check
+    next if clashes.empty?
+
+    clashes.each { |message| warn "[ReactManifest] #{message}" }
+    warn "[ReactManifest] #{clashes.size} declaration clash(es) found."
+    exit 1
+  end
+
   desc "Print the JSX dependency map and warnings without writing any files"
   task analyze: :environment do
     config     = ReactManifest.configuration
@@ -130,6 +159,14 @@ namespace :react_manifest do
     scan_result    = scanner.scan(classification)
     dep_map        = ReactManifest::DependencyMap.new(scan_result)
     dep_map.print_report
+
+    reasons = ReactManifest::Generator.new(config).promotion_reasons
+    unless reasons.empty?
+      puts "\nPromotions (app/ components emitted into #{config.shared_bundle}):"
+      reasons.sort.each do |req, bundles|
+        puts "  #{req}  <- used by: #{bundles.sort.join(', ')}"
+      end
+    end
   end
 
   desc "Analyze application*.js files — show what migrate_application would change"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.34
+  version: 0.3.1
 platform: ruby
 authors:
 - Oliver Noonan
@@ -29,6 +29,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
+- !ruby/object:Gem::Dependency
+  name: mini_racer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -119,20 +133,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: mini_racer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: |
   react-manifest-rails automatically generates per-controller Sprockets manifest
   files for Rails applications using react-rails + Sprockets. It eliminates the
@@ -152,9 +152,11 @@ files:
 - lib/react_manifest/application_analyzer.rb
 - lib/react_manifest/application_migrator.rb
 - lib/react_manifest/ast_extractor.rb
+- lib/react_manifest/component_index.rb
 - lib/react_manifest/configuration.rb
 - lib/react_manifest/dependency_map.rb
 - lib/react_manifest/generator.rb
+- lib/react_manifest/gitignore_patcher.rb
 - lib/react_manifest/layout_patcher.rb
 - lib/react_manifest/logging.rb
 - lib/react_manifest/path_utils.rb