Fix bin/dev pack generation in Bundler context (#1907)

* Fix bin/dev pack generation failure when run from Bundler context

When bin/dev runs in a Bundler context, calling `bundle exec rake` can fail
or cause issues. This change detects when we're already inside a Bundler
context and runs the Rake task directly instead of shelling out.

Key improvements:
- Detects Bundler context and runs tasks directly
- Falls back to bundle exec when not in Bundler context
- Properly handles silent mode for both execution paths
- Loads Rails environment when needed

This fixes pack generation failures when using bin/dev.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

* Add rails_available? check to prevent nil Rails.application

The previous implementation didn't check if Rails.application was available
before calling load_tasks, which caused test failures. This adds the
rails_available? method to check if Rails is properly initialized.

Also updates run_rake_task_directly to use task.reenable for better
re-execution support.

Fixes RSpec test failures in pack_generator_spec.rb

* Improve pack generator robustness and error handling

Based on code review feedback, this commit addresses several critical issues:

1. **Better Bundler context detection**: Now checks ENV['BUNDLE_GEMFILE']
   for more robust detection of meaningful Bundler contexts

2. **Enhanced Rails availability checking**: Safely verifies Rails.application
   can actually load tasks, with proper error handling

3. **Consistent error handling**: Errors are always written to stderr,
   even in silent mode. Backtrace included when DEBUG env var is set

4. **Reduced code complexity**: Refactored run_rake_task_directly into
   smaller, focused methods (load_rake_tasks, prepare_rake_task,
   capture_output, handle_rake_error) to satisfy RuboCop complexity checks

5. **Maintained test compatibility**: Tests continue to pass because the
   code properly falls back to bundle exec in test environment where
   BUNDLE_GEMFILE is not set

These changes ensure:
- Tests work correctly (they mock system calls which are used in test env)
- Production bin/dev usage is optimized (direct Rake execution when safe)
- Error messages are never silently swallowed
- More robust detection of execution context

---------

Co-authored-by: Claude <[email protected]>

Author: justin808

lib/react_on_rails/dev/pack_generator.rb

@@ -9,10 +9,10 @@ class << self
         def generate(verbose: false)
           if verbose
             puts "📦 Generating React on Rails packs..."
-            success = system "bundle exec rake react_on_rails:generate_packs"
+            success = run_pack_generation
           else
             print "📦 Generating packs... "
-            success = system "bundle exec rake react_on_rails:generate_packs > /dev/null 2>&1"
+            success = run_pack_generation(silent: true)
             puts success ? "✅" : "❌"
           end
 
@@ -21,6 +21,100 @@ def generate(verbose: false)
           puts "❌ Pack generation failed"
           exit 1
         end
+
+        private
+
+        def run_pack_generation(silent: false)
+          # If we're already inside a Bundler context AND Rails is available (e.g., called from bin/dev),
+          # we can directly require and run the task. Otherwise, use bundle exec.
+          if should_run_directly?
+            run_rake_task_directly(silent: silent)
+          else
+            run_via_bundle_exec(silent: silent)
+          end
+        end
+
+        def should_run_directly?
+          # Check if we're in a meaningful Bundler context with BUNDLE_GEMFILE
+          return false unless defined?(Bundler)
+          return false unless ENV["BUNDLE_GEMFILE"]
+          return false unless rails_available?
+
+          true
+        end
+
+        def rails_available?
+          return false unless defined?(Rails)
+          return false unless Rails.respond_to?(:application)
+          return false if Rails.application.nil?
+
+          # Verify Rails app can actually load tasks
+          begin
+            Rails.application.respond_to?(:load_tasks)
+          rescue StandardError
+            false
+          end
+        end
+
+        def run_rake_task_directly(silent: false)
+          require "rake"
+
+          load_rake_tasks
+          task = prepare_rake_task
+
+          capture_output(silent) do
+            task.invoke
+            true
+          end
+        rescue StandardError => e
+          handle_rake_error(e, silent)
+          false
+        end
+
+        def load_rake_tasks
+          return if Rake::Task.task_defined?("react_on_rails:generate_packs")
+
+          Rails.application.load_tasks
+        end
+
+        def prepare_rake_task
+          task = Rake::Task["react_on_rails:generate_packs"]
+          task.reenable # Allow re-execution if called multiple times
+          task
+        end
+
+        def capture_output(silent)
+          return yield unless silent
+
+          original_stdout = $stdout
+          original_stderr = $stderr
+          output_buffer = StringIO.new
+          $stdout = output_buffer
+          $stderr = output_buffer
+
+          begin
+            yield
+          ensure
+            $stdout = original_stdout
+            $stderr = original_stderr
+          end
+        end
+
+        def handle_rake_error(error, _silent)
+          error_msg = "Error generating packs: #{error.message}"
+          error_msg += "\n#{error.backtrace.join("\n")}" if ENV["DEBUG"]
+
+          # Always write to stderr, even in silent mode
+          warn error_msg
+        end
+
+        def run_via_bundle_exec(silent: false)
+          if silent
+            system "bundle exec rake react_on_rails:generate_packs > /dev/null 2>&1"
+          else
+            system "bundle exec rake react_on_rails:generate_packs"
+          end
+        end
       end
     end
   end