Address code review feedback for verbose flag implementation

Based on thorough code review feedback, this commit addresses several
improvements to make the implementation more robust and explicit:

1. **RBS Type Signatures**: Updated type signatures to include verbose
   parameter in run_pack_generation and run_via_bundle_exec methods.

2. **Explicit Parameter Passing**: Made verbose parameter explicit in
   verbose branch (line 41) for consistency and clarity.

3. **Environment Variable Propagation**: Made env var propagation explicit
   in bundle exec path using system's env hash parameter, ensuring the
   variable is properly passed to subprocess even when ENV context differs.

4. **Comprehensive Test Coverage**: Added 3 new tests to verify:
   - REACT_ON_RAILS_VERBOSE env var is set to "true" in verbose mode
   - REACT_ON_RAILS_VERBOSE env var is set to "false" in quiet mode
   - Environment variable cleanup happens even on failure
   - All bundle exec calls include the env var in the system call

This ensures the verbose mode propagation is reliable across all execution
paths (direct rake task and bundle exec).

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

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

Author: justin808

lib/react_on_rails/dev/pack_generator.rb

@@ -38,7 +38,7 @@ def generate(verbose: false)
 
           if verbose
             puts "📦 Generating React on Rails packs..."
-            success = run_pack_generation(verbose: true)
+            success = run_pack_generation(silent: false, verbose: true)
           else
             print "📦 Generating packs... "
             success = run_pack_generation(silent: true, verbose: false)
@@ -67,7 +67,7 @@ def run_pack_generation(silent: false, verbose: false)
           if should_run_directly?
             run_rake_task_directly(silent: silent)
           else
-            run_via_bundle_exec(silent: silent)
+            run_via_bundle_exec(silent: silent, verbose: verbose)
           end
         ensure
           # Clean up environment variable
@@ -151,17 +151,22 @@ def handle_rake_error(error, _silent)
           # rubocop:enable Style/StderrPuts, Style/GlobalStdStream
         end
 
-        def run_via_bundle_exec(silent: false)
+        def run_via_bundle_exec(silent: false, verbose: false)
+          # Environment variable is already set in run_pack_generation, but we make it explicit here
+          # for clarity and to ensure it's passed to the subprocess
+          env = { "REACT_ON_RAILS_VERBOSE" => verbose ? "true" : "false" }
+
           # Need to unbundle to prevent Bundler from intercepting our bundle exec call
           # when already running inside a Bundler context (e.g., from bin/dev)
           with_unbundled_context do
             if silent
               system(
+                env,
                 "bundle", "exec", "rake", "react_on_rails:generate_packs",
                 out: File::NULL, err: File::NULL
               )
             else
-              system("bundle", "exec", "rake", "react_on_rails:generate_packs")
+              system(env, "bundle", "exec", "rake", "react_on_rails:generate_packs")
             end
           end
         end

sig/react_on_rails/dev/pack_generator.rbs

@@ -5,15 +5,15 @@ module ReactOnRails
 
       private
 
-      def self.run_pack_generation: (?silent: bool) -> bool
+      def self.run_pack_generation: (?silent: bool, ?verbose: bool) -> bool
       def self.should_run_directly?: () -> bool
       def self.rails_available?: () -> bool
       def self.run_rake_task_directly: (?silent: bool) -> bool
       def self.load_rake_tasks: () -> void
       def self.prepare_rake_task: () -> untyped
       def self.capture_output: (bool) { () -> bool } -> bool
       def self.handle_rake_error: (Exception, bool) -> void
-      def self.run_via_bundle_exec: (?silent: bool) -> (bool | nil)
+      def self.run_via_bundle_exec: (?silent: bool, ?verbose: bool) -> (bool | nil)
     end
   end
 end

spec/react_on_rails/dev/pack_generator_spec.rb

@@ -177,6 +177,46 @@
         expect { described_class.generate(verbose: false) }
           .not_to output(/This should be suppressed/).to_stdout_from_any_process
       end
+
+      it "sets REACT_ON_RAILS_VERBOSE environment variable when verbose is true" do
+        env_value = nil
+        allow(mock_task).to receive(:invoke) do
+          env_value = ENV.fetch("REACT_ON_RAILS_VERBOSE", nil)
+        end
+
+        described_class.generate(verbose: true)
+
+        expect(env_value).to eq("true")
+        # Ensure cleanup happened
+        expect(ENV.fetch("REACT_ON_RAILS_VERBOSE", nil)).to be_nil
+      end
+
+      it "sets REACT_ON_RAILS_VERBOSE environment variable to false when verbose is false" do
+        env_value = nil
+        allow(mock_task).to receive(:invoke) do
+          env_value = ENV.fetch("REACT_ON_RAILS_VERBOSE", nil)
+        end
+
+        described_class.generate(verbose: false)
+
+        expect(env_value).to eq("false")
+        # Ensure cleanup happened
+        expect(ENV.fetch("REACT_ON_RAILS_VERBOSE", nil)).to be_nil
+      end
+
+      it "cleans up REACT_ON_RAILS_VERBOSE environment variable even when task fails" do
+        allow(mock_task).to receive(:invoke).and_raise(StandardError.new("Task failed"))
+
+        # Mock STDERR.puts to suppress error output
+        # rubocop:disable Style/GlobalStdStream
+        allow(STDERR).to receive(:puts)
+        # rubocop:enable Style/GlobalStdStream
+
+        expect { described_class.generate(verbose: true) }.to raise_error(SystemExit)
+
+        # Ensure cleanup happened even on failure
+        expect(ENV.fetch("REACT_ON_RAILS_VERBOSE", nil)).to be_nil
+      end
     end
 
     context "when not in Bundler context" do
@@ -187,33 +227,38 @@
 
       it "runs pack generation successfully in verbose mode using bundle exec" do
         allow(described_class).to receive(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs")
+          .with({ "REACT_ON_RAILS_VERBOSE" => "true" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs")
           .and_return(true)
 
         expect { described_class.generate(verbose: true) }
           .to output(/📦 Generating React on Rails packs.../).to_stdout_from_any_process
 
         expect(described_class).to have_received(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs")
+          .with({ "REACT_ON_RAILS_VERBOSE" => "true" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs")
       end
 
       it "runs pack generation successfully in quiet mode using bundle exec" do
         allow(described_class).to receive(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs",
+          .with({ "REACT_ON_RAILS_VERBOSE" => "false" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs",
                 out: File::NULL, err: File::NULL)
           .and_return(true)
 
         expect { described_class.generate(verbose: false) }
           .to output(/📦 Generating packs\.\.\. ✅/).to_stdout_from_any_process
 
         expect(described_class).to have_received(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs",
+          .with({ "REACT_ON_RAILS_VERBOSE" => "false" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs",
                 out: File::NULL, err: File::NULL)
       end
 
       it "exits with error when pack generation fails" do
         allow(described_class).to receive(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs",
+          .with({ "REACT_ON_RAILS_VERBOSE" => "false" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs",
                 out: File::NULL, err: File::NULL)
           .and_return(false)
 
@@ -233,14 +278,16 @@
 
       it "falls back to bundle exec when Rails is not defined" do
         allow(described_class).to receive(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs")
+          .with({ "REACT_ON_RAILS_VERBOSE" => "true" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs")
           .and_return(true)
 
         expect { described_class.generate(verbose: true) }
           .to output(/📦 Generating React on Rails packs.../).to_stdout_from_any_process
 
         expect(described_class).to have_received(:system)
-          .with("bundle", "exec", "rake", "react_on_rails:generate_packs")
+          .with({ "REACT_ON_RAILS_VERBOSE" => "true" },
+                "bundle", "exec", "rake", "react_on_rails:generate_packs")
       end
     end