a11y-lint 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0d462b5e30cff7f4b1c5adaa3eeb9d2ac1a1aa9d3dad477b1841e38e271f22a
-  data.tar.gz: 66d8731b7371b98e4fede0445536d994fcd3405721dfb0617f1c139bd5fce925
+  metadata.gz: ecfe715cda47636bb8dc87f9cf3655c641d33d2e10cfd8471be73b2dd7336a1f
+  data.tar.gz: 818bb7d22993ac9036ac148d60adce32c2ef7ee342bc741bbd8e64d893414d2f
 SHA512:
-  metadata.gz: 6459a600d8cbd2465d5a9096eb99e36f319d1576cc685273b78505c636c15f77590104eec89ff4142d6525f70d5fc861822837fdf55cca9ed1afbad9a20011b5
-  data.tar.gz: 3c22904b9d168f559b9bc83522e1a5422fad6f2dd3d5beffd158ad06135ef6dacc85fdf3d832970b330ed1f4fd25c68a41b3bd8a34ef57ca6df8c2211a694dca
+  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

@@ -5,6 +5,32 @@ 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.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [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

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
 
@@ -24,8 +24,9 @@ a11y-lint is a Ruby gem (v0.1.0) for accessibility linting. It uses the `A11y::L
 - **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`
@@ -34,5 +35,5 @@ a11y-lint is a Ruby gem (v0.1.0) for accessibility linting. It uses the `A11y::L
 ## Code Style
 
 RuboCop is configured in `.rubocop.yml`:
-- Target Ruby version: 3.1
+- Target Ruby version: 3.3
 - Enforces double quotes for strings

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

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

@@ -5,66 +5,45 @@ module A11y
     # Wraps a Phlex HTML tag call or helper method call
     # as a queryable node for lint rules.
     class PhlexNode
-      attr_reader :line, :children
-
-      # Phlex method names that map to a different HTML tag.
-      TAG_ALIASES = {
-        "ruby_element" => "ruby",
-        "template_tag" => "template"
-      }.freeze
-
-      HTML_TAGS = Set.new(
-        %w[
-          a abbr address article aside b bdi bdo
-          blockquote body br button caption cite code
-          col colgroup data datalist dd del details dfn
-          dialog div dl dt em embed fieldset figcaption
-          figure footer form h1 h2 h3 h4 h5 h6 head
-          header hgroup hr html i iframe img input ins
-          kbd label legend li link main map mark menu
-          meter nav noscript object ol optgroup option
-          output p picture pre progress q rp rt
-          ruby_element s samp script search section
-          select slot small span strong style sub
-          summary sup table tbody td template_tag
-          textarea tfoot th thead time title tr u ul
-          var video wbr
-        ]
-      ).freeze
+      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: {}, ruby_code: nil, children: []
+        line:, tag_name: nil, attributes: {},
+        call_node: nil, children: [],
+        block_body_codes: nil,
+        block_has_text_children: false
       )
-        @tag_name_string = tag_name
-        @attributes_hash = attributes
-        @ruby_code_string = ruby_code
+        @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
-
-      def tag_name
-        @tag_name_string
-      end
-
-      def attribute?(name)
-        @attributes_hash.key?(name)
-      end
-
-      def attributes
-        @attributes_hash
-      end
+      # rubocop:enable Metrics/ParameterLists
 
       def ruby_code
-        @ruby_code_string
+        nil
       end
 
-      def self.html_tag?(method_name)
-        HTML_TAGS.include?(method_name)
+      def attribute?(name)
+        attributes.key?(name)
       end
 
-      def self.html_tag_name(method_name)
-        TAG_ALIASES.fetch(method_name, method_name)
+      def block_has_text_children?
+        @block_has_text_children
       end
 
       def self.build_tag(call_node, children: [])
@@ -77,10 +56,16 @@ module A11y
         )
       end
 
-      def self.build_helper(call_node, source)
+      def self.build_helper(
+        call_node,
+        block_body_codes: nil,
+        block_has_text_children: false
+      )
         new(
-          ruby_code: ruby_code_for(call_node, source),
-          line: call_node.location.start_line
+          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
 
@@ -106,16 +91,7 @@ module A11y
         end
       end
 
-      def self.ruby_code_for(call_node, source)
-        return call_node.slice unless call_node.block
-
-        stop = call_node.block.location.start_offset
-        start = call_node.location.start_offset
-        "#{source[start...stop].rstrip} do"
-      end
-
       private_class_method :kwarg_key, :kwarg_nodes,
-                           :ruby_code_for,
                            :extract_attributes
     end
   end

data/lib/a11y/lint/phlex_runner.rb

@@ -37,8 +37,7 @@ module A11y
       end
 
       def process_call(node)
-        name = node.name.to_s
-        if PhlexNode.html_tag?(name)
+        if PhlexNode.html_tag?(node.name.to_s)
           check_tag(node)
         else
           check_helper(node)
@@ -51,16 +50,20 @@ module A11y
       end
 
       def check_helper(node)
-        check_node(PhlexNode.build_helper(node, @source))
+        codes, has_text = analyze_helper_block(node)
+        helper = PhlexNode.build_helper(
+          node,
+          block_body_codes: codes,
+          block_has_text_children: has_text
+        )
+        check_node(helper)
         walk_block(node.block)
       end
 
       def collect_block_children(block)
         return [] unless block.is_a?(Prism::BlockNode)
 
-        children = []
-        gather_children(block, children)
-        children
+        [].tap { |c| gather_children(block, c) }
       end
 
       def gather_children(parent, result)
@@ -77,11 +80,32 @@ module A11y
 
       def gather_tag_child(child, result)
         kids = collect_block_children(child.block)
-        node = PhlexNode.build_tag(child, children: kids)
-        result << node
-        check_node(node)
+        result << PhlexNode.build_tag(child, children: kids)
+        check_node(result.last)
       end
 
+      def analyze_helper_block(call_node)
+        block = call_node.block
+        return [nil, false] unless block.is_a?(Prism::BlockNode)
+
+        codes = []
+        has_text = scan_block_content(block, codes)
+        [codes.empty? ? nil : codes, has_text]
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def scan_block_content(node, codes)
+        node.child_nodes.compact.each do |child|
+          return true if child.is_a?(Prism::YieldNode)
+          return true if tag_call?(child) && child.block
+          next if tag_call?(child)
+          next codes << child.slice if receiverless_call?(child)
+          return true if scan_block_content(child, codes)
+        end
+        false
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
       def walk_block(block)
         return unless block.is_a?(Prism::BlockNode)
 
@@ -89,8 +113,7 @@ module A11y
       end
 
       def tag_call?(node)
-        receiverless_call?(node) &&
-          PhlexNode.html_tag?(node.name.to_s)
+        receiverless_call?(node) && PhlexNode.html_tag?(node.name.to_s)
       end
 
       def receiverless_call?(node)
@@ -103,10 +126,8 @@ module A11y
           next unless message
 
           @offenses << Offense.new(
-            rule: rule_class.rule_name,
-            filename: @filename,
-            line: node.line,
-            message: message
+            rule: rule_class.rule_name, filename: @filename,
+            line: node.line, message: message
           )
         end
       end

data/lib/a11y/lint/phlex_tags.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module A11y
+  module Lint
+    # Maps Phlex method names to their HTML tag equivalents.
+    module PhlexTags
+      # Phlex method names that map to a different HTML tag.
+      TAG_ALIASES = {
+        "ruby_element" => "ruby",
+        "template_tag" => "template"
+      }.freeze
+
+      HTML_TAGS = Set.new(
+        %w[
+          a
+          abbr
+          address
+          article
+          aside
+          b
+          bdi
+          bdo
+          blockquote
+          body
+          br
+          button
+          caption
+          cite
+          code
+          col
+          colgroup
+          data
+          datalist
+          dd
+          del
+          details
+          dfn
+          dialog
+          div
+          dl
+          dt
+          em
+          embed
+          fieldset
+          figcaption
+          figure
+          footer
+          form
+          h1
+          h2
+          h3
+          h4
+          h5
+          h6
+          head
+          header
+          hgroup
+          hr
+          html
+          i
+          iframe
+          img
+          input
+          ins
+          kbd
+          label
+          legend
+          li
+          link
+          main
+          map
+          mark
+          menu
+          meter
+          nav
+          noscript
+          object
+          ol
+          optgroup
+          option
+          output
+          p
+          picture
+          pre
+          progress
+          q
+          rp
+          rt
+          ruby_element
+          s
+          samp
+          script
+          search
+          section
+          select
+          slot
+          small
+          span
+          strong
+          style
+          sub
+          summary
+          sup
+          table
+          tbody
+          td
+          template_tag
+          textarea
+          tfoot
+          th
+          thead
+          time
+          title
+          tr
+          u
+          ul
+          var
+          video
+          wbr
+        ]
+      ).freeze
+
+      def html_tag?(method_name)
+        HTML_TAGS.include?(method_name)
+      end
+
+      def html_tag_name(method_name)
+        TAG_ALIASES.fetch(method_name, method_name)
+      end
+    end
+  end
+end

data/lib/a11y/lint/ruby_code.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module A11y
+  module Lint
+    # Represents a Ruby code string extracted from a template.
+    # Parses the code with Prism and exposes the resulting CallNode.
+    class RubyCode
+      def initialize(code)
+        @code = code
+      end
+
+      # Returns the Prism::CallNode for the outermost receiverless
+      # method call in the code, or nil if none exists.
+      def call_node
+        @call_node ||= parse
+      end
+
+      private
+
+      attr_reader(:code)
+
+      # Parses the code string into a Prism AST and returns the first
+      # receiverless CallNode, or nil if the code is empty, invalid,
+      # or contains no method calls (e.g. a plain variable or literal).
+      def parse
+        return if code.nil? || code.empty?
+        return unless prism_parse_result.success?
+
+        prism_node = find_receiverless_call(prism_parse_result.value)
+        prism_node ? CallNode.new(prism_node) : nil
+      end
+
+      # Walks the Prism AST to find the first method call without a
+      # receiver (e.g. `link_to(...)` rather than `obj.link_to(...)`).
+      # Rails helper calls in templates are always receiverless.
+      def find_receiverless_call(node)
+        return node if node.is_a?(Prism::CallNode) && node.receiver.nil?
+
+        node.child_nodes.compact.each do |child|
+          found = find_receiverless_call(child)
+          return found if found
+        end
+        nil
+      end
+
+      # Prism.parse returns a Prism::ParseResult which contains the
+      # AST (via .value) and whether the parse succeeded (via .success?).
+      # The AST is always present since Prism does error-tolerant parsing.
+      def prism_parse_result
+        @prism_parse_result ||= Prism.parse(source)
+      end
+
+      # Slim/ERB block forms end with ` do` (e.g. `link_to("#") do`)
+      # which isn't valid Ruby on its own. Appending `\nend` makes it
+      # parseable and gives the resulting CallNode a `.block` attribute.
+      def source
+        if code.match?(/\s+do\s*\z/)
+          "#{code}\nend"
+        else
+          code
+        end
+      end
+    end
+  end
+end

data/lib/a11y/lint/rule.rb

@@ -19,6 +19,10 @@ module A11y
       def check
         raise NotImplementedError
       end
+
+      private
+
+      attr_reader(:node)
     end
   end
 end

data/lib/a11y/lint/rules/perceivable/image_tag_missing_alt.rb

@@ -1,88 +1,24 @@
 # frozen_string_literal: true
 
-require "ripper"
-
 module A11y
   module Lint
     module Rules
       # Checks that image_tag calls include an alt option (WCAG 1.1.1).
       class ImageTagMissingAlt < Rule
         def check
-          return unless an_image_tag_without_an_alt_attribute?
+          return if no_offense?
 
           "image_tag is missing an alt option (WCAG 1.1.1)"
         end
 
         private
 
-        def an_image_tag_without_an_alt_attribute?
-          code = @node.ruby_code
-          return false unless code
-
-          sexp = Ripper.sexp(code)
-          return false unless sexp
-
-          call = extract_image_tag_call(sexp)
-          call && !alt_key_within?(call)
-        end
-
-        # Walks the Ripper S-expression tree to find
-        # the image_tag call node, if present.
-        def extract_image_tag_call(sexp)
-          return unless sexp.is_a?(Array)
-          return sexp if image_tag_call?(sexp)
-
-          sexp.each do |child|
-            result = extract_image_tag_call(child)
-            return result if result
-          end
-
-          nil
-        end
-
-        # Matches both calling styles:
-        #   image_tag "photo.jpg"  => :command
-        #   image_tag("photo.jpg") => :method_add_arg
-        def image_tag_call?(sexp)
-          case sexp
-          in [:command, [:@ident, "image_tag", *], *] then true
-          in [:method_add_arg, [:fcall, [:@ident, "image_tag", *]], *] then true
-          else false
-          end
-        end
-
-        # Recursively searches the sexp for an
-        # :assoc_new node whose key is "alt".
-        def alt_key_within?(sexp)
-          return true if alt_key?(sexp)
-          return false unless sexp.is_a?(Array)
-
-          sexp.any? { |child| alt_key_within?(child) }
-        end
-
-        # Checks if a sexp is a hash pair (assoc_new)
-        # with "alt" as the key.
-        def alt_key?(sexp)
-          return false unless sexp.is_a?(Array) && sexp[0] == :assoc_new
-
-          alt_key_value?(sexp[1])
-        end
-
-        def alt_key_value?(key)
-          alt_symbol_key?(key) || alt_string_key?(key)
-        end
-
-        # Matches symbol-style key: `alt: "..."`
-        def alt_symbol_key?(key)
-          key in [:@label, "alt:", *]
+        def no_offense?
+          !image_tag || image_tag.keyword?(:alt)
         end
 
-        # Matches string-style key: `"alt" => "..."`
-        def alt_string_key?(key)
-          key in [
-            :string_literal,
-            [:string_content, [:@tstring_content, "alt", *]]
-          ]
+        def image_tag
+          @image_tag ||= node.call_node&.find("image_tag")
         end
       end
     end

data/lib/a11y/lint/rules/robust/missing_accessible_name.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ripper"
-
 module A11y
   module Lint
     module Rules
@@ -11,120 +9,37 @@ module A11y
         METHODS = %w[link_to external_link_to button_tag].freeze
 
         def check
-          return unless (code = @node.ruby_code)
-
-          clean_code = code.sub(/\s+do\s*\z/, "")
-          is_block = clean_code != code
-          call = parse_call(clean_code)
-          return unless call
-          return if aria_label_within?(call)
-          return unless first_arg_empty_string?(call) || is_block
+          return if no_offense?
 
-          offense_message(extract_method_name(call))
+          offense_message(helper_call.method_name)
         end
 
         private
 
-        def offense_message(method_name)
-          <<~MSG.strip
-            #{method_name} missing an accessible name \
-            requires an aria-label (WCAG 4.1.2)
-          MSG
+        def no_offense?
+          !helper_call ||
+            aria_label? ||
+            !(helper_call.first_positional_arg_empty_string? ||
+              (helper_call.block? && node.block_has_only_icon_helpers?))
         end
 
-        def parse_call(code)
-          sexp = Ripper.sexp(code)
-          return unless sexp
-
-          extract_matching_call(sexp)
+        def aria_label?
+          helper_call.keyword?(:aria, :label) ||
+            helper_call.keyword?(:"aria-label")
         end
 
-        def extract_matching_call(sexp)
-          return unless sexp.is_a?(Array)
-          return sexp if matching_call?(sexp)
-
-          sexp.each do |child|
-            result = extract_matching_call(child)
-            return result if result
+        def helper_call
+          @helper_call ||= begin
+            call = node.call_node
+            call if call && METHODS.include?(call.method_name)
           end
-
-          nil
         end
 
-        def matching_call?(sexp)
-          name = call_method_name(sexp)
-          name ? METHODS.include?(name) : false
-        end
-
-        def call_method_name(sexp)
-          case sexp
-          in [:command, [:@ident, name, *], *]
-            name
-          in [:method_add_arg,
-              [:fcall, [:@ident, name, *]], *]
-            name
-          else nil
-          end
-        end
-
-        def extract_method_name(call)
-          call_method_name(call)
-        end
-
-        def first_arg_empty_string?(call)
-          args = extract_args(call)
-          return false unless args&.first
-
-          args.first in [:string_literal, [:string_content]]
-        end
-
-        def extract_args(call)
-          case call
-          in [:command, _, [:args_add_block, args, *]] then args
-          in [:method_add_arg, _,
-             [:arg_paren, [:args_add_block, args, *]]]
-            then args
-          in [:method_add_arg, _, [:arg_paren, Array => args]] then args
-          else nil
-          end
-        end
-
-        def aria_label_within?(sexp)
-          return true if aria_hash_with_label?(sexp)
-          return true if aria_label_string_key?(sexp)
-          return false unless sexp.is_a?(Array)
-
-          sexp.any? { |child| aria_label_within?(child) }
-        end
-
-        def aria_hash_with_label?(sexp)
-          return false unless sexp.is_a?(Array) && sexp[0] == :assoc_new
-
-          key = sexp[1]
-          value = sexp[2]
-
-          (key in [:@label, "aria:", *]) && label_key_within?(value)
-        end
-
-        def label_key_within?(sexp)
-          return true if label_key?(sexp)
-          return false unless sexp.is_a?(Array)
-
-          sexp.any? { |child| label_key_within?(child) }
-        end
-
-        def label_key?(sexp)
-          sexp.is_a?(Array) &&
-            sexp[0] == :assoc_new &&
-            (sexp[1] in [:@label, "label:", *])
-        end
-
-        def aria_label_string_key?(sexp)
-          return false unless sexp.is_a?(Array) && sexp[0] == :assoc_new
-
-          sexp[1] in [:string_literal,
-            [:string_content,
-              [:@tstring_content, "aria-label", *]]]
+        def offense_message(method_name)
+          <<~MSG.strip
+            #{method_name} missing an accessible name \
+            requires an aria-label (WCAG 4.1.2)
+          MSG
         end
       end
     end

data/lib/a11y/lint/slim_node.rb

@@ -4,6 +4,8 @@ module A11y
   module Lint
     # Wraps a Slim AST s-expression as a queryable node for lint rules.
     class SlimNode
+      include BlockInspection
+
       attr_reader :line
 
       def initialize(sexp, line:)
@@ -16,11 +18,17 @@ module A11y
       end
 
       def ruby_code
-        return unless @sexp[0] == :slim && @sexp[1] == :output
+        return unless slim_output?
 
         @sexp[3]
       end
 
+      def call_node
+        return unless slim_output?
+
+        @call_node ||= parse_call_node
+      end
+
       def attribute?(name)
         attributes.key?(name)
       end
@@ -40,12 +48,59 @@ module A11y
         collect_children(body)
       end
 
+      # Returns ruby_code strings from child :slim :output nodes
+      # inside a block body. Only meaningful for output nodes
+      # (e.g. `= button_tag(...) do`).
+      def block_body_codes
+        return unless slim_output?
+
+        collect_output_codes(@sexp[4])
+      end
+
+      # Returns true when the block body contains visible text or
+      # HTML tag children (i.e. content that provides an accessible name).
+      def block_has_text_children?
+        return false unless slim_output?
+
+        text_content?(@sexp[4])
+      end
+
       private
 
       def html_tag?
         @sexp[0] == :html && @sexp[1] == :tag
       end
 
+      def slim_output?
+        @sexp[0] == :slim && @sexp[1] == :output
+      end
+
+      def parse_call_node
+        RubyCode.new(@sexp[3]).call_node
+      end
+
+      def collect_output_codes(sexp)
+        return [] unless sexp.is_a?(Array)
+        return [sexp[3]] if slim_output_sexp?(sexp)
+
+        sexp.flat_map { |child| collect_output_codes(child) }
+      end
+
+      def slim_output_sexp?(sexp)
+        sexp.is_a?(Array) && sexp[0] == :slim && sexp[1] == :output
+      end
+
+      def text_content?(sexp)
+        return false unless sexp.is_a?(Array)
+        return true if slim_text_sexp?(sexp) || html_tag_sexp?(sexp)
+
+        sexp.any? { |child| text_content?(child) }
+      end
+
+      def slim_text_sexp?(sexp)
+        sexp[0] == :slim && sexp[1] == :text
+      end
+
       def collect_children(sexp)
         return [] unless sexp.is_a?(Array)
         return [SlimNode.new(sexp, line: @line)] if html_tag_sexp?(sexp)

data/lib/a11y/lint/slim_runner.rb

@@ -9,12 +9,15 @@ module A11y
       end
 
       def run(source, filename:)
+        require "slim"
         sexp = Slim::Parser.new.call(source)
         @line = 1
         @filename = filename
         @offenses = []
         walk(sexp)
         @offenses
+      rescue LoadError
+        raise SlimLoadError
       end
 
       private

data/lib/a11y/lint/version.rb

@@ -2,6 +2,6 @@
 
 module A11y
   module Lint
-    VERSION = "0.8.0"
+    VERSION = "0.10.0"
   end
 end

data/lib/a11y/lint.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
-require "slim"
 require "nokogiri"
-require "prism"
+require_relative "lint/errors"
 require_relative "lint/version"
 require_relative "lint/offense"
+require_relative "lint/call_node"
+require_relative "lint/ruby_code"
+require_relative "lint/block_inspection"
 require_relative "lint/slim_node"
 require_relative "lint/erb_node"
+require_relative "lint/phlex_tags"
 require_relative "lint/phlex_node"
 require_relative "lint/configuration"
 require_relative "lint/rule"
@@ -17,9 +20,3 @@ require_relative "lint/rules/robust/missing_accessible_name"
 require_relative "lint/slim_runner"
 require_relative "lint/erb_runner"
 require_relative "lint/phlex_runner"
-
-module A11y
-  module Lint
-    class Error < StandardError; end
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: a11y-lint
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Abdullah Hashim
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.13'
-- !ruby/object:Gem::Dependency
-  name: prism
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: slim
   requirement: !ruby/object:Gem::Requirement
@@ -44,7 +30,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -69,13 +55,18 @@ files:
 - Rakefile
 - exe/a11y-lint
 - lib/a11y/lint.rb
+- lib/a11y/lint/block_inspection.rb
+- lib/a11y/lint/call_node.rb
 - lib/a11y/lint/cli.rb
 - lib/a11y/lint/configuration.rb
 - lib/a11y/lint/erb_node.rb
 - lib/a11y/lint/erb_runner.rb
+- lib/a11y/lint/errors.rb
 - lib/a11y/lint/offense.rb
 - lib/a11y/lint/phlex_node.rb
 - lib/a11y/lint/phlex_runner.rb
+- lib/a11y/lint/phlex_tags.rb
+- lib/a11y/lint/ruby_code.rb
 - lib/a11y/lint/rule.rb
 - lib/a11y/lint/rules/perceivable/image_tag_missing_alt.rb
 - lib/a11y/lint/rules/perceivable/img_missing_alt.rb
@@ -100,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="