Replace fragile regex validation with Shakapacker 9.0+ integration

Addresses code review feedback about fragile regex matching by implementing
a proper integration with Shakapacker 9.0+ private_output_path.

**Key Changes:**

**1. Auto-Detection from Shakapacker (configuration.rb)**
- New `auto_detect_server_bundle_path_from_shakapacker` method
- Automatically reads `private_output_path` from Shakapacker 9.0+ config
- Only applies if user hasn't explicitly set `server_bundle_output_path`
- Gracefully falls back to default if detection fails
- Logs info message when auto-detection succeeds

**2. Removed Fragile Regex Validation (doctor.rb)**
- Removed `validate_server_bundle_path_sync` method (regex matching)
- Removed `extract_webpack_output_path` method (pattern detection)
- Removed `normalize_path` method (no longer needed)
- Replaced with `check_shakapacker_private_output_path` method

**3. Recommendation-Based Doctor Checks (doctor.rb)**
- Detects Shakapacker version and capabilities
- Pre-9.0: Recommends upgrading for better DX
- 9.0+ without config: Shows how to configure private_output_path
- 9.0+ with config matching: Success message
- 9.0+ with config mismatch: Warning with fix instructions
- No Shakapacker: Informs about manual configuration

**4. Updated Generator Templates**
- **React on Rails initializer**: Documents Shakapacker 9.0+ approach first
- **Webpack config**: Shows config.privateOutputPath pattern
- Both templates emphasize single source of truth in shakapacker.yml
- Clear migration path for older Shakapacker versions

**5. Comprehensive Test Coverage (8 new tests)**
- Shakapacker not defined scenario
- Pre-9.0 Shakapacker (no private_output_path support)
- 9.0+ with matching config
- 9.0+ with mismatched config
- 9.0+ without config
- Error handling
- All tests passing

**Benefits:**
- No fragile regex parsing of webpack configs
- Single source of truth in shakapacker.yml
- Automatic configuration for Shakapacker 9.0+ users
- Backward compatible with older Shakapacker versions
- Clear upgrade path and recommendations
- Robust error handling

**Breaking Changes:** None
- Existing configurations continue to work
- Auto-detection only applies to default values
- Explicit user configuration always takes precedence

Addresses: @justin's feedback on PR #1967

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

Co-Authored-By: Claude <noreply@anthropic.com>

Author: justin808

lib/generators/react_on_rails/templates/base/base/config/initializers/react_on_rails.rb.tt

@@ -12,17 +12,19 @@ ReactOnRails.configure do |config|
   # Set to "" if you're not using server rendering
   config.server_bundle_js_file = "server-bundle.js"
 
-  # ⚠️ IMPORTANT: This must match output.path in config/webpack/serverWebpackConfig.js
+  # ⚠️ RECOMMENDED: Use Shakapacker 9.0+ private_output_path instead
   #
-  # Both are currently set to 'ssr-generated' (relative to Rails.root)
-  # Keeping these in sync ensures React on Rails can find the server bundle at runtime.
+  # If using Shakapacker 9.0+, add to config/shakapacker.yml:
+  #   private_output_path: ssr-generated
   #
-  # Run 'rails react_on_rails:doctor' to verify these configs are in sync.
+  # React on Rails will auto-detect this value, eliminating the need to set it here.
+  # This keeps your webpack and Rails configs in sync automatically.
   #
-  # Configure where server bundles are output. Defaults to "ssr-generated".
-  # This path is relative to Rails.root and should point to a private directory
-  # (outside of public/) for security.
-  config.server_bundle_output_path = "ssr-generated"
+  # For older Shakapacker versions or custom setups, manually configure:
+  # config.server_bundle_output_path = "ssr-generated"
+  #
+  # The path is relative to Rails.root and should point to a private directory
+  # (outside of public/) for security. Run 'rails react_on_rails:doctor' to verify.
 
   # Enforce that server bundles are only loaded from private (non-public) directories.
   # When true, server bundles will only be loaded from the configured server_bundle_output_path.

lib/generators/react_on_rails/templates/base/base/config/webpack/serverWebpackConfig.js.tt

@@ -45,14 +45,20 @@ const configureServer = () => {
   serverWebpackConfig.plugins.unshift(new bundler.optimize.LimitChunkCountPlugin({ maxChunks: 1 }));
 
   // Custom output for the server-bundle
-  // ⚠️ IMPORTANT: This output.path must match server_bundle_output_path in
-  //              config/initializers/react_on_rails.rb
   //
-  // Both are currently set to 'ssr-generated' (relative to Rails.root)
-  // Keeping these in sync ensures React on Rails can find the server bundle at runtime.
+  // ⚠️ RECOMMENDED: Use Shakapacker 9.0+ for automatic configuration
   //
-  // Server bundles are output to a private directory (not public) for security.
-  // This prevents server-side code from being exposed via the web server.
+  // With Shakapacker 9.0+, use config.privateOutputPath to automatically sync
+  // with shakapacker.yml private_output_path. This eliminates manual path configuration.
+  //
+  // For Shakapacker 9.0+:
+  //   serverWebpackConfig.output = {
+  //     filename: 'server-bundle.js',
+  //     globalObject: 'this',
+  //     path: config.privateOutputPath,
+  //   };
+  //
+  // For older Shakapacker or custom setups, use hardcoded path:
   serverWebpackConfig.output = {
     filename: 'server-bundle.js',
     globalObject: 'this',

lib/react_on_rails/configuration.rb

@@ -184,6 +184,7 @@ def setup_config_values
       check_component_registry_timeout
       validate_generated_component_packs_loading_strategy
       validate_enforce_private_server_bundles
+      auto_detect_server_bundle_path_from_shakapacker
     end
 
     private
@@ -257,6 +258,35 @@ def validate_enforce_private_server_bundles
                                  "the public directory. Please set it to a directory outside of public."
     end
 
+    # Auto-detect server_bundle_output_path from Shakapacker 9.0+ private_output_path
+    # Only sets if user hasn't explicitly configured server_bundle_output_path
+    def auto_detect_server_bundle_path_from_shakapacker
+      # Skip if user explicitly set server_bundle_output_path to something other than default
+      return if server_bundle_output_path != "ssr-generated"
+
+      # Skip if Shakapacker is not available
+      return unless defined?(::Shakapacker)
+
+      # Check if Shakapacker config has private_output_path method (9.0+)
+      return unless ::Shakapacker.config.respond_to?(:private_output_path)
+
+      begin
+        private_path = ::Shakapacker.config.private_output_path
+        return unless private_path
+
+        # Convert from Pathname to relative string path
+        relative_path = private_path.to_s.sub("#{Rails.root}/", "")
+        self.server_bundle_output_path = relative_path
+
+        Rails.logger.info("ReactOnRails: Auto-detected server_bundle_output_path from " \
+                          "shakapacker.yml private_output_path: '#{relative_path}'")
+      rescue StandardError => e
+        # Fail gracefully - if auto-detection fails, keep the default
+        Rails.logger.debug("ReactOnRails: Could not auto-detect server bundle path from " \
+                           "Shakapacker: #{e.message}")
+      end
+    end
+
     def check_minimum_shakapacker_version
       ReactOnRails::PackerUtils.raise_shakapacker_version_incompatible_for_basic_pack_generation unless
         ReactOnRails::PackerUtils.supports_basic_pack_generation?

lib/react_on_rails/doctor.rb

@@ -688,8 +688,8 @@ def analyze_server_rendering_config(content)
       enforce_private_match = content.match(/config\.enforce_private_server_bundles\s*=\s*([^\s\n,]+)/)
       checker.add_info("  enforce_private_server_bundles: #{enforce_private_match[1]}") if enforce_private_match
 
-      # Validate webpack config matches Rails config
-      validate_server_bundle_path_sync(rails_bundle_path)
+      # Check Shakapacker integration and provide recommendations
+      check_shakapacker_private_output_path(rails_bundle_path)
 
       # RSC bundle file (Pro feature)
       rsc_bundle_match = content.match(/config\.rsc_bundle_js_file\s*=\s*["']([^"']+)["']/)
@@ -1405,91 +1405,69 @@ def log_debug(message)
       Rails.logger.debug(message)
     end
 
-    # Validates that webpack serverWebpackConfig.js output.path matches
-    # React on Rails config.server_bundle_output_path
-    def validate_server_bundle_path_sync(rails_bundle_path)
-      webpack_config_path = "config/webpack/serverWebpackConfig.js"
-
-      unless File.exist?(webpack_config_path)
-        checker.add_info("\n  ℹ️  Webpack server config not found - skipping path validation")
+    # Check Shakapacker private_output_path integration and provide recommendations
+    # rubocop:disable Metrics/MethodLength
+    def check_shakapacker_private_output_path(rails_bundle_path)
+      unless defined?(::Shakapacker)
+        checker.add_info("\n  ℹ️  Shakapacker not detected - using manual configuration")
         return
       end
 
-      begin
-        webpack_content = File.read(webpack_config_path)
+      # Check if Shakapacker 9.0+ with private_output_path support
+      unless ::Shakapacker.config.respond_to?(:private_output_path)
+        checker.add_info(<<~MSG.strip)
+          \n  💡 Recommendation: Upgrade to Shakapacker 9.0+
 
-        # Try to extract the path from webpack config
-        webpack_bundle_path = extract_webpack_output_path(webpack_content, webpack_config_path)
+          Shakapacker 9.0+ adds 'private_output_path' in shakapacker.yml for server bundles.
+          This eliminates the need to configure server_bundle_output_path separately.
 
-        return unless webpack_bundle_path
+          Benefits:
+          - Single source of truth in shakapacker.yml
+          - Automatic detection by React on Rails
+          - No configuration duplication
+        MSG
+        return
+      end
 
-        # Normalize and compare paths
-        normalized_webpack_path = normalize_path(webpack_bundle_path)
-        normalized_rails_path = normalize_path(rails_bundle_path)
+      # Shakapacker 9.0+ is available
+      begin
+        private_path = ::Shakapacker.config.private_output_path
 
-        if normalized_webpack_path == normalized_rails_path
-          checker.add_success("\n  ✅ Webpack and Rails configs are in sync (both use '#{rails_bundle_path}')")
-        else
-          checker.add_warning(<<~MSG.strip)
-            \n  ⚠️  Configuration mismatch detected!
+        if private_path
+          relative_path = private_path.to_s.sub("#{Rails.root}/", "")
 
-            React on Rails config (config/initializers/react_on_rails.rb):
-              server_bundle_output_path = "#{rails_bundle_path}"
+          if relative_path == rails_bundle_path
+            checker.add_success("\n  ✅ Using Shakapacker 9.0+ private_output_path: '#{relative_path}'")
+            checker.add_info("     Auto-detected from shakapacker.yml - no manual config needed")
+          else
+            checker.add_warning(<<~MSG.strip)
+              \n  ⚠️  Configuration mismatch detected!
 
-            Webpack config (#{webpack_config_path}):
-              output.path = "#{webpack_bundle_path}" (relative to Rails.root)
+              Shakapacker private_output_path: '#{relative_path}'
+              React on Rails server_bundle_output_path: '#{rails_bundle_path}'
 
-            These must match for server rendering to work correctly.
+              Recommendation: Remove server_bundle_output_path from your React on Rails
+              initializer and let it auto-detect from shakapacker.yml private_output_path.
+            MSG
+          end
+        else
+          checker.add_info(<<~MSG.strip)
+            \n  💡 Recommendation: Configure private_output_path in shakapacker.yml
 
-            To fix:
-            1. Update server_bundle_output_path in config/initializers/react_on_rails.rb, OR
-            2. Update output.path in #{webpack_config_path}
+            Add to config/shakapacker.yml:
+              private_output_path: #{rails_bundle_path}
 
-            Make sure both point to the same directory relative to Rails.root.
+            This will:
+            - Keep webpack and Rails configs in sync automatically
+            - Enable auto-detection by React on Rails
+            - Serve as single source of truth for server bundle location
           MSG
         end
       rescue StandardError => e
-        checker.add_info("\n  ℹ️  Could not validate webpack config: #{e.message}")
-      end
-    end
-
-    # Extract output.path from webpack config, supporting multiple patterns
-    def extract_webpack_output_path(webpack_content, _webpack_config_path)
-      # Pattern 1: path: require('path').resolve(__dirname, '../../ssr-generated')
-      # Explicitly match ../../path pattern for clarity
-      hardcoded_pattern = %r{path:\s*require\(['"]path['"]\)\.resolve\(__dirname,\s*['"]\.\./\.\./([^'"]+)['"]\)}
-      if (match = webpack_content.match(hardcoded_pattern))
-        return match[1]
-      end
-
-      # Pattern 2: path: config.outputPath (can't validate - runtime value)
-      if webpack_content.match?(/path:\s*config\.outputPath/)
-        checker.add_info(<<~MSG.strip)
-          \n  ℹ️  Webpack config uses config.outputPath (from shakapacker.yml)
-          Cannot validate sync with Rails config as this is resolved at build time.
-          Ensure your shakapacker.yml public_output_path matches server_bundle_output_path.
-        MSG
-        return nil
+        checker.add_info("\n  ℹ️  Could not check Shakapacker config: #{e.message}")
       end
-
-      # Pattern 3: path: some_variable (can't validate)
-      if webpack_content.match?(/path:\s*[a-zA-Z_]\w*/)
-        checker.add_info("\n  ℹ️  Webpack config uses a variable for output.path - cannot validate")
-        return nil
-      end
-
-      checker.add_info("\n  ℹ️  Could not parse webpack server bundle path - skipping validation")
-      nil
-    end
-
-    # Normalize path for comparison (remove leading ./, trailing /)
-    def normalize_path(path)
-      return path unless path.is_a?(String)
-
-      normalized = path.strip
-      normalized = normalized.sub(%r{^\.?/}, "") # Remove leading ./ or /
-      normalized.sub(%r{/$}, "") # Remove trailing /
     end
+    # rubocop:enable Metrics/MethodLength
   end
   # rubocop:enable Metrics/ClassLength
 end