react-manifest-rails 0.3.0 → 0.3.2

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.3.0".freeze
+  VERSION = "0.3.2".freeze
 end

data/lib/react_manifest/view_helpers.rb

@@ -10,33 +10,49 @@ 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)
+      request_store["react_manifest.bundle_tag_rendered"] = true
+
       # 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:
     # 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.
+    #
+    # A call after react_bundle_tag is in the layout body (page chrome), so its root gets
+    # data-react-persist: a Turbolinks wrapper keeps it mounted and hands it new props.
     def react_component(*args, **kwargs, &block)
-      html = super
+      html = bundle_tag_rendered? ? super(*persistent_args(args, kwargs), &block) : super
 
       component_name = args.first
       bundles = ReactManifest.resolve_bundles_for_component_direct(component_name)
@@ -48,7 +64,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 +74,44 @@ module ReactManifest
 
     private
 
+    def bundle_tag_rendered?
+      request_store["react_manifest.bundle_tag_rendered"]
+    end
+
+    # react-rails takes (name, props = {}, options = {}); trailing keywords fill the next slot.
+    def persistent_args(args, kwargs)
+      name, props, options = kwargs.empty? ? args : [*args, kwargs]
+      options = { tag: options } if options.is_a?(Symbol)
+      options ||= {}
+      [name, props || {}, options.merge(data: { react_persist: true }.merge(options[:data] || {}))]
+    end
+
+    # 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 }
@@ -68,12 +122,16 @@ module ReactManifest
     end
 
     def emitted_bundles
-      # ActionView can instantiate multiple helper contexts during one request.
-      # Store emitted bundles in request env so layout + template helpers dedupe.
+      request_store["react_manifest.emitted_bundles"] ||= []
+    end
+
+    # ActionView can instantiate multiple helper contexts during one request.
+    # Request env is shared by layout + template helpers; fall back to the view itself.
+    def request_store
       if respond_to?(:request, true) && request
-        request.env["react_manifest.emitted_bundles"] ||= []
+        request.env
       else
-        @emitted_bundles ||= []
+        @request_store ||= {}
       end
     end
   end

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"
@@ -19,7 +20,6 @@ require "react_manifest/watcher"
 require "react_manifest/reporter"
 require "react_manifest/view_helpers"
 
-# rubocop:disable Metrics/ModuleLength
 module ReactManifest
   class << self
     def configuration
@@ -178,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")
@@ -286,4 +218,3 @@ module ReactManifest
     end
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/tasks/react_manifest.rake

@@ -136,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 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,6 +152,7 @@ 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