react-manifest-rails 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d0636de70da440909d01ca2748f51e9b73533a2c787b59984d906bac001b34c
-  data.tar.gz: d5a1c1982d5e875b0794c0645b07391edfff54f210f3dc394c0650ab0929d76d
+  metadata.gz: 5a26dc7e8929f42fed07d13c8d38d3390d99d8063c81e5887ac171e52c1d9303
+  data.tar.gz: defd50858d68d0e22fdd396d6be214af15edb6eb6c5c030c1047c17f1f2ab0e6
 SHA512:
-  metadata.gz: fd86d54537b980dfff2ad4a7ab620b483716a8df735fed7cb4a6f0cc92c65297552c2295f2eda81017bb5fe290e2fc9500c91e04e2ff1700637162749609f2e8
-  data.tar.gz: 3bad752f3e4404f33a01fabd28c35b4dea27216b8adb8f4e312a0d3748bdbba85e06250866adc166bb9d49a723c1846163b2b8f8a0d75c50aa589ff461eb34dd
+  metadata.gz: d94c1392eaaa325b56225b618f318d0af156c4696dc806a2ba238796c10c75f128c4a7369475a455d1e6f851edd8ca66a5a10e86ed246a0d15917ba00a198bab
+  data.tar.gz: 86ddf03428eb1889ea9bcabd463fa761bc5738a724e201197323228ef067cd1d400f85da40d273a69cc06bf7c8016a9bba732ddd36e6c56147d980d14bda74ce

data/CHANGELOG.md

@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.9] - 2026-04-15
+
+### Added
+- `rails react_manifest:setup` — one-command onboarding that patches `application.js`, `manifest.js`, and layout files, then generates initial bundles. Supports `DRY_RUN=1` preview mode.
+- `ReactManifest::LayoutPatcher` — automatically inserts `react_bundle_tag` into ERB, HAML, and Slim layouts after `javascript_include_tag`, with `</head>` fallback. Preserves indentation and is idempotent.
+- `ReactManifest::SprocketsManifestPatcher` — adds the `//= link_tree ../javascripts/ux_manifests .js` directive to `app/assets/config/manifest.js` so Sprockets 4 compiles the generated bundles.
+
+### Fixed
+- Removed a `Proc` from `config.assets.precompile` that crashed Sprockets 4.2+ with `NoMethodError: undefined method 'start_with?' for an instance of Proc`. The `link_tree` directive (handled by `SprocketsManifestPatcher`) is the correct mechanism.
+
+### Changed
+- `react_manifest:generate` now warns if the Sprockets manifest has not yet been patched.
+- README rewritten with a streamlined Quick Start centred on `react_manifest:setup`.
+- Confirmed full production asset pipeline compatibility: all ux bundles compile, minify, digest, and gzip correctly via `assets:precompile` with any standard JS compressor (uglifier/mini_racer, terser, libv8).
+
 ## [0.2.8] - 2026-04-15
 
 ### Fixed

data/README.md

@@ -2,144 +2,183 @@
 
 Generate per-controller Sprockets manifests for React code in Rails.
 
-This gem creates `ux_*.js` bundles and includes them with `react_bundle_tag`.
+Instead of one monolithic `application.js`, each controller gets a lean `ux_<controller>.js` bundle that only loads what it needs. Shared components, hooks, and libraries are automatically bundled into a single `ux_shared.js` included on every page.
 
-## Quick Start (Development)
+## Quick Start
 
-1. Add gems:
+### 1. Add to Gemfile
 
 ```ruby
-# Gemfile
 gem "react-manifest-rails"
 
 group :development do
-  gem "listen", "~> 3.0"
+  gem "listen", "~> 3.0"  # optional — enables auto-regeneration on file change
 end
 ```
 
-2. Install:
-
 ```bash
 bundle install
 ```
 
-If your app uses this standard layout, you can keep defaults and only create the initializer if you want overrides:
-
-```text
-ux_root:     app/assets/javascripts/ux
-app_dir:     app
-output_dir:  app/assets/javascripts
-extensions:  js, jsx
-```
-
-3. Add initializer:
+### 2. Add initializer
 
 ```ruby
 # config/initializers/react_manifest.rb
-require "react_manifest"
-
 ReactManifest.configure do |config|
-  config.ux_root = "app/assets/javascripts/ux"
-  config.app_dir = "app"
+  # All defaults shown — only override what you need to change.
+  config.ux_root    = "app/assets/javascripts/ux"
+  config.app_dir    = "app"
   config.output_dir = "app/assets/javascripts"
-  config.manifest_subdir = "ux_manifests"
-  config.shared_bundle = "ux_shared"
-  config.always_include = []
-  config.ignore = []
-  config.exclude_paths = ["react", "react_dev", "vendor"]
-  config.size_threshold_kb = 500
-  config.dry_run = false
-  config.verbose = false
-  config.stdout_logging = true
 end
 ```
 
-4. Put React files under:
+### 3. Run setup
+
+```bash
+bundle exec rails react_manifest:setup
+```
+
+This one command:
+- Patches `application.js` to remove globally-required React files (they'll be per-controller instead)
+- Patches `app/assets/config/manifest.js` to add the `link_tree` directive Sprockets needs to compile the bundles
+- Patches your layout(s) to insert `react_bundle_tag`
+- Generates the initial `ux_*.js` manifests
+
+Preview changes without writing anything:
+
+```bash
+DRY_RUN=1 bundle exec rails react_manifest:setup
+```
+
+### 4. Organise your React files
 
 ```text
 app/assets/javascripts/ux/
   app/
-    users/
+    users/          → compiled into ux_users.js
       users_index.jsx
-  components/
+    dashboard/      → compiled into ux_dashboard.js
+      dashboard.jsx
+  components/       → compiled into ux_shared.js (included on every page)
     nav.jsx
+    button.jsx
+  hooks/            → also goes into ux_shared.js
+    use_modal.js
+  lib/              → also goes into ux_shared.js
+    helpers.js
 ```
 
-5. Include bundles in your layout:
-
-```erb
-<%= react_bundle_tag defer: true %>
-```
-
-6. Start server:
+### 5. Start the server
 
 ```bash
 bundle exec rails s
 ```
 
 In development:
-- If expected `ux_*.js` files are missing, the gem generates them once on boot.
-- If `listen` is installed, file changes regenerate manifests automatically.
-- If `listen` is missing, run `bundle exec rails react_manifest:generate` manually.
-- Set `config.stdout_logging = false` to silence ReactManifest console lines while keeping Rails logger output.
+- Missing `ux_*.js` files are generated automatically on boot.
+- If `listen` is installed, saving any file under `ux/` regenerates affected manifests instantly.
+- Without `listen`, run `bundle exec rails react_manifest:generate` after adding files.
 
-## Configuration Notes
+## How Bundle Inclusion Works
 
-- `ignore`:
-  - Skips controller directory names directly under `ux/app/`.
-  - Example: `ignore = ["admin"]` skips `ux/app/admin/*`.
+Generation is **directory-based** — deterministic and conservative by design.
 
-- `exclude_paths`:
-  - Excludes files by matching path segments while scanning the `ux_root` tree.
-  - Example: `exclude_paths = ["vendor"]` excludes `ux/vendor/*` and any nested `.../vendor/...` segment.
-  - This is not based on what is included in `application.js`.
+- `ux_shared.js`: every file from directories outside `ux/app/` (i.e. `components/`, `hooks/`, `lib/`, etc.)
+- `ux_<controller>.js`: `ux_shared` + every file under `ux/app/<controller>/`
 
-- `dry_run`:
-  - Preview mode only; computes and prints changes but writes no files.
+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.
 
-- `verbose` vs `stdout_logging`:
-  - `verbose`: extra diagnostic detail.
-  - `stdout_logging`: whether ReactManifest status lines are printed to terminal stdout.
-
-- Scope:
-  - Manifest generation only scans files under `ux_root`.
+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
 
-- `ux_shared.js`: shared files outside `ux/app/`
-- `ux_<controller>.js`: one bundle per directory under `ux/app/`
-- Generated manifests are written to `app/assets/javascripts/ux_manifests/` by default.
-- Existing legacy `app/assets/javascripts/ux_*.js` files are moved automatically on generation.
+```
+app/assets/javascripts/ux_manifests/   ← generated; do not edit
+  ux_shared.js
+  ux_users.js
+  ux_dashboard.js
+  ...
+```
 
-Example:
-- `ux/app/users/...` -> `ux_users.js`
-- `ux/app/admin/...` -> `ux_admin.js`
+Files carry an `AUTO-GENERATED` header. Any file without it is never overwritten — you can pin a manifest by removing the header.
 
-## Commands
+Writes are atomic (temp file + rename) and idempotent (SHA-256 comparison skips unchanged files).
 
-- Generate manifests now:
+## Asset Compilation & Minification
 
-```bash
-bundle exec rails react_manifest:generate
-```
+The generated files are standard Sprockets manifests — `//= require` directives only. Sprockets processes them identically to `application.js`:
 
-- Watch in foreground (debugging only; not required in normal dev):
+- **Development**: concatenated and served from memory.
+- **Production** (`assets:precompile`): concatenated, minified (with whatever JS compressor your app uses — `uglifier`/`mini_racer`, `terser`, libv8, etc.), digested, and gzipped.
 
-```bash
-bundle exec rails react_manifest:watch
+The gem hooks into `assets:precompile` as a prerequisite, so manifest generation always runs before Sprockets begins compiling.
+
+## Configuration
+
+```ruby
+ReactManifest.configure do |config|
+  config.ux_root          = "app/assets/javascripts/ux"
+  config.app_dir          = "app"          # subdirectory of ux_root containing per-controller dirs
+  config.output_dir       = "app/assets/javascripts"
+  config.manifest_subdir  = "ux_manifests" # subdirectory of output_dir for generated files
+  config.shared_bundle    = "ux_shared"
+  config.extensions       = %w[js jsx]     # add ts tsx for TypeScript
+  config.always_include   = []             # extra shared files always added to every bundle
+  config.ignore           = []             # controller dir names to skip entirely
+  config.exclude_paths    = ["react", "react_dev", "vendor"]  # path segments to exclude
+  config.size_threshold_kb = 500           # warn if a bundle exceeds this
+  config.dry_run          = false          # never write; only print what would change
+  config.verbose          = false          # extra diagnostic detail
+  config.stdout_logging   = true           # print status lines to terminal
+end
 ```
 
-- Print bundle size report:
+### Key option notes
+
+- **`ignore`**: skips entire controller dirs under `ux/app/`. `ignore = ["admin"]` excludes `ux/app/admin/`.
+- **`exclude_paths`**: excludes files whose path contains any listed segment. Not based on `application.js`.
+- **`dry_run`**: also honoured by `DRY_RUN=1` environment variable at runtime.
+- **`extensions`**: add `ts` and `tsx` to enable TypeScript source detection.
+
+## Commands
 
 ```bash
+# First-time setup (patches application.js, manifest.js, layouts; generates manifests)
+bundle exec rails react_manifest:setup
+
+# Regenerate all manifests
+bundle exec rails react_manifest:generate
+
+# Preview any command without writing
+DRY_RUN=1 bundle exec rails react_manifest:setup
+DRY_RUN=1 bundle exec rails react_manifest:generate
+
+# Analyse which shared symbols are used per controller
+bundle exec rails react_manifest:analyze
+
+# Print bundle size report
 bundle exec rails react_manifest:report
+
+# Watch for changes in foreground (debugging only — dev server already does this)
+bundle exec rails react_manifest:watch
+
+# Remove all generated manifests
+bundle exec rails react_manifest:clean
 ```
 
 ## Troubleshooting
 
-### `react_manifest:generate` is not recognized
+### `AssetNotPrecompiledError` for `ux_*.js`
+
+Sprockets 4 requires an explicit `link_tree` directive to compile files from non-standard paths. Run setup (or manually add the directive):
+
+```bash
+bundle exec rails react_manifest:setup
+```
+
+This adds `//= link_tree ../javascripts/ux_manifests .js` to `app/assets/config/manifest.js`.
 
-Run:
+### `react_manifest` tasks not found
 
 ```bash
 bundle exec rails -T | grep react_manifest
@@ -147,28 +186,30 @@ bundle exec rails -T | grep react_manifest
 
 If nothing appears:
 - Confirm the gem is in `Gemfile` and installed (`bundle show react-manifest-rails`).
-- Ensure the gem is not disabled with `require: false`.
-- Restart Spring/server (`bin/spring stop`, then re-run command).
+- Ensure it is not loaded with `require: false`.
+- Restart Spring: `bin/spring stop`.
 
-### Server starts but nothing happens
+### Server starts but no bundles are served
 
-Check these in order:
-- `app/assets/javascripts/ux` exists.
-- Your controller files are under `ux/app/<controller>/`.
-- Your layout includes `<%= react_bundle_tag %>`.
-- Run `bundle exec rails react_manifest:generate` once and check for generated `ux_*.js` in `app/assets/javascripts`.
+Check in order:
+1. `app/assets/javascripts/ux/` exists.
+2. Controller files are under `ux/app/<controller>/`.
+3. Your layout includes `<%= react_bundle_tag %>`.
+4. Run `bundle exec rails react_manifest:generate` and confirm files appear in `ux_manifests/`.
+5. Confirm `app/assets/config/manifest.js` contains the `link_tree` directive (run setup again if missing).
 
-### Auto-watch in dev does not run
+### Auto-watch not running in development
 
-- Ensure `listen` is in the development group.
-- Restart the Rails server after adding `listen`.
-- If you choose not to install `listen`, manual generation is the supported fallback.
+- Add `listen` to the development group in your Gemfile and `bundle install`.
+- Restart the Rails server.
+- Without `listen`, run `react_manifest:generate` manually after making changes.
 
 ## Compatibility
 
 - Ruby: 3.2+
-- Rails/Railties: 7.x to 8.x
-- Asset pipeline: Sprockets
+- Rails: 7.x – 8.x
+- Asset pipeline: Sprockets 3 and 4
+- JS compressors: uglifier / mini_racer, terser, libv8 / therubyracer — all work transparently
 
 ## License
 

data/lib/react_manifest/layout_patcher.rb

@@ -0,0 +1,121 @@
+module ReactManifest
+  # Patches Rails layout files to insert `react_bundle_tag` after the
+  # `javascript_include_tag` call, or before `</head>` as a fallback.
+  #
+  # Supports .html.erb, .html.haml, and .html.slim.
+  # Skips files that already contain `react_bundle_tag`.
+  # Atomic write: backs up original before writing.
+  #
+  # Usage:
+  #   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
+
+    Result = Struct.new(:file, :status, :detail, keyword_init: true)
+
+    def initialize(config = ReactManifest.configuration)
+      @config = config
+    end
+
+    # Patch all layout files. Returns array of Result objects.
+    def patch!
+      layouts = find_layouts
+      if layouts.empty?
+        $stdout.puts "[ReactManifest] No layout files found in #{layouts_dir}"
+        return []
+      end
+      layouts.map { |f| patch_file(f) }
+    end
+
+    private
+
+    def find_layouts
+      Dir.glob(File.join(layouts_dir, "*.html.{erb,haml,slim}"))
+         .reject { |f| File.directory?(f) }
+         .sort
+    end
+
+    def layouts_dir
+      Rails.root.join("app", "views", "layouts").to_s
+    end
+
+    def patch_file(path)
+      content = File.read(path, encoding: "utf-8")
+
+      if content.include?("react_bundle_tag")
+        return Result.new(file: path, status: :already_patched,
+                          detail: "react_bundle_tag already present")
+      end
+
+      ext         = detect_ext(path)
+      new_content = insert_bundle_tag(content, ext)
+
+      if new_content.nil?
+        return Result.new(file: path, status: :no_injection_point,
+                          detail: "Could not find javascript_include_tag or </head> — add react_bundle_tag manually")
+      end
+
+      if @config.dry_run?
+        $stdout.puts "[ReactManifest] 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)}"
+      Result.new(file: path, status: :patched, detail: nil)
+    end
+
+    # Insert the bundle tag line after `javascript_include_tag` (preferred),
+    # or before `</head>` / `%head` close as a fallback.
+    def insert_bundle_tag(content, ext)
+      lines = content.lines
+
+      # Preferred: insert after javascript_include_tag
+      js_idx = lines.index { |l| l.include?("javascript_include_tag") }
+
+      # Fallback: insert before closing </head>
+      head_idx = lines.rindex { |l| l.include?("</head>") } unless js_idx
+
+      insert_after = js_idx || (head_idx ? head_idx - 1 : nil)
+      return nil if insert_after.nil?
+
+      # Match indentation of the reference line
+      indent = lines[js_idx || head_idx][/^\s*/]
+      tag    = bundle_tag_line(ext, indent)
+
+      new_lines = lines.dup
+      new_lines.insert(insert_after + 1, tag)
+      new_lines.join
+    end
+
+    def bundle_tag_line(ext, indent)
+      case ext
+      when :haml, :slim
+        "#{indent}#{BUNDLE_TAG_HAML}"
+      else
+        "#{indent}#{BUNDLE_TAG_ERB}"
+      end
+    end
+
+    def detect_ext(path)
+      case path
+      when /\.html\.haml$/ then :haml
+      when /\.html\.slim$/ then :slim
+      else :erb
+      end
+    end
+
+    def short(path)
+      path.to_s.sub("#{Rails.root}/", "")
+    end
+
+    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}" }
+    end
+  end
+end

data/lib/react_manifest/sprockets_manifest_patcher.rb

@@ -0,0 +1,96 @@
+module ReactManifest
+  # Patches the Sprockets asset manifest (app/assets/config/manifest.js) to add a
+  # `link_tree` directive for the ux_manifests directory.
+  #
+  # This is required so Sprockets knows to compile and serve the generated ux_*.js
+  # bundle files. Without it, javascript_include_tag raises AssetNotPrecompiledError.
+  #
+  # Usage:
+  #   ReactManifest::SprocketsManifestPatcher.new(config).patch!
+  class SprocketsManifestPatcher
+    MANIFEST_GLOB = "app/assets/config/manifest.js".freeze
+
+    Result = Struct.new(:file, :status, :detail, keyword_init: true)
+
+    def initialize(config = ReactManifest.configuration)
+      @config = config
+    end
+
+    # Patch the Sprockets manifest file. Returns a Result.
+    def patch!
+      path = manifest_path
+      unless path
+        return Result.new(
+          file: nil,
+          status: :not_found,
+          detail: "#{MANIFEST_GLOB} not found — create it and add //= link_tree ../javascripts/ux_manifests .js"
+        )
+      end
+
+      content = File.read(path, encoding: "utf-8")
+      directive = link_tree_directive
+
+      if content.include?(directive.strip)
+        return Result.new(file: path, status: :already_patched, detail: "link_tree directive already present")
+      end
+
+      new_content = append_directive(content, directive)
+
+      if @config.dry_run?
+        $stdout.puts "[ReactManifest] DRY-RUN: would patch #{short(path)}"
+        $stdout.puts "  + #{directive.strip}"
+        return Result.new(file: path, status: :dry_run, detail: nil)
+      end
+
+      File.write(path, new_content, encoding: "utf-8")
+      $stdout.puts "[ReactManifest] Patched Sprockets manifest: #{short(path)}"
+      Result.new(file: path, status: :patched, detail: nil)
+    end
+
+    # Returns the directive string that should be present.
+    def link_tree_directive
+      subdir = normalize_subdir
+      "//= link_tree ../javascripts/#{subdir} .js\n"
+    end
+
+    # Returns true if the manifest file already contains the link_tree directive.
+    def already_patched?
+      path = manifest_path
+      return false unless path
+
+      File.read(path, encoding: "utf-8").include?(link_tree_directive.strip)
+    rescue Errno::ENOENT, Errno::EACCES
+      false
+    end
+
+    private
+
+    def manifest_path
+      candidate = Rails.root.join(MANIFEST_GLOB).to_s
+      File.exist?(candidate) ? candidate : nil
+    end
+
+    def normalize_subdir
+      # Strip leading/trailing slashes from manifest_subdir for path safety.
+      @config.manifest_subdir.to_s.gsub(%r{^/+|/+$}, "")
+    end
+
+    def append_directive(content, directive)
+      # Insert after last //= line for clean ordering.
+      lines = content.lines
+      last_directive_idx = lines.rindex { |l| l.strip.start_with?("//=") }
+
+      if last_directive_idx
+        new_lines = lines.dup
+        new_lines.insert(last_directive_idx + 1, directive)
+        new_lines.join
+      else
+        content + directive
+      end
+    end
+
+    def short(path)
+      path.to_s.sub("#{Rails.root}/", "")
+    end
+  end
+end

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.8".freeze
+  VERSION = "0.2.9".freeze
 end

data/lib/react_manifest.rb

@@ -8,6 +8,8 @@ require "react_manifest/dependency_map"
 require "react_manifest/generator"
 require "react_manifest/application_analyzer"
 require "react_manifest/application_migrator"
+require "react_manifest/layout_patcher"
+require "react_manifest/sprockets_manifest_patcher"
 require "react_manifest/watcher"
 require "react_manifest/reporter"
 require "react_manifest/view_helpers"

data/tasks/react_manifest.rake

@@ -1,4 +1,91 @@
 namespace :react_manifest do
+  desc "One-step setup: patch application.js, layout files, then generate manifests"
+  task setup: :environment do
+    dry = ENV["DRY_RUN"].to_s =~ /\A(1|true|yes)\z/i || ReactManifest.configuration.dry_run?
+    ReactManifest.configure { |c| c.dry_run = true } if dry
+
+    config = ReactManifest.configuration
+
+    puts ""
+    puts "=== react-manifest-rails setup ==="
+    puts "(DRY-RUN — no files will be written)\n" if config.dry_run?
+    puts ""
+
+    # 1. Confirm ux_root exists
+    puts "1) Checking ux_root..."
+    unless Dir.exist?(config.abs_ux_root)
+      puts "   ! Not found: #{config.ux_root}"
+      puts "   Create #{config.ux_root}/app/<controller>/ with your JSX files, then re-run."
+      puts ""
+      next
+    end
+    puts "   ✓ #{config.ux_root} found"
+
+    # 2. Patch application.js (remove ux requires, keep vendor)
+    puts "\n2) Patching application.js..."
+    migrator = ReactManifest::ApplicationMigrator.new(config)
+    mig_results = migrator.migrate!
+    if mig_results.empty?
+      puts "   No application*.js files found — nothing to migrate."
+    else
+      mig_results.each do |r|
+        case r[:status]
+        when :already_clean then puts "   ✓ #{r[:file].sub("#{Rails.root}/", '')} — already clean"
+        when :migrated      then puts "   ✓ #{r[:file].sub("#{Rails.root}/", '')} — migrated (backup at .bak)"
+        when :dry_run       then puts "   ~ #{r[:file].sub("#{Rails.root}/", '')} — (dry-run preview above)"
+        when :backup_failed then puts "   ✗ #{r[:file].sub("#{Rails.root}/", '')} — backup failed: #{r[:error]}"
+        end
+      end
+    end
+
+    # 3. Patch Sprockets manifest.js (add link_tree for ux_manifests)
+    puts "\n3) Patching Sprockets asset manifest..."
+    sm_glob = ReactManifest::SprocketsManifestPatcher::MANIFEST_GLOB
+    sm_result = ReactManifest::SprocketsManifestPatcher.new(config).patch!
+    case sm_result.status
+    when :patched         then puts "   ✓ #{sm_result.file.sub("#{Rails.root}/", '')}"
+    when :already_patched then puts "   ✓ #{sm_glob} — already has link_tree"
+    when :dry_run         then puts "   ~ #{sm_glob} — (dry-run preview above)"
+    when :not_found       then puts "   ! #{sm_result.detail}"
+    end
+
+    # 4. Patch layout files (insert react_bundle_tag)
+    puts "\n4) Patching layout files..."
+    patcher = ReactManifest::LayoutPatcher.new(config)
+    patch_results = patcher.patch!
+    if patch_results.empty?
+      puts "   No layout files found."
+      puts "   Add <%= react_bundle_tag defer: true %> to your layout manually."
+    else
+      patch_results.each do |r|
+        case r.status
+        when :patched           then puts "   ✓ #{r.file.sub("#{Rails.root}/", '')}"
+        when :already_patched   then puts "   ✓ #{r.file.sub("#{Rails.root}/", '')} — already has react_bundle_tag"
+        when :dry_run           then puts "   ~ #{r.file.sub("#{Rails.root}/", '')} — (dry-run preview above)"
+        when :no_injection_point then puts "   ! #{r.file.sub("#{Rails.root}/", '')} — #{r.detail}"
+        end
+      end
+    end
+
+    # 5. Generate manifests
+    puts "\n5) Generating ux_*.js manifests..."
+    gen_results = ReactManifest::Generator.new(config).run!
+    written   = gen_results.count { |r| r[:status] == :written }
+    unchanged = gen_results.count { |r| r[:status] == :unchanged }
+    dry_count = gen_results.count { |r| r[:status] == :dry_run }
+
+    if config.dry_run?
+      puts "   ~ #{dry_count} manifest(s) would be written"
+    else
+      puts "   ✓ #{written} written, #{unchanged} unchanged"
+    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?
+    puts ""
+  end
+
   desc "Generate all ux_*.js Sprockets manifests from the ux/ directory tree"
   task generate: :environment do
     config = ReactManifest.configuration
@@ -25,8 +112,12 @@ namespace :react_manifest do
       end
     end
 
-    # Print any scanner warnings
-    results # warnings are printed inline by scanner via $stdout in verbose mode
+    # Print any scanner warnings # warnings are printed inline by scanner via $stdout in verbose mode
+
+    unless ReactManifest::SprocketsManifestPatcher.new(config).already_patched?
+      puts "[ReactManifest] NOTICE: app/assets/config/manifest.js is missing the link_tree directive."
+      puts "[ReactManifest] Run `rails react_manifest:setup` to add it automatically."
+    end
   end
 
   desc "Print the JSX dependency map and warnings without writing any files"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Oliver Noonan
@@ -141,9 +141,11 @@ files:
 - lib/react_manifest/configuration.rb
 - lib/react_manifest/dependency_map.rb
 - lib/react_manifest/generator.rb
+- lib/react_manifest/layout_patcher.rb
 - lib/react_manifest/railtie.rb
 - lib/react_manifest/reporter.rb
 - lib/react_manifest/scanner.rb
+- lib/react_manifest/sprockets_manifest_patcher.rb
 - lib/react_manifest/tree_classifier.rb
 - lib/react_manifest/version.rb
 - lib/react_manifest/view_helpers.rb