react-manifest-rails 0.2.27 → 0.2.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95a89b37c1332d074e881e5676c346540b069ecbeafc7dd42526ce53f24a0285
-  data.tar.gz: e351a53101a5b3c91f31e8fd9279e221fd0a345c56d7f6d003ca5a6d5280624f
+  metadata.gz: 8688e621b55d1a5b9db497668b4942fc97c8f4aad5f7778c7a7fc4a412990d04
+  data.tar.gz: c46872893e465f9684c68688a8f8ca02d361afd7bfa8421eb1b69b0180f8c3d9
 SHA512:
-  metadata.gz: 5fa34a6989ccedc7a1b459e3ba68365ec16c82606069c319c7c093d7440cfe4a7e223a4e617e4b25fa1f4b5ab345c73e80fd2f0e0d12d0773121d5221cb2aefa
-  data.tar.gz: eb604c20d10c84b9bf0abd6091e346eed18cb05063d88de4f1f8ec8e034dfe399db51c3c66d4ca0d7f8d67e9f1e57cc0c84823804c5da45e5d04e23467a4b55b
+  metadata.gz: 76a4b4aed865531470d641be4bb0d6608d30410d66463aad17e71b37a73acafe2fb4a825c5f3f89c0bc5e6a91d7016396699572d575950dca71a242378cbc6f3
+  data.tar.gz: 2bbd77ad7db859306d6cfdb6a75a476bfca219b1e22cf0b3aa54bd12f3c42d8a441c35a1e07dbb4e5a0c3c198b968683a15f814fd64bf59a55a91b1ca3d2b9d1

data/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.28] - 2026-05-11
+
+### Fixed
+- Boot generation now runs after app initializers (`config/initializers/`) have loaded, so the generator always uses the fully-configured `ux_root` and related settings. Previously the initializer ran during the Railtie phase (before `config/initializers/`), causing it to silently generate against default paths and produce unchanged manifests.
+
 ## [0.2.27] - 2026-05-11
 
 ### Fixed

data/lib/react_manifest/application_analyzer.rb

@@ -6,6 +6,8 @@ module ReactManifest
   #
   # Produces a human-readable report without writing anything.
   class ApplicationAnalyzer
+    include ReactManifest::Logging
+
     DIRECTIVE_PATTERN = %r{^\s*//=\s+(require(?:_tree|_directory)?)\s+(.+)$}
 
     # Libs we recognise as vendor (case-insensitive partial match on the require path)
@@ -47,30 +49,30 @@ module ReactManifest
 
     # Pretty-print the analysis report to stdout
     def print_report(results = analyze)
-      puts "\n=== ReactManifest: Application Manifest Analysis ===\n"
+      log_info "\n=== ReactManifest: Application Manifest Analysis ===\n"
 
       if results.empty?
-        puts "No application*.js files found in #{@config.abs_output_dir}"
+        log_info "No application*.js files found in #{@config.abs_output_dir}"
         return
       end
 
       results.each do |result|
         rel = result.file.sub("#{Rails.root}/", "")
         status = result.clean? ? "✓ already clean" : "⚠ needs migration"
-        puts "\n#{rel} [#{status}]"
-        puts "-" * 60
+        log_info "\n#{rel} [#{status}]"
+        log_info "-" * 60
 
         icon_map = { vendor: "  ✓ KEEP   ", ux_code: "  ✗ REMOVE ", unknown: "  ? REVIEW " }
         result.directives.each do |d|
           icon = icon_map[d.classification]
-          puts "#{icon} #{d.original_line.strip}"
-          puts "           → #{d.note}" if d.note
+          log_info "#{icon} #{d.original_line.strip}"
+          log_info "           → #{d.note}" if d.note
         end
       end
 
-      puts "\n"
-      puts "Run `rails react_manifest:migrate_application` to apply changes."
-      puts "Use `--dry-run` (or config.dry_run = true) to preview first.\n\n"
+      log_info "\n"
+      log_info "Run `rails react_manifest:migrate_application` to apply changes."
+      log_info "Use `--dry-run` (or config.dry_run = true) to preview first.\n\n"
     end
 
     private

data/lib/react_manifest/application_migrator.rb

@@ -8,6 +8,8 @@ module ReactManifest
   #   - Never removes :vendor or :passthrough lines
   #   - Adds a managed-by comment at the top
   class ApplicationMigrator
+    include ReactManifest::Logging
+
     MANAGED_COMMENT = <<~JS.freeze
       // Non-UX libraries — loaded on every page.
       // React app code is now served per-controller via react_bundle_tag.
@@ -30,13 +32,13 @@ module ReactManifest
       results = @analyzer.analyze
 
       if results.empty?
-        $stdout.puts "[ReactManifest] No application*.js files found to migrate."
+        log_info "No application*.js files found to migrate."
         return []
       end
 
       results.map do |result|
         if result.clean?
-          $stdout.puts "[ReactManifest] #{short(result.file)} — already clean, skipping."
+          log_info "#{short(result.file)} — already clean, skipping."
           { file: result.file, status: :already_clean }
         else
           rewrite(result)
@@ -51,7 +53,7 @@ module ReactManifest
       new_content = build_new_content(result)
 
       if @config.dry_run?
-        $stdout.puts "\n[ReactManifest] DRY-RUN: #{short(file)}"
+        log_info "DRY-RUN: #{short(file)}"
         print_diff(file, new_content)
         return { file: file, status: :dry_run }
       end
@@ -61,15 +63,22 @@ module ReactManifest
       begin
         FileUtils.cp(file, bak_path)
         File.chmod(0o600, bak_path)
-        $stdout.puts "[ReactManifest] Backup: #{short(bak_path)}"
+        log_info "Backup: #{short(bak_path)}"
       rescue StandardError => e
-        $stdout.puts "[ReactManifest] ERROR: Could not create backup of #{short(file)}: #{e.message}"
-        $stdout.puts "[ReactManifest] Migration aborted for #{short(file)} — original file unchanged."
+        log_warn "ERROR: Could not create backup of #{short(file)}: #{e.message}"
+        log_warn "Migration aborted for #{short(file)} — original file unchanged."
         return { file: file, status: :backup_failed, error: e.message }
       end
 
-      File.write(file, new_content, encoding: "utf-8")
-      $stdout.puts "[ReactManifest] Migrated: #{short(file)}"
+      tmp = "#{file}.tmp.#{Process.pid}"
+      begin
+        File.write(tmp, new_content, encoding: "utf-8")
+        File.rename(tmp, file)
+      rescue StandardError => e
+        FileUtils.rm_f(tmp)
+        raise e
+      end
+      log_info "Migrated: #{short(file)}"
 
       { file: file, status: :migrated, backup: bak_path }
     end
@@ -120,8 +129,8 @@ module ReactManifest
       removed = old_lines - new_lines
       added   = new_lines - old_lines
 
-      removed.each { |l| $stdout.puts "  - #{l}" }
-      added.each   { |l| $stdout.puts "  + #{l}" }
+      removed.each { |l| log_info "  - #{l}" }
+      added.each   { |l| log_info "  + #{l}" }
     end
 
     def short(path)

data/lib/react_manifest/configuration.rb

@@ -135,8 +135,17 @@ module ReactManifest
       File.join(abs_output_dir, subdir)
     end
 
+    def excluded_path?(abs_path)
+      parts = abs_path.split(File::SEPARATOR)
+      exclude_paths.any? { |ep| parts.include?(ep) }
+    end
+
     def normalized_manifest_subdir
       manifest_subdir.to_s.gsub(%r{\A/+|/+\z}, "")
     end
+
+    def cache_key
+      [ux_root, app_dir, extensions, always_include, exclude_paths, external_providers].hash
+    end
   end
 end

data/lib/react_manifest/dependency_map.rb

@@ -9,6 +9,8 @@ module ReactManifest
   #   map.shared_files_for("users")      # => ["ux/components/...", ...]
   #   map.controllers_using("ux/lib/api_helpers") # => ["users", "admin"]
   class DependencyMap
+    include ReactManifest::Logging
+
     attr_reader :symbol_index, :controller_usages, :warnings
 
     def initialize(scan_result)
@@ -40,29 +42,29 @@ module ReactManifest
 
     # Pretty-print for the analyze rake task
     def print_report
-      puts "\n=== ReactManifest Dependency Analysis ===\n\n"
+      log_info "\n=== ReactManifest Dependency Analysis ===\n\n"
 
-      puts "Shared Symbol Index (#{@symbol_index.size} symbols):"
+      log_info "Shared Symbol Index (#{@symbol_index.size} symbols):"
       @symbol_index.each do |sym, file|
         # Strip non-printable/control characters to prevent terminal manipulation
         safe_sym  = sym.gsub(/[^\x20-\x7E]/, "?")
         safe_file = file.gsub(/[^\x20-\x7E]/, "?")
-        puts "  #{safe_sym.ljust(40)} #{safe_file}"
+        log_info "  #{safe_sym.ljust(40)} #{safe_file}"
       end
 
-      puts "\nPer-Controller Usage:"
+      log_info "\nPer-Controller Usage:"
       @controller_usages.each do |ctrl, files|
-        puts "\n  [#{ctrl}] (#{files.size} shared references)"
-        files.each { |f| puts "    #{f}" }
-        puts "    (none)" if files.empty?
+        log_info "\n  [#{ctrl}] (#{files.size} shared references)"
+        files.each { |f| log_info "    #{f}" }
+        log_info "    (none)" if files.empty?
       end
 
       unless @warnings.empty?
-        puts "\nWarnings (#{@warnings.size}):"
-        @warnings.each { |w| puts "  ⚠  #{w}" }
+        log_info "\nWarnings (#{@warnings.size}):"
+        @warnings.each { |w| log_warn "  ⚠  #{w}" }
       end
 
-      puts "\n"
+      log_info "\n"
     end
   end
 end

data/lib/react_manifest/generator.rb

@@ -1,5 +1,6 @@
 require "digest"
 require "tmpdir"
+require_relative "path_utils"
 
 module ReactManifest
   # Generates all ux_*.js Sprockets manifest files.
@@ -24,6 +25,9 @@ module ReactManifest
   # Never touches application.js, application_dev.js, or files in exclude_paths.
   # rubocop:disable Metrics/ClassLength
   class Generator
+    include PathUtils
+    include ReactManifest::Logging
+
     HEADER = <<~JS.freeze
       // AUTO-GENERATED — DO NOT EDIT
       // react-manifest-rails %<version>s
@@ -42,9 +46,7 @@ module ReactManifest
     # written and others stale/missing.
     def run!
       classification = @classifier.classify
-      scan_result = Scanner.new(@config).scan(classification)
-      controller_context = build_controller_context(classification.controller_dirs, classification.shared_dirs,
-                                                    scan_result)
+      controller_context = build_controller_context(classification.controller_dirs)
 
       # Phase 1: build all content in memory — no I/O.
       shared_manifest = build_shared(classification.shared_dirs)
@@ -61,6 +63,28 @@ module ReactManifest
       results
     end
 
+    # Remove all AUTO-GENERATED ux_*.js manifests. Silently skips files that
+    # disappear between the directory scan and the read (TOCTOU-safe).
+    # Returns { removed: N, skipped: N }.
+    def clean!
+      targets  = [@config.abs_manifest_dir, @config.abs_output_dir].uniq
+      removed  = 0
+      skipped  = 0
+
+      targets.each do |dir|
+        Dir.glob(File.join(dir, "ux_*.js")).each do |file|
+          if auto_generated?(file)
+            File.delete(file)
+            removed += 1
+          else
+            skipped += 1
+          end
+        end
+      end
+
+      { removed: removed, skipped: skipped }
+    end
+
     private
 
     # ------------------------------------------------------------------ shared
@@ -88,8 +112,6 @@ module ReactManifest
       lines = header_lines
       always_include_reqs = controller_context[:always_include_requires].fetch(ctrl[:bundle_name], [])
       dep_requires = controller_dependency_requires(ctrl[:bundle_name], controller_context)
-      controller_context[:shared_lib_requires]
-      controller_context[:shared_requires].fetch(ctrl[:bundle_name], Set.new).to_a.sort
       ext_reqs = controller_context[:external_requires].fetch(ctrl[:bundle_name], Set.new).to_a.sort
 
       files = js_files_in(ctrl[:path])
@@ -105,25 +127,14 @@ module ReactManifest
       { filename: "#{ctrl[:bundle_name]}.js", content: "#{lines.join("\n")}\n" }
     end
 
-    # rubocop:disable Metrics/AbcSize
-    def build_controller_context(controller_dirs, shared_dirs, scan_result)
+    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 }
-      shared_require_paths = shared_require_path_set(shared_dirs)
-      shared_requires = Hash.new { |h, k| h[k] = Set.new }
-      shared_dependency_map = build_shared_dependency_map(shared_dirs, shared_require_paths, scan_result)
-      shared_lib_requires = shared_lib_require_paths(shared_dirs)
 
       controller_dirs.each do |ctrl|
-        scan_result.controller_usages.fetch(ctrl[:name], []).each do |req_path|
-          shared_requires[ctrl[:bundle_name]] << req_path
-        end
-        shared_requires[ctrl[:bundle_name]] = expand_shared_requires(shared_requires[ctrl[:bundle_name]],
-                                                                     shared_dependency_map)
-
         # Index controller-defined symbols for cross-app detection
         bundle_name = ctrl[:bundle_name]
         files = js_files_in(ctrl[:path])
@@ -176,12 +187,9 @@ module ReactManifest
         bundle_files: bundle_files,
         dependencies: dependencies,
         always_include_requires: always_include_requires,
-        shared_lib_requires: shared_lib_requires,
-        shared_requires: shared_requires,
         external_requires: external_requires
       }
     end
-    # rubocop:enable Metrics/AbcSize
 
     def controller_dependency_requires(bundle_name, controller_context)
       deps = transitive_dependencies(bundle_name, controller_context[:dependencies])
@@ -254,7 +262,7 @@ module ReactManifest
       end
 
       if @config.dry_run?
-        $stdout.puts "[ReactManifest] DRY-RUN: would write #{dest}"
+        log_info "DRY-RUN: would write #{dest}"
         print_diff(dest, content)
         return { path: dest, status: :dry_run }
       end
@@ -286,7 +294,7 @@ module ReactManifest
       if @config.dry_run?
         legacy_files.each do |legacy|
           target = File.join(manifest_dir, File.basename(legacy))
-          $stdout.puts "[ReactManifest] DRY-RUN: would move #{legacy} -> #{target}"
+          log_info "DRY-RUN: would move #{legacy} -> #{target}"
         end
         return
       end
@@ -320,7 +328,7 @@ module ReactManifest
       files = Dir.glob(File.join(dir, "**", @config.extensions_glob))
                  .reject { |f| File.directory?(f) }
                  .reject { |f| auto_generated?(f) }
-                 .reject { |f| excluded_path?(f) }
+                 .reject { |f| @config.excluded_path?(f) }
                  .sort
 
       # Deduplicate by logical require path: if both foo.js and foo.jsx exist,
@@ -336,20 +344,11 @@ module ReactManifest
       end
     end
 
-    # Returns true if the file path contains a component matching any exclude_path.
-    # exclude_paths are matched against individual path segments, so "vendor" matches
-    # ux/vendor/foo.js but not ux/vendor_custom/foo.js.
-    def excluded_path?(abs_path)
-      parts = abs_path.split(File::SEPARATOR)
-      @config.exclude_paths.any? { |ep| parts.include?(ep) }
-    end
-
     def relative_require_path(abs_path)
       # 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 -> logical path.
-      rel.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
+      strip_asset_extension(rel)
     end
 
     def extract_defined_symbols(file_path)
@@ -365,22 +364,7 @@ module ReactManifest
 
     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
+      SymbolExtractor.extract_usages(content)
     rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
       []
     end
@@ -390,7 +374,7 @@ module ReactManifest
 
       Dir.glob(File.join(dir, "**", @config.extensions_glob))
          .reject { |f| File.directory?(f) }
-         .reject { |f| excluded_path?(f) }
+         .reject { |f| @config.excluded_path?(f) }
          .sort
     end
 
@@ -400,68 +384,8 @@ module ReactManifest
       Rails.root.join(path).to_s
     end
 
-    def shared_require_path_set(shared_dirs)
-      shared_dirs.each_with_object(Set.new) do |shared_dir, paths|
-        js_files_in(shared_dir[:path]).each do |file_path|
-          paths << normalize_require_path(relative_require_path(file_path))
-        end
-      end
-    end
-
-    def shared_lib_require_paths(shared_dirs)
-      shared_dirs.each_with_object([]) do |shared_dir, paths|
-        next unless File.basename(shared_dir[:path]) == "lib"
-
-        js_files_in(shared_dir[:path]).each do |file_path|
-          paths << normalize_require_path(relative_require_path(file_path))
-        end
-      end.sort.uniq
-    end
-
-    def build_shared_dependency_map(shared_dirs, shared_require_paths, scan_result)
-      dependency_map = Hash.new { |h, k| h[k] = Set.new }
-
-      shared_symbol_index = scan_result.symbol_index.each_with_object({}) do |(sym, req_path), index|
-        normalized = normalize_require_path(req_path)
-        next unless shared_require_paths.include?(normalized)
-
-        index[sym] = normalized
-      end
-
-      shared_dirs.each do |shared_dir|
-        js_files_in(shared_dir[:path]).each do |file_path|
-          from_req = normalize_require_path(relative_require_path(file_path))
-          extract_used_component_symbols(file_path).each do |sym|
-            to_req = shared_symbol_index[sym]
-            next if to_req.nil? || to_req == from_req
-
-            dependency_map[from_req] << to_req
-          end
-        end
-      end
-
-      dependency_map
-    end
-
-    def expand_shared_requires(initial_requires, dependency_map)
-      expanded = Set.new(initial_requires)
-      queue = initial_requires.to_a
-
-      until queue.empty?
-        req = queue.shift
-        dependency_map.fetch(req, Set.new).each do |dep_req|
-          next if expanded.include?(dep_req)
-
-          expanded << dep_req
-          queue << dep_req
-        end
-      end
-
-      expanded
-    end
-
     def normalize_require_path(path)
-      path.to_s.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
+      strip_asset_extension(path)
     end
 
     def warn_on_external_controller_references(file_path, symbol_to_bundle)
@@ -469,9 +393,9 @@ module ReactManifest
         dep_bundle = symbol_to_bundle[sym]
         next unless dep_bundle
 
-        warn "[ReactManifest] External file '#{relative_require_path(file_path)}' references " \
-             "controller-only symbol '#{sym}' (#{dep_bundle}). " \
-             "Move '#{sym}' to a shared ux dir to avoid duplicate runtime declarations."
+        log_warn "External file '#{relative_require_path(file_path)}' references " \
+                 "controller-only symbol '#{sym}' (#{dep_bundle}). " \
+                 "Move '#{sym}' to a shared ux dir to avoid duplicate runtime declarations."
       end
     end
 
@@ -492,18 +416,18 @@ module ReactManifest
         removed = old_lines - new_lines
         added   = new_lines - old_lines
 
-        removed.each { |l| $stdout.puts "  - #{l.chomp}" }
-        added.each   { |l| $stdout.puts "  + #{l.chomp}" }
+        removed.each { |l| log_info "  - #{l.chomp}" }
+        added.each   { |l| log_info "  + #{l.chomp}" }
       else
-        new_content.each_line { |l| $stdout.puts "  + #{l.chomp}" }
+        new_content.each_line { |l| log_info "  + #{l.chomp}" }
       end
     end
 
     def print_summary(results)
       counts = results.group_by { |r| r[:status] }.transform_values(&:count)
-      $stdout.puts "[ReactManifest] Generated: #{counts[:written] || 0} written, " \
-                   "#{counts[:unchanged] || 0} unchanged, " \
-                   "#{counts[:skipped_pinned] || 0} skipped (not auto-generated)"
+      log_info "Generated: #{counts[:written] || 0} written, " \
+               "#{counts[:unchanged] || 0} unchanged, " \
+               "#{counts[:skipped_pinned] || 0} skipped (not auto-generated)"
     end
   end
   # rubocop:enable Metrics/ClassLength

data/lib/react_manifest/layout_patcher.rb

@@ -9,6 +9,8 @@ module ReactManifest
   # Usage:
   #   ReactManifest::LayoutPatcher.new(config).patch!
   class LayoutPatcher
+    include ReactManifest::Logging
+
     LAYOUTS_GLOB   = "app/views/layouts/*.html.{erb,haml,slim}".freeze
     BUNDLE_TAG_ERB = "<%= react_bundle_tag %>\n".freeze
     BUNDLE_TAG_HAML = "= react_bundle_tag\n".freeze
@@ -23,7 +25,7 @@ module ReactManifest
     def patch!
       layouts = find_layouts
       if layouts.empty?
-        $stdout.puts "[ReactManifest] No layout files found in #{layouts_dir}"
+        log_info "No layout files found in #{layouts_dir}"
         return []
       end
       layouts.map { |f| patch_file(f) }
@@ -58,13 +60,20 @@ module ReactManifest
       end
 
       if @config.dry_run?
-        $stdout.puts "[ReactManifest] DRY-RUN: would patch #{short(path)}"
+        log_info "DRY-RUN: would patch #{short(path)}"
         print_diff(content, new_content)
         return Result.new(file: path, status: :dry_run, detail: nil)
       end
 
-      File.write(path, new_content, encoding: "utf-8")
-      $stdout.puts "[ReactManifest] Patched layout: #{short(path)}"
+      tmp = "#{path}.tmp.#{Process.pid}"
+      begin
+        File.write(tmp, new_content, encoding: "utf-8")
+        File.rename(tmp, path)
+      rescue StandardError => e
+        FileUtils.rm_f(tmp)
+        raise e
+      end
+      log_info "Patched layout: #{short(path)}"
       Result.new(file: path, status: :patched, detail: nil)
     end
 
@@ -115,7 +124,7 @@ module ReactManifest
     def print_diff(old_content, new_content)
       old_lines = old_content.lines.map(&:chomp)
       new_lines = new_content.lines.map(&:chomp)
-      (new_lines - old_lines).each { |l| $stdout.puts "  + #{l}" }
+      (new_lines - old_lines).each { |l| log_info "  + #{l}" }
     end
   end
 end

data/lib/react_manifest/logging.rb

@@ -0,0 +1,31 @@
+module ReactManifest
+  module Logging
+    def log_debug(message)
+      full = "[ReactManifest] #{message}"
+      Rails.logger.debug(full)
+      $stdout.puts(full) if stdout_logging_needed?
+    end
+
+    def log_info(message)
+      full = "[ReactManifest] #{message}"
+      Rails.logger.info(full)
+      $stdout.puts(full) if stdout_logging_needed?
+    end
+
+    def log_warn(message)
+      full = "[ReactManifest] #{message}"
+      Rails.logger.warn(full)
+      $stdout.puts(full) if stdout_logging_needed?
+    end
+
+    private
+
+    def stdout_logging_needed?
+      ReactManifest.configuration.stdout_logging? && !rails_console?
+    end
+
+    def rails_console?
+      defined?(Rails::Console)
+    end
+  end
+end

data/lib/react_manifest/path_utils.rb

@@ -0,0 +1,11 @@
+module ReactManifest
+  module PathUtils
+    # Matches compound and single Sprockets-understood asset extensions.
+    # Order is significant: compound forms must precede their singles.
+    STRIPPABLE_EXTENSIONS = /\.(ts\.tsx|js\.jsx|tsx|ts|jsx|js)$/
+
+    def strip_asset_extension(path)
+      path.to_s.sub(STRIPPABLE_EXTENSIONS, "")
+    end
+  end
+end

data/lib/react_manifest/railtie.rb

@@ -3,28 +3,23 @@ require "rails/railtie"
 module ReactManifest
   class Railtie < Rails::Railtie
     # ----------------------------------------------------------------
-    # In development, generate once on boot if expected manifests are missing.
-    # This makes first-run setup deterministic even before any file change event.
+    # In development, always regenerate manifests on boot so that files
+    # added between restarts (e.g. via git merge) are picked up immediately.
+    # The generator is idempotent — it skips writes when content is unchanged.
     # ----------------------------------------------------------------
-    initializer "react_manifest.ensure_manifests" do
+    initializer "react_manifest.ensure_manifests", after: :load_config_initializers do
       next unless Rails.env.development?
 
       config = ReactManifest.configuration
-      # Private class method: call via send from the initializer instance context.
-      missing = self.class.send(:missing_manifest_bundles, config)
-      next if missing.empty?
-
-      message = "[ReactManifest] Missing manifests on boot: #{missing.join(', ')}. Generating now..."
-      Rails.logger&.info(message)
-      $stdout.puts(message) if config.stdout_logging?
 
       begin
         results = ReactManifest::Generator.new(config).run!
         written = results.count { |r| r[:status] == :written }
-        unchanged = results.count { |r| r[:status] == :unchanged }
-        done = "[ReactManifest] Boot generation complete: #{written} written, #{unchanged} unchanged"
-        Rails.logger&.info(done)
-        $stdout.puts(done) if config.stdout_logging?
+        if written.positive?
+          done = "[ReactManifest] Boot generation complete: #{written} written"
+          Rails.logger&.info(done)
+          $stdout.puts(done) if config.stdout_logging?
+        end
       rescue StandardError => e
         error = "[ReactManifest] Could not generate manifests on boot: #{e.message}"
         Rails.logger&.warn(error)
@@ -99,21 +94,5 @@ module ReactManifest
         Rake::Task["assets:precompile"].enhance(["react_manifest:generate"])
       end
     end
-
-    class << self
-      private
-
-      def missing_manifest_bundles(config)
-        expected_manifest_bundles(config).reject do |bundle_name|
-          File.exist?(File.join(config.abs_manifest_dir, "#{bundle_name}.js")) ||
-            File.exist?(File.join(config.abs_output_dir, "#{bundle_name}.js"))
-        end
-      end
-
-      def expected_manifest_bundles(config)
-        classification = ReactManifest::TreeClassifier.new(config).classify
-        ([config.shared_bundle] + classification.controller_dirs.map { |ctrl| ctrl[:bundle_name] }).uniq
-      end
-    end
   end
 end