a11y-lint 0.14.1 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17ce590d5fc702bdcf3feb01606767c2aaa0938ca6a40b3f456737d7e9f519f2
-  data.tar.gz: b1ec19b360ccbc592fd42a9848cfdb351b924f3752b3041afa063f64bfd3e380
+  metadata.gz: 27003e9edd9b1055dd6c2ddd37ac6da8958bb3a608f5bb8fbfa103eb167ddb0e
+  data.tar.gz: 5af458356a27d126373c8780ca2cec362d7d2e05b70edfdb45236a90f70b82a9
 SHA512:
-  metadata.gz: fa1db2cd985c446515c75808512e3663859af93d254949e51fb3638e0ee1fe7cf2172a55686f66b937476e8739a9f24910b8662ef03e285445dfab9079983be3
-  data.tar.gz: 045c3ec7a7e4442a47517020aa2cf3da15496a3e304a1768e8e067d7767f2cd0693db025711f25c05e02736c6d3f0095378e9dfb68ed1a3b19ebcb3e8232a49e
+  metadata.gz: a03ec8dba3eea02eaf7195e6b06f7ef60e628fbe4fd0de1a36c646123e5a335f8244fb10d6fe1a10f3570d95d133e9e32ccdd3ab0619401b93ccf82c6040c4d7
+  data.tar.gz: 632ec73a902867c26723f05814717ec53f8f32df73d3d9db7f99afc5cfd1530899cb418e1172b4076de7b0b2f72a48f2ce179f08c506ec7a013cf4ebcae6b625

data/.claude/commands/implement.md

@@ -0,0 +1,46 @@
+---
+description: Plan and implement a GitHub issue end-to-end on a new branch
+argument-hint: <issue-number>
+allowed-tools: Bash(gh issue view:*), Bash(gh repo view:*), Bash(git checkout:*), Bash(git switch:*), Bash(git branch:*), Bash(git status:*), Bash(git diff:*), Bash(bundle exec:*), Bash(bin/setup:*), Bash(bin/console:*), Bash(grep:*), Bash(rg:*), Bash(ls:*), Bash(find:*), Read, Edit, Write, Glob, Grep
+---
+
+Plan and implement GitHub issue **#$ARGUMENTS** in this repo, end-to-end, on a fresh branch. Do **not** commit or push — leave the working tree dirty for the user to review.
+
+## What to do
+
+1. **Fetch the issue.** Run `gh issue view $ARGUMENTS` (and `gh issue view $ARGUMENTS --comments` if there are comments) to read the title, body, and any discussion. Do **not** pass `--repo`.
+
+2. **Create a branch.** From the current branch, run `git checkout -b <slug>` where `<slug>` is `issue-$ARGUMENTS-<short-kebab-summary>` (e.g. `issue-87-anchor-button-phlex-helpers`). Keep it under ~50 chars. If the branch already exists, switch to it instead.
+
+3. **Plan before coding.** Produce a short plan covering:
+   - Which files you'll touch or create
+   - For new rules: the WCAG principle directory under `lib/a11y/lint/rules/`, the rule class name (see CLAUDE.md "Rule Scoping Convention"), and whether it has an HTML/helper pair
+   - Tests to add (Slim + ERB + Phlex parity per `.claude/rules/testing.md`)
+   - Dummy app fixtures to add in `test/fixtures/dummy_app/app/views/home/home.html.{slim,erb}` and any Phlex view
+   - Open questions, if any — ask once, then proceed
+
+4. **Implement the plan.**
+   - Follow `CLAUDE.md` (rule scoping, node interface, configuration loading) and `.claude/rules/testing.md` (no `setup`, all three calling styles for `ruby_code` rules, Slim/ERB/Phlex parity, inline HEREDOC fixtures).
+   - For new rules: register the rule, add good/bad examples to dummy app fixtures, and add a docs page under `docs/src/rules/` if the issue is adding a user-visible rule.
+   - Add an entry under `[Unreleased]` in `CHANGELOG.md` for any user-visible change (bug fixes, new rules, behavior changes). Skip for internal refactors and test-only changes.
+
+5. **Run the suite until green.** `bundle exec rake` runs tests + RuboCop. Iterate on failures. If a fix is non-obvious, surface it before grinding.
+
+6. **Stop without committing.** Leave changes staged-or-unstaged in the working tree. In your final reply:
+   - List the branch name
+   - Summarize what changed (files added/modified, tests added)
+   - Confirm `bundle exec rake` is green (or call out what's still failing and why)
+   - Suggest the next command (`git add -A && git commit -m "..."` or a `gh pr create` once the user is ready) — but do **not** run it
+
+## Out of scope
+
+- Committing, pushing, or opening a PR
+- Cross-repo support
+- Auto-closing the issue
+- Picking the issue automatically (always passed explicitly)
+
+## Style notes
+
+- Plan first, code second. A 5-line plan beats a 50-line one.
+- Match the conventions of recent rules and recent commits — skim `git log --oneline -20` and a nearby rule file before inventing a new pattern.
+- If the issue is ambiguous, ask **one** round of clarifying questions before implementing — voice input drops context, but too many questions defeat the point.

data/.rubocop.yml

@@ -29,5 +29,4 @@ Metrics/AbcSize:
     - "test/**/*"
 
 Metrics/MethodLength:
-  Exclude:
-    - "test/**/*"
+  Enabled: false

data/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.14.2] - 2026-05-05
+
+### Fixed
+
+- `AnchorMissingAccessibleName` and `ButtonMissingAccessibleName` no longer report Phlex `a`/`button` tags that use the nested-hash shorthand for `aria-label` (e.g. `aria: { label: "..." }`). `PhlexNode` now flattens nested kwarg hashes the way Phlex does at render time (`aria: { label: "x" }` → `aria-label="x"`, `data: { controller: "y" }` → `data-controller="y"`), so every Phlex tag rule benefits
+- `AnchorMissingAccessibleName` and `ButtonMissingAccessibleName` no longer report Phlex `a`/`button` tags whose accessible name comes from the block's auto-emitted return value. Phlex renders the block's last expression when it's a string-like value, and `PhlexRunner` now recognizes string literals (`{ "Clear all" }`, `{ "Hi #{name}" }`), method calls with a receiver (`{ account.email }`, `{ tab[:text] }`), lowercase receiverless calls (`{ external_url }`, `{ add_label }`), method-parameter / local-variable reads, and ternary / `if` / `unless` expressions whose branches resolve to text. Capitalized component calls (`{ Pencil(...) }`) and blank string literals are still treated as having no accessible name
+- `AnchorMissingAccessibleName` and `ButtonMissingAccessibleName` no longer report Phlex `a`/`button` tags that forward a block argument (`a(href:, &block)`, `button(type: "submit", &block)`) inside a wrapper method. The accessible name is supplied by the caller's block, which can't be resolved from the tag call site, so forwarded blocks are now trusted by default
+- `AnchorMissingAccessibleName` and `ButtonMissingAccessibleName` no longer report Phlex `a`/`button` tags whose accessible name is passed as a positional argument (`a("Click me", href: "/x")`, `button("Submit", type: :submit)`). Phlex's tag API renders the first positional argument as text content, and `PhlexRunner` now applies the same recognizer used for block content to the positional arg — string literals, interpolated strings, method calls (with or without a receiver), `t`/`translate` and other phlex-rails value helpers, and local variable / method-parameter reads. Empty/whitespace strings and capitalized component calls (`a(Pencil(...), href: ...)`) are still reported
+
 ## [0.14.1] - 2026-05-03
 
 ### Fixed

data/lib/a11y/lint/cli.rb

@@ -34,7 +34,7 @@ module A11y
         option_parser.parse!(@argv)
       end
 
-      def option_parser # rubocop:disable Metrics/MethodLength
+      def option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: a11y-lint [options] [file_or_directory ...]"
 

data/lib/a11y/lint/phlex_node.rb

@@ -100,7 +100,31 @@ module A11y
 
         kwarg_nodes(call_node).each_with_object({}) do |elem, h|
           key = kwarg_key(elem.key)
-          h[key] = kwarg_value(elem.value) if key
+          next unless key
+
+          if elem.value.is_a?(Prism::HashNode)
+            flatten_nested_hash(key, elem.value, h)
+          else
+            h[key] = kwarg_value(elem.value)
+          end
+        end
+      end
+
+      # Mirrors Phlex's render-time flattening of nested kwarg hashes
+      # (e.g. `aria: { label: "x" }` -> `aria-label="x"`). Inner key
+      # underscores become dashes the same way Phlex/Rails do.
+      def self.flatten_nested_hash(prefix, hash_node, attrs)
+        hash_node.elements.each do |inner|
+          next unless inner.is_a?(Prism::AssocNode)
+          next unless (inner_key = kwarg_key(inner.key))
+
+          full_key = "#{prefix}-#{inner_key.tr("_", "-")}"
+
+          if inner.value.is_a?(Prism::HashNode)
+            flatten_nested_hash(full_key, inner.value, attrs)
+          else
+            attrs[full_key] = kwarg_value(inner.value)
+          end
         end
       end
 
@@ -125,8 +149,13 @@ module A11y
         end
       end
 
-      private_class_method :kwarg_key, :kwarg_nodes, :kwarg_value,
-                           :extract_attributes
+      private_class_method(
+        :extract_attributes,
+        :flatten_nested_hash,
+        :kwarg_key,
+        :kwarg_nodes,
+        :kwarg_value
+      )
     end
   end
 end

data/lib/a11y/lint/phlex_runner/block_text_scanner.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module A11y
+  module Lint
+    class PhlexRunner
+      # Decides whether a Phlex tag block produces accessible text.
+      # Stateless: only reads the given Prism block node and pre-collected
+      # child tags.
+      class BlockTextScanner
+        # Phlex auto-emits the return value of these calls into the document:
+        # `plain` / `text` are built-in; the rest are registered as value
+        # helpers by phlex-rails via `register_value_helper`.
+        TEXT_CALLS = %w[
+          plain text
+          t translate l localize
+          pluralize truncate
+          number_to_currency number_to_human number_to_human_size
+          number_to_percentage number_to_phone
+          number_with_delimiter number_with_precision
+          highlight excerpt
+        ].to_set.freeze
+
+        def self.scan(block, children:)
+          new(block, children).scan
+        end
+
+        # Public recognizer for a single Prism node — used by PhlexRunner
+        # to inspect a tag's first positional argument, where Phlex emits
+        # the value as text content (`a("Click", href: "/x")`).
+        def self.text_emitting?(node)
+          new(nil, []).text_emitting?(node)
+        end
+
+        def self.non_blank_string_literal?(node)
+          case node
+          when Prism::StringNode
+            !node.unescaped.strip.empty?
+          when Prism::InterpolatedStringNode
+            node.parts.any? do |part|
+              if part.is_a?(Prism::StringNode)
+                !part.unescaped.strip.empty?
+              else
+                true
+              end
+            end
+          else
+            false
+          end
+        end
+
+        def initialize(block, children)
+          @block = block
+          @children = children
+        end
+
+        def scan
+          return false unless @block.is_a?(Prism::BlockNode)
+
+          scan_for_text(@block) || @children.any?(&:text_content?)
+        end
+
+        def text_emitting?(node)
+          auto_emitted_text?(node)
+        end
+
+        private
+
+        # A Phlex tag block produces accessible text if any statement
+        # contains an explicit text marker (yield, plain/text/t/..., a
+        # non-blank string literal), or if the block's last expression
+        # auto-emits a value Phlex renders as text.
+        def scan_for_text(block)
+          statements = block_statements(block)
+          return false if statements.empty?
+
+          return true if statements.any? { |stmt| explicit_text?(stmt) }
+
+          auto_emitted_text?(statements.last)
+        end
+
+        def block_statements(block)
+          return [] unless block.is_a?(Prism::BlockNode)
+
+          body = block.body
+          body.is_a?(Prism::StatementsNode) ? body.body : []
+        end
+
+        def explicit_text?(node)
+          return false if node.nil?
+          return true if node.is_a?(Prism::YieldNode)
+          return true if self.class.non_blank_string_literal?(node)
+          return text_call?(node) if node.is_a?(Prism::CallNode)
+
+          # Recurse only into conditional/grouping nodes — descending into
+          # call args would treat string literals like `foo("bar")`'s "bar"
+          # as block text, which it isn't.
+          return false unless conditional_container?(node)
+
+          node.child_nodes.compact.any? { |c| explicit_text?(c) }
+        end
+
+        def auto_emitted_text?(node)
+          return false if node.nil?
+          return true if explicit_text?(node)
+
+          case node
+          when Prism::LocalVariableReadNode
+            true
+          when Prism::CallNode
+            auto_emitted_call?(node)
+          when Prism::IfNode, Prism::UnlessNode
+            if_branch_lasts(node).any? { |last| auto_emitted_text?(last) }
+          end
+        end
+
+        def auto_emitted_call?(call)
+          return true if call.receiver
+
+          name = call.name.to_s
+          return false if PhlexNode.html_tag?(name)
+          return true if TEXT_CALLS.include?(name)
+
+          # Lowercase receiverless calls (locals, helper methods) auto-emit
+          # their return value. Capitalized names are Phlex components,
+          # which emit their own HTML, not text.
+          lowercase_name?(name)
+        end
+
+        def conditional_container?(node)
+          node.is_a?(Prism::IfNode) ||
+            node.is_a?(Prism::UnlessNode) ||
+            node.is_a?(Prism::BeginNode) ||
+            node.is_a?(Prism::StatementsNode) ||
+            node.is_a?(Prism::ElseNode) ||
+            node.is_a?(Prism::ParenthesesNode)
+        end
+
+        def lowercase_name?(name)
+          first = name[0]
+          first && first == first.downcase && first != first.upcase
+        end
+
+        def if_branch_lasts(node)
+          if_branch_statements(node).flat_map do |stmts|
+            stmts.is_a?(Prism::StatementsNode) ? [stmts.body.last].compact : []
+          end
+        end
+
+        def if_branch_statements(node)
+          branches = [node.statements]
+          collect_else_branches(if_else_clause(node), branches)
+          branches.compact
+        end
+
+        def collect_else_branches(current, branches)
+          while current.is_a?(Prism::IfNode) || current.is_a?(Prism::UnlessNode)
+            branches << current.statements
+            current = if_else_clause(current)
+          end
+          branches << current.statements if current.is_a?(Prism::ElseNode)
+        end
+
+        def if_else_clause(node)
+          case node
+          when Prism::IfNode then node.subsequent
+          when Prism::UnlessNode then node.else_clause
+          end
+        end
+
+        def text_call?(node)
+          node.is_a?(Prism::CallNode) &&
+            node.receiver.nil? &&
+            TEXT_CALLS.include?(node.name.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/a11y/lint/phlex_runner/phlex_call.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module A11y
+  module Lint
+    class PhlexRunner
+      # Wraps a `Prism::CallNode` with the predicates and block accessors
+      # PhlexRunner uses to classify and traverse Phlex view code:
+      # tag vs helper, block form (`do...end`, `&block`, none),
+      # first positional arg, class values.
+      class PhlexCall
+        # Phlex tag/helper calls are always receiverless; a call like
+        # `helpers.image_tag(...)` has a receiver and is skipped.
+        def self.wrap(node)
+          return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
+
+          new(node)
+        end
+
+        def initialize(call_node)
+          @call_node = call_node
+        end
+
+        attr_reader(:call_node)
+
+        def name
+          call_node.name.to_s
+        end
+
+        def line
+          call_node.location.start_line
+        end
+
+        def tag?
+          PhlexNode.html_tag?(name)
+        end
+
+        def helper?
+          !tag?
+        end
+
+        def block
+          call_node.block
+        end
+
+        # The block as a Prism::BlockNode, or nil for `&block` forwards
+        # and calls without a block.
+        def block_node
+          block.is_a?(Prism::BlockNode) ? block : nil
+        end
+
+        # `tag(&block)` defers content to the caller; we can't see what
+        # they emit, so trust the wrapper rather than report a false
+        # positive.
+        def forwarded_block?
+          block.is_a?(Prism::BlockArgumentNode)
+        end
+
+        def block_children
+          block_node ? block_node.child_nodes.compact : []
+        end
+
+        def block_has_text?(children = [])
+          BlockTextScanner.scan(block_node, children: children)
+        end
+
+        # Phlex's tag API emits the first positional argument as text
+        # content (`a("Click me", href: "/x")` is equivalent to
+        # `a(href: "/x") { "Click me" }`).
+        def arg_has_text?
+          arg = first_positional_arg
+          return false if arg.nil?
+
+          BlockTextScanner.text_emitting?(arg)
+        end
+
+        def first_positional_arg
+          return nil unless call_node.arguments
+
+          call_node.arguments.arguments.find do |arg|
+            !arg.is_a?(Prism::KeywordHashNode) &&
+              !arg.is_a?(Prism::BlockArgumentNode)
+          end
+        end
+
+        def class_values
+          PhlexNode.kwarg_class_values(call_node)
+        end
+      end
+    end
+  end
+end

data/lib/a11y/lint/phlex_runner.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "prism"
+require_relative "phlex_runner/block_text_scanner"
+require_relative "phlex_runner/phlex_call"
 
 module A11y
   module Lint
@@ -9,19 +11,6 @@ module A11y
     class PhlexRunner
       PHLEX_PATTERN = /\bdef\s+view_template\b/
 
-      # Phlex auto-emits the return value of these calls into the document:
-      # `plain` / `text` are built-in; the rest are registered as value
-      # helpers by phlex-rails via `register_value_helper`.
-      TEXT_CALLS = %w[
-        plain text
-        t translate l localize
-        pluralize truncate
-        number_to_currency number_to_human number_to_human_size
-        number_to_percentage number_to_phone
-        number_with_delimiter number_with_precision
-        highlight excerpt
-      ].to_set.freeze
-
       def initialize(rules = nil, configuration: Configuration.new)
         @rules = rules || configuration.enabled_rules
         @configuration = configuration
@@ -43,27 +32,25 @@ module A11y
       attr_reader :rules, :configuration
 
       def walk(node)
-        if receiverless_call?(node)
-          process_call(node)
+        if (call = PhlexCall.wrap(node))
+          process_call(call)
         else
           node.child_nodes.compact.each { |c| walk(c) }
         end
       end
 
-      def process_call(node)
-        if PhlexNode.html_tag?(node.name.to_s)
-          check_tag(node)
-        else
-          check_helper(node)
-        end
+      def process_call(call)
+        call.tag? ? check_tag(call) : check_helper(call)
       end
 
-      def check_tag(node)
-        children = collect_block_children(node.block)
-        has_text = tag_block_has_text?(node.block, children)
+      def check_tag(call)
+        children = collect_block_children(call.block_node)
+        has_text = call.forwarded_block? ||
+                   call.arg_has_text? ||
+                   call.block_has_text?(children)
         check_node(
           PhlexNode.build_tag(
-            node,
+            call.call_node,
             children: children,
             text_content: has_text,
             configuration: configuration
@@ -71,114 +58,100 @@ module A11y
         )
       end
 
-      def check_helper(node)
-        codes, has_text = analyze_helper_block(node)
+      def check_helper(call)
+        codes, has_text = analyze_helper_block(call)
         helper = PhlexNode.build_helper(
-          node,
+          call.call_node,
           block_body_codes: codes,
           block_has_text_children: has_text,
           configuration: configuration
         )
         check_node(helper)
-        walk_block(node.block)
+        walk_block(call.block_node)
       end
 
-      def collect_block_children(block)
-        return [] unless block.is_a?(Prism::BlockNode)
+      def collect_block_children(block_node)
+        return [] unless block_node
 
-        [].tap { |c| gather_children(block, c) }
+        [].tap { |c| gather_children(block_node, c) }
       end
 
       def gather_children(parent, result)
         parent.child_nodes.compact.each do |child|
-          if tag_call?(child)
-            gather_tag_child(child, result)
-          elsif receiverless_call?(child)
-            check_helper(child)
+          child_call = PhlexCall.wrap(child)
+          if child_call&.tag?
+            gather_tag_child(child_call, result)
+          elsif child_call
+            check_helper(child_call)
           else
             gather_children(child, result)
           end
         end
       end
 
-      def gather_tag_child(child, result)
-        kids = collect_block_children(child.block)
-        has_text = tag_block_has_text?(child.block, kids)
+      def gather_tag_child(call, result)
+        kids = collect_block_children(call.block_node)
+        has_text = call.arg_has_text? || call.block_has_text?(kids)
         tag = PhlexNode.build_tag(
-          child, children: kids, text_content: has_text,
-                 configuration: configuration
+          call.call_node, children: kids, text_content: has_text,
+                          configuration: configuration
         )
         check_node(tag)
-        result << tag unless hidden_wrapper_tag?(child)
+        result << tag unless hidden_wrapper_tag?(call)
       end
 
-      def hidden_wrapper_tag?(call_node)
+      def hidden_wrapper_tag?(call)
         classes = configuration.hidden_wrapper_classes
         return false if classes.empty?
 
-        tag_class_values(call_node).any? { |klass| classes.include?(klass) }
+        call.class_values.any? { |klass| classes.include?(klass) }
       end
 
-      def tag_class_values(call_node)
-        return [] unless call_node.arguments
-
-        PhlexNode.kwarg_class_values(call_node)
-      end
-
-      def tag_block_has_text?(block, children)
-        return false unless block.is_a?(Prism::BlockNode)
-
-        scan_for_text(block) || children.any?(&:text_content?)
-      end
-
-      def scan_for_text(node)
-        node.child_nodes.compact.any? do |child|
-          text_call?(child) || child.is_a?(Prism::YieldNode) ||
-            (!receiverless_call?(child) && scan_for_text(child))
-        end
-      end
-
-      def analyze_helper_block(call_node)
-        block = call_node.block
-        return [nil, false] unless block.is_a?(Prism::BlockNode)
+      def analyze_helper_block(call)
+        block = call.block_node
+        return [nil, false] unless block
 
         codes = []
         has_text = scan_block_content(block, codes)
         [codes.empty? ? nil : codes, has_text]
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
       def scan_block_content(node, codes)
         node.child_nodes.compact.each do |child|
-          next if tag_call?(child) && hidden_wrapper_tag?(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)
+          return true if visit_helper_block_child(child, codes)
         end
         false
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
 
-      def walk_block(block)
-        return unless block.is_a?(Prism::BlockNode)
+      def visit_helper_block_child(child, codes)
+        child_call = PhlexCall.wrap(child)
+        return handle_call_block_child(child_call, codes) if child_call
+
+        block_child_text?(child) || scan_block_content(child, codes)
+      end
+
+      def handle_call_block_child(child_call, codes)
+        return false if child_call.tag? && hidden_wrapper_tag?(child_call)
+        return true if tag_call_has_text_block?(child_call)
+        return false if child_call.tag?
 
-        block.child_nodes.compact.each { |c| walk(c) }
+        codes << child_call.call_node.slice
+        false
       end
 
-      def tag_call?(node)
-        receiverless_call?(node) && PhlexNode.html_tag?(node.name.to_s)
+      def block_child_text?(child)
+        child.is_a?(Prism::YieldNode) ||
+          BlockTextScanner.non_blank_string_literal?(child)
       end
 
-      def text_call?(node)
-        receiverless_call?(node) && TEXT_CALLS.include?(node.name.to_s)
+      def tag_call_has_text_block?(child_call)
+        child_call.tag? && !child_call.block.nil?
       end
 
-      def receiverless_call?(node)
-        node.is_a?(Prism::CallNode) && node.receiver.nil?
+      def walk_block(block_node)
+        return unless block_node
+
+        block_node.child_nodes.compact.each { |c| walk(c) }
       end
 
       def check_node(node)

data/lib/a11y/lint/version.rb

@@ -2,6 +2,6 @@
 
 module A11y
   module Lint
-    VERSION = "0.14.1"
+    VERSION = "0.14.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: a11y-lint
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Abdullah Hashim
@@ -45,6 +45,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/commands/implement.md"
 - ".claude/commands/task.md"
 - ".claude/rules/testing.md"
 - ".rubocop.yml"
@@ -117,6 +118,8 @@ files:
 - lib/a11y/lint/offense.rb
 - lib/a11y/lint/phlex_node.rb
 - lib/a11y/lint/phlex_runner.rb
+- lib/a11y/lint/phlex_runner/block_text_scanner.rb
+- lib/a11y/lint/phlex_runner/phlex_call.rb
 - lib/a11y/lint/phlex_tags.rb
 - lib/a11y/lint/ruby_code.rb
 - lib/a11y/lint/rules/perceivable/area_missing_alt.rb