rails_accessibility_testing 1.4.3 → 1.5.0

data/lib/rails_accessibility_testing/change_detector.rb

@@ -1,112 +1,25 @@
 # frozen_string_literal: true
 
 module RailsAccessibilityTesting
-  # Detects if relevant files have changed to determine if accessibility checks should run
+  # Simple helper to convert routes to testable paths
   class ChangeDetector
-    # Time window for considering files as "recently changed" (in seconds)
-    CHANGE_WINDOW = 300 # 5 minutes
-
-    # Directories to monitor for changes
-    MONITORED_DIRECTORIES = %w[app/views app/controllers app/helpers].freeze
-
-    # View file extensions to check
-    VIEW_EXTENSIONS = %w[erb haml slim].freeze
-
     class << self
-      # Check if relevant files have changed
-      # @param current_path [String] The current Rails path being tested
-      # @return [Boolean] true if files have changed, false otherwise
-      def files_changed?(current_path)
-        return false unless current_path
-
-        view_file = determine_view_file_from_path(current_path)
-        return true if view_file_recently_modified?(view_file)
-        return true if git_has_uncommitted_changes?
-        return true if any_monitored_files_recently_modified?
-
-        false
-      end
-
-      private
-
-      # Check if a specific view file was recently modified
-      def view_file_recently_modified?(view_file)
-        return false unless view_file && File.exist?(view_file)
-
-        File.mtime(view_file) > Time.now - CHANGE_WINDOW
-      end
-
-      # Check if git has uncommitted changes in monitored directories
-      def git_has_uncommitted_changes?
-        git_status = `git status --porcelain #{MONITORED_DIRECTORIES.join(' ')} 2>/dev/null`
-        git_status.strip.length.positive?
-      rescue StandardError
-        false # Git not available or not a git repo
-      end
-
-      # Check if any monitored files were recently modified
-      def any_monitored_files_recently_modified?
-        monitored_files.any? do |file|
-          File.exist?(file) && File.mtime(file) > Time.now - CHANGE_WINDOW
-        end
-      end
-
-      # Get all monitored files
-      def monitored_files
-        view_files + controller_files + helper_files
-      end
-
-      # Get all view files
-      def view_files
-        VIEW_EXTENSIONS.flat_map do |ext|
-          Dir.glob("app/views/**/*.#{ext}")
-        end
-      end
-
-      # Get all controller files
-      def controller_files
-        Dir.glob('app/controllers/**/*.rb')
-      end
-
-      # Get all helper files
-      def helper_files
-        Dir.glob('app/helpers/**/*.rb')
-      end
-
-      # Determine view file from Rails path
-      def determine_view_file_from_path(path)
-        return nil unless path
-
-        clean_path = path.split('?').first.split('#').first
-        return nil unless clean_path.start_with?('/')
-
-        parts = clean_path.sub(/\A\//, '').split('/')
-        return nil if parts.empty?
-
-        find_view_file(parts)
-      end
-
-      # Find view file based on path parts
-      def find_view_file(parts)
-        if parts.length >= 2
-          controller = parts[0..-2].join('/')
-          action = parts.last
-          find_view_for_action(controller, action)
-        elsif parts.length == 1
-          find_view_for_action(parts[0], 'index')
-        end
-      end
-
-      # Find view file for a specific controller and action
-      def find_view_for_action(controller, action)
-        view_paths = VIEW_EXTENSIONS.flat_map do |ext|
-          [
-            "app/views/#{controller}/#{action}.html.#{ext}",
-            "app/views/#{controller}/_#{action}.html.#{ext}"
-          ]
-        end
-
-        view_paths.find { |vp| File.exist?(vp) }
+      # Convert route to path string for testing
+      # @param route [ActionDispatch::Journey::Route] The route object
+      # @return [String, nil] The path string or nil if route can't be converted
+      def route_to_path(route)
+        return nil unless route.respond_to?(:path)
+        return nil unless route.verb.to_s.include?('GET')
+        
+        path_spec = route.path.spec.to_s
+        path = path_spec.dup
+        path.gsub!(/\(\.:format\)/, '')
+        path.gsub!(/\(:id\)/, '1')
+        path.gsub!(/\(:(\w+)\)/, '1')
+        path.gsub!(/\([^)]*\)/, '')
+        path = '/' if path.empty? || path == '/'
+        path = "/#{path}" unless path.start_with?('/')
+        path.include?(':') ? nil : path
       end
     end
   end

data/lib/rails_accessibility_testing/checks/base_check.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../accessibility_helper'
+
 module RailsAccessibilityTesting
   module Checks
     # Base class for all accessibility checks
@@ -24,6 +26,9 @@ module RailsAccessibilityTesting
     #
     # @api private
     class BaseCheck
+      # Include partial detection methods from AccessibilityHelper
+      include AccessibilityHelper::PartialDetection
+      
       attr_reader :page, :context
       
       # Initialize the check
@@ -65,19 +70,20 @@ module RailsAccessibilityTesting
           rule_name: self.class.rule_name,
           message: message,
           element_context: element_context,
-          page_context: page_context,
+          page_context: page_context(element_context),
           wcag_reference: wcag_reference,
           remediation: remediation
         )
       end
       
       # Get page context
+      # @param element_context [Hash] Optional element context to help find partials
       # @return [Hash]
-      def page_context
+      def page_context(element_context = nil)
         {
           url: safe_page_url,
           path: safe_page_path,
-          view_file: determine_view_file
+          view_file: determine_view_file(element_context)
         }
       end
       
@@ -123,7 +129,8 @@ module RailsAccessibilityTesting
       end
       
       # Determine likely view file (simplified version)
-      def determine_view_file
+      # Also checks for partials that might contain the element
+      def determine_view_file(element_context = nil)
         return nil unless safe_page_path
         
         path = safe_page_path.split('?').first.split('#').first
@@ -134,7 +141,21 @@ module RailsAccessibilityTesting
             controller = route[:controller]
             action = route[:action]
             
-            find_view_file_for_controller_action(controller, action)
+            view_file = find_view_file_for_controller_action(controller, action)
+            
+            # If we found the view file and have element context, check for partials
+            if view_file && element_context
+              # Scan the view file for rendered partials
+              partials_in_view = find_partials_in_view_file(view_file)
+              
+              # Check if element matches any partial in the view
+              if partials_in_view.any?
+                partial_file = find_partial_for_element_in_list(controller, element_context, partials_in_view)
+                return partial_file if partial_file
+              end
+            end
+            
+            view_file
           rescue StandardError
             nil
           end
@@ -142,12 +163,40 @@ module RailsAccessibilityTesting
       end
       
       # Find view file for controller and action
+      # Handles cases where action name doesn't match view file name
       def find_view_file_for_controller_action(controller, action)
         extensions = %w[erb haml slim]
+        controller_path = "app/views/#{controller}"
+        
+        # First, try exact matches
         extensions.each do |ext|
-          view_path = "app/views/#{controller}/#{action}.html.#{ext}"
-          return view_path if File.exist?(view_path)
+          view_paths = [
+            "#{controller_path}/#{action}.html.#{ext}",
+            "#{controller_path}/_#{action}.html.#{ext}",
+            "#{controller_path}/#{action}.#{ext}"
+          ]
+          
+          found = view_paths.find { |vp| File.exist?(vp) }
+          return found if found
         end
+        
+        # If exact match not found, scan all view files in the controller directory
+        # This handles cases like: search action -> search_result.html.erb
+        if File.directory?(controller_path)
+          extensions.each do |ext|
+            # Look for files that might match the action (e.g., search_result, search_results, etc.)
+            pattern = "#{controller_path}/*#{action}*.html.#{ext}"
+            matching_files = Dir.glob(pattern)
+            
+            # Prefer files that start with the action name
+            preferred = matching_files.find { |f| File.basename(f).start_with?("#{action}_") || File.basename(f).start_with?("#{action}.") }
+            return preferred if preferred
+            
+            # Return first match if any found
+            return matching_files.first if matching_files.any?
+          end
+        end
+        
         nil
       end
     end

data/lib/rails_accessibility_testing/checks/heading_check.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RailsAccessibilityTesting
+  module Checks
+    # Comprehensive heading accessibility checks
+    #
+    # WCAG 2.1 AA requirements for headings:
+    # - 1.3.1 Info and Relationships (Level A): Proper heading hierarchy
+    # - 2.4.6 Headings and Labels (Level AA): Descriptive headings
+    # - 4.1.2 Name, Role, Value (Level A): Headings must have accessible names
+    #
+    # @api private
+    class HeadingCheck < BaseCheck
+      def self.rule_name
+        :heading
+      end
+      
+      def check
+        violations = []
+        headings = page.all('h1, h2, h3, h4, h5, h6', visible: true)
+        
+        if headings.empty?
+          return violations  # Warning only, not error
+        end
+        
+        # Check 1: Missing H1
+        h1_count = headings.count { |h| h.tag_name == 'h1' }
+        first_heading = headings.first
+        first_heading_level = first_heading ? first_heading.tag_name[1].to_i : nil
+        
+        if h1_count == 0
+          # If the first heading is h2 or higher, provide a more specific message
+          if first_heading_level && first_heading_level >= 2
+            element_ctx = element_context(first_heading)
+            violations << violation(
+              message: "Page has h#{first_heading_level} but no h1 heading",
+              element_context: element_ctx,
+              wcag_reference: "1.3.1",
+              remediation: "Add an <h1> heading before the first h#{first_heading_level}:\n\n<h1>Main Page Title</h1>\n<h#{first_heading_level}>#{first_heading.text}</h#{first_heading_level}>"
+            )
+          else
+            violations << violation(
+              message: "Page missing H1 heading",
+              element_context: { tag: 'page', text: 'Page has no H1 heading' },
+              wcag_reference: "1.3.1",
+              remediation: "Add an <h1> heading to your page:\n\n<h1>Main Page Title</h1>"
+            )
+          end
+        end
+        
+        # Check 2: Multiple H1s (WCAG 1.3.1)
+        if h1_count > 1
+          # Report error for each h1 after the first one
+          h1_elements = headings.select { |h| h.tag_name == 'h1' }
+          h1_elements[1..-1].each do |h1|
+            element_ctx = element_context(h1)
+            violations << violation(
+              message: "Page has multiple h1 headings (#{h1_count} total) - only one h1 should be used per page",
+              element_context: element_ctx,
+              wcag_reference: "1.3.1",
+              remediation: "Use only one <h1> per page. Convert additional h1s to h2 or lower:\n\n<h1>Main Title</h1>\n<h2>Section Title</h2>"
+            )
+          end
+        end
+        
+        # Check 3: Heading hierarchy skipped levels (WCAG 1.3.1)
+        previous_level = 0
+        headings.each do |heading|
+          current_level = heading.tag_name[1].to_i
+          if current_level > previous_level + 1
+            element_ctx = element_context(heading)
+            violations << violation(
+              message: "Heading hierarchy skipped (h#{previous_level} to h#{current_level})",
+              element_context: element_ctx,
+              wcag_reference: "1.3.1",
+              remediation: "Fix the heading hierarchy. Don't skip levels. Use h#{previous_level + 1} instead of h#{current_level}."
+            )
+          end
+          previous_level = current_level
+        end
+        
+        # Check 4: Empty headings (WCAG 4.1.2)
+        headings.each do |heading|
+          heading_text = heading.text.strip
+          # Check if heading is empty or only contains whitespace/formatting
+          if heading_text.empty? || heading_text.match?(/^\s*$/)
+            element_ctx = element_context(heading)
+            violations << violation(
+              message: "Empty heading detected (<#{heading.tag_name}>) - headings must have accessible text",
+              element_context: element_ctx,
+              wcag_reference: "4.1.2",
+              remediation: "Add descriptive text to the heading:\n\n<#{heading.tag_name}>Descriptive Heading Text</#{heading.tag_name}>"
+            )
+          end
+        end
+        
+        # Check 5: Headings with only images (no alt text or empty alt) (WCAG 4.1.2)
+        headings.each do |heading|
+          # Check if heading contains only images
+          images = heading.all('img', visible: true)
+          if images.any? && heading.text.strip.empty?
+            # Check if all images have alt text
+            images_without_alt = images.select { |img| img[:alt].nil? || img[:alt].strip.empty? }
+            if images_without_alt.any?
+              element_ctx = element_context(heading)
+              violations << violation(
+                message: "Heading contains images without alt text - headings must have accessible text",
+                element_context: element_ctx,
+                wcag_reference: "4.1.2",
+                remediation: "Add alt text to images in the heading, or add visible text alongside the images:\n\n<h1><img src=\"image.jpg\" alt=\"Descriptive text\">Heading Text</h1>"
+              )
+            end
+          end
+        end
+        
+        # Check 6: Headings used only for styling (WCAG 2.4.6)
+        # This is harder to detect automatically, but we can check for very short or generic text
+        headings.each do |heading|
+          heading_text = heading.text.strip
+          # Very short headings (1-2 characters) might be styling-only
+          # Generic text like "•", "→", "..." are likely styling
+          if heading_text.length <= 2 && heading_text.match?(/^[•→…\s\-_=]+$/)
+            element_ctx = element_context(heading)
+            violations << violation(
+              message: "Heading appears to be used for styling only (text: '#{heading_text}') - headings should be descriptive",
+              element_context: element_ctx,
+              wcag_reference: "2.4.6",
+              remediation: "Use CSS for styling instead of headings. Replace with a <div> or <span> with appropriate CSS classes."
+            )
+          end
+        end
+        
+        violations
+      end
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/checks/image_alt_text_check.rb

@@ -15,14 +15,14 @@ module RailsAccessibilityTesting
       def check
         violations = []
         
+        # Use native attribute access instead of JavaScript evaluation for better performance
         page.all('img', visible: :all).each do |img|
-          has_alt_attribute = page.evaluate_script("arguments[0].hasAttribute('alt')", img.native)
-          # Get alt value - might be nil, empty string, or actual text
-          alt_value = img[:alt] || ""
-          # Also check via JavaScript to be sure
-          alt_value_js = page.evaluate_script("arguments[0].getAttribute('alt')", img.native) || ""
+          # Get alt value directly from Capybara element (faster than JavaScript)
+          alt_value = img[:alt]
+          # Check if alt attribute exists (nil means missing, empty string means present but empty)
+          has_alt_attribute = img.native.attribute('alt') != nil rescue false
           
-          if has_alt_attribute == false
+          if !has_alt_attribute
             element_ctx = element_context(img)
             
             violations << violation(
@@ -31,7 +31,7 @@ module RailsAccessibilityTesting
               wcag_reference: "1.1.1",
               remediation: generate_remediation(element_ctx)
             )
-          elsif (alt_value.blank? || alt_value_js.blank?) && has_alt_attribute
+          elsif alt_value.blank? && has_alt_attribute
             # Image has alt attribute but it's empty - warn about this
             # Empty alt is valid for decorative images, but we should check if it's actually decorative
             element_ctx = element_context(img)

data/lib/rails_accessibility_testing/checks/interactive_elements_check.rb

@@ -23,7 +23,17 @@ module RailsAccessibilityTesting
           aria_labelledby = element[:"aria-labelledby"]
           title = element[:title]
           
-          if text.blank? && aria_label.blank? && aria_labelledby.blank? && title.blank?
+          # Check if element contains an image with alt text (common pattern for logo links)
+          has_image_with_alt = false
+          if text.blank?
+            images = element.all('img', visible: :all)
+            has_image_with_alt = images.any? do |img|
+              alt = img[:alt]
+              alt.present? && !alt.strip.empty?
+            end
+          end
+          
+          if text.blank? && aria_label.blank? && aria_labelledby.blank? && title.blank? && !has_image_with_alt
             element_ctx = element_context(element)
             tag = element.tag_name
             

data/lib/rails_accessibility_testing/cli/command.rb

@@ -335,9 +335,11 @@ module RailsAccessibilityTesting
       end
       
       def generate_human_report(results)
+        timestamp = Time.now.strftime("%H:%M:%S")
+        
         output = []
         output << "=" * 70
-        output << "Rails A11y Accessibility Report"
+        output << "Rails A11y Accessibility Report • #{timestamp}"
         output << "=" * 70
         output << ""
         output << "Summary:"

data/lib/rails_accessibility_testing/config/yaml_loader.rb

@@ -116,7 +116,7 @@ module RailsAccessibilityTesting
             'form_labels' => true,
             'image_alt_text' => true,
             'interactive_elements' => true,
-            'heading_hierarchy' => true,
+            'heading' => true,
             'keyboard_accessibility' => true,
             'aria_landmarks' => true,
             'form_errors' => true,

data/lib/rails_accessibility_testing/engine/rule_engine.rb

@@ -25,22 +25,45 @@ module RailsAccessibilityTesting
       # Run all enabled checks against a page
       # @param page [Capybara::Session] The page to check
       # @param context [Hash] Additional context (url, path, etc.)
+      # @param progress_callback [Proc] Optional callback for progress updates
       # @return [Array<Violation>] Array of violations found
-      def check(page, context: {})
+      def check(page, context: {}, progress_callback: nil)
         @violation_collector.reset
         
-        enabled_checks.each do |check_class|
-          next if rule_ignored?(check_class.rule_name)
+        checks_to_run = enabled_checks.reject { |check_class| rule_ignored?(check_class.rule_name) }
+        total_checks = checks_to_run.length
+        
+        checks_to_run.each_with_index do |check_class, index|
+          check_number = index + 1
+          check_name = humanize_check_name(check_class.rule_name)
+          
+          # Report progress
+          if progress_callback
+            progress_callback.call(check_number, total_checks, check_name, :start)
+          end
           
           begin
             check_instance = check_class.new(page: page, context: context)
             violations = check_instance.run
-            @violation_collector.add(violations) if violations.any?
+            
+            if violations.any?
+              @violation_collector.add(violations)
+              if progress_callback
+                progress_callback.call(check_number, total_checks, check_name, :found_issues, violations.length)
+              end
+            else
+              if progress_callback
+                progress_callback.call(check_number, total_checks, check_name, :passed)
+              end
+            end
           rescue StandardError => e
             # Log but don't fail - one check error shouldn't stop others
             if defined?(RailsAccessibilityTesting) && RailsAccessibilityTesting.config.respond_to?(:logger) && RailsAccessibilityTesting.config.logger
               RailsAccessibilityTesting.config.logger.error("Check #{check_class.rule_name} failed: #{e.message}")
             end
+            if progress_callback
+              progress_callback.call(check_number, total_checks, check_name, :error, e.message)
+            end
           end
         end
         
@@ -55,7 +78,7 @@ module RailsAccessibilityTesting
           Checks::FormLabelsCheck,
           Checks::ImageAltTextCheck,
           Checks::InteractiveElementsCheck,
-          Checks::HeadingHierarchyCheck,
+          Checks::HeadingCheck,
           Checks::KeyboardAccessibilityCheck,
           Checks::AriaLandmarksCheck,
           Checks::FormErrorsCheck,
@@ -93,6 +116,27 @@ module RailsAccessibilityTesting
           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
           .downcase
       end
+      
+      # Convert rule name to human-readable check name
+      def humanize_check_name(rule_name)
+        # Map of rule names to friendly display names
+        friendly_names = {
+          'form_labels' => 'Form Labels',
+          'image_alt_text' => 'Image Alt Text',
+          'interactive_elements' => 'Interactive Elements',
+          'heading' => 'Heading Hierarchy',
+          'keyboard_accessibility' => 'Keyboard Accessibility',
+          'aria_landmarks' => 'ARIA Landmarks',
+          'form_errors' => 'Form Error Associations',
+          'table_structure' => 'Table Structure',
+          'duplicate_ids' => 'Duplicate IDs',
+          'skip_links' => 'Skip Links',
+          'color_contrast' => 'Color Contrast'
+        }
+        
+        rule_str = rule_name.to_s
+        friendly_names[rule_str] || rule_str.split('_').map(&:capitalize).join(' ')
+      end
     end
   end
 end

data/lib/rails_accessibility_testing/error_message_builder.rb

@@ -45,14 +45,18 @@ module RailsAccessibilityTesting
       end
 
       def page_info(page_context)
-        lines = [
-          '📄 Page Being Tested:',
-          "   URL: #{page_context[:url] || '(unknown)'}",
-          "   Path: #{page_context[:path] || '(unknown)'}"
-        ]
-
+        lines = ['📄 Page Being Tested:']
+        
+        # Show view file first and prominently if available
         if page_context[:view_file]
-          lines << "   📝 Likely View File: #{page_context[:view_file]}"
+          lines << "   📝 View File: #{page_context[:view_file]}"
+          lines << "   🔗 Path: #{page_context[:path] || '(unknown)'}"
+          lines << "   🌐 URL: #{page_context[:url] || '(unknown)'}" if page_context[:url] && !page_context[:url].include?('127.0.0.1')
+        else
+          # Fallback to path/URL if view file not found
+          lines << "   🔗 Path: #{page_context[:path] || '(unknown)'}"
+          lines << "   🌐 URL: #{page_context[:url] || '(unknown)'}" if page_context[:url]
+          lines << "   ⚠️  View file not detected - check path: #{page_context[:path]}"
         end
 
         lines.join("\n") + "\n"
@@ -109,8 +113,14 @@ module RailsAccessibilityTesting
           interactive_element_remediation(error_type, element_context)
         when /Page missing H1 heading/i
           missing_h1_remediation
+        when /multiple h1|Multiple h1/i
+          multiple_h1_remediation(error_type, element_context)
         when /Heading hierarchy skipped/i
           heading_hierarchy_remediation(error_type, element_context)
+        when /Empty heading|heading.*empty/i
+          empty_heading_remediation(element_context)
+        when /heading.*styling|styling.*heading/i
+          heading_styling_remediation(element_context)
         when /Modal dialog has no focusable elements/i
           modal_remediation
         when /Page missing MAIN landmark/i
@@ -134,8 +144,14 @@ module RailsAccessibilityTesting
             interactive_element_remediation(error_type, element_context)
           when /missing.*H1/i
             missing_h1_remediation
+          when /multiple.*h1/i
+            multiple_h1_remediation(error_type, element_context)
           when /hierarchy.*skipped/i
             heading_hierarchy_remediation(error_type, element_context)
+          when /empty.*heading|heading.*empty/i
+            empty_heading_remediation(element_context)
+          when /heading.*styling|styling.*heading/i
+            heading_styling_remediation(element_context)
           when /modal.*focusable/i
             modal_remediation
           when /missing.*MAIN/i
@@ -228,6 +244,46 @@ module RailsAccessibilityTesting
         remediation
       end
 
+      def multiple_h1_remediation(error_type, element_context)
+        # Extract h1 count from error message if available
+        match = error_type.match(/(\d+)\s+total/)
+        h1_count = match ? match[1] : "multiple"
+        
+        remediation = "   Fix multiple h1 headings:\n\n"
+        remediation += "   Current: Page has #{h1_count} <h1> headings\n"
+        remediation += "   Should be: Only one <h1> per page\n\n"
+        remediation += "   Example fix:\n"
+        remediation += "   <h1>Main Page Title</h1>\n"
+        remediation += "   <h2>Section Title</h2>  ← Convert additional h1s to h2\n\n"
+        remediation += "   💡 Best Practice: Use only one <h1> for the main page title.\n"
+        remediation += "      Use <h2> for major sections, <h3> for subsections, etc.\n"
+        remediation
+      end
+
+      def empty_heading_remediation(element_context)
+        tag = element_context[:tag] || "h1"
+        remediation = "   Fix empty heading:\n\n"
+        remediation += "   Current: <#{tag}></#{tag}>\n"
+        remediation += "   Should be: <#{tag}>Descriptive Heading Text</#{tag}>\n\n"
+        remediation += "   Example:\n"
+        remediation += "   <#{tag}>Introduction to Our Services</#{tag}>\n\n"
+        remediation += "   💡 Best Practice: Headings must have accessible text.\n"
+        remediation += "      Screen readers need text content to announce headings.\n"
+        remediation
+      end
+
+      def heading_styling_remediation(element_context)
+        remediation = "   Fix heading used for styling:\n\n"
+        remediation += "   Current: Using <h1> or <h2> for visual styling only\n"
+        remediation += "   Should be: Use CSS classes for styling\n\n"
+        remediation += "   Example fix:\n"
+        remediation += "   ❌ <h1>•</h1>  (bad - heading for styling)\n"
+        remediation += "   ✅ <div class=\"decorative-bullet\">•</div>  (good - div with CSS)\n\n"
+        remediation += "   💡 Best Practice: Headings should be semantic, not decorative.\n"
+        remediation += "      Use <div> or <span> with CSS classes for visual styling.\n"
+        remediation
+      end
+
       def heading_hierarchy_remediation(error_type, element_context)
         # Extract heading levels from error_type: "HEADING hierarchy skipped (h1 to h3)"
         match = error_type.match(/h(\d+) to h(\d+)/)