a11y-lint 0.7.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcce561f67949c3ba5eb95447325e06ce67c2e759733c0623168ce5948183222
-  data.tar.gz: 59a739dcb7b14d79d2b8c7a4bb135853c04f3f1e79558cf8ddc05c0435c52a18
+  metadata.gz: ecfe715cda47636bb8dc87f9cf3655c641d33d2e10cfd8471be73b2dd7336a1f
+  data.tar.gz: 818bb7d22993ac9036ac148d60adce32c2ef7ee342bc741bbd8e64d893414d2f
 SHA512:
-  metadata.gz: d03e078e621d82b48f114f6f8a2ecfa7bf05f746892bf5640c6ee5e5817ac740ee086ddb6dab3a7c993436d653bbd38f15967696a58f41802d335a67a22ab2ea
-  data.tar.gz: 1a07a2c565896cde540e09adc8352602166ce7da1ecdcb555c52220a8fc764504abab43bf17ebefb0fe436ca4cff3835d9bae355fd620d08b3f64c6dcf83d291
+  metadata.gz: 3a0d354908cfc0c670db3556f0854e1e91f0486ae502ff6f93395a95923d1a6b7b456bd625ffb476ba8f7e8d3f8bea5f859ed4875e0cf172770be5e87da8517f
+  data.tar.gz: e0e5e582649edc60f0df35635af190beb49b2ab69c9da392e9ae31326918c6704962b5a5cd6d60f8e1bb8bf47474a9d4b2fdb18baf424f3013871a7d3cc17a10

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.3
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
@@ -13,6 +13,12 @@ Layout/LineLength:
     - "a11y-lint.gemspec"
 
 Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/AbcSize:
   Exclude:
     - "test/**/*"
 

data/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-04-15
+
+### Changed
+
+- Introduce `A11y::Lint::CallNode` wrapper so rules express accessibility logic, not AST traversal
+- Expose Prism `CallNode` from `SlimNode` and `ErbNode` via the new `RubyCode` parser
+- Expose Prism `CallNode` from `PhlexNode` instead of converting to string
+- Extract Phlex HTML tag constants into `PhlexTags` module
+
+## [0.9.0] - 2026-04-15
+
+### Changed
+
+- **Breaking:** Require Ruby >= 3.3.0 (was 3.1.0). Prism ships with Ruby 3.3+ as a bundled gem
+- **Breaking:** `slim` is now an optional dependency. Add `gem "slim"` to your Gemfile if you lint `.slim` files. A `SlimLoadError` is raised with a helpful message if the gem is missing
+- `prism` is no longer a declared dependency (bundled with Ruby 3.3+)
+- Replace Ripper with Prism for Ruby code parsing in `ImageTagMissingAlt` and `MissingAccessibleName` rules
+- Custom error classes are now defined in `lib/a11y/lint/errors.rb`
+
+### Fixed
+
+- `MissingAccessibleName`: fix false positive when block contains visible text or HTML tags (e.g. `link_to do` with a `span` or plain text inside)
+- Add `block_body_codes` and `block_has_text_children?` to all three node types (Slim, ERB, Phlex) so block content inspection works across all pipelines
+
+## [0.8.0] - 2026-04-14
+
+### Added
+
+- Phlex view support: scans `.rb` files containing Phlex components
+  - Detects Phlex files by the presence of a `def view_template` method
+  - All existing rules (`ImgMissingAlt`, `ImageTagMissingAlt`, `ListInvalidChildren`, `MissingAccessibleName`) work with Phlex views
+  - CLI automatically discovers `.rb` files when scanning directories
+
+### Changed
+
+- **Breaking:** `Node` has been renamed to `SlimNode` for consistency with `ErbNode` and `PhlexNode`
+
+### Dependencies
+
+- Added `prism` gem for Ruby AST parsing
+
 ## [0.7.2] - 2026-04-13
 
 ### Fixed

data/CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-a11y-lint is a Ruby gem (v0.1.0) for accessibility linting. It uses the `A11y::Lint` module namespace. Requires Ruby >= 3.1.0.
+a11y-lint is a Ruby gem (v0.1.0) for accessibility linting. It uses the `A11y::Lint` module namespace. Requires Ruby >= 3.3.0.
 
 ## Commands
 
@@ -19,19 +19,21 @@ a11y-lint is a Ruby gem (v0.1.0) for accessibility linting. It uses the `A11y::L
 
 ## Architecture
 
-- **CLI:** `lib/a11y/lint/cli.rb` — command-line interface; executable at `exe/a11y-lint`; routes `.slim` files to `SlimRunner` and `.erb` files to `ErbRunner`
+- **CLI:** `lib/a11y/lint/cli.rb` — command-line interface; executable at `exe/a11y-lint`; routes `.slim` files to `SlimRunner`, `.erb` files to `ErbRunner`, and `.rb` files to `PhlexRunner`
 - **Entry point:** `lib/a11y/lint.rb` — defines the `A11y::Lint` module and `A11y::Lint::Error` exception
-- **Slim pipeline:** `SlimRunner` parses Slim templates via `Slim::Parser`; `Node` wraps Slim S-expressions
+- **Slim pipeline:** `SlimRunner` parses Slim templates via `Slim::Parser`; `SlimNode` wraps Slim S-expressions
 - **ERB pipeline:** `ErbRunner` parses ERB templates via Nokogiri; `ErbNode` wraps Nokogiri nodes and extracted `<%= %>` Ruby code
+- **Phlex pipeline:** `PhlexRunner` parses Phlex view classes via Prism; `PhlexNode` wraps Prism AST call nodes; detects Phlex files by the presence of `def view_template`
+- **Ruby code parsing:** `RubyCode` (`lib/a11y/lint/ruby_code.rb`) — parses a Ruby code string once with Prism and exposes the resulting `CallNode`; used by `SlimNode` and `ErbNode` so rules work against a parsed AST instead of re-parsing strings
 - **Configuration:** `lib/a11y/lint/configuration.rb` — loads `.a11y-lint.yml` to enable/disable individual rules; searches upward from the target path
-- **Rules:** `lib/a11y/lint/rules/` — organized by WCAG principle (`perceivable/`, `operable/`, `understandable/`, `robust/`); rules implement `check(node)` against the shared node interface (`tag_name`, `attribute?`, `attributes`, `ruby_code`, `line`)
+- **Rules:** `lib/a11y/lint/rules/` — organized by WCAG principle (`perceivable/`, `operable/`, `understandable/`, `robust/`); rules implement `check(node)` against the shared node interface (`tag_name`, `attribute?`, `attributes`, `call_node`, `line`)
 - **Version:** `lib/a11y/lint/version.rb`
 - **Type signatures (RBS):** `sig/a11y/lint.rbs`
 - **Tests:** `test/` directory using Minitest; test helper at `test/test_helper.rb`
-- **Dummy app:** `test/fixtures/dummy_app/` — a fixture app with Slim/ERB templates for end-to-end smoke testing before releases (`bundle exec a11y-lint test/fixtures/dummy_app`)
+- **Dummy app:** `test/fixtures/dummy_app/` — a fixture app with Slim/ERB/Phlex templates for end-to-end smoke testing before releases (`bundle exec a11y-lint test/fixtures/dummy_app`)
 
 ## Code Style
 
 RuboCop is configured in `.rubocop.yml`:
-- Target Ruby version: 3.1
+- Target Ruby version: 3.3
 - Enforces double quotes for strings

data/README.md

@@ -33,7 +33,7 @@ a11y-lint app/views/
 a11y-lint app/views/home.html.slim app/views/about.html.slim
 ```
 
-With no arguments, it scans the current directory recursively for `.slim` and `.erb` files:
+With no arguments, it scans the current directory recursively for `.slim`, `.erb`, and `.rb` (Phlex) files:
 
 ```bash
 a11y-lint
@@ -64,10 +64,21 @@ a11y-lint --config path/to/.a11y-lint.yml app/views/
 ```ruby
 require "a11y/lint"
 
+# Slim
 source = File.read("app/views/home.html.slim")
-runner = A11y::Lint::SlimRunner.new([A11y::Lint::Rules::ImgMissingAlt.new])
+runner = A11y::Lint::SlimRunner.new([A11y::Lint::Rules::ImgMissingAlt])
 offenses = runner.run(source, filename: "app/views/home.html.slim")
 
+# ERB
+source = File.read("app/views/home.html.erb")
+runner = A11y::Lint::ErbRunner.new([A11y::Lint::Rules::ImgMissingAlt])
+offenses = runner.run(source, filename: "app/views/home.html.erb")
+
+# Phlex
+source = File.read("app/views/home_view.rb")
+runner = A11y::Lint::PhlexRunner.new([A11y::Lint::Rules::ImgMissingAlt])
+offenses = runner.run(source, filename: "app/views/home_view.rb")
+
 offenses.each do |offense|
   puts "#{offense.filename}:#{offense.line} [#{offense.rule}] #{offense.message}"
 end

data/lib/a11y/lint/block_inspection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module A11y
+  module Lint
+    # Shared block-content queries for node types.
+    # Depends on the host class implementing
+    # #block_has_text_children? and #block_body_codes.
+    module BlockInspection
+      ICON_HELPERS = %w[inline_svg icon image_tag svg_icon].freeze
+
+      def block_has_only_icon_helpers?
+        return false if block_has_text_children?
+
+        codes = block_body_codes
+        return true unless codes&.any?
+
+        codes.all? { |code| icon_helper_call?(code) }
+      end
+
+      private
+
+      def icon_helper_call?(code)
+        call = RubyCode.new(code).call_node
+        call && ICON_HELPERS.include?(call.method_name)
+      end
+    end
+  end
+end

data/lib/a11y/lint/call_node.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module A11y
+  module Lint
+    # Wraps a Prism::CallNode with a rule-friendly query API.
+    class CallNode
+      attr_reader :prism_node
+
+      def initialize(prism_node)
+        @prism_node = prism_node
+      end
+
+      def method_name
+        @prism_node.name.to_s
+      end
+
+      # Checks for a keyword argument by name.
+      #   keyword?(:alt)          => alt: or "alt" =>
+      #   keyword?(:aria, :label) => aria: { label: ... }
+      #   keyword?(:"aria-label") => "aria-label" =>
+      def keyword?(*keys)
+        return false unless (kw_hash = find_keyword_hash)
+
+        if keys.length == 1
+          flat_keyword?(kw_hash, keys[0])
+        else
+          nested_keyword?(kw_hash, keys[0], keys[1])
+        end
+      end
+
+      def positional_args
+        return [] unless @prism_node.arguments
+
+        @prism_node.arguments.arguments.reject do |a|
+          a.is_a?(Prism::KeywordHashNode)
+        end
+      end
+
+      def first_positional_arg_empty_string?
+        first = positional_args.first
+        first.is_a?(Prism::StringNode) && first.unescaped.empty?
+      end
+
+      def block?
+        !@prism_node.block.nil?
+      end
+
+      # Finds a receiverless call by method name in this node's
+      # subtree (including self). Returns a CallNode or nil.
+      def find(name)
+        found = search_for_call(@prism_node, name)
+        found ? self.class.new(found) : nil
+      end
+
+      private
+
+      def flat_keyword?(kw_hash, key)
+        kw_hash.elements.any? do |assoc|
+          key_name(assoc) == key.to_s
+        end
+      end
+
+      def nested_keyword?(kw_hash, outer_key, inner_key)
+        assoc = kw_hash.elements.find do |a|
+          key_name(a) == outer_key.to_s
+        end
+        return false unless assoc&.value.is_a?(Prism::HashNode)
+
+        assoc.value.elements.any? do |inner|
+          key_name(inner) == inner_key.to_s
+        end
+      end
+
+      def find_keyword_hash
+        return unless @prism_node.arguments
+
+        @prism_node.arguments.arguments.find do |arg|
+          arg.is_a?(Prism::KeywordHashNode)
+        end
+      end
+
+      def key_name(assoc)
+        return unless assoc.is_a?(Prism::AssocNode)
+
+        case assoc.key
+        when Prism::SymbolNode then assoc.key.unescaped
+        when Prism::StringNode then assoc.key.unescaped
+        end
+      end
+
+      def search_for_call(node, name)
+        if node.is_a?(Prism::CallNode) &&
+           node.receiver.nil? &&
+           node.name.to_s == name
+          return node
+        end
+
+        node.child_nodes.compact.each do |child|
+          found = search_for_call(child, name)
+          return found if found
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/a11y/lint/cli.rb

@@ -4,8 +4,7 @@ require "optparse"
 
 module A11y
   module Lint
-    # Command-line interface for running accessibility
-    # linting on Slim templates.
+    # Command-line interface for running accessibility linting.
     class CLI
       def initialize(argv, stdout: $stdout, stderr: $stderr)
         @argv = argv
@@ -19,7 +18,7 @@ module A11y
         files = resolve_files(@argv)
 
         if files.empty?
-          @stderr.puts("No .slim or .erb files found")
+          @stderr.puts("No .slim, .erb, or .rb files found")
           return 0
         end
 
@@ -62,7 +61,7 @@ module A11y
 
       def expand_path(path)
         if File.directory?(path)
-          Dir.glob(File.join(path, "**", "*.{slim,erb}"))
+          Dir.glob(File.join(path, "**", "*.{slim,erb,rb}"))
         elsif File.file?(path)
           [path]
         else
@@ -75,14 +74,23 @@ module A11y
         rules = all_rules
         slim_runner = SlimRunner.new(rules)
         erb_runner = ErbRunner.new(rules)
+        phlex_runner = PhlexRunner.new(rules)
 
         files.flat_map do |file|
           source = File.read(file)
-          runner = file.end_with?(".erb") ? erb_runner : slim_runner
+          runner = runner_for(file, slim_runner, erb_runner, phlex_runner)
           runner.run(source, filename: file)
         end
       end
 
+      def runner_for(file, slim_runner, erb_runner, phlex_runner)
+        case File.extname(file)
+        when ".erb" then erb_runner
+        when ".rb" then phlex_runner
+        else slim_runner
+        end
+      end
+
       def all_rules
         configuration = Configuration.load(
           @config_path,

data/lib/a11y/lint/erb_node.rb

@@ -5,16 +5,26 @@ module A11y
     # Wraps a Nokogiri node or extracted ERB output tag
     # as a queryable node for lint rules.
     class ErbNode
-      attr_reader :line
+      include BlockInspection
 
-      def initialize(line:, nokogiri_node: nil, ruby_code: nil)
-        @nokogiri_node = nokogiri_node
-        @ruby_code_string = ruby_code
+      attr_reader(:block_body_codes, :line, :ruby_code)
+
+      def initialize(
+        line:,
+        block_body_codes: nil,
+        block_has_text_children: false,
+        nokogiri_node: nil,
+        ruby_code: nil
+      )
         @line = line
+        @block_body_codes = block_body_codes
+        @block_has_text_children = block_has_text_children
+        @nokogiri_node = nokogiri_node
+        @ruby_code = ruby_code
       end
 
       def tag_name
-        @nokogiri_node&.name
+        nokogiri_node&.name
       end
 
       def attribute?(name)
@@ -25,25 +35,31 @@ module A11y
         @attributes ||= extract_attributes
       end
 
-      def ruby_code
-        @ruby_code_string
+      def call_node
+        @call_node ||= RubyCode.new(ruby_code).call_node
+      end
+
+      def block_has_text_children?
+        @block_has_text_children
       end
 
       # Returns direct element children wrapped as ErbNode objects.
       def children
-        return [] unless @nokogiri_node
+        return [] unless nokogiri_node
 
-        @nokogiri_node.element_children.map do |child|
+        nokogiri_node.element_children.map do |child|
           ErbNode.new(nokogiri_node: child, line: child.line)
         end
       end
 
       private
 
+      attr_reader(:nokogiri_node)
+
       def extract_attributes
-        return {} unless @nokogiri_node
+        return {} unless nokogiri_node
 
-        @nokogiri_node
+        nokogiri_node
           .attributes
           .each_with_object({}) do |(name, _attr), result|
             result[name] = true

data/lib/a11y/lint/erb_runner.rb

@@ -53,12 +53,38 @@ module A11y
         source.scan(ERB_OUTPUT_TAG) do
           match = Regexp.last_match
           code = match[1]
-          line_number = source[0...match.begin(0)].count("\n") + 1
-          node = ErbNode.new(ruby_code: code, line: line_number)
-          check_node(node)
+          line = source[0...match.begin(0)].count("\n") + 1
+          check_node(
+            build_erb_output_node(source, code, line, match.end(0))
+          )
         end
       end
 
+      def build_erb_output_node(source, code, line, match_end)
+        block_body_codes, block_has_text =
+          extract_block_info(source, code, match_end)
+
+        ErbNode.new(
+          ruby_code: code, line: line,
+          block_body_codes: block_body_codes,
+          block_has_text_children: block_has_text
+        )
+      end
+
+      def extract_block_info(source, code, match_end)
+        return [nil, false] unless code.match?(/\s+do\s*\z/)
+
+        rest = source[match_end..]
+        end_match = rest.match(/<%-?\s*end\s*-?%>/m)
+        return [nil, false] unless end_match
+
+        block_content = rest[0...end_match.begin(0)]
+        codes = block_content.scan(ERB_OUTPUT_TAG).map { |m| m[0].strip }
+        text_only = block_content.gsub(ERB_TAG, "").strip
+
+        [codes, !text_only.empty?]
+      end
+
       def check_node(node)
         rules.each do |rule_class|
           message = rule_class.check(node)

data/lib/a11y/lint/errors.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module A11y
+  module Lint
+    class Error < StandardError; end
+
+    # Raised when slim is not installed.
+    class SlimLoadError < Error
+      def initialize
+        super(
+          "a11y-lint needs the `slim` gem to lint .slim files. " \
+          "Add `gem \"slim\"` to your Gemfile."
+        )
+      end
+    end
+  end
+end

data/lib/a11y/lint/phlex_node.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module A11y
+  module Lint
+    # Wraps a Phlex HTML tag call or helper method call
+    # as a queryable node for lint rules.
+    class PhlexNode
+      include BlockInspection
+      extend PhlexTags
+
+      attr_reader(
+        :attributes,
+        :block_body_codes,
+        :call_node,
+        :children,
+        :line,
+        :tag_name
+      )
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(
+        line:, tag_name: nil, attributes: {},
+        call_node: nil, children: [],
+        block_body_codes: nil,
+        block_has_text_children: false
+      )
+        @tag_name = tag_name
+        @attributes = attributes
+        @call_node = call_node
+        @line = line
+        @children = children
+        @block_body_codes = block_body_codes
+        @block_has_text_children = block_has_text_children
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def ruby_code
+        nil
+      end
+
+      def attribute?(name)
+        attributes.key?(name)
+      end
+
+      def block_has_text_children?
+        @block_has_text_children
+      end
+
+      def self.build_tag(call_node, children: [])
+        name = call_node.name.to_s
+        new(
+          tag_name: html_tag_name(name),
+          attributes: extract_attributes(call_node),
+          line: call_node.location.start_line,
+          children: children
+        )
+      end
+
+      def self.build_helper(
+        call_node,
+        block_body_codes: nil,
+        block_has_text_children: false
+      )
+        new(
+          call_node: CallNode.new(call_node),
+          line: call_node.location.start_line,
+          block_body_codes: block_body_codes,
+          block_has_text_children: block_has_text_children
+        )
+      end
+
+      def self.extract_attributes(call_node)
+        return {} unless call_node.arguments
+
+        kwarg_nodes(call_node).each_with_object({}) do |elem, h|
+          key = kwarg_key(elem.key)
+          h[key] = true if key
+        end
+      end
+
+      def self.kwarg_nodes(call_node)
+        args = call_node.arguments.arguments
+        args.select { |a| a.is_a?(Prism::KeywordHashNode) }
+            .flat_map { |a| a.elements.select { |e| e.is_a?(Prism::AssocNode) } }
+      end
+
+      def self.kwarg_key(key_node)
+        case key_node
+        when Prism::SymbolNode then key_node.value
+        when Prism::StringNode then key_node.unescaped
+        end
+      end
+
+      private_class_method :kwarg_key, :kwarg_nodes,
+                           :extract_attributes
+    end
+  end
+end