rubocop-view_component 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa0434208243f306c17f51b681abdf59f6152d6afdd0014c608c5b4e08e893c2
-  data.tar.gz: e709241be864e024f8ce410b6620d62bcdd12cd090e2593b378c0169a628f1e9
+  metadata.gz: ab88d6999ec2a99b6f9e459d22a14b9d727b62edd967088fa22aef709681dbdb
+  data.tar.gz: b06b97cebdb888ba95176af4d9d664c9f75bf75865eacb148bc327bba761f77f
 SHA512:
-  metadata.gz: 6d0a9815a58ab3326c9366e7abb2d85cd18e1c87216c731c2fccfeba3d70eae2188856b1c619ba9be2d37c776d463d00efe4f2b7d680998e6e7679b582ab22da
-  data.tar.gz: f195f94ca71e89a4f807a8074ddac30a65462faab27dc01b18f1f58f4a29d85df5699a4dcead7a670e7f311b3fe87816cd49ae98b3813540fa2e4c0707273fc8
+  metadata.gz: 8b6aa5e13ce63d13205335bb2d900a29d57e80ce1b9d1906c92e3548d85941875b18235a36775849e35752fed347c260e842289fb8e805ad0ee7670c252c89b1
+  data.tar.gz: b65833f97c6211d366b5c0cdeba807e501f6ef10a8a878f63e0379de23be3c2a4842542e50e43171254886204990ae5224a4d3e3abbe90f72be1e05f9cfb0f08

data/.rubocop.yml

@@ -12,6 +12,9 @@ AllCops:
   TargetRubyVersion: 3.2
   NewCops: enable
   SuggestExtensions: false
+  # Required by this gem's own cops, which resolve ancestry through the
+  # project index (see docs/rubydex.md).
+  UseProjectIndex: true
   Exclude:
     - 'verification/**/*'
     - 'script/verify'

data/{CLAUDE.md → AGENTS.md}

@@ -1,6 +1,6 @@
-# CLAUDE.md
+# AGENTS.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to coding agents when working with code in this repository.
 
 ## Project Overview
 
@@ -40,7 +40,7 @@ All cops inherit from `RuboCop::Cop::Base` and are located in `lib/rubocop/cop/v
 ### Shared Modules
 
 **`ViewComponent::Base`** (`lib/rubocop/cop/view_component/base.rb`)
-- Includes `RuboCop::Cop::ProjectIndexHelp` for rubydex integration
+- Includes `RuboCop::Cop::ProjectIndexHelp` for [rubydex integration](docs/rubydex.md)
 - Provides `view_component_class?(node)` - Detects ViewComponent classes via ancestry resolution
 - Provides `view_component_parent?(node)` - Checks if inheriting from ViewComponent::Base
 - Provides `view_component_parent_class?(node)` - Checks if a class is an abstract parent (has descendants)

data/README.md

@@ -13,7 +13,7 @@ gem 'rubocop-view_component', require: false
 Add to your `.rubocop.yml`:
 
 ```yaml
-require:
+plugins:
   - rubocop-view_component
 ```
 **Note:** From v0.7.0 onwards, this gem makes use of [rubydex](https://github.com/Shopify/rubydex) to discover which classes inherit from `ViewComponent::Base`. `UseProjectIndex` is required. Without it, cops that depend on ancestry detection will raise an error.
@@ -35,15 +35,15 @@ This gem provides several cops to enforce ViewComponent best practices:
 - **ViewComponent/NoGlobalState** - Prevent direct access to `params`, `request`, `session`, etc.
 - **ViewComponent/PreferPrivateMethods** - Suggest making helper methods private (analyzes ERB templates to avoid flagging methods used in views)
 - **ViewComponent/PreferSlots** - Detect HTML parameters that should be slots
-- **ViewComponent/PreferComposition** - Avoid inheriting one ViewComponent from another (prefer composition)
-- **ViewComponent/TestRenderedOutput** - Encourage testing rendered output over private methods
-- **ViewComponent/MissingPreview** - Ensure every ViewComponent has a corresponding preview file (requires `PreviewPaths` configuration). Abstract base classes with descendants are automatically exempt.
+- **ViewComponent/PreferComposition** - Avoid inheriting one ViewComponent from another (prefer composition). Abstract bases without their own template, such as `ApplicationComponent`, are allowed
+- **ViewComponent/TestRenderedOutput** - Encourage testing rendered output over private methods. Supports Minitest and RSpec styles, including components built via `described_class.new` or a `let`/`subject` helper
+- **ViewComponent/MissingPreview** - Ensure every ViewComponent has a corresponding preview file (defaults to `test/components/previews` and `spec/components/previews` if `PreviewPaths` is not configured). Abstract base classes with descendants are automatically exempt.
 
 ## Optional Configuration
 
 ### Components Directory
 
-Several cops (`ComponentSuffix`, `PreferComposition`, `MissingPreview`, `TestRenderedOutput`) default to running only on files under `app/components/`. If your project uses a different path, override `Include` in your `.rubocop.yml`:
+Several cops (`ComponentSuffix`, `PreferComposition`, `TestRenderedOutput`) default to running only on files under `app/components/`. If your project uses a different path, override `Include` in your `.rubocop.yml`:
 
 ```yaml
 # .rubocop.yml
@@ -53,6 +53,23 @@ ViewComponent/ComponentSuffix:
     - 'engines/*/app/components/**/*.rb'
 ```
 
+### Additional Source Paths
+
+`AllCops/ProjectIndexIncludesGems` only indexes a gem's `lib`, so a class that inherits through a
+Rails engine's `app/components` stays unresolved. If your components inherit from an engine gem,
+point the cops at its sources:
+
+```yaml
+# .rubocop.yml
+ViewComponent:
+  AdditionalSourcePaths:
+    - ../my_engine/app/components
+```
+
+Paths are relative to the config file that sets them. The cops index those directories themselves
+and fall back to them when RuboCop's index can't resolve a constant. Unlike `ComponentNamespaces`,
+this only adds declarations to the index — it does not treat a whole namespace as components.
+
 ### No Super
 
 ViewComponent convention is to not call `super` in component initializers, but that may cause `Lint/MissingSuper` failures from RuboCop. We suggest disabling that rule for your view components directory, for example:
@@ -143,6 +160,26 @@ To force download the latest Polaris source:
 script/verify polaris --update
 ```
 
+### Flowbite Components
+
+To verify against [substancelab/flowbite-components](https://github.com/substancelab/flowbite-components) locally:
+
+```bash
+script/verify flowbite
+```
+
+If you intentionally change cop behavior, regenerate the snapshot:
+
+```bash
+script/verify flowbite --regenerate
+```
+
+To force download the latest Flowbite source:
+
+```bash
+script/verify flowbite --update
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/andyw8/rubocop-view_component.

data/config/default.yml

@@ -1,5 +1,11 @@
 ViewComponent:
   ComponentNamespaces: []
+  # Source directories the cops index themselves, in addition to RuboCop's
+  # project index. Use this when ancestry passes through a gem RuboCop does not
+  # index (notably a Rails engine's app/components, which
+  # AllCops/ProjectIndexIncludesGems misses because it only covers a gem's lib).
+  # Paths are relative to the config file that sets them.
+  AdditionalSourcePaths: []
 
 ViewComponent/ComponentSuffix:
   Description: 'Enforce -Component suffix for ViewComponent classes.'
@@ -15,8 +21,6 @@ ViewComponent/MissingPreview:
   Enabled: true
   VersionAdded: '0.5.0'
   Severity: convention
-  Include:
-    - 'app/components/**/*_component.rb'
   PreviewPaths:
     - test/components/previews
     - spec/components/previews

data/docs/rubydex.md

@@ -0,0 +1,136 @@
+# rubydex integration
+
+This gem uses [rubydex](https://github.com/Shopify/rubydex), Shopify's high-performance
+static analysis toolkit for Ruby, to answer questions that cannot be answered from a
+single file's AST.
+
+Most ViewComponent cops only care about *ancestry*: is this class (or the class it
+inherits from) ultimately a `ViewComponent::Base` descendant? A class may inherit from
+`ApplicationComponent`, which inherits from a gem's base class, which finally inherits
+from `ViewComponent::Base` — none of which is visible in the file being inspected.
+Resolving that chain requires a project-wide index, and that is what rubydex provides.
+
+## How RuboCop exposes the index
+
+RuboCop 1.89+ integrates rubydex behind an opt-in flag. This gem requires that
+version (see `rubocop-view_component.gemspec`).
+
+1. When `AllCops/UseProjectIndex` is `true`, RuboCop builds a resolved
+   `Rubydex::Graph` for the whole project (`RuboCop::ProjectIndexLoader`).
+2. The graph is exposed to cops through `RuboCop::Cop::Base#project_index`.
+3. Cops that mix in `RuboCop::Cop::ProjectIndexHelp` also get an
+   `external_dependency_checksum` override, which invalidates RuboCop's result cache
+   whenever an indexed file changes on disk.
+
+If the `rubydex` gem is not installed, or the running Ruby is older than 3.2, RuboCop
+warns and degrades to file-local analysis (`project_index` is `nil`).
+
+## How this gem uses it
+
+`ViewComponent::Base` (`lib/rubocop/cop/view_component/base.rb`) includes
+`ProjectIndexHelp` and queries the index through `resolve_constant_in_index`:
+
+- `view_component_class?` — resolves a class's superclass expression and checks it.
+- `view_component_parent?` — resolves a constant and calls
+  `declaration.has_ancestor?("ViewComponent::Base")`.
+- `view_component_parent_class?` — checks `has_ancestor?` plus `declaration.descendants`
+  to detect abstract base classes that have their own subclasses in the project.
+- `resolved_index_declaration` — returns the raw declaration for a constant, or nil
+  when it isn't defined in the index. This lets a cop distinguish "resolved but not a
+  ViewComponent" from "not resolvable", and inspect the declaration (for example, to
+  locate the class's source file).
+- `inside_view_component?` — finds the enclosing class and delegates to
+  `view_component_class?`.
+
+`PreferComposition` uses `resolved_index_declaration` together with the parent's
+template to tell a concrete component apart from an abstract base: it flags a parent
+only when its name follows the component convention *and* the index resolves it to a
+ViewComponent that has its own template. Bases without a template (such as
+`ApplicationComponent`) and constants that resolve to something other than a
+ViewComponent are allowed.
+
+All of these call `require_project_index!` first, which raises with an actionable
+message if the index is unavailable:
+
+```
+ViewComponent cops require `AllCops/UseProjectIndex: true` in your .rubocop.yml
+for ancestry-based class detection.
+```
+
+The one exception is `ComponentNamespaces`: if a class's fully-qualified name matches a
+configured namespace prefix, `view_component_class?` can return `true` without touching
+the index, so projects that use explicit namespaces can avoid the requirement in that
+specific case.
+
+## Configuration
+
+Enable the index in your `.rubocop.yml`:
+
+```yaml
+AllCops:
+  UseProjectIndex: true
+```
+
+If your components inherit from a library (e.g. Primer) whose base class lives in a gem,
+also enable gem indexing so the ancestry chain can be followed through the gem's source:
+
+```yaml
+AllCops:
+  ProjectIndexIncludesGems: true
+```
+
+### Rails engines
+
+Gem indexing only covers a gem's `lib`. A Rails engine's components live under `app/components`,
+so a chain that passes through one — such as a project's components inheriting
+`MyEngine::ApplicationComponent` — stays unresolved even with the flag on. List the engine's
+sources in `ViewComponent/AdditionalSourcePaths` and the cops index them in a small supplementary
+graph of their own, used as a fallback when RuboCop's index can't resolve a constant:
+
+```yaml
+ViewComponent:
+  AdditionalSourcePaths:
+    - ../my_engine/app/components
+```
+
+Paths are relative to the config file that sets them, and the supplementary files take part in the
+result cache's checksum, so changing one invalidates a cached run. `ComponentNamespaces` is not a
+substitute here: it treats *every* class under the namespace as a component, which is wrong for a
+namespace that also holds helpers, tests, or other application code.
+
+## Performance notes
+
+- The index always covers the whole project (rooted at the directory of the config that
+  enabled it), not just the files in the current run, so cross-file offenses are
+  consistent between full runs, editor runs, and CI shards.
+- `external_dependency_checksum` ties the result cache to the indexed files' mtimes and
+  sizes, so a warm cache is reused until a relevant file changes.
+- On Windows, parallel inspection is skipped when the index is enabled.
+
+## Testing
+
+Specs do not build a full RuboCop run. `spec/support/project_index_helpers.rb` builds a
+`Rubydex::Graph` directly from a set of in-memory sources:
+
+```ruby
+graph = Rubydex::Graph.new
+graph.index_source("file:///user_component.rb", source, "ruby")
+graph.resolve
+```
+
+`ProjectIndexHelpers::LazyIndex` wraps the graph and lazily indexes the source under
+inspection on first miss, mirroring how the real runner indexes every project file
+(including the one being inspected). `spec_helper.rb` assigns this to each cop's
+`project_index` before examples run.
+
+The real-world verification suites (`verification/*_rubocop_config.yml`) set
+`UseProjectIndex: true` so the cops are exercised through the actual RuboCop runner.
+
+## Further reading
+
+- rubydex repository: <https://github.com/Shopify/rubydex>
+- Ruby API documentation: <https://shopify.github.io/rubydex/>
+- "One engine, many tools — Introducing Rubydex":
+  <https://railsatscale.com/2026-05-12-one-engine-many-tools/>
+- RuboCop 1.89 project-wide analysis announcement:
+  <https://metaredux.com/posts/2026/08/05/rubocop-1-89.html>

data/lib/rubocop/cop/view_component/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rubydex"
+require_relative "supplementary_index"
 
 module RuboCop
   module Cop
@@ -9,6 +10,7 @@ module RuboCop
       # Requires rubydex with UseProjectIndex: true for ancestry resolution.
       module Base
         include ProjectIndexHelp
+        include SupplementaryIndex
 
         VC_BASE = "ViewComponent::Base"
 
@@ -29,12 +31,8 @@ module RuboCop
 
         # Check if a constant node resolves to a class with ViewComponent::Base as ancestor
         def view_component_parent?(node)
-          return false unless node.const_type?
-
-          require_project_index!
-
-          declaration = resolve_constant_in_index(node)
-          return false unless declaration.respond_to?(:has_ancestor?)
+          declaration = view_component_declaration(node)
+          return false unless declaration
 
           declaration.name == VC_BASE || declaration.has_ancestor?(VC_BASE)
         end
@@ -44,15 +42,24 @@ module RuboCop
         def view_component_parent_class?(node)
           return false unless node&.class_type?
 
-          require_project_index!
-
-          declaration = resolve_constant_in_index(node.identifier)
-          return false unless declaration.respond_to?(:has_ancestor?)
+          declaration = view_component_declaration(node.identifier)
+          return false unless declaration
 
           declaration.has_ancestor?(VC_BASE) &&
             declaration.descendants.any? { |d| d.name != declaration.name }
         end
 
+        # Resolve a constant node to its declaration in the project index, or
+        # nil when the node is not a constant or isn't defined anywhere in the
+        # index. The declaration may or may not be a ViewComponent; callers can
+        # inspect it (for example, to locate the class's source file).
+        def resolved_index_declaration(node)
+          return nil unless node&.const_type?
+
+          require_project_index!
+          resolve_constant_in_index(node)
+        end
+
         def fully_qualified_name(node)
           namespace = node.parent_module_name
           short_name = node.identifier.source
@@ -88,6 +95,16 @@ module RuboCop
             for ancestry-based class detection.
           MSG
         end
+
+        private
+
+        # Resolve a constant node to a namespace declaration in the project
+        # index, or nil when the node is not a constant or does not resolve to a
+        # class or module.
+        def view_component_declaration(node)
+          declaration = resolved_index_declaration(node)
+          declaration if declaration.respond_to?(:has_ancestor?)
+        end
       end
     end
   end

data/lib/rubocop/cop/view_component/prefer_composition.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "template_analyzer"
+
 module RuboCop
   module Cop
     module ViewComponent
@@ -7,6 +9,13 @@ module RuboCop
       # instead of using composition. Inheriting one component from another
       # causes confusion when each has its own template.
       #
+      # A parent is only flagged when its name follows the component convention
+      # (the `Component` suffix, or a configured `ComponentNamespaces` prefix)
+      # and the project index confirms it is a ViewComponent with its own
+      # template. Abstract bases without a template, such as
+      # `ApplicationComponent`, are allowed, as are classes the index resolves
+      # to something other than a ViewComponent.
+      #
       # @example
       #   # bad
       #   class UserCardComponent < BaseCardComponent
@@ -19,31 +28,55 @@ module RuboCop
       #
       class PreferComposition < RuboCop::Cop::Base
         include ViewComponent::Base
+        include TemplateAnalyzer
 
         MSG = "Avoid inheriting from another ViewComponent."
 
         def on_class(node)
           parent_class = node.parent_class
-          return unless parent_class
-          return if view_component_parent?(parent_class)
-          return unless component_like_parent?(parent_class)
+          return unless parent_class&.const_type?
+          return unless inheritance_violation?(parent_class)
 
           add_offense(parent_class)
         end
 
         private
 
-        def component_like_parent?(node)
-          return false unless node.const_type?
+        # The name heuristic decides which parents are worth checking; the
+        # project index then confirms whether the parent really is a concrete
+        # ViewComponent. A parent the index can't resolve falls back to the name
+        # heuristic so projects without gem indexing are unaffected.
+        def inheritance_violation?(parent_class)
+          return false unless component_like_parent?(parent_class)
+
+          declaration = resolved_index_declaration(parent_class)
+          return true if declaration.nil?
+          return false unless view_component_parent?(parent_class)
+
+          parent_has_template?(declaration)
+        end
+
+        def parent_has_template?(declaration)
+          declaration.definitions.any? do |definition|
+            path = definition_source_path(definition)
+            path && template_paths_for(path).any?
+          end
+        rescue StandardError
+          false
+        end
+
+        def definition_source_path(definition)
+          location = definition.location
+          return nil unless location.uri.start_with?("file://")
+
+          location.to_file_path
+        end
 
+        def component_like_parent?(node)
           source = node.source
           source.end_with?("Component") ||
             component_namespaces.any? { |ns| source.start_with?(ns) }
         end
-
-        def component_namespaces
-          cop_config.fetch("ComponentNamespaces", [])
-        end
       end
     end
   end

data/lib/rubocop/cop/view_component/prefer_private_methods.rb

@@ -44,28 +44,68 @@ module RuboCop
           return unless body
 
           children = body.begin_type? ? body.children : [body]
-          check_children(children, methods_called_in_templates)
+          check_children(children, methods_called_in_templates, indexed_visibilities(class_node))
         end
 
-        def check_children(children, template_method_calls)
+        def check_children(children, template_method_calls, indexed_visibilities)
           current_visibility = :public
 
           children.each do |child|
-            if visibility_modifier?(child)
+            if bare_visibility_modifier?(child)
               current_visibility = child.method_name
-            elsif should_flag?(child, current_visibility, template_method_calls)
+            elsif child.def_type?
+              visibility = indexed_visibilities.fetch(child.method_name, current_visibility)
+              next unless should_flag?(child, visibility, template_method_calls)
+
               add_offense(child, message: format(MSG, method_name: child.method_name))
             end
           end
         end
 
         def should_flag?(child, visibility, template_method_calls)
-          child.def_type? &&
-            visibility == :public &&
+          visibility == :public &&
             !allowed_public_method?(child.method_name) &&
             !template_method_calls.include?(child.method_name)
         end
 
+        # The effective visibility of each method defined in the class, taken
+        # from the project index. This covers the forms an in-file walk cannot
+        # see: `private :name`, `private def name`, `public :name`, and
+        # visibility applied in another file. Empty when the class is not in
+        # the index (for example with `ComponentNamespaces`, which does not
+        # require one), in which case the in-file keyword below is used
+        # instead.
+        def indexed_visibilities(class_node)
+          return {} unless project_index && class_node.identifier
+
+          declaration = resolved_index_declaration(class_node.identifier)
+          return {} unless declaration.is_a?(Rubydex::Namespace)
+
+          declaration.members.each_with_object({}) do |member, visibilities|
+            next unless member.is_a?(Rubydex::Method)
+
+            visibilities[member_method_name(member)] = member.visibility
+          end
+        rescue StandardError
+          {}
+        end
+
+        def member_method_name(member)
+          member.unqualified_name.sub(/\(.*\)\z/, "").to_sym
+        end
+
+        # A `private`/`protected`/`public` call with no arguments, which
+        # changes the visibility of every method that follows it. Forms that
+        # name their methods do not change it: `private :name` and
+        # `private def name` are handled by the index above.
+        def bare_visibility_modifier?(node)
+          return false unless node.send_type?
+          return false unless node.receiver.nil?
+          return false unless %i[private protected public].include?(node.method_name)
+
+          node.arguments.empty?
+        end
+
         def allowed_public_method?(method_name)
           allowed_public_methods.include?(method_name.to_s) ||
             allowed_public_method_patterns.any? { |pattern| method_name.to_s.match?(pattern) }
@@ -91,13 +131,6 @@ module RuboCop
           warn "Warning: Failed to analyze templates: #{e.message}" if ENV["RUBOCOP_DEBUG"]
           Set.new
         end
-
-        def visibility_modifier?(node)
-          return false unless node.send_type?
-          return false unless node.receiver.nil?
-
-          %i[private protected public].include?(node.method_name)
-        end
       end
     end
   end

data/lib/rubocop/cop/view_component/rspec_scope.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module ViewComponent
+      # Helpers for navigating the RSpec example-group structure of a spec file.
+      #
+      # RSpec specs often build a component indirectly, through `described_class`
+      # inside a `describe SomeComponent` block or through a `let`/`subject`
+      # helper. This module locates those constructs without knowing whether the
+      # referenced constant is actually a ViewComponent; that judgement is left
+      # to the cop, which has access to the project index.
+      module RSpecScope
+        EXAMPLE_METHODS = %i[it specify example].freeze
+        EXAMPLE_GROUP_METHODS = %i[describe context feature example_group].freeze
+        MEMOIZED_HELPER_METHODS = %i[let let! subject subject!].freeze
+
+        def rspec_example_block?(node)
+          EXAMPLE_METHODS.include?(node.send_node&.method_name)
+        end
+
+        # The constant argument of the nearest enclosing `describe` block, if any.
+        # `each_ancestor` yields the closest ancestor first, so an inner
+        # `describe` wins over an outer one.
+        def enclosing_described_class(node)
+          node.each_ancestor(:block) do |ancestor|
+            send_node = ancestor.send_node
+            next unless send_node&.method?(:describe)
+
+            first_argument = send_node.first_argument
+            return first_argument if first_argument&.const_type?
+          end
+
+          nil
+        end
+
+        def described_class_reference?(node)
+          node.send_type? && node.method?(:described_class)
+        end
+
+        # Bare method calls (no receiver, no arguments) within +node+, e.g.
+        # `component` in `expect(component.title)`.
+        def referenced_helper_names(node)
+          node.each_node(:send).filter_map do |send_node|
+            next unless send_node.receiver.nil?
+            next unless send_node.arguments.empty?
+
+            send_node.method_name
+          end
+        end
+
+        # Maps helper name to block body for every `let`/`subject` defined in an
+        # enclosing example group. Inner definitions are visited first and win
+        # over outer ones, matching how the name resolves at runtime.
+        def helper_definitions(node)
+          node.each_ancestor(:block).with_object({}) do |ancestor, definitions|
+            next unless example_group_block?(ancestor)
+
+            each_helper_definition(ancestor) do |name, body|
+              definitions[name] ||= body
+            end
+          end
+        end
+
+        private
+
+        def each_helper_definition(group)
+          return unless group.body
+
+          statements_of(group.body).each do |statement|
+            next unless statement.block_type?
+
+            name = helper_name(statement.send_node)
+            yield(name, statement.body) if name
+          end
+        end
+
+        def statements_of(node)
+          node.begin_type? ? node.children : [node]
+        end
+
+        def helper_name(send_node)
+          return nil unless MEMOIZED_HELPER_METHODS.include?(send_node&.method_name)
+
+          first_argument = send_node.first_argument
+          return first_argument.value if first_argument&.sym_type?
+          return :subject if %i[subject subject!].include?(send_node.method_name)
+
+          nil
+        end
+
+        def example_group_block?(node)
+          EXAMPLE_GROUP_METHODS.include?(node.send_node&.method_name)
+        end
+      end
+    end
+  end
+end