Support script file hooks and display hook values in logs

This addresses the remaining code review feedback:

1. Display hook value in log messages
   - Show actual hook path/command when skipping generate_packs
   - Helps users understand what's configured

2. Support script file hook detection
   - Check if hook is a direct command (e.g., "bundle exec rake...")
   - Or if it's a script file path (e.g., "bin/precompile_hook")
   - Read script file contents to detect generate_packs task

3. Add shakapacker_precompile_hook_value method
   - Returns the configured hook value for logging/debugging
   - Returns nil if no hook is configured or on error

4. Document future enhancement
   - Note that hooks will support lists in the future
   - Allow prepending/appending multiple commands
   - Currently only single hook value is supported

5. Comprehensive test coverage
   - Test direct command detection
   - Test script file detection and reading
   - Test hook value retrieval
   - All 40 examples passing

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

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

Author: justin808

lib/react_on_rails/configuration.rb

@@ -240,7 +240,8 @@ def adjust_precompile_task
       precompile_tasks = lambda {
         # Skip generate_packs if shakapacker has a precompile hook configured
         if ReactOnRails::PackerUtils.shakapacker_precompile_hook_configured?
-          puts "Skipping react_on_rails:generate_packs (configured in shakapacker precompile hook)"
+          hook_value = ReactOnRails::PackerUtils.shakapacker_precompile_hook_value
+          puts "Skipping react_on_rails:generate_packs (configured in shakapacker precompile hook: #{hook_value})"
         else
           Rake::Task["react_on_rails:generate_packs"].invoke
         end

lib/react_on_rails/dev/pack_generator.rb

@@ -28,7 +28,10 @@ class << self
         def generate(verbose: false)
           # Skip if shakapacker has a precompile hook configured
           if ReactOnRails::PackerUtils.shakapacker_precompile_hook_configured?
-            puts "⏭️  Skipping pack generation (handled by shakapacker precompile hook)" if verbose
+            if verbose
+              hook_value = ReactOnRails::PackerUtils.shakapacker_precompile_hook_value
+              puts "⏭️  Skipping pack generation (handled by shakapacker precompile hook: #{hook_value})"
+            end
             return
           end
 

lib/react_on_rails/packer_utils.rb

@@ -172,13 +172,16 @@ def self.raise_shakapacker_version_incompatible_for_basic_pack_generation
     #
     # Returns false if detection fails for any reason (missing shakapacker, malformed config, etc.)
     # to ensure generate_packs runs rather than being incorrectly skipped
+    #
+    # Note: Currently checks a single hook value. Future enhancement will support hook lists
+    # to allow prepending/appending multiple commands. See related Shakapacker issue for details.
     def self.shakapacker_precompile_hook_configured?
       return false unless defined?(::Shakapacker)
 
-      hooks = extract_precompile_hooks
-      return false if hooks.nil?
+      hook_value = extract_precompile_hook
+      return false if hook_value.nil?
 
-      hook_contains_generate_packs?(hooks)
+      hook_contains_generate_packs?(hook_value)
     rescue StandardError => e
       # Swallow errors during hook detection to fail safe - if we can't detect the hook,
       # we should run generate_packs rather than skip it incorrectly.
@@ -188,19 +191,53 @@ def self.shakapacker_precompile_hook_configured?
       false
     end
 
-    def self.extract_precompile_hooks
+    def self.extract_precompile_hook
       # Access config data using private :data method since there's no public API
       # to access the raw configuration hash needed for hook detection
       config_data = ::Shakapacker.config.send(:data)
 
       # Try symbol keys first (Shakapacker's internal format), then fall back to string keys
+      # Note: Currently only one hook value is supported, but this will change to support lists
       config_data&.dig(:hooks, :precompile) || config_data&.dig("hooks", "precompile")
     end
 
-    def self.hook_contains_generate_packs?(hooks)
-      # Check if any hook contains the generate_packs rake task using word boundary
-      # to avoid false positives from comments or similar strings
-      Array(hooks).any? { |hook| hook.to_s.match?(/\breact_on_rails:generate_packs\b/) }
+    def self.hook_contains_generate_packs?(hook_value)
+      # The hook value can be either:
+      # 1. A direct command containing the rake task
+      # 2. A path to a script file that needs to be read
+      return false if hook_value.blank?
+
+      # Check if it's a direct command first
+      return true if hook_value.to_s.match?(/\breact_on_rails:generate_packs\b/)
+
+      # Check if it's a script file path
+      script_path = resolve_hook_script_path(hook_value)
+      return false unless script_path && File.exist?(script_path)
+
+      # Read and check script contents
+      script_contents = File.read(script_path)
+      script_contents.match?(/\breact_on_rails:generate_packs\b/)
+    rescue StandardError
+      # If we can't read the script, assume it doesn't contain generate_packs
+      false
+    end
+
+    def self.resolve_hook_script_path(hook_value)
+      # Hook value might be a script path relative to Rails root
+      return nil unless defined?(Rails) && Rails.respond_to?(:root)
+
+      potential_path = Rails.root.join(hook_value.to_s.strip)
+      potential_path if potential_path.file?
+    end
+
+    # Returns the configured precompile hook value for logging/debugging
+    # Returns nil if no hook is configured
+    def self.shakapacker_precompile_hook_value
+      return nil unless defined?(::Shakapacker)
+
+      extract_precompile_hook
+    rescue StandardError
+      nil
     end
   end
 end

spec/react_on_rails/dev/pack_generator_spec.rb

@@ -25,12 +25,13 @@
 
     context "when shakapacker precompile hook is configured" do
       before do
-        allow(ReactOnRails::PackerUtils).to receive(:shakapacker_precompile_hook_configured?).and_return(true)
+        allow(ReactOnRails::PackerUtils).to receive_messages(shakapacker_precompile_hook_configured?: true,
+                                                             shakapacker_precompile_hook_value: "bin/precompile_hook")
       end
 
-      it "skips pack generation in verbose mode" do
+      it "skips pack generation in verbose mode and shows hook value" do
         expect { described_class.generate(verbose: true) }
-          .to output(/⏭️  Skipping pack generation \(handled by shakapacker precompile hook\)/)
+          .to output(%r{⏭️  Skipping pack generation \(handled by shakapacker precompile hook: bin/precompile_hook\)})
           .to_stdout_from_any_process
       end
 

spec/react_on_rails/packer_utils_spec.rb

@@ -159,29 +159,57 @@ module ReactOnRails
       end
 
       context "when precompile hook contains react_on_rails:generate_packs" do
-        it "returns true for single hook with symbol keys" do
+        it "returns true for direct command with symbol keys" do
           allow(mock_config).to receive(:send).with(:data).and_return(
             { hooks: { precompile: "bundle exec rake react_on_rails:generate_packs" } }
           )
 
           expect(described_class.shakapacker_precompile_hook_configured?).to be(true)
         end
 
-        it "returns true for single hook with string keys" do
+        it "returns true for direct command with string keys" do
           allow(mock_config).to receive(:send).with(:data).and_return(
             { "hooks" => { "precompile" => "bundle exec rake react_on_rails:generate_packs" } }
           )
 
           expect(described_class.shakapacker_precompile_hook_configured?).to be(true)
         end
 
-        it "returns true for hook in array" do
+        it "returns true when hook points to script file containing the task" do
           allow(mock_config).to receive(:send).with(:data).and_return(
-            { hooks: { precompile: ["bundle exec rake react_on_rails:generate_packs", "echo done"] } }
+            { hooks: { precompile: "bin/shakapacker_precompile" } }
           )
 
+          # Mock Rails.root
+          rails_root = instance_double(Pathname)
+          allow(Rails).to receive(:root).and_return(rails_root)
+
+          script_path = instance_double(Pathname, file?: true)
+          allow(rails_root).to receive(:join).with("bin/shakapacker_precompile").and_return(script_path)
+          allow(File).to receive(:exist?).with(script_path).and_return(true)
+          allow(File).to receive(:read).with(script_path)
+                                       .and_return("#!/bin/bash\nbundle exec rake react_on_rails:generate_packs\n")
+
           expect(described_class.shakapacker_precompile_hook_configured?).to be(true)
         end
+
+        it "returns false when hook points to script file without the task" do
+          allow(mock_config).to receive(:send).with(:data).and_return(
+            { hooks: { precompile: "bin/other_script" } }
+          )
+
+          # Mock Rails.root
+          rails_root = instance_double(Pathname)
+          allow(Rails).to receive(:root).and_return(rails_root)
+
+          script_path = instance_double(Pathname, file?: true)
+          allow(rails_root).to receive(:join).with("bin/other_script").and_return(script_path)
+          allow(File).to receive(:exist?).with(script_path).and_return(true)
+          allow(File).to receive(:read).with(script_path)
+                                       .and_return("#!/bin/bash\necho 'doing other stuff'\n")
+
+          expect(described_class.shakapacker_precompile_hook_configured?).to be(false)
+        end
       end
 
       context "when precompile hook does not contain react_on_rails:generate_packs" do
@@ -222,6 +250,35 @@ module ReactOnRails
         end
       end
     end
+
+    describe ".shakapacker_precompile_hook_value" do
+      let(:mock_config) { instance_double("::Shakapacker::Config") } # rubocop:disable RSpec/VerifiedDoubleReference
+
+      before do
+        allow(::Shakapacker).to receive(:config).and_return(mock_config)
+      end
+
+      it "returns the hook value when configured" do
+        hook_value = "bin/shakapacker_precompile"
+        allow(mock_config).to receive(:send).with(:data).and_return(
+          { hooks: { precompile: hook_value } }
+        )
+
+        expect(described_class.shakapacker_precompile_hook_value).to eq(hook_value)
+      end
+
+      it "returns nil when no hook is configured" do
+        allow(mock_config).to receive(:send).with(:data).and_return({})
+
+        expect(described_class.shakapacker_precompile_hook_value).to be_nil
+      end
+
+      it "returns nil when an error occurs" do
+        allow(mock_config).to receive(:send).with(:data).and_raise(StandardError.new("test error"))
+
+        expect(described_class.shakapacker_precompile_hook_value).to be_nil
+      end
+    end
   end
 
   describe "version constants validation" do