react-manifest-rails 0.2.2 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36adf78621e6d6b409a6242cccfe34fc7ab916357771c81683c17ef58c80b9a7
-  data.tar.gz: 4a4f18f2c4b3749376bb2c3adae8c9be6a881f9df04411a49c903c01d917282f
+  metadata.gz: 91ed3c8b3020fda5a5d811b059fdc654dd22c220878c42e76a42011ee899713e
+  data.tar.gz: a3ea26760e50e90e85d35a790fac7df24fbbaa38c717e56f071b61dc7003dcfd
 SHA512:
-  metadata.gz: 665b92d9ba95e189fbc7791ad3a620df282df1ac9d865ccdd481618f41d47f53d86cb013881f5beac312115b73a7f862933145980ba6b4d9cda872ec3cd3e938
-  data.tar.gz: 2be3a86848583a94dcf49cd0b1f637b20d9f88ed8f2ca5abafe357f50ae51589d74c14164024a46e4c0ef6b9f969baa0e76017ba79518b4d98d1ff8a72716e59
+  metadata.gz: f6648f2f5dbe48b37a3a96db8a472308be09af4ca652a1b5cb70132ec82d7a6b423451298c5c58721baf566a8b798df33e05a6da7a399036d5b589385bf3ba0a
+  data.tar.gz: 25ec716c8cb0c806152762e0e70c93468a68b3d07cb68a002180be303be892953ae2f2b4b400343c1607e821b44928a7303f264ec2129366f200230d71e523e2

data/CHANGELOG.md

@@ -5,6 +5,33 @@ 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.5] - 2026-04-15
+
+### Fixed
+- Updated root `Gemfile.lock` to stay in sync with gemspec version changes, fixing frozen Bundler install failures in the release workflow.
+
+### Changed
+- Follow-up release from `0.2.4` to ensure GitHub Release trusted publishing can complete successfully.
+
+## [0.2.4] - 2026-04-15
+
+### Changed
+- Clarified configuration semantics for `ignore`, `exclude_paths`, `dry_run`, `verbose`, and `stdout_logging` in inline code comments.
+- Updated README with clearer guidance on default configuration usage and explicit behavior notes for `ignore` vs `exclude_paths`.
+- Documented that scanning scope is limited to `ux_root` and that `exclude_paths` is path-segment based (not `application.js` include based).
+
+## [0.2.3] - 2026-04-15
+
+### Added
+- Compatibility entrypoint (`lib/react-manifest-rails.rb`) so default Bundler auto-require reliably loads the Railtie and rake tasks.
+- Development boot-time sync that generates missing `ux_*.js` manifests once on server start.
+- Configurable stdout logging with `config.stdout_logging` for visible generation events in development.
+
+### Changed
+- Streamlined README into a concise development-first quickstart with direct troubleshooting for missing tasks and watcher behavior.
+- Improved `react_manifest:generate` diagnostics when `ux_root` is missing or no controller bundles are detected.
+- Watcher and boot-time generation now emit clearer runtime status lines for easier debugging.
+
 ## [0.2.2] - 2026-04-15
 
 ### Changed

data/README.md

@@ -1,353 +1,172 @@
 # react-manifest-rails
 
-**Zero-touch Sprockets manifest generation for react-rails apps**
+Generate per-controller Sprockets manifests for React code in Rails.
 
-A Rails gem that automatically generates lean, controller-specific JavaScript bundles for applications using `react-rails` and Sprockets, eliminating the need for monolithic `application.js` files.
+This gem creates `ux_*.js` bundles and includes them with `react_bundle_tag`.
 
-## Features
+## Quick Start (Development)
 
-- **Automatic bundle generation**: Creates per-controller `ux_*.js` manifests on-demand
-- **Smart file watching**: Automatically regenerates bundles when files change in development
-- **Intelligent bundle resolution**: The `react_bundle_tag` view helper automatically selects the correct bundles for each controller
-- **Namespace-aware**: Handles nested controllers and namespaces gracefully (e.g., `admin/users` → `ux_admin_users`)
-- **Shared bundles**: Automatically extracts shared dependencies into a `ux_shared` bundle
-- **Always-include bundles**: Configure bundles that should be loaded on every page
-- **Production-ready**: Integrates seamlessly with `assets:precompile` for CI/production deployments
-- **Zero configuration**: Works out-of-the-box with sensible defaults for standard Rails projects
-
-## Advantages
-
-### 1. Smaller Bundle Sizes
-Instead of a single monolithic `application.js` that loads all React components for the entire app, each controller gets its own lean bundle containing only the components it needs. This means:
-- **Faster page loads**: Users only download what they need
-- **Better caching**: Components unchanged on their page won't bust the cache
-- **Reduced bandwidth**: Particularly beneficial for mobile users
-
-### 2. Simplified Development
-- **Automatic regeneration**: Changes to component files are automatically bundled—no manual build steps
-- **No configuration needed**: Works with standard Rails directory structures immediately
-- **Easy integration**: Drop the gem in and it works with your existing `react-rails` setup
-
-### 3. Production Reliability
-- **CI/CD friendly**: Integrates with `assets:precompile` for automated deployments
-- **Deterministic builds**: Consistent bundle generation across environments
-- **Safety checks**: Warns about oversized bundles to catch potential issues
-
-### 4. Developer Experience
-- **Per-controller organization**: Bundle structure mirrors your Rails controller layout
-- **Smart bundle selection**: View helper automatically picks the right bundles—no manual tag management
-- **Clear visibility**: Built-in reporter shows exactly what's in each bundle
-
-## Installation
-
-Add the gem to your `Gemfile`:
+1. Add gems:
 
 ```ruby
-gem 'react-manifest-rails'
+# Gemfile
+gem "react-manifest-rails"
+
+group :development do
+  gem "listen", "~> 3.0"
+end
 ```
 
-Then run:
+2. Install:
 
 ```bash
 bundle install
 ```
 
-## Setup
-
-### 1. Create your UX directory structure
-
-By default, the gem expects your React components to live in `app/assets/javascripts/ux/`. You should organize it like this:
+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
 ```
-app/assets/javascripts/ux/
-├── app/                          # Per-controller components (becomes ux_*.js bundles)
-│   ├── users/
-│   │   ├── UserCard.jsx
-│   │   └── UserList.jsx
-│   ├── products/
-│   │   └── ProductGrid.jsx
-│   └── dashboard/
-│       └── Dashboard.jsx
-├── shared/                        # Shared utilities (becomes ux_shared)
-│   ├── api.js
-│   └── utils.js
-└── components/                    # Global components (becomes ux_shared)
-    └── Navigation.jsx
-```
-
-### 2. Configure the gem (Optional)
 
-Create an initializer at `config/initializers/react_manifest.rb`:
+3. Add initializer:
 
 ```ruby
+# config/initializers/react_manifest.rb
+require "react_manifest"
+
 ReactManifest.configure do |config|
-  # Where your UX root lives (default: "app/assets/javascripts/ux")
   config.ux_root = "app/assets/javascripts/ux"
-
-  # Subdir within ux_root containing per-controller components (default: "app")
   config.app_dir = "app"
-
-  # Where generated manifests are written (default: "app/assets/javascripts")
   config.output_dir = "app/assets/javascripts"
-
-  # Name of the shared bundle (default: "ux_shared")
   config.shared_bundle = "ux_shared"
-
-  # Bundles to always include on every page (default: [])
-  # config.always_include = ["ux_main"]
-
-  # Directories within app_dir to ignore (default: [])
-  # config.ignore = ["internal_tools"]
-
-  # Warn if any bundle exceeds this size in KB (default: 500, 0 to disable)
+  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
 ```
 
-### 3. Use the view helper
-
-In your layout template (`app/views/layouts/application.html.erb` or similar):
-
-```erb
-<head>
-  <%= javascript_include_tag "application" %>
-  <%= react_bundle_tag defer: true %>
-</head>
-```
-
-The `react_bundle_tag` helper automatically:
-1. Includes the shared bundle (`ux_shared`)
-2. Includes any bundles in `config.always_include`
-3. Includes the controller-specific bundle (e.g., `ux_users` for UsersController)
-4. Returns an empty string gracefully if there's no matching bundle
-
-## How It Works
-
-### Bundle Generation
-
-The gem scans your `app/assets/javascripts/ux/` directory and generates Sprockets manifests:
-
-- **Controller-specific bundles**: Each directory under `ux/app/` becomes a bundle
-  - `ux/app/users/` → `ux_users.js`
-  - `ux/app/admin/reports/` → `ux_admin_reports.js`
-
-- **Shared bundle**: Everything outside `ux/app/` (e.g., `shared/`, `components/`) automatically goes into `ux_shared.js`
-
-- **Dependency tracking**: The gem analyzes dependencies to prevent duplication across bundles
-
-### Development
-
-In development, a file watcher automatically:
-- Detects changes to component files
-- Regenerates affected bundles
-- Updates manifests in real-time
-
-### Production
-
-The gem integrates with Rails' `assets:precompile` task:
-
-```bash
-rails assets:precompile
-```
-
-This ensures all bundles are generated before deployment.
-
-## View Helper Usage
-
-### Basic usage
+4. Put React files under:
 
-```erb
-<%= react_bundle_tag %>
+```text
+app/assets/javascripts/ux/
+  app/
+    users/
+      users_index.jsx
+  components/
+    nav.jsx
 ```
 
-### With HTML options
+5. Include bundles in your layout:
 
 ```erb
-<%= react_bundle_tag defer: true, async: true %>
+<%= react_bundle_tag defer: true %>
 ```
 
-### Automatic resolution
-
-The helper automatically resolves bundles based on `controller_path`:
-
-| Controller | Resolved Bundles |
-|-----------|------------------|
-| UsersController | ux_shared + ux_users |
-| Admin::ReportsController | ux_shared + ux_admin_reports (or ux_admin if not found) |
-| Pages::LandingController | ux_shared + ux_pages_landing (or ux_pages, or ux_landing) |
-
-## Rake Tasks
-
-### Generate bundles (one-time)
+6. Start server:
 
 ```bash
-rails react_manifest:generate
+bundle exec rails s
 ```
 
-### Watch for changes (development)
+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.
 
-```bash
-rails react_manifest:watch
-```
+## Configuration Notes
 
-### Show bundle contents
+- `ignore`:
+  - Skips controller directory names directly under `ux/app/`.
+  - Example: `ignore = ["admin"]` skips `ux/app/admin/*`.
 
-```bash
-rails react_manifest:report
-```
+- `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`.
 
-## Configuration Reference
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `ux_root` | `"app/assets/javascripts/ux"` | Root directory of your React components |
-| `app_dir` | `"app"` | Subdirectory of `ux_root` for per-controller components |
-| `output_dir` | `"app/assets/javascripts"` | Where generated manifests are written |
-| `shared_bundle` | `"ux_shared"` | Name of the shared bundle |
-| `always_include` | `[]` | Array of bundle names to load on every page |
-| `ignore` | `[]` | Directories to skip during scanning |
-| `exclude_paths` | `["react", "react_dev", "vendor"]` | Top-level directories to exclude |
-| `size_threshold_kb` | `500` | Warn if a bundle exceeds this size (0 = disabled) |
-| `dry_run` | `false` | Print what would change without writing files |
-| `verbose` | `false` | Enable extra logging |
+- `dry_run`:
+  - Preview mode only; computes and prints changes but writes no files.
 
-## Troubleshooting
+- `verbose` vs `stdout_logging`:
+  - `verbose`: extra diagnostic detail.
+  - `stdout_logging`: whether ReactManifest status lines are printed to terminal stdout.
 
-### Bundle not being generated
-- Check that your components are in the correct directory structure (`app/assets/javascripts/ux/app/...`)
-- Run `rails react_manifest:report` to see what bundles were detected
-- Check Rails logs for any file watcher errors
+- Scope:
+  - Manifest generation only scans files under `ux_root`.
 
-### Components not loading
-- Verify `react_bundle_tag` is in your layout
-- Check that the bundle name matches your controller path
-- Make sure components are in the `ux/` directory, not elsewhere
+## What Gets Generated
 
-### Size warnings
-- The gem warns when bundles exceed 500KB
-- Consider splitting large bundles into smaller, more focused ones
-- Adjust `config.size_threshold_kb` in your initializer if needed
+- `ux_shared.js`: shared files outside `ux/app/`
+- `ux_<controller>.js`: one bundle per directory under `ux/app/`
 
-## TypeScript / Custom Extensions
+Example:
+- `ux/app/users/...` -> `ux_users.js`
+- `ux/app/admin/...` -> `ux_admin.js`
 
-By default the gem scans `*.js` and `*.jsx` files. To add TypeScript support:
+## Commands
 
-```ruby
-ReactManifest.configure do |config|
-  config.extensions = %w[js jsx ts tsx]
-end
-```
-
-This affects file scanning, manifest generation, and the development file watcher.
-
-## File Watching (`listen` gem)
-
-The development file watcher requires the `listen` gem, which is **not** a hard dependency. If `listen` is absent the watcher is silently disabled and you must regenerate manifests manually.
-
-To enable watching, add `listen` to the development group in your app's `Gemfile`:
-
-```ruby
-gem "listen", "~> 3.0", group: :development
-```
-
-> **Note:** Changes to `config/initializers/react_manifest.rb` are not picked up by the watcher — you must restart the server after editing the initializer.
-
-## Migrating an Existing `application.js`
-
-If you are adding this gem to an app that already has a monolithic `application.js`, use the built-in migration tools:
-
-**Step 1 — Analyse what's there:**
-
-```bash
-rails react_manifest:analyze
-```
-
-This classifies each `//= require` line as `:vendor` (keep), `:ux_code` (remove), or `:unknown` (review manually). No files are modified.
-
-**Step 2 — Preview changes:**
+- Generate manifests now:
 
 ```bash
-REACT_MANIFEST_DRY_RUN=1 rails react_manifest:migrate_application
+bundle exec rails react_manifest:generate
 ```
 
-**Step 3 — Apply changes:**
+- Watch in foreground (debugging only; not required in normal dev):
 
 ```bash
-rails react_manifest:migrate_application
+bundle exec rails react_manifest:watch
 ```
 
-A `.bak` backup is created next to each modified file before any write.
-
-**Step 4 — Generate bundles and verify:**
+- Print bundle size report:
 
 ```bash
-rails react_manifest:generate
-rails assets:precompile  # or just start the dev server
+bundle exec rails react_manifest:report
 ```
 
-**Rolling back:** Simply restore the `.bak` file and remove the generated `ux_*.js` manifests.
-
 ## Troubleshooting
 
-### Bundle not being generated
-- Verify components live under `ux/app/<controller>/` (not directly under `ux/`)
-- Run `rails react_manifest:report` to see detected bundles
-- Check Rails logs for file watcher errors
-
-### Components not loading
-- Confirm `react_bundle_tag` is present in your layout
-- Check that the bundle name matches your controller path
-- Run `rails react_manifest:generate` to force regeneration
+### `react_manifest:generate` is not recognized
 
-### Bundle appears more than once in HTML output
-- A bundle name in `config.always_include` that is also the controller bundle will be deduplicated automatically. Check whether both the shared bundle name and a specific bundle are listed in `always_include`.
+Run:
 
-### Watcher stops responding
-- This is usually resolved by restarting the development server
-- Ensure the `listen` gem is installed (see above)
+```bash
+bundle exec rails -T | grep react_manifest
+```
 
-### Generator crashes on first run
-- Check that the process has write permission to `config.output_dir`
-- Verify `config.ux_root` exists; the generator is a no-op if the directory is missing
+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).
 
-### Size warnings
-- The gem warns when bundles exceed `config.size_threshold_kb` (default 500 KB)
-- Consider splitting large controller directories or moving shared code into the shared bundle
-- Adjust the threshold: `config.size_threshold_kb = 1000`
+### Server starts but nothing happens
 
-## Performance
+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`.
 
-| Scenario | Typical time |
-|----------|-------------|
-| Initial generation (small project, ~20 controllers) | < 1 s |
-| Initial generation (large project, ~100 controllers) | 2–5 s |
-| Watcher debounce (regeneration after file change) | ~300 ms |
-| Memory overhead (symbol index, large project) | < 10 MB |
+### Auto-watch in dev does not run
 
-Scanning is purely regex-based — no Node.js or transpilation step required.
+- 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.
 
 ## Compatibility
 
-| Dependency | Supported versions |
-|------------|-------------------|
-| Ruby | 3.2, 3.3 |
-| Rails / Railties | 6.1 – 8.x |
-| Sprockets | 3.x, 4.x |
-| listen (optional) | ~> 3.0 |
-
-> **Pre-1.0 notice:** The public API (configuration keys, rake task names, view helper signature) may change in minor versions until 1.0 is released. Pin to a patch version if stability is critical: `gem "react-manifest-rails", "~> 0.1.0"`.
-
-## Requirements
-
-- Ruby >= 3.2
-- Rails >= 6.1
-- Sprockets
-- react-rails
+- Ruby: 3.2+
+- Rails/Railties: 7.x to 8.x
+- Asset pipeline: Sprockets
 
 ## License
 
-MIT License. See LICENSE for details.
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/olivernoonan/react-manifest-rails.
+MIT

data/lib/react-manifest-rails.rb

@@ -0,0 +1 @@
+require "react_manifest_rails"

data/lib/react_manifest/configuration.rb

@@ -23,10 +23,14 @@ module ReactManifest
     # Bundles always prepended by react_bundle_tag (e.g. ["ux_main"])
     attr_accessor :always_include
 
-    # Directories under app_dir to completely ignore
+    # Controller directory names directly under ux_root/app_dir to skip entirely.
+    # Example: ignore = ["admin"] skips ux/app/admin/* when building ux_<controller>.js.
     attr_accessor :ignore
 
-    # Top-level dirs under output_dir to never scan (vendor libs, etc.)
+    # Path segments to exclude while scanning files under ux_root.
+    # This is segment matching (not full path matching), so "vendor" excludes
+    # ux/vendor/foo.js and ux/app/users/vendor/bar.jsx, but not ux/vendor_custom/x.js.
+    # These are not application.js includes; they only affect ux tree scanning.
     attr_accessor :exclude_paths
 
     # Warn if a bundle exceeds this size in KB (0 = disabled)
@@ -35,12 +39,17 @@ module ReactManifest
     # File extensions to scan (default: js and jsx; add "ts", "tsx" for TypeScript)
     attr_accessor :extensions
 
-    # Print what would change, write nothing
+    # Preview mode: print what would change, write nothing.
+    # Applies anywhere generation runs (manual task, boot sync, watcher).
     attr_accessor :dry_run
 
-    # Extra logging
+    # Extra diagnostic logging (summary lines and richer error context).
     attr_accessor :verbose
 
+    # Emit ReactManifest status lines to stdout in development.
+    # Independent from Rails.logger output.
+    attr_accessor :stdout_logging
+
     def initialize
       @ux_root           = "app/assets/javascripts/ux"
       @app_dir           = "app"
@@ -53,6 +62,7 @@ module ReactManifest
       @extensions        = %w[js jsx]
       @dry_run           = false
       @verbose           = false
+      @stdout_logging    = true
     end
 
     def dry_run?
@@ -63,6 +73,10 @@ module ReactManifest
       !!@verbose
     end
 
+    def stdout_logging?
+      !!@stdout_logging
+    end
+
     # Glob fragment used by Dir.glob, e.g. "*.{js,jsx}" or "*.{js,jsx,ts,tsx}"
     def extensions_glob
       "*.{#{extensions.join(',')}}"

data/lib/react_manifest/railtie.rb

@@ -2,6 +2,35 @@ 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.
+    # ----------------------------------------------------------------
+    initializer "react_manifest.ensure_manifests" do
+      next unless Rails.env.development?
+
+      config = ReactManifest.configuration
+      missing = self.class.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?
+      rescue StandardError => e
+        error = "[ReactManifest] Could not generate manifests on boot: #{e.message}"
+        Rails.logger&.warn(error)
+        $stdout.puts(error) if config.stdout_logging?
+      end
+    end
+
     # Expose config as Rails.application.config.react_manifest
     config.react_manifest = ReactManifest.configuration
 
@@ -12,6 +41,7 @@ module ReactManifest
       if Rails.env.development? && !ReactManifest::Watcher.running?
         begin
           ReactManifest::Watcher.start(ReactManifest.configuration)
+          Rails.logger&.info("[ReactManifest] Development watcher is active") if ReactManifest.configuration.verbose?
         rescue StandardError => e
           Rails.logger.warn "[ReactManifest] Could not start file watcher: #{e.message}"
         end
@@ -42,5 +72,21 @@ module ReactManifest
         Rake::Task["assets:precompile"].enhance(["react_manifest:generate"])
       end
     end
+
+    class << self
+      private
+
+      def missing_manifest_bundles(config)
+        output_dir = config.abs_output_dir
+        expected_manifest_bundles(config).reject do |bundle_name|
+          File.exist?(File.join(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

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.2".freeze
+  VERSION = "0.2.5".freeze
 end

data/lib/react_manifest/watcher.rb

@@ -65,6 +65,7 @@ module ReactManifest
         msg = "[ReactManifest] #{message}"
         if defined?(Rails) && Rails.logger
           Rails.logger.info(msg)
+          $stdout.puts(msg) if Rails.env.development? && ReactManifest.configuration.stdout_logging?
         else
           $stdout.puts msg
         end

data/tasks/react_manifest.rake

@@ -1,7 +1,15 @@
 namespace :react_manifest do
   desc "Generate all ux_*.js Sprockets manifests from the ux/ directory tree"
   task generate: :environment do
-    results = ReactManifest::Generator.new.run!
+    config = ReactManifest.configuration
+
+    unless Dir.exist?(config.abs_ux_root)
+      puts "[ReactManifest] ux_root not found: #{config.abs_ux_root}"
+      puts "[ReactManifest] Create it (for example: app/assets/javascripts/ux) then run this task again."
+      next
+    end
+
+    results = ReactManifest::Generator.new(config).run!
 
     written   = results.count { |r| r[:status] == :written }
     unchanged = results.count { |r| r[:status] == :unchanged }
@@ -12,6 +20,9 @@ namespace :react_manifest do
       puts "[ReactManifest] DRY-RUN complete: #{dry} manifest(s) would be written"
     else
       puts "[ReactManifest] Done: #{written} written, #{unchanged} unchanged, #{skipped} skipped"
+      if (written + unchanged + skipped).zero?
+        puts "[ReactManifest] No manifests generated. Ensure ux/app/<controller>/ contains .js or .jsx files."
+      end
     end
 
     # Print any scanner warnings

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.5
 platform: ruby
 authors:
 - Oliver Noonan
@@ -134,6 +134,7 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - README.md
+- lib/react-manifest-rails.rb
 - lib/react_manifest.rb
 - lib/react_manifest/application_analyzer.rb
 - lib/react_manifest/application_migrator.rb