rails_accessibility_testing 1.5.8 → 1.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: deb1a679b569b2ea1335bd383dd3c3c35a604291cd504acf83b02d6bc8093a33
-  data.tar.gz: beeb61ac0b6d7ba710485c03f340427943b5580e77b04c5d77b4b2ea2b395e16
+  metadata.gz: 9f8824e08bc8db71c7a6598998b44c6b39826f367398c8c98a1ef85366a044e2
+  data.tar.gz: bd9337c4b6b89deae25b1adfc9dbec92645c934703e930d5f5048c71a59117b5
 SHA512:
-  metadata.gz: e5712af98873a226fe1d6b834e4c57983897787859adcd4613c24dafd4c2cd60ed9629b6b4865d595dadcfd2452e60766d4ac703a41ffe5ca98a5510801cc9c2
-  data.tar.gz: b3d7cad5a19ddd2b502e4e5a44721e8ecfb787c901ffe65d5904cd98daea202d5d4cd04c8da454f28158d98e2d5450166a6cee953681e762f9aad636c4c2f863
+  metadata.gz: cd9fdfced6342b861ae5d1db4ee852b4c566c9572d62dac463fdc0d7566d37ef1201201c36c3af4d45393d24af7f0a504f76f7eaf25322e7025a577eeb3d94dc
+  data.tar.gz: a2672850fd85a29fb3a304243f1367215c282a34e63df58f5878d274dd31176465afaad23734699124bd6649032b68ff578f0d6a1ae4b6ec853d2f4ffd7ef23c

data/CHANGELOG.md

@@ -5,6 +5,72 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.10] - 2024-12-01
+
+### Changed
+- **Configuration flag renamed**: The `enabled` flag has been renamed to `accessibility_enabled` for better clarity. The old `enabled` key is still supported for backward compatibility.
+
+### Added
+- **Composed Page Scanning**: The static scanner now analyzes complete page compositions (layout + view + partials) for page-level accessibility checks, eliminating false positives for heading hierarchy, ARIA landmarks, duplicate IDs, and heading issues.
+- **View Composition Builder**: New comprehensive system that traces the complete page structure by finding all partials recursively across all directories in `app/views`.
+- **Exhaustive Partial Detection**: Enhanced partial detection that finds partials in any subdirectory, not just specific folders. Works for deeply nested namespaces (e.g., `collections/collection_questions`).
+- **ERB Content Detection**: Improved handling of ERB expressions (`<%= ... %>`) to prevent false positives for empty headings and missing accessible names on buttons.
+
+### Changed
+- **Heading Hierarchy Checks**: Now performed on the complete composed page instead of individual files, preventing false positives when H1 is in layout or partials.
+- **ARIA Landmarks Checks**: Now checks for `<main>` landmark across the entire composed page.
+- **Duplicate ID Checks**: Now checks for duplicate IDs across the complete page composition.
+- **Empty Heading Checks**: Now checks for empty headings across the complete composed page.
+- **Partial Search**: Enhanced to traverse ALL folders in `app/views` recursively using `Dir.glob`, making it a general solution that works for any folder structure.
+
+### Fixed
+- Fixed false positive for "Page missing MAIN landmark" when `<main>` is in the layout file.
+- Fixed false positive for "Page has h2 but no h1 heading" when H1 is in a partial rendered via `render @model`.
+- Fixed false positive for "Heading hierarchy skipped (h0 to h2)" when first heading is h2.
+- Fixed false positive for "Duplicate ID 'ERB_CONTENT'" by filtering out ERB placeholder strings.
+- Fixed partial detection for Rails shorthand patterns (`render @model`, `render collection: @models`).
+- Fixed namespaced partial path resolution (e.g., `layouts/_advance_search`).
+- Fixed path normalization to handle both relative and absolute paths consistently.
+
+### Performance
+- Optimized exhaustive directory search to return first match found instead of checking all matches.
+
+## [Unreleased]
+
+### Added
+- **Composed Page Scanning**: The static scanner now analyzes complete page compositions (layout + view + partials) for page-level accessibility checks, eliminating false positives for heading hierarchy, ARIA landmarks, duplicate IDs, and heading issues.
+- **View Composition Builder**: New comprehensive system that traces the complete page structure by finding all partials recursively across all directories in `app/views`.
+- **Exhaustive Partial Detection**: Enhanced partial detection that finds partials in any subdirectory, not just specific folders. Works for deeply nested namespaces (e.g., `collections/collection_questions`).
+- **ERB Content Detection**: Improved handling of ERB expressions (`<%= ... %>`) to prevent false positives for empty headings and missing accessible names on buttons.
+
+### Changed
+- **Heading Hierarchy Checks**: Now performed on the complete composed page instead of individual files, preventing false positives when H1 is in layout or partials.
+- **ARIA Landmarks Checks**: Now checks for `<main>` landmark across the entire composed page.
+- **Duplicate ID Checks**: Now checks for duplicate IDs across the complete page composition.
+- **Empty Heading Checks**: Now checks for empty headings across the complete composed page.
+- **Partial Search**: Enhanced to traverse ALL folders in `app/views` recursively using `Dir.glob`, making it a general solution that works for any folder structure.
+
+### Fixed
+- Fixed false positive for "Page missing MAIN landmark" when `<main>` is in the layout file.
+- Fixed false positive for "Page has h2 but no h1 heading" when H1 is in a partial rendered via `render @model`.
+- Fixed false positive for "Heading hierarchy skipped (h0 to h2)" when first heading is h2.
+- Fixed false positive for "Duplicate ID 'ERB_CONTENT'" by filtering out ERB placeholder strings.
+- Fixed partial detection for Rails shorthand patterns (`render @model`, `render collection: @models`).
+- Fixed namespaced partial path resolution (e.g., `layouts/_advance_search`).
+- Fixed path normalization to handle both relative and absolute paths consistently.
+
+### Performance
+- Optimized exhaustive directory search to return first match found instead of checking all matches.
+
+## [1.5.9] - 2024-12-01
+
+### Added
+- **Force option for manual checks**: Added `force: true` parameter to `check_comprehensive_accessibility` and `check_basic_accessibility` to bypass `enabled: false` setting
+- **Manual check flexibility**: You can now force manual checks to run even when accessibility checks are globally disabled
+
+### Improved
+- **Manual check documentation**: Clarified that manual checks can be run separately in RSpec specs regardless of configuration
+
 ## [1.5.8] - 2024-12-01
 
 ### Fixed

data/README.md

@@ -7,7 +7,7 @@
 
 **The RSpec + RuboCop of accessibility for Rails. Catch WCAG violations before they reach production.**
 
-**Current Version:** 1.5.5
+**Current Version:** 1.5.9
 
 📖 **[📚 Full Documentation](https://rayraycodes.github.io/rails-accessibility-testing/)** | [💻 GitHub](https://github.com/rayraycodes/rails-accessibility-testing) | [💎 RubyGems](https://rubygems.org/gems/rails_accessibility_testing)
 
@@ -51,6 +51,13 @@ Rails Accessibility Testing fills a critical gap in the Rails testing ecosystem.
 - **Accurate error counting**: Properly tracks and displays error/warning counts
 - **Persistent output**: Errors stay visible in terminal (no clearing)
 
+#### 🔍 Composed Page Scanning (NEW in 1.5.9+)
+- **Complete page analysis**: Analyzes full page composition (layout + view + partials) for page-level checks
+- **Eliminates false positives**: No more false positives when H1 is in layout or partials
+- **Exhaustive partial finding**: Traverses ALL folders recursively to find all partials
+- **Works for any structure**: General solution that works for any Rails folder structure (collections, items, profiles, loan_requests, etc.)
+- **Page-level checks**: Heading hierarchy, ARIA landmarks, duplicate IDs, and empty headings checked across complete page
+
 #### 🔍 Smart View File Detection
 - **Intelligent matching**: Automatically finds view files even when action names don't match
 - **Controller directory scanning**: Searches all view files to find the correct template
@@ -61,6 +68,7 @@ Rails Accessibility Testing fills a critical gap in the Rails testing ecosystem.
 - **Optimized DOM queries**: Faster image alt checks without JavaScript evaluation
 - **Removed delays**: Eliminated unnecessary sleep calls in live scanner
 - **Efficient scanning**: ~25-30% faster page scans
+- **Optimized directory search**: Returns first match found instead of checking all matches
 
 #### 🎨 Enhanced Developer Experience
 - **Real-time progress**: Step-by-step feedback during accessibility checks

data/docs_site/architecture.md

@@ -3,7 +3,45 @@ layout: default
 title: Architecture
 ---
 
-# Architecture Overview
+# Architecture
+
+## Composed Page Scanning
+
+The gem now uses **composed page scanning** for page-level accessibility checks. This ensures that checks like heading hierarchy, ARIA landmarks, and duplicate IDs are evaluated against the complete rendered page (layout + view + partials), not individual files.
+
+### View Composition Builder
+
+The `ViewCompositionBuilder` class traces the complete page structure:
+
+1. **Finds Layout File**: Identifies the layout file (defaults to `application.html.erb`)
+2. **Finds View File**: The main view file being rendered
+3. **Recursively Finds Partials**: Discovers all partials rendered in the view, including:
+   - Partials in the same directory
+   - Partials in `layouts/`, `shared/`, `application/`
+   - Partials in any subdirectory (exhaustive search)
+   - Nested partials (partials within partials)
+
+### Partial Detection
+
+The gem detects all Rails render patterns:
+- `render 'partial'`
+- `render partial: 'partial'`
+- `render @model` (Rails shorthand)
+- `render collection: @models`
+- `render partial: 'item', collection: @items`
+- `render partial: 'form', locals: {...}`
+
+### Exhaustive Folder Traversal
+
+The partial search traverses ALL folders in `app/views` recursively using `Dir.glob`, ensuring partials are found regardless of their location:
+- `app/views/collections/`
+- `app/views/collections/collection_questions/`
+- `app/views/items/`
+- `app/views/profiles/`
+- `app/views/loan_requests/`
+- Any other nested structure
+
+This makes it a general solution that works for any Rails application structure. Overview
 
 This guide explains how Rails Accessibility Testing works under the hood in simple terms.
 

data/docs_site/getting_started.md

@@ -144,12 +144,12 @@ Rails Accessibility Testing runs **11 comprehensive checks** automatically. Thes
 1. **Form Labels** - All form inputs have associated labels
 2. **Image Alt Text** - All images have descriptive alt attributes
 3. **Interactive Elements** - Buttons, links have accessible names
-4. **Heading Hierarchy** - Proper h1-h6 structure without skipping levels
+4. **Heading Hierarchy** - Proper h1-h6 structure without skipping levels (checked across complete page: layout + view + partials)
 5. **Keyboard Accessibility** - All interactive elements are keyboard accessible
-6. **ARIA Landmarks** - Proper use of ARIA landmark roles
+6. **ARIA Landmarks** - Proper use of ARIA landmark roles (checked across complete page: layout + view + partials)
 7. **Form Error Associations** - Form errors are properly linked to form fields
 8. **Table Structure** - Tables have proper headers
-9. **Duplicate IDs** - No duplicate ID attributes
+9. **Duplicate IDs** - No duplicate ID attributes (checked across complete page: layout + view + partials)
 10. **Skip Links** - Skip navigation links present
 11. **Color Contrast** - Text meets WCAG contrast requirements (optional, disabled by default)
 

data/docs_site/index.md

@@ -7,7 +7,7 @@ title: Home
 
 **The RSpec + RuboCop of accessibility for Rails. Catch WCAG violations before they reach production.**
 
-**Version:** 1.5.5
+**Version:** 1.5.9
 
 Rails Accessibility Testing is a comprehensive, opinionated but configurable gem that makes accessibility testing as natural as unit testing. It integrates seamlessly into your Rails workflow, catching accessibility issues as you code—not after deployment.
 

data/exe/a11y_live_scanner

@@ -35,10 +35,11 @@ begin
     require 'rails_accessibility_testing/config/yaml_loader'
     profile = defined?(Rails) && Rails.env.test? ? :test : :development
     config = RailsAccessibilityTesting::Config::YamlLoader.load(profile: profile)
-    enabled = config.fetch('enabled', true)
+    # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+    enabled = config.fetch('accessibility_enabled', config.fetch('enabled', true))
     unless enabled
-      puts "⏸️  Accessibility checks are disabled (enabled: false in config/accessibility.yml)"
-      puts "   Set enabled: true to enable accessibility scanning"
+      puts "⏸️  Accessibility checks are disabled (accessibility_enabled: false in config/accessibility.yml)"
+      puts "   Set accessibility_enabled: true to enable accessibility scanning"
       puts "   Scanner process will remain running but will not scan files"
       puts ""
       # Keep process alive so Foreman doesn't kill other processes

data/exe/a11y_static_scanner

@@ -29,10 +29,11 @@ begin
     require 'rails_accessibility_testing/config/yaml_loader'
     profile = defined?(Rails) && Rails.env.test? ? :test : :development
     config = RailsAccessibilityTesting::Config::YamlLoader.load(profile: profile)
-    enabled = config.fetch('enabled', true)
+    # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+    enabled = config.fetch('accessibility_enabled', config.fetch('enabled', true))
     unless enabled
-      puts "⏸️  Accessibility checks are disabled (enabled: false in config/accessibility.yml)"
-      puts "   Set enabled: true to enable accessibility scanning"
+      puts "⏸️  Accessibility checks are disabled (accessibility_enabled: false in config/accessibility.yml)"
+      puts "   Set accessibility_enabled: true to enable accessibility scanning"
       puts "   Scanner process will remain running but will not scan files"
       puts ""
       # Keep process alive so Foreman doesn't kill other processes

data/lib/generators/rails_a11y/install/templates/accessibility.yml.erb

@@ -3,11 +3,11 @@
 # This file configures accessibility checks for your Rails application.
 # See https://github.com/your-org/rails-a11y for full documentation.
 
-# Global enable/disable flag
+# Global enable/disable flag for all accessibility checks
 # Set to false to completely disable all accessibility checks (manual and automatic)
 # When false, check_comprehensive_accessibility and automatic checks will be skipped
 # Default: true
-enabled: true
+accessibility_enabled: true
 
 # WCAG compliance level (A, AA, AAA)
 wcag_level: AA

data/lib/rails_accessibility_testing/accessibility_helper.rb

@@ -46,14 +46,34 @@ module RailsAccessibilityTesting
         # render partial: "partial_name"
         # render 'path/to/partial'
         # render partial: 'path/to/partial'
+        # render @model (Rails shorthand - renders _model.html.erb)
+        # render collection: @models (renders _model.html.erb for each)
+        # render partial: 'partial', locals: {...}
+        # render partial: 'partial', collection: @items
         # <%= render 'partial_name' %>
         # <%= render partial: 'partial_name' %>
+        # <%= render @model %>
+        # <%= render collection: @models %>
         
         patterns = [
+          # Standard partial renders (with or without partial: keyword)
           /render\s+(?:partial:\s*)?['"]([^'"]+)['"]/,
           /render\s+(?:partial:\s*)?:(\w+)/,
           /<%=?\s*render\s+(?:partial:\s*)?['"]([^'"]+)['"]/,
-          /<%=?\s*render\s+(?:partial:\s*)?:(\w+)/
+          /<%=?\s*render\s+(?:partial:\s*)?:(\w+)/,
+          # Rails shorthand: render @model (renders _model.html.erb)
+          /render\s+@(\w+)/,
+          /<%=?\s*render\s+@(\w+)/,
+          # Collection renders: render collection: @models (renders _model.html.erb)
+          /render\s+collection:\s*@(\w+)/,
+          /<%=?\s*render\s+collection:\s*@(\w+)/,
+          # Partial with collection: render partial: 'item', collection: @items
+          /render\s+partial:\s*['"]([^'"]+)['"]\s*,\s*collection:/,
+          /<%=?\s*render\s+partial:\s*['"]([^'"]+)['"]\s*,\s*collection:/,
+          # Partial with locals: render partial: 'form', locals: {...}
+          # (extract just the partial name, ignore locals)
+          /render\s+partial:\s*['"]([^'"]+)['"]\s*,\s*locals:/,
+          /<%=?\s*render\s+partial:\s*['"]([^'"]+)['"]\s*,\s*locals:/
         ]
         
         patterns.each do |pattern|
@@ -77,6 +97,23 @@ module RailsAccessibilityTesting
           end
         end
         
+        # Also check for Rails shorthand: render @model (renders _model.html.erb)
+        # This is separate because it needs special handling
+        content.scan(/render\s+@(\w+)/) do |match|
+          model_name = match[0]
+          partial_name = model_name.underscore
+          partial_name = "_#{partial_name}" unless partial_name.start_with?('_')
+          partials << partial_name unless partials.include?(partial_name)
+        end
+        
+        # Check for collection renders: render collection: @models
+        content.scan(/render\s+collection:\s*@(\w+)/) do |match|
+          model_name = match[0]
+          partial_name = model_name.underscore.singularize  # collection uses singular
+          partial_name = "_#{partial_name}" unless partial_name.start_with?('_')
+          partials << partial_name unless partials.include?(partial_name)
+        end
+        
         partials
       end
       
@@ -210,9 +247,11 @@ module RailsAccessibilityTesting
   end
 
   # Basic accessibility check - runs 5 basic checks
-  def check_basic_accessibility
+  # @param force [Boolean] If true, bypasses the accessibility_enabled: false setting (default: false)
+  def check_basic_accessibility(force: false)
     # Check if accessibility checks are globally disabled
-    return if accessibility_disabled?
+    # Manual calls can use force: true to bypass the accessibility_enabled: false setting
+    return if !force && accessibility_disabled?
     
     @accessibility_errors ||= []
     @accessibility_warnings ||= []
@@ -244,10 +283,12 @@ module RailsAccessibilityTesting
 
   # Full comprehensive check - runs all 11 checks including advanced
   # Uses the RuleEngine and checks from the checks/ folder for consistency
+  # @param force [Boolean] If true, bypasses the accessibility_enabled: false setting (default: false)
   # @return [Hash] Hash with :errors and :warnings counts
-  def check_comprehensive_accessibility
+  def check_comprehensive_accessibility(force: false)
     # Check if accessibility checks are globally disabled - do this FIRST before any output
-    if accessibility_disabled?
+    # Manual calls can use force: true to bypass the accessibility_enabled: false setting
+    if !force && accessibility_disabled?
       return { errors: 0, warnings: 0, page_context: {} }
     end
     
@@ -447,7 +488,8 @@ module RailsAccessibilityTesting
       require 'rails_accessibility_testing/config/yaml_loader'
       profile = defined?(Rails) && Rails.env.test? ? :test : :development
       config = RailsAccessibilityTesting::Config::YamlLoader.load(profile: profile)
-      enabled = config.fetch('enabled', true)  # Default to enabled if not specified
+      # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+      enabled = config.fetch('accessibility_enabled', config.fetch('enabled', true))  # Default to enabled if not specified
       disabled = !enabled  # Return true if disabled
       disabled
     rescue StandardError => e

data/lib/rails_accessibility_testing/checks/heading_check.rb

@@ -23,7 +23,7 @@ module RailsAccessibilityTesting
           return violations  # Warning only, not error
         end
         
-        # Check 1: Missing H1
+        # Check 1: Missing H1 (page-level check - checks complete composed page)
         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
@@ -32,30 +32,35 @@ module RailsAccessibilityTesting
           # 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)
+            # Mark as page-level check - H1 might be in layout or partial
+            element_ctx[:page_level_check] = true
+            element_ctx[:check_type] = 'heading_hierarchy'
             violations << violation(
-              message: "Page has h#{first_heading_level} but no h1 heading",
+              message: "Page has h#{first_heading_level} but no h1 heading (checked complete page: layout + view + partials)",
               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}>"
+              remediation: "Add an <h1> heading to your page. The H1 can be in the layout, view, or a partial:\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' },
+              message: "Page missing H1 heading (checked complete page: layout + view + partials)",
+              element_context: { tag: 'page', text: 'Page has no H1 heading', page_level_check: true, check_type: 'heading_hierarchy' },
               wcag_reference: "1.3.1",
-              remediation: "Add an <h1> heading to your page:\n\n<h1>Main Page Title</h1>"
+              remediation: "Add an <h1> heading to your page. The H1 can be in the layout, view, or a partial:\n\n<h1>Main Page Title</h1>"
             )
           end
         end
         
-        # Check 2: Multiple H1s (WCAG 1.3.1)
+        # Check 2: Multiple H1s (WCAG 1.3.1) - page-level check
         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)
+            element_ctx[:page_level_check] = true
+            element_ctx[:check_type] = 'heading_hierarchy'
             violations << violation(
-              message: "Page has multiple h1 headings (#{h1_count} total) - only one h1 should be used per page",
+              message: "Page has multiple h1 headings (#{h1_count} total) - only one h1 should be used per page (checked complete page: layout + view + partials)",
               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>"
@@ -63,14 +68,16 @@ module RailsAccessibilityTesting
           end
         end
         
-        # Check 3: Heading hierarchy skipped levels (WCAG 1.3.1)
+        # Check 3: Heading hierarchy skipped levels (WCAG 1.3.1) - page-level check
         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)
+            element_ctx[:page_level_check] = true
+            element_ctx[:check_type] = 'heading_hierarchy'
             violations << violation(
-              message: "Heading hierarchy skipped (h#{previous_level} to h#{current_level})",
+              message: "Heading hierarchy skipped (h#{previous_level} to h#{current_level}) - checked complete page: layout + view + partials",
               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}."

data/lib/rails_accessibility_testing/composed_page_scanner.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require_relative 'view_composition_builder'
+require_relative 'erb_extractor'
+
+module RailsAccessibilityTesting
+  # Scans a complete composed page (layout + view + partials) for heading hierarchy
+  # This ensures heading hierarchy is checked across the entire page, not just individual files
+  #
+  # @api private
+  class ComposedPageScanner
+    def initialize(view_file)
+      @view_file = view_file
+      @builder = ViewCompositionBuilder.new(view_file)
+    end
+
+    # Scan the complete composed page for heading hierarchy violations
+    # @return [Hash] Hash with :errors and :warnings arrays
+    def scan_heading_hierarchy
+      return { errors: [], warnings: [] } unless @view_file && File.exist?(@view_file)
+
+      # Build composition
+      all_files = @builder.build
+      return { errors: [], warnings: [] } if all_files.empty?
+
+      # Get all headings from complete composition
+      headings = @builder.all_headings
+      return { errors: [], warnings: [] } if headings.empty?
+
+      violations = []
+
+      # Check 1: Missing H1
+      h1_count = headings.count { |h| h[:level] == 1 }
+      first_heading = headings.first
+
+      if h1_count == 0
+        if first_heading
+          violations << create_violation(
+            message: "Page has h#{first_heading[:level]} but no h1 heading (checked complete page: layout + view + partials)",
+            heading: first_heading,
+            wcag_reference: "1.3.1",
+            remediation: "Add an <h1> heading to your page. The H1 can be in the layout, view, or a partial:\n\n<h1>Main Page Title</h1>"
+          )
+        else
+          violations << create_violation(
+            message: "Page missing H1 heading (checked complete page: layout + view + partials)",
+            heading: nil,
+            wcag_reference: "1.3.1",
+            remediation: "Add an <h1> heading to your page. The H1 can be in the layout, view, or a partial:\n\n<h1>Main Page Title</h1>"
+          )
+        end
+      end
+
+      # Check 2: Multiple H1s
+      if h1_count > 1
+        h1_headings = headings.select { |h| h[:level] == 1 }
+        h1_headings[1..-1].each do |h1|
+          violations << create_violation(
+            message: "Page has multiple h1 headings (#{h1_count} total) - only one h1 should be used per page (checked complete page: layout + view + partials)",
+            heading: h1,
+            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
+      # Only flag if we're skipping from a real heading (not from h0)
+      # If the first heading is h2, that's fine - it just means no h1 exists (handled by Check 1)
+      previous_level = nil
+      headings.each do |heading|
+        current_level = heading[:level]
+        if previous_level && current_level > previous_level + 1
+          # Only flag if we're skipping from a real heading level
+          violations << create_violation(
+            message: "Heading hierarchy skipped (h#{previous_level} to h#{current_level}) - checked complete page: layout + view + partials",
+            heading: heading,
+            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
+
+      # Convert to errors/warnings format (matching ViolationConverter format)
+      errors = violations.map do |v|
+        {
+          type: v[:message],
+          element: {
+            tag: v[:heading] ? "h#{v[:heading][:level]}" : 'page',
+            text: v[:heading] ? v[:heading][:text] : 'Page-level heading hierarchy check',
+            file: v[:file] || @view_file
+          },
+          file: v[:file] || @view_file,
+          line: v[:line] || 1,
+          wcag: v[:wcag_reference],
+          remediation: v[:remediation],
+          page_level_check: true,
+          check_type: 'heading_hierarchy'
+        }
+      end
+
+      { errors: errors, warnings: [] }
+    end
+    
+    # Scan the complete composed page for all heading issues (not just hierarchy)
+    # This includes: empty headings, styling-only headings, etc.
+    # @return [Hash] Hash with :errors and :warnings arrays
+    def scan_all_headings
+      return { errors: [], warnings: [] } unless @view_file && File.exist?(@view_file)
+      
+      # Build composition
+      all_files = @builder.build
+      return { errors: [], warnings: [] } if all_files.empty?
+      
+      # Get all headings from complete composition
+      headings = @builder.all_headings
+      return { errors: [], warnings: [] } if headings.empty?
+      
+      errors = []
+      warnings = []
+      
+      # Check for empty headings (across complete page)
+      headings.each do |heading|
+        heading_text = heading[:text]
+        
+        # Check if heading contains ERB placeholder
+        has_erb_content = heading_text.include?('ERB_CONTENT')
+        
+        # Check if heading is empty or only contains whitespace
+        if (heading_text.empty? || heading_text.match?(/^\s*$/)) && !has_erb_content
+          errors << {
+            type: "Empty heading detected (<h#{heading[:level]}>) - headings must have accessible text (checked complete page: layout + view + partials)",
+            element: {
+              tag: "h#{heading[:level]}",
+              text: 'Empty heading',
+              file: heading[:file]
+            },
+            file: heading[:file],
+            line: heading[:line],
+            wcag: "4.1.2",
+            remediation: "Add descriptive text to the heading:\n\n<h#{heading[:level]}>Descriptive Heading Text</h#{heading[:level]}>",
+            page_level_check: true,
+            check_type: 'heading_empty'
+          }
+        end
+        
+        # Check for styling-only headings (very short or generic text)
+        if heading_text.length <= 2 && heading_text.match?(/^[•→…\s\-_=]+$/)
+          warnings << {
+            type: "Heading appears to be used for styling only (text: '#{heading_text}') - headings should be descriptive (checked complete page: layout + view + partials)",
+            element: {
+              tag: "h#{heading[:level]}",
+              text: heading_text,
+              file: heading[:file]
+            },
+            file: heading[:file],
+            line: heading[:line],
+            wcag: "2.4.6",
+            remediation: "Use CSS for styling instead of headings. Replace with a <div> or <span> with appropriate CSS classes.",
+            page_level_check: true,
+            check_type: 'heading_styling'
+          }
+        end
+      end
+      
+      { errors: errors, warnings: warnings }
+    end
+    
+    # Scan the complete composed page for duplicate IDs
+    # IDs must be unique across the entire page (layout + view + partials)
+    # @return [Hash] Hash with :errors and :warnings arrays
+    def scan_duplicate_ids
+      return { errors: [], warnings: [] } unless @view_file && File.exist?(@view_file)
+      
+      # Build composition
+      all_files = @builder.build
+      return { errors: [], warnings: [] } if all_files.empty?
+      
+      # Collect all IDs from complete composition
+      id_map = {} # id => [{ file: String, line: Integer, element: String }]
+      
+      all_files.each do |file|
+        # Handle both relative and absolute paths
+        file_path = if File.exist?(file)
+          file
+        elsif defined?(Rails) && Rails.root
+          rails_path = Rails.root.join(file)
+          rails_path.exist? ? rails_path.to_s : nil
+        else
+          nil
+        end
+        next unless file_path && File.exist?(file_path)
+        
+        content = File.read(file_path)
+        html_content = ErbExtractor.extract_html(content)
+        doc = Nokogiri::HTML::DocumentFragment.parse(html_content)
+        
+        # Find all elements with IDs
+        doc.css('[id]').each do |element|
+          id = element[:id]
+          next if id.nil? || id.to_s.strip.empty?
+          # Skip ERB_CONTENT placeholder - it's not a real ID
+          next if id == 'ERB_CONTENT'
+          
+          id_map[id] ||= []
+          line = find_line_number_for_element(content, element)
+          id_map[id] << {
+            file: file_path,  # Use resolved path
+            line: line,
+            element: element.name
+          }
+        end
+      end
+      
+      errors = []
+      
+      # Find duplicate IDs
+      id_map.each do |id, occurrences|
+        if occurrences.length > 1
+          # Report all occurrences after the first one
+          occurrences[1..-1].each do |occurrence|
+            errors << {
+              type: "Duplicate ID '#{id}' found (checked complete page: layout + view + partials) - IDs must be unique across the entire page",
+              element: {
+                tag: occurrence[:element],
+                id: id,
+                file: occurrence[:file]
+              },
+              file: occurrence[:file],
+              line: occurrence[:line],
+              wcag: "4.1.1",
+              remediation: "Remove or rename the duplicate ID. Each ID must be unique on the page:\n\n<!-- Change one of these -->\n<div id=\"#{id}\">...</div>\n<div id=\"#{id}\">...</div>\n\n<!-- To -->\n<div id=\"#{id}\">...</div>\n<div id=\"#{id}-2\">...</div>",
+              page_level_check: true,
+              check_type: 'duplicate_ids'
+            }
+          end
+        end
+      end
+      
+      { errors: errors, warnings: [] }
+    end
+    
+    # Helper to find line number for an element
+    def find_line_number_for_element(content, element)
+      tag_name = element.name
+      id = element[:id]
+      
+      lines = content.split("\n")
+      lines.each_with_index do |line, index|
+        if line.include?("<#{tag_name}") && (id.nil? || line.include?("id=\"#{id}\"") || line.include?("id='#{id}'"))
+          return index + 1
+        end
+      end
+      
+      1
+    end
+    
+    # Scan the complete composed page for ARIA landmarks
+    # This ensures landmarks in layout are detected when scanning view files
+    # @return [Hash] Hash with :errors and :warnings arrays
+    def scan_aria_landmarks
+      return { errors: [], warnings: [] } unless @view_file && File.exist?(@view_file)
+      
+      # Build composition
+      all_files = @builder.build
+      return { errors: [], warnings: [] } if all_files.empty?
+      
+      # Check for main landmark across all files
+      has_main = false
+      main_location = nil
+      
+      all_files.each do |file|
+        next unless File.exist?(file)
+        
+        content = File.read(file)
+        html_content = ErbExtractor.extract_html(content)
+        doc = Nokogiri::HTML::DocumentFragment.parse(html_content)
+        
+        # Check for <main> tag or [role="main"]
+        main_elements = doc.css('main, [role="main"]')
+        if main_elements.any?
+          has_main = true
+          main_location = file
+          break
+        end
+      end
+      
+      warnings = []
+      
+      # Only report missing main if it's truly missing from the complete page
+      unless has_main
+        warnings << {
+          type: "Page missing MAIN landmark (checked complete page: layout + view + partials)",
+          element: {
+            tag: 'page',
+            text: 'Page-level ARIA landmark check'
+          },
+          file: @view_file,
+          line: 1,
+          wcag: "1.3.1",
+          remediation: "Add a <main> landmark to your page. It can be in the layout, view, or a partial:\n\n<main id=\"maincontent\">\n  <!-- Page content -->\n</main>",
+          page_level_check: true,
+          check_type: 'aria_landmarks'
+        }
+      end
+      
+      { errors: [], warnings: warnings }
+    end
+
+    private
+
+    def create_violation(message:, heading:, wcag_reference:, remediation:)
+      {
+        message: message,
+        file: heading ? heading[:file] : @view_file,
+        line: heading ? heading[:line] : 1,
+        wcag_reference: wcag_reference,
+        remediation: remediation,
+        heading: heading  # Keep heading info for element context
+      }
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/config/yaml_loader.rb

@@ -84,7 +84,8 @@ module RailsAccessibilityTesting
           merged_system_specs = base_system_specs.merge(profile_system_specs)
           
           base_config.merge(
-            'enabled' => profile_config.fetch('enabled', base_config.fetch('enabled', true)),  # Profile can override enabled, default to true
+            # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+            'accessibility_enabled' => profile_config.fetch('accessibility_enabled', profile_config.fetch('enabled', base_config.fetch('accessibility_enabled', base_config.fetch('enabled', true)))),  # Profile can override, supports legacy 'enabled' key
             'checks' => merged_checks,
             'summary' => merged_summary,
             'scan_strategy' => profile_config['scan_strategy'] || base_config['scan_strategy'] || 'paths',
@@ -123,7 +124,7 @@ module RailsAccessibilityTesting
         # Default configuration when no file exists
         def default_config
           {
-            'enabled' => true,  # Global enable/disable flag for all accessibility checks
+            'accessibility_enabled' => true,  # Global enable/disable flag for all accessibility checks
             'wcag_level' => 'AA',
             'checks' => default_checks,
             'summary' => {

data/lib/rails_accessibility_testing/rspec_integration.rb

@@ -52,7 +52,8 @@ module RailsAccessibilityTesting
           require 'rails_accessibility_testing/config/yaml_loader'
           profile = defined?(Rails) && Rails.env.test? ? :test : :development
           config = Config::YamlLoader.load(profile: profile)
-          enabled = config.fetch('enabled', true)  # Default to enabled if not specified
+          # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+          enabled = config.fetch('accessibility_enabled', config.fetch('enabled', true))  # Default to enabled if not specified
           !enabled  # Return true if disabled
         rescue StandardError
           false  # If config can't be loaded, assume enabled

data/lib/rails_accessibility_testing/static_file_scanner.rb

@@ -36,7 +36,8 @@ module RailsAccessibilityTesting
       # Check if accessibility checks are globally disabled
       begin
         config = Config::YamlLoader.load(profile: :test)
-        enabled = config.fetch('enabled', true)
+        # Support both 'accessibility_enabled' (new) and 'enabled' (legacy) for backward compatibility
+        enabled = config.fetch('accessibility_enabled', config.fetch('enabled', true))
         return { errors: [], warnings: [] } unless enabled
       rescue StandardError
         # If config can't be loaded, continue (assume enabled)
@@ -70,14 +71,56 @@ module RailsAccessibilityTesting
         # Run all enabled checks using existing RuleEngine
         violations = engine.check(static_page, context: context)
 
-        # Convert violations to errors/warnings format with line numbers
+        # For page-level checks, use composed page scanner
+        # This checks the complete page (layout + view + partials) for:
+        # - All heading checks (hierarchy, empty, styling-only)
+        # - ARIA landmarks (main, etc.)
+        # - Duplicate IDs (must be unique across entire page)
+        require_relative 'composed_page_scanner'
+        composed_scanner = ComposedPageScanner.new(@view_file)
+        hierarchy_result = composed_scanner.scan_heading_hierarchy
+        all_headings_result = composed_scanner.scan_all_headings
+        landmarks_result = composed_scanner.scan_aria_landmarks
+        duplicate_ids_result = composed_scanner.scan_duplicate_ids
+        
+        # Filter out page-level violations from regular violations
+        # (we'll use the composed page scanner results instead)
+        heading_violations = violations.select { |v| 
+          v.rule_name.to_s == 'heading'
+        }
+        landmarks_violations = violations.select { |v| 
+          v.rule_name.to_s == 'aria_landmarks' &&
+          (v.message.include?('missing MAIN') || v.message.include?('missing main') || 
+           v.message.include?('MAIN landmark')) 
+        }
+        duplicate_ids_violations = violations.select { |v|
+          v.rule_name.to_s == 'duplicate_ids'
+        }
+        other_violations = violations.reject { |v| 
+          heading_violations.include?(v) || landmarks_violations.include?(v) || duplicate_ids_violations.include?(v)
+        }
+        
+        # Convert non-page-level violations to errors/warnings format
         line_number_finder = LineNumberFinder.new(@file_content)
-        ViolationConverter.convert(
-          violations,
+        result = ViolationConverter.convert(
+          other_violations,
           view_file: @view_file,
           line_number_finder: line_number_finder,
           config: config
         )
+        
+        # Add composed page results (all heading checks + landmarks + duplicate IDs)
+        result[:errors] = (result[:errors] || []) + 
+                         hierarchy_result[:errors] + 
+                         all_headings_result[:errors] + 
+                         duplicate_ids_result[:errors]
+        result[:warnings] = (result[:warnings] || []) + 
+                          hierarchy_result[:warnings] + 
+                          all_headings_result[:warnings] + 
+                          landmarks_result[:warnings] + 
+                          duplicate_ids_result[:warnings]
+        
+        result
       rescue StandardError => e
         # If engine fails, log error and return empty results
         if defined?(Rails) && Rails.env.development?

data/lib/rails_accessibility_testing/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module RailsAccessibilityTesting
-  VERSION = "1.5.8"
+  VERSION = "1.5.10"
 end
 

data/lib/rails_accessibility_testing/view_composition_builder.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'nokogiri'
+require_relative 'accessibility_helper'
+require_relative 'erb_extractor'
+
+# Builds a composition graph of a Rails page (layout + view + partials)
+# This allows us to check heading hierarchy across the complete composed page
+# rather than individual files
+module RailsAccessibilityTesting
+  # Builds the composition of a Rails page by tracing:
+  # - Layout file (application.html.erb)
+  # - View file (yield content)
+  # - All partials rendered (recursively)
+  #
+  # @api private
+  class ViewCompositionBuilder
+    include AccessibilityHelper::PartialDetection
+
+    attr_reader :view_file, :layout_file, :all_files
+
+    def initialize(view_file)
+      @view_file = view_file
+      @layout_file = nil
+      @all_files = []
+      @visited_files = Set.new
+    end
+
+    # Build the complete composition
+    # @return [Array<String>] Array of all file paths in the composition
+    def build
+      # Resolve view file path (handle relative/absolute)
+      view_file_path = normalize_path(@view_file)
+      return [] unless view_file_path && File.exist?(view_file_path)
+
+      @all_files = []
+      @visited_files = Set.new
+
+      # Find layout file
+      @layout_file = find_layout_file_for_view(view_file_path)
+      if @layout_file
+        layout_path = normalize_path(@layout_file)
+        @all_files << layout_path if layout_path && File.exist?(layout_path)
+      end
+
+      # Recursively find all partials (handles nested partials, collections, etc.)
+      # Note: find_all_partials_recursive adds files to @all_files and @visited_files
+      # We call it BEFORE manually adding to ensure it processes the file
+      find_all_partials_recursive(view_file_path)
+      if @layout_file
+        layout_path = normalize_path(@layout_file)
+        find_all_partials_recursive(layout_path) if layout_path
+      end
+      
+      # Ensure view file is in @all_files (it should be added by find_all_partials_recursive)
+      @all_files << view_file_path unless @all_files.include?(view_file_path)
+
+      @all_files.uniq
+    end
+    
+    # Normalize file path to consistent format (absolute if possible)
+    def normalize_path(file_path)
+      return nil unless file_path
+      
+      # Try with Rails.root first (most reliable for Rails apps)
+      if defined?(Rails) && Rails.root
+        rails_path = Rails.root.join(file_path)
+        return rails_path.to_s if File.exist?(rails_path)
+      end
+      
+      # If file exists as-is (relative or absolute), return it
+      return file_path if File.exist?(file_path)
+      
+      # Try making it absolute if it's relative
+      if !file_path.start_with?('/')
+        expanded = File.expand_path(file_path)
+        return expanded if File.exist?(expanded)
+      end
+      
+      # Return original if nothing works (will be checked later)
+      file_path
+    end
+
+    # Get all headings from the complete composition
+    # @return [Array<Hash>] Array of heading info: { level: 1-6, text: String, file: String, line: Integer }
+    def all_headings
+      headings = []
+
+      @all_files.each do |file|
+        # Handle both relative and absolute paths
+        file_path = if File.exist?(file)
+          file
+        elsif defined?(Rails) && Rails.root
+          rails_path = Rails.root.join(file)
+          rails_path.exist? ? rails_path.to_s : nil
+        else
+          nil
+        end
+        
+        next unless file_path && File.exist?(file_path)
+
+        content = File.read(file_path)
+        html_content = ErbExtractor.extract_html(content)
+        doc = Nokogiri::HTML::DocumentFragment.parse(html_content)
+
+        doc.css('h1, h2, h3, h4, h5, h6').each do |heading|
+          level = heading.name[1].to_i
+          text = heading.text.strip
+          line = find_line_number(content, heading)
+
+          headings << {
+            level: level,
+            text: text,
+            file: file_path,  # Use resolved path
+            line: line
+          }
+        end
+      end
+
+      # Sort by file order (layout first, then view, then partials)
+      # This preserves the DOM order
+      headings.sort_by do |h|
+        file_index = @all_files.index(h[:file]) || 999
+        [file_index, h[:line]]
+      end
+    end
+
+    private
+
+    # Find layout file for a view
+    # Handles:
+    # - Explicit layout declaration in view: layout 'custom_layout'
+    # - Controller-level layout (via ApplicationController)
+    # - Default application layout
+    def find_layout_file_for_view(view_file)
+      return nil unless view_file && File.exist?(view_file)
+
+      # Check for layout declaration in view file
+      content = File.read(view_file)
+      layout_match = content.match(/layout\s+['"]([^'"]+)['"]/)
+      layout_name = layout_match ? layout_match[1] : 'application'
+
+      # Try to find layout file
+      extensions = %w[erb haml slim]
+      extensions.each do |ext|
+        layout_path = "app/views/layouts/#{layout_name}.html.#{ext}"
+        if File.exist?(layout_path)
+          return layout_path
+        elsif defined?(Rails) && Rails.root
+          rails_path = Rails.root.join(layout_path)
+          return rails_path.to_s if File.exist?(rails_path)
+        end
+      end
+
+      # Default to application layout
+      extensions.each do |ext|
+        layout_path = "app/views/layouts/application.html.#{ext}"
+        if File.exist?(layout_path)
+          return layout_path
+        elsif defined?(Rails) && Rails.root
+          rails_path = Rails.root.join(layout_path)
+          return rails_path.to_s if File.exist?(rails_path)
+        end
+      end
+
+      nil
+    end
+
+    # Recursively find all partials rendered in a file
+    # Handles nested partials, collections, and all Rails render patterns
+    def find_all_partials_recursive(file)
+      # Normalize file path to consistent format
+      file_path = normalize_path(file)
+      return unless file_path && File.exist?(file_path)
+      return if @visited_files.include?(file_path)
+
+      @visited_files.add(file_path)
+      content = File.read(file_path)
+
+      # Find all partials rendered in this file
+      # Use the PartialDetection module method (handles all Rails patterns)
+      partials = find_partials_in_view_file(file_path)
+      
+      # Also check for Rails shorthand: render @model (renders _model.html.erb)
+      content.scan(/render\s+@(\w+)/) do |match|
+        model_name = match[0]
+        partial_name = model_name.underscore
+        partials << partial_name unless partials.include?(partial_name)
+      end
+
+      partials.each do |partial_name|
+        partial_file = find_partial_file(partial_name)
+        next unless partial_file
+        
+        # Normalize partial file path to consistent format
+        full_partial_path = normalize_path(partial_file)
+        next unless full_partial_path && File.exist?(full_partial_path)
+        next if @all_files.include?(full_partial_path)
+
+        @all_files << full_partial_path
+
+        # Recursively find partials within this partial (handles nested partials)
+        find_all_partials_recursive(full_partial_path)
+      end
+    end
+
+    # Find the actual file path for a partial name
+    def find_partial_file(partial_name)
+      extensions = %w[erb haml slim]
+
+      # Handle namespaced partials (e.g., 'layouts/_navbar', 'layouts/navbar')
+      if partial_name.include?('/')
+        parts = partial_name.split('/')
+        dir = parts[0..-2].join('/')
+        name = parts.last
+        # Remove leading underscore from name if present
+        name = name.start_with?('_') ? name[1..-1] : name
+        partial_path = "app/views/#{dir}/_#{name}"
+        
+        extensions.each do |ext|
+          full_path = "#{partial_path}.html.#{ext}"
+          # Try with Rails.root first (most reliable)
+          if defined?(Rails) && Rails.root
+            rails_path = Rails.root.join(full_path)
+            return rails_path.to_s if File.exist?(rails_path)
+          end
+          # Fallback to relative path
+          if File.exist?(full_path)
+            return full_path
+          end
+        end
+      else
+        # Non-namespaced partial - remove leading underscore if present
+        clean_name = partial_name.start_with?('_') ? partial_name[1..-1] : partial_name
+        
+        # Try view directory first (same directory as view file)
+        # Handle both absolute and relative paths
+        view_dir_path = File.dirname(@view_file)
+        if view_dir_path.include?('app/views/')
+          # Extract directory relative to app/views
+          view_dir = view_dir_path.sub(/^.*\/app\/views\//, '')
+        else
+          view_dir = view_dir_path.sub('app/views/', '')
+        end
+        partial_path = "app/views/#{view_dir}/_#{clean_name}"
+        
+        extensions.each do |ext|
+          full_path = "#{partial_path}.html.#{ext}"
+          # Try with Rails.root if file doesn't exist (for absolute paths)
+          if File.exist?(full_path)
+            return full_path
+          elsif defined?(Rails) && Rails.root
+            rails_path = Rails.root.join(full_path)
+            return rails_path.to_s if File.exist?(rails_path)
+          end
+        end
+
+        # Try standard directories first (most common locations)
+        standard_dirs = ['layouts', 'shared', 'application']
+        standard_dirs.each do |dir|
+          partial_path = "app/views/#{dir}/_#{clean_name}"
+          extensions.each do |ext|
+            full_path = "#{partial_path}.html.#{ext}"
+            # Try with Rails.root first
+            if defined?(Rails) && Rails.root
+              rails_path = Rails.root.join(full_path)
+              return rails_path.to_s if File.exist?(rails_path)
+            end
+            # Fallback to relative path
+            if File.exist?(full_path)
+              return full_path
+            end
+          end
+        end
+        
+        # Exhaustive search: traverse ALL folders in app/views recursively
+        # This ensures we find partials in any subdirectory (collections, items, profiles, loan_requests, etc.)
+        # Only do this if partial wasn't found in standard locations (performance optimization)
+        if defined?(Rails) && Rails.root
+          views_dir = Rails.root.join('app', 'views')
+          if File.exist?(views_dir)
+            # Search for partial in all subdirectories (use first match found)
+            extensions.each do |ext|
+              pattern = views_dir.join('**', "_#{clean_name}.html.#{ext}")
+              found_path = Dir.glob(pattern).first
+              return found_path if found_path && File.exist?(found_path)
+            end
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Find line number for an element in the original ERB file
+    def find_line_number(content, element)
+      # Simple approach: find the line containing the tag
+      tag_name = element.name
+      text = element.text.strip[0..50] # First 50 chars for matching
+
+      lines = content.split("\n")
+      lines.each_with_index do |line, index|
+        if line.include?("<#{tag_name}") && (text.empty? || line.include?(text[0..20]))
+          return index + 1
+        end
+      end
+
+      1 # Default to line 1 if not found
+    end
+  end
+end
+

data/lib/rails_accessibility_testing.rb

@@ -55,6 +55,8 @@ require_relative 'rails_accessibility_testing/line_number_finder'
 require_relative 'rails_accessibility_testing/violation_converter'
 require_relative 'rails_accessibility_testing/static_file_scanner'
 require_relative 'rails_accessibility_testing/static_scanning'
+require_relative 'rails_accessibility_testing/view_composition_builder'
+require_relative 'rails_accessibility_testing/composed_page_scanner'
 # Only load RSpec-specific components when RSpec is available
 if defined?(RSpec)
   require_relative 'rails_accessibility_testing/shared_examples'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_accessibility_testing
 version: !ruby/object:Gem::Version
-  version: 1.5.8
+  version: 1.5.10
 platform: ruby
 authors:
 - Regan Maharjan
@@ -143,6 +143,7 @@ files:
 - lib/rails_accessibility_testing/checks/skip_links_check.rb
 - lib/rails_accessibility_testing/checks/table_structure_check.rb
 - lib/rails_accessibility_testing/cli/command.rb
+- lib/rails_accessibility_testing/composed_page_scanner.rb
 - lib/rails_accessibility_testing/config/yaml_loader.rb
 - lib/rails_accessibility_testing/configuration.rb
 - lib/rails_accessibility_testing/engine/rule_engine.rb
@@ -161,6 +162,7 @@ files:
 - lib/rails_accessibility_testing/static_page_adapter.rb
 - lib/rails_accessibility_testing/static_scanning.rb
 - lib/rails_accessibility_testing/version.rb
+- lib/rails_accessibility_testing/view_composition_builder.rb
 - lib/rails_accessibility_testing/violation_converter.rb
 - lib/tasks/accessibility.rake
 homepage: https://rayraycodes.github.io/rails-accessibility-testing/