rails_accessibility_testing 1.5.3 → 1.5.5

data/lib/rails_accessibility_testing/erb_extractor.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RailsAccessibilityTesting
+  # Extracts HTML from ERB templates by converting Rails helpers to HTML
+  # This allows static analysis of view files without rendering them
+  #
+  # @api private
+  class ErbExtractor
+    # Convert ERB template to HTML for static analysis
+    # @param content [String] ERB template content
+    # @return [String] Extracted HTML
+    def self.extract_html(content)
+      new(content).extract
+    end
+
+    def initialize(content)
+      @content = content.dup
+    end
+
+    def extract
+      convert_rails_helpers
+      remove_erb_tags
+      cleanup_whitespace
+      @content
+    end
+
+    private
+
+    # Convert Rails helpers to placeholder HTML
+    def convert_rails_helpers
+      convert_form_helpers
+      convert_image_helpers
+      convert_link_helpers
+      convert_button_helpers
+    end
+
+    # Convert form field helpers
+    def convert_form_helpers
+      # select_tag "name", options, id: "custom_id" or select_tag "name"
+      @content.gsub!(/<%=\s*select_tag\s+["']?(\w+)["']?[^%]*%>/) do |match|
+        name = $1
+        # Try to extract id from the match if present
+        id_match = match.match(/id:\s*["']([^"']+)["']/) || match.match(/id:\s*:(\w+)/)
+        id = id_match ? id_match[1] : name
+        "<select name=\"#{name}\" id=\"#{id}\"></select>"
+      end
+
+      # text_field_tag "name"
+      @content.gsub!(/<%=\s*text_field_tag\s+["']?(\w+)["']?[^%]*%>/) do
+        name = $1
+        "<input type=\"text\" name=\"#{name}\" id=\"#{name}\">"
+      end
+
+      # password_field_tag "name"
+      @content.gsub!(/<%=\s*password_field_tag\s+["']?(\w+)["']?[^%]*%>/) do
+        name = $1
+        "<input type=\"password\" name=\"#{name}\" id=\"#{name}\">"
+      end
+
+      # email_field_tag "name"
+      @content.gsub!(/<%=\s*email_field_tag\s+["']?(\w+)["']?[^%]*%>/) do
+        name = $1
+        "<input type=\"email\" name=\"#{name}\" id=\"#{name}\">"
+      end
+
+      # text_area_tag "name"
+      @content.gsub!(/<%=\s*text_area_tag\s+["']?(\w+)["']?[^%]*%>/) do
+        name = $1
+        "<textarea name=\"#{name}\" id=\"#{name}\"></textarea>"
+      end
+
+      # f.submit "text"
+      @content.gsub!(/<%=\s*f\.submit\s+["']([^"']+)["'][^%]*%>/) do
+        text = $1
+        "<input type=\"submit\" value=\"#{text}\">"
+      end
+    end
+
+    # Convert image helpers
+    def convert_image_helpers
+      # image_tag "path"
+      @content.gsub!(/<%=\s*image_tag\s+["']([^"']+)["'][^%]*%>/) do
+        src = $1
+        "<img src=\"#{src}\">"
+      end
+    end
+
+    # Convert link helpers
+    def convert_link_helpers
+      # link_to with block (do...end) - might have content, might be empty
+      @content.gsub!(/<%=\s*link_to\s+[^%]+do[^%]*%>.*?<%[\s]*end[\s]*%>/m) do |match|
+        # Check if block has visible content (text or images)
+        has_content = match.match?(/[^<%>]{3,}/) # At least 3 non-tag characters
+        has_content ? "<a href=\"#\">content</a>" : "<a href=\"#\"></a>"
+      end
+
+      # link_to "text", path
+      @content.gsub!(/<%=\s*link_to\s+["']([^"']+)["'],\s*[^%]+%>/) do
+        text = $1
+        "<a href=\"#\">#{text}</a>"
+      end
+
+      # link_to path, options (might be empty)
+      @content.gsub!(/<%=\s*link_to\s+[^,]+,\s*[^%]+%>/) do
+        "<a href=\"#\"></a>"
+      end
+
+      # link_to path (no text, no options)
+      @content.gsub!(/<%=\s*link_to\s+[^,\s%]+%>/) do
+        "<a href=\"#\"></a>"
+      end
+    end
+
+    # Convert button helpers
+    def convert_button_helpers
+      # button_tag "text"
+      @content.gsub!(/<%=\s*button_tag\s+["']([^"']+)["'][^%]*%>/) do
+        text = $1
+        "<button>#{text}</button>"
+      end
+
+      # button "text"
+      @content.gsub!(/<%=\s*button\s+["']([^"']+)["'][^%]*%>/) do
+        text = $1
+        "<button>#{text}</button>"
+      end
+    end
+
+    # Remove ERB tags
+    def remove_erb_tags
+      @content.gsub!(/<%[^%]*%>/, '')
+      @content.gsub!(/<%=.*?%>/, '')
+    end
+
+    # Clean up extra whitespace
+    def cleanup_whitespace
+      @content.gsub!(/\n\s*\n\s*\n/, "\n\n")
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/error_message_builder.rb

@@ -27,15 +27,20 @@ module RailsAccessibilityTesting
       # @param error_type [String] Type of accessibility error
       # @param element_context [Hash] Context about the element
       # @param page_context [Hash] Context about the page
+      # @param show_fixes [Boolean] Whether to show fix suggestions (default: true)
       # @return [String] Formatted error message
-      def build(error_type:, element_context:, page_context:)
-        [
+      def build(error_type:, element_context:, page_context:, show_fixes: true)
+        parts = [
           header(error_type),
           page_info(page_context),
-          element_info(element_context),
-          remediation_section(error_type, element_context),
-          footer
-        ].compact.join("\n")
+          element_info(element_context)
+        ]
+        
+        # Only add remediation section if show_fixes is true
+        parts << remediation_section(error_type, element_context) if show_fixes
+        
+        parts << footer
+        parts.compact.join("\n")
       end
 
       private

data/lib/rails_accessibility_testing/file_change_tracker.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module RailsAccessibilityTesting
+  # Tracks file modification times to detect changes
+  # Used by static scanner to only scan files that have changed
+  #
+  # @api private
+  class FileChangeTracker
+    class << self
+      # Get the path to the scan state file
+      # @return [String] Path to the state file
+      def state_file_path
+        return @state_file_path if defined?(@state_file_path) && @state_file_path
+        
+        if defined?(Rails) && Rails.root
+          @state_file_path = Rails.root.join('tmp', '.rails_a11y_scanned_files.json').to_s
+        else
+          @state_file_path = File.join(Dir.pwd, 'tmp', '.rails_a11y_scanned_files.json')
+        end
+      end
+
+      # Load the last scan state
+      # @return [Hash] Hash of file paths to modification times
+      def load_state
+        return {} unless File.exist?(state_file_path)
+        
+        JSON.parse(File.read(state_file_path))
+      rescue StandardError
+        {}
+      end
+
+      # Save the scan state
+      # @param state [Hash] Hash of file paths to modification times
+      def save_state(state)
+        FileUtils.mkdir_p(File.dirname(state_file_path))
+        
+        # Atomic write to avoid partial writes
+        temp_file = "#{state_file_path}.tmp"
+        File.write(temp_file, JSON.pretty_generate(state))
+        FileUtils.mv(temp_file, state_file_path)
+      rescue StandardError => e
+        # Silently fail - don't break scanning if state save fails
+      end
+
+      # Check which files have changed since last scan
+      # @param files [Array<String>] List of file paths to check
+      # @return [Array<String>] List of files that have changed or are new
+      def changed_files(files)
+        state = load_state
+        changed = []
+        
+        files.each do |file|
+          next unless File.exist?(file)
+          
+          current_mtime = File.mtime(file).to_f
+          last_mtime = state[file]&.to_f
+          
+          # File is new or modified if mtime differs
+          if last_mtime.nil? || current_mtime != last_mtime
+            changed << file
+          end
+        end
+        
+        changed
+      end
+
+      # Update state with current file modification times
+      # @param files [Array<String>] List of file paths to update
+      def update_state(files)
+        state = load_state
+        
+        files.each do |file|
+          next unless File.exist?(file)
+          state[file] = File.mtime(file).to_f
+        end
+        
+        # Remove files that no longer exist
+        state.delete_if { |file, _| !File.exist?(file) }
+        
+        save_state(state)
+      end
+
+      # Clear the scan state (useful for forcing full rescan)
+      def clear_state
+        File.delete(state_file_path) if File.exist?(state_file_path)
+      rescue StandardError
+        # Silently fail
+      end
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/line_number_finder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RailsAccessibilityTesting
+  # Finds line numbers for elements in source files
+  # Used by static file scanner to report exact file locations
+  #
+  # @api private
+  class LineNumberFinder
+    def initialize(file_content)
+      @file_content = file_content
+      @lines = file_content.split("\n")
+    end
+
+    # Find line number for an element based on its context
+    # @param element_context [Hash] Element context with tag, id, src, href, etc.
+    # @return [Integer, nil] Line number (1-indexed) or nil if not found
+    def find_line_number(element_context)
+      return nil unless element_context && @file_content
+
+      tag_name = element_context[:tag]
+      id = element_context[:id]
+      src = element_context[:src]
+      href = element_context[:href]
+      type = element_context[:input_type] || element_context[:type]
+
+      @lines.each_with_index do |line, index|
+        # Must contain the tag name
+        next unless line.include?("<#{tag_name}") || (tag_name && line.include?("<#{tag_name.upcase}"))
+
+        # Try to match by ID first (most specific)
+        if id.present? && line.include?("id=") && line.include?(id)
+          id_match = line.match(/id=["']([^"']+)["']/)
+          return index + 1 if id_match && id_match[1] == id
+        end
+
+        # Try to match by src (for images)
+        if src.present? && line.include?("src=") && line.include?(src)
+          return index + 1
+        end
+
+        # Try to match by href (for links)
+        if href.present? && line.include?("href=") && line.include?(href)
+          return index + 1
+        end
+
+        # Try to match by type (for inputs)
+        if type.present? && line.include?("type=") && line.include?(type)
+          return index + 1
+        end
+
+        # If no specific attributes, check if this is likely the element
+        if tag_name && line.match(/<#{tag_name}[^>]*>/)
+          return index + 1
+        end
+      end
+
+      nil
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/rspec_integration.rb

@@ -142,17 +142,50 @@ module RailsAccessibilityTesting
         
         # Show overall summary after all tests complete
         config.after(:suite) do
-          # Show summary if we tested any pages
-          if @@accessibility_results && @@accessibility_results[:pages_tested].any?
-            show_overall_summary(@@accessibility_results)
+          # Check if summary should be shown
+          begin
+            require 'rails_accessibility_testing/config/yaml_loader'
+            profile = defined?(Rails) && Rails.env.test? ? :test : :development
+            config_data = RailsAccessibilityTesting::Config::YamlLoader.load(profile: profile)
+            summary_config = config_data['summary'] || {}
+            show_summary = summary_config.fetch('show_summary', true)
+            errors_only = summary_config.fetch('errors_only', false)
+            
+            return unless show_summary
+            
+            # Show summary if we tested any pages
+            if @@accessibility_results && @@accessibility_results[:pages_tested].any?
+              show_overall_summary(@@accessibility_results, errors_only: errors_only)
+            end
+          rescue StandardError => e
+            # Silently fail if config can't be loaded
           end
         end
       end
       
+      # Load summary configuration from YAML
+      def load_summary_config
+        require 'rails_accessibility_testing/config/yaml_loader'
+        profile = defined?(Rails) && Rails.env.test? ? :test : :development
+        config = RailsAccessibilityTesting::Config::YamlLoader.load(profile: profile)
+        summary_config = config['summary'] || {}
+        {
+          'show_summary' => summary_config.fetch('show_summary', true),
+          'errors_only' => summary_config.fetch('errors_only', false),
+          'show_fixes' => summary_config.fetch('show_fixes', true)
+        }
+      end
+      
       # Show overall summary of all pages tested
-      def show_overall_summary(results)
+      def show_overall_summary(results, config_data = nil)
         return unless results && results[:pages_tested].any?
         
+        # Load config if not provided
+        config_data ||= load_summary_config
+        
+        # Filter out warnings if errors_only is true
+        errors_only = config_data['errors_only']
+        
         puts "\n" + "="*80
         puts "📊 COMPREHENSIVE ACCESSIBILITY TEST REPORT"
         puts "="*80
@@ -161,11 +194,15 @@ module RailsAccessibilityTesting
         puts "   Total pages tested: #{results[:pages_tested].length}"
         puts "   ✅ Passed (no issues):  #{results[:pages_passed]} page#{'s' if results[:pages_passed] != 1}"
         puts "   ❌ Failed (errors):     #{results[:pages_failed]} page#{'s' if results[:pages_failed] != 1}"
-        puts "   ⚠️  Warnings only:      #{results[:pages_with_warnings]} page#{'s' if results[:pages_with_warnings] != 1}"
+        unless errors_only
+          puts "   ⚠️  Warnings only:      #{results[:pages_with_warnings]} page#{'s' if results[:pages_with_warnings] != 1}"
+        end
         puts ""
         puts "📋 Total Issues Across All Pages:"
         puts "   ❌ Total errors:   #{results[:total_errors]}"
-        puts "   ⚠️  Total warnings: #{results[:total_warnings]}"
+        unless errors_only
+          puts "   ⚠️  Total warnings: #{results[:total_warnings]}"
+        end
         puts ""
         
         # Show pages with errors (highest priority)
@@ -175,49 +212,53 @@ module RailsAccessibilityTesting
           pages_with_errors.each do |page|
             view_file = page[:view_file] || page[:path]
             puts "   • #{view_file}"
-            puts "     Errors: #{page[:errors]}#{", Warnings: #{page[:warnings]}" if page[:warnings] > 0}"
+            puts "     Errors: #{page[:errors]}#{", Warnings: #{page[:warnings]}" if page[:warnings] > 0 && !errors_only}"
             puts "     Path: #{page[:path]}" if page[:view_file] && page[:path] != view_file
           end
           puts ""
         end
         
-        # Show pages with warnings only
-        pages_with_warnings_only = results[:pages_tested].select { |p| p[:status] == :warning }
-        if pages_with_warnings_only.any?
-          puts "⚠️  Pages with Warnings Only (#{pages_with_warnings_only.length}):"
-          pages_with_warnings_only.each do |page|
-            view_file = page[:view_file] || page[:path]
-            puts "   • #{view_file}"
-            puts "     Warnings: #{page[:warnings]}"
-            puts "     Path: #{page[:path]}" if page[:view_file] && page[:path] != view_file
+        # Show pages with warnings only (only if not errors_only)
+        unless errors_only
+          pages_with_warnings_only = results[:pages_tested].select { |p| p[:status] == :warning }
+          if pages_with_warnings_only.any?
+            puts "⚠️  Pages with Warnings Only (#{pages_with_warnings_only.length}):"
+            pages_with_warnings_only.each do |page|
+              view_file = page[:view_file] || page[:path]
+              puts "   • #{view_file}"
+              puts "     Warnings: #{page[:warnings]}"
+              puts "     Path: #{page[:path]}" if page[:view_file] && page[:path] != view_file
+            end
+            puts ""
           end
-          puts ""
         end
         
-        # Show summary of pages that passed
-        pages_passed = results[:pages_tested].select { |p| p[:status] == :passed }
-        if pages_passed.any?
-          if pages_passed.length <= 15
-            puts "✅ Pages Passed All Checks (#{pages_passed.length}):"
-            pages_passed.each do |page|
-              puts "   ✓ #{page[:path]}"
-            end
-          else
-            puts "✅ #{pages_passed.length} pages passed all accessibility checks"
-            puts "   (Showing first 10):"
-            pages_passed.first(10).each do |page|
-              puts "   ✓ #{page[:path]}"
+        # Show summary of pages that passed (only if not errors_only)
+        unless errors_only
+          pages_passed = results[:pages_tested].select { |p| p[:status] == :passed }
+          if pages_passed.any?
+            if pages_passed.length <= 15
+              puts "✅ Pages Passed All Checks (#{pages_passed.length}):"
+              pages_passed.each do |page|
+                puts "   ✓ #{page[:path]}"
+              end
+            else
+              puts "✅ #{pages_passed.length} pages passed all accessibility checks"
+              puts "   (Showing first 10):"
+              pages_passed.first(10).each do |page|
+                puts "   ✓ #{page[:path]}"
+              end
+              puts "   ... and #{pages_passed.length - 10} more"
             end
-            puts "   ... and #{pages_passed.length - 10} more"
+            puts ""
           end
-          puts ""
         end
         
         # Final summary
         puts "="*80
         if results[:total_errors] > 0
           puts "❌ OVERALL STATUS: FAILED - #{results[:total_errors]} error#{'s' if results[:total_errors] != 1} found across #{results[:pages_failed]} page#{'s' if results[:pages_failed] != 1}"
-        elsif results[:total_warnings] > 0
+        elsif !errors_only && results[:total_warnings] > 0
           puts "⚠️  OVERALL STATUS: PASSED WITH WARNINGS - #{results[:total_warnings]} warning#{'s' if results[:total_warnings] != 1} found"
         else
           puts "✅ OVERALL STATUS: PASSED - All #{results[:pages_tested].length} page#{'s' if results[:pages_tested].length != 1} passed accessibility checks!"

data/lib/rails_accessibility_testing/shared_examples.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Shared examples for accessibility testing
 # Automatically available when rails_accessibility_testing is required
 

data/lib/rails_accessibility_testing/static_file_scanner.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'fileutils'
+require_relative 'static_page_adapter'
+require_relative 'engine/rule_engine'
+require_relative 'config/yaml_loader'
+require_relative 'erb_extractor'
+require_relative 'line_number_finder'
+require_relative 'violation_converter'
+
+module RailsAccessibilityTesting
+  # Static file scanner that scans view files directly without visiting pages
+  # Uses the existing RuleEngine and all 11 checks from the checks/ folder
+  # Reports errors with exact file locations and line numbers
+  #
+  # @example
+  #   scanner = StaticFileScanner.new('app/views/pages/home.html.erb')
+  #   result = scanner.scan
+  #   # => { errors: [...], warnings: [...] }
+  #
+  # @api public
+  class StaticFileScanner
+    attr_reader :view_file
+
+    def initialize(view_file)
+      @view_file = view_file
+      @file_content = nil
+    end
+
+    # Scan the view file for accessibility issues using all checks via RuleEngine
+    # @return [Hash] Hash with :errors and :warnings arrays
+    def scan
+      return { errors: [], warnings: [] } unless File.exist?(@view_file)
+
+      @file_content = File.read(@view_file)
+
+      # Extract HTML from ERB template using modular extractor
+      html_content = ErbExtractor.extract_html(@file_content)
+
+      # Create static page adapter (makes Nokogiri look like Capybara)
+      static_page = StaticPageAdapter.new(html_content, view_file: @view_file)
+
+      # Load config and create engine (reuse existing infrastructure)
+      # This automatically loads and runs all 11 checks:
+      # FormLabelsCheck, ImageAltTextCheck, InteractiveElementsCheck,
+      # HeadingCheck, KeyboardAccessibilityCheck, AriaLandmarksCheck,
+      # FormErrorsCheck, TableStructureCheck, DuplicateIdsCheck,
+      # SkipLinksCheck, ColorContrastCheck
+      begin
+        config = Config::YamlLoader.load(profile: :test)
+        engine = Engine::RuleEngine.new(config: config)
+
+        # Context for violations
+        context = {
+          url: nil,
+          path: nil,
+          view_file: @view_file
+        }
+
+        # Run all enabled checks using existing RuleEngine
+        violations = engine.check(static_page, context: context)
+
+        # Convert violations to errors/warnings format with line numbers
+        line_number_finder = LineNumberFinder.new(@file_content)
+        ViolationConverter.convert(
+          violations,
+          view_file: @view_file,
+          line_number_finder: line_number_finder,
+          config: config
+        )
+      rescue StandardError => e
+        # If engine fails, return empty results
+        # Could log error here if needed
+        { errors: [], warnings: [] }
+      end
+    end
+  end
+end
+

data/lib/rails_accessibility_testing/static_page_adapter.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module RailsAccessibilityTesting
+  # Adapter that makes a Nokogiri document look like a Capybara page
+  # This allows existing checks to work with static file scanning
+  class StaticPageAdapter
+    attr_reader :doc, :view_file
+
+    def initialize(html_content, view_file:)
+      @doc = Nokogiri::HTML::DocumentFragment.parse(html_content)
+      @view_file = view_file
+    end
+
+    # Capybara-like interface: page.all('selector', visible: :all)
+    def all(selector, visible: true)
+      elements = @doc.css(selector)
+      # Filter by visibility if needed (for now, return all)
+      elements.map { |el| StaticElementAdapter.new(el, self) }
+    end
+
+    # Capybara-like interface: page.has_css?('selector')
+    def has_css?(selector, wait: true)
+      @doc.css(selector).any?
+    end
+
+    # Capybara-like interface: page.current_url
+    def current_url
+      nil # Not applicable for static files
+    end
+
+    # Capybara-like interface: page.current_path
+    def current_path
+      nil # Not applicable for static files
+    end
+
+    # Get line number for an element (delegated to scanner)
+    def line_number_for(element)
+      # This will be set by the scanner if needed
+      nil
+    end
+  end
+
+  # Adapter that makes a Nokogiri element look like a Capybara element
+  class StaticElementAdapter
+    attr_reader :native, :adapter
+
+    def initialize(nokogiri_element, adapter)
+      @element = nokogiri_element
+      @adapter = adapter
+      @native = nokogiri_element
+    end
+
+    # Capybara-like interface: element.tag_name
+    def tag_name
+      @element.name
+    end
+
+    # Capybara-like interface: element[:id]
+    def [](attribute)
+      @element[attribute]
+    end
+
+    # Capybara-like interface: element.text
+    def text
+      @element.text
+    end
+
+    # Capybara-like interface: element.visible?
+    def visible?
+      # For static scanning, assume all elements are visible
+      # Could be enhanced to check CSS display/visibility
+      true
+    end
+
+    # Capybara-like interface: element.find(:xpath, '..')
+    def find(selector_type, xpath)
+      if selector_type == :xpath && xpath == '..'
+        parent = @element.parent
+        return StaticElementAdapter.new(parent, @adapter) if parent && parent.element?
+        nil
+      end
+      nil
+    rescue StandardError
+      nil
+    end
+
+    # Get line number for this element
+    def line_number
+      @adapter.line_number_for(@element)
+    end
+
+    # Convert to HTML string
+    def to_html
+      @element.to_html
+    end
+
+    # Support for native.attribute() calls used by checks
+    def native
+      NativeWrapper.new(@element)
+    end
+
+    # Wrapper for native element attribute access
+    class NativeWrapper
+      def initialize(element)
+        @element = element
+      end
+
+      def attribute(name)
+        @element[name]
+      end
+    end
+  end
+end
+