Improve doctor async checks: enhance regex precision and add comprehensive tests

- Remove overly broad string form regex that could cause false positives
- Add support for both :async symbol and async: true hash syntax
- Add word boundary \b to prevent matching :async_mode or similar
- Improve multi-line javascript_pack_tag detection
- Add comprehensive inline documentation with examples
- Add test for async: true pattern detection
- Add test to confirm defer: "async" does not trigger false positive
- Add test for multi-line javascript_pack_tag calls
- Improve comment filtering logic to handle multi-line tags correctly
- Use String#include? for better performance (RuboCop compliance)

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

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

Author: justin808

lib/react_on_rails/doctor.rb

@@ -1203,21 +1203,44 @@ def scan_pattern_for_async(pattern)
     end
 
     def file_has_async_pack_tag?(content)
-      content.match?(/javascript_pack_tag.*:async/) || content.match?(/javascript_pack_tag.*["']async["']/)
+      # Match javascript_pack_tag with :async symbol or async: true hash syntax
+      # Examples that should match:
+      #   - javascript_pack_tag "app", :async
+      #   - javascript_pack_tag "app", async: true
+      #   - javascript_pack_tag "app", :async, other_option: value
+      # Examples that should NOT match:
+      #   - javascript_pack_tag "app", defer: "async" (async is a string value, not the option)
+      #   - javascript_pack_tag "app", :defer
+      # Note: Theoretical edge case `data: { async: true }` would match but is extremely unlikely
+      # in real code and represents a harmless false positive (showing a warning when not needed)
+      # Use word boundary \b to ensure :async is not part of a longer symbol like :async_mode
+      # [^<]* allows matching across newlines within ERB tags but stops at closing ERB tag
+      content.match?(/javascript_pack_tag[^<]*(?::async\b|async:\s*true)/)
     end
 
     def content_has_only_commented_async?(content)
       # Check if all occurrences of javascript_pack_tag with :async are in comments
+      # Returns true if ONLY commented async usage exists (no active async usage)
+      # Note: We need to check the full content first (for multi-line tags) before line-by-line filtering
+
+      # First check if there's any javascript_pack_tag with :async in the full content
+      return true unless file_has_async_pack_tag?(content)
+
+      # Now check line-by-line to see if all occurrences are commented
+      # For multi-line tags, we check if the starting line is commented
       has_uncommented_async = content.each_line.any? do |line|
-        # Skip ERB comments (<%# ... %>)
-        next if line.match?(/<%\s*#.*javascript_pack_tag.*:async/)
-        # Skip HAML comments (-# ...)
-        next if line.match?(/^\s*-#.*javascript_pack_tag.*:async/)
-        # Skip HTML comments (<!-- ... -->)
-        next if line.match?(/<!--.*javascript_pack_tag.*:async.*-->/)
+        # Skip lines that don't contain javascript_pack_tag
+        next unless line.include?("javascript_pack_tag")
 
-        # Check if line has javascript_pack_tag with :async
-        line.match?(/javascript_pack_tag.*:async/)
+        # Skip ERB comments (<%# ... %>) - matches ERB comment opening with optional whitespace
+        next if line.match?(/<%\s*#.*javascript_pack_tag/)
+        # Skip HAML comments (-# ...) - matches line-starting HAML comments
+        next if line.match?(/^\s*-#.*javascript_pack_tag/)
+        # Skip HTML comments (<!-- ... -->) - matches complete HTML comment blocks
+        next if line.match?(/<!--.*javascript_pack_tag/)
+
+        # If we reach here, this line has an uncommented javascript_pack_tag
+        true
       end
 
       !has_uncommented_async
@@ -1229,9 +1252,14 @@ def config_has_async_loading_strategy?
 
       content = File.read(config_path)
       # Check if generated_component_packs_loading_strategy is set to :async
-      # Filter out commented lines to avoid false positives
+      # Filter out commented lines (lines starting with # after optional whitespace)
       content.each_line.any? do |line|
-        line !~ /^\s*#/ && line.match?(/config\.generated_component_packs_loading_strategy\s*=\s*:async/)
+        # Skip lines that start with # (after optional whitespace)
+        next if line.match?(/^\s*#/)
+
+        # Match: config.generated_component_packs_loading_strategy = :async
+        # Use word boundary \b to ensure :async is the complete symbol, not part of :async_mode etc.
+        line.match?(/config\.generated_component_packs_loading_strategy\s*=\s*:async\b/)
       end
     rescue Errno::ENOENT, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
       # Log the error if Rails logger is available

spec/lib/react_on_rails/doctor_spec.rb

@@ -292,6 +292,40 @@
       end
     end
 
+    context "when view files contain javascript_pack_tag with async: true" do
+      before do
+        allow(Dir).to receive(:glob).with("app/views/**/*.erb")
+                                    .and_return(["app/views/layouts/application.html.erb"])
+        allow(Dir).to receive(:glob).with("app/views/**/*.haml").and_return([])
+        allow(File).to receive(:exist?).with("app/views/layouts/application.html.erb").and_return(true)
+        allow(File).to receive(:read).with("app/views/layouts/application.html.erb")
+                                     .and_return('<%= javascript_pack_tag "app", async: true %>')
+        allow(doctor).to receive(:relativize_path).with("app/views/layouts/application.html.erb")
+                                                  .and_return("app/views/layouts/application.html.erb")
+      end
+
+      it "returns files with async" do
+        files = doctor.send(:scan_view_files_for_async_pack_tag)
+        expect(files).to include("app/views/layouts/application.html.erb")
+      end
+    end
+
+    context "when view files contain defer: \"async\" (false positive check)" do
+      before do
+        allow(Dir).to receive(:glob).with("app/views/**/*.erb")
+                                    .and_return(["app/views/layouts/application.html.erb"])
+        allow(Dir).to receive(:glob).with("app/views/**/*.haml").and_return([])
+        allow(File).to receive(:exist?).with("app/views/layouts/application.html.erb").and_return(true)
+        allow(File).to receive(:read).with("app/views/layouts/application.html.erb")
+                                     .and_return('<%= javascript_pack_tag "app", defer: "async" %>')
+      end
+
+      it "does not return files (async is a string value, not the option)" do
+        files = doctor.send(:scan_view_files_for_async_pack_tag)
+        expect(files).to be_empty
+      end
+    end
+
     context "when view files do not contain async" do
       before do
         allow(Dir).to receive(:glob).with("app/views/**/*.erb")
@@ -355,6 +389,24 @@
         expect(files).to be_empty
       end
     end
+
+    context "when javascript_pack_tag spans multiple lines" do
+      before do
+        allow(Dir).to receive(:glob).with("app/views/**/*.erb")
+                                    .and_return(["app/views/layouts/application.html.erb"])
+        allow(Dir).to receive(:glob).with("app/views/**/*.haml").and_return([])
+        allow(File).to receive(:exist?).with("app/views/layouts/application.html.erb").and_return(true)
+        allow(File).to receive(:read).with("app/views/layouts/application.html.erb")
+                                     .and_return("<%= javascript_pack_tag \"app\",\n  :async %>")
+        allow(doctor).to receive(:relativize_path).with("app/views/layouts/application.html.erb")
+                                                  .and_return("app/views/layouts/application.html.erb")
+      end
+
+      it "returns files with async" do
+        files = doctor.send(:scan_view_files_for_async_pack_tag)
+        expect(files).to include("app/views/layouts/application.html.erb")
+      end
+    end
   end
 
   describe "#config_has_async_loading_strategy?" do