eager_eye 1.2.4 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dee00b4a1b227d3fe506af3663b4a00730c312d61f9a1db876c4a59e7cbbd62
-  data.tar.gz: 1ce8596e9752c3b2f4fc2fa2d9463fcb9eeca1f50f9031c9ef1acbaef95ba08f
+  metadata.gz: f996747b6c12e539180e66cc74c11c70acfab4a6e4b84aed4039cc7b58dafe53
+  data.tar.gz: f23d5a21ceecc39c71b0303a5748472a8ea5e0f5f3256ffd5a10084a5af8a39c
 SHA512:
-  metadata.gz: 1c453c88107dfa5b3fbbdf1c66a2f2ca5fc2d2df3a99f91e27827f36a720e59d4974e9f880fad2668adf05116a81bcd69b8cdca6d3a0c0e24b8f3332f3c886a1
-  data.tar.gz: a1bc480d5b3d1d82eb8eccb7697ff50cab9ba94fbf127a08cd39f3278dfe90a95ebc14df28cf518e26bac86ad2ba59eaacdb5efc783e58caae8187d670b4f071
+  metadata.gz: a75d25669ab2d7e96dbccb107ae30f817e5fd6a291651b68bc56dbea21f50bd5c8b24b0633dd21d6faeeb5a8abd999abc6baf57ac9c7e8c3c06aa4542dc570d3
+  data.tar.gz: 7d2e5af151c02923bf4e64f05bc277711228729fa08ddee3dd79699623efc33f3689290c1739c025d7851db0b59d90feeac99e3a65c9a13862fac8f36ddf46b6

data/.rubocop.yml

@@ -20,7 +20,7 @@ Metrics/BlockLength:
     - "lib/eager_eye/railtie.rb"
 
 Metrics/ClassLength:
-  Max: 165
+  Max: 170
 
 Metrics/ParameterLists:
   Max: 6

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.6] - 2026-02-25
+
+### Changed
+
+- Extract shared class-inspection logic into `ClassInspector` concern to reduce duplication across detectors
+- Refactor all detectors to use `ClassInspector` for parent class and naming convention checks
+- Simplify `Analyzer` by removing redundant delegation and streamlining detector orchestration
+- Clean up `DelegationParser` with leaner parsing logic
+- Improve `Base` detector with consolidated helper methods
+- Streamline reporter classes (`Base`, `Console`) for clarity and consistency
+
+### Removed
+
+- Remove duplicated class-matching code from `CallbackQuery`, `CountInIteration`, `CustomMethodQuery`, `DecoratorNPlusOne`, `DelegationNPlusOne`, `LoopAssociation`, and `SerializerNesting`
+
+## [1.2.5] - 2026-02-21
+
+### Added
+
+- **New Detector: `DecoratorNPlusOne`** - Detects N+1 queries inside decorator/presenter classes
+  - Catches `object.comments.map(...)`, `__getobj__.items.each { ... }`, `model.posts`, `source.tags` patterns
+  - Identifies decorator classes by inheritance (`Draper::Decorator`, `SimpleDelegator`, `Delegator`) or name suffix (`Decorator`, `Presenter`, `ViewObject`)
+  - Targets all four object reference styles: `object`, `__getobj__`, `source`, `model`
+  - Skips ActiveStorage methods (`attached?`, `blob`, `variant`, etc.) to prevent false positives
+  - Suggests eager loading in the controller before decorating the collection
+
 ## [1.2.4] - 2026-02-21
 
 ### Added

data/README.md

@@ -10,7 +10,7 @@
 
 <p align="center">
   <a href="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml"><img src="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml/badge.svg" alt="CI"></a>
-  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.4-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.6-red.svg" alt="Gem Version"></a>
   <a href="https://github.com/hamzagedikkaya/eager_eye"><img src="https://img.shields.io/badge/coverage-95%25-brightgreen.svg" alt="Coverage"></a>
   <a href="https://www.ruby-lang.org/"><img src="https://img.shields.io/badge/ruby-%3E%3D%203.1-ruby.svg" alt="Ruby"></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
@@ -42,7 +42,7 @@
 
 ## Features
 
-✨ **Detects 8 types of N+1 problems:**
+✨ **Detects 9 types of N+1 problems:**
 - Loop associations (queries in iterations)
 - Serializer nesting issues
 - Missing counter caches
@@ -51,6 +51,7 @@
 - Callback query N+1s
 - Pluck to array misuse
 - Delegation N+1s (hidden via `delegate :method, to: :association`)
+- Decorator N+1s (Draper, SimpleDelegator, Presenter, ViewObject)
 
 🔧 **Developer-friendly:**
 - Inline suppression (like RuboCop)
@@ -369,6 +370,34 @@ EagerEye detects these by:
 2. Tracking which methods delegate to which associations
 3. Flagging calls to those methods inside iteration blocks when the association is not preloaded
 
+### 9. Decorator N+1
+
+Detects N+1 queries inside Draper decorators, SimpleDelegator subclasses, and classes named `Decorator`, `Presenter`, or `ViewObject`. Each decorator wraps a single record — when a collection is decorated without preloading, every method that accesses an association triggers a new query per record.
+
+```ruby
+# Bad - N+1 on each decorated post
+class PostDecorator < Draper::Decorator
+  def comment_summary
+    object.comments.map(&:body).join(", ")   # Query for each post!
+  end
+
+  def tag_list
+    object.tags.map(&:name).join(", ")        # Another query for each post!
+  end
+end
+
+# Controller - no includes = N+1
+@posts = Post.all.decorate
+
+# Good - Eager load before decorating
+@posts = Post.includes(:comments, :tags).all.decorate
+```
+
+Supports the following object references inside decorators:
+- `object` — Draper standard
+- `__getobj__` — SimpleDelegator standard
+- `source`, `model` — alternative Draper aliases
+
 ## Inline Suppression
 
 Suppress false positives using inline comments (RuboCop-style):
@@ -412,6 +441,7 @@ Both CamelCase and snake_case formats are accepted:
 | Callback Query | `CallbackQuery` | `callback_query` |
 | Pluck to Array | `PluckToArray` | `pluck_to_array` |
 | Delegation N+1 | `DelegationNPlusOne` | `delegation_n_plus_one` |
+| Decorator N+1 | `DecoratorNPlusOne` | `decorator_n_plus_one` |
 | All Detectors | `all` | `all` |
 
 ## Auto-fix (Experimental)
@@ -515,6 +545,7 @@ enabled_detectors:
   - callback_query
   - pluck_to_array
   - delegation_n_plus_one
+  - decorator_n_plus_one
 
 # Severity levels per detector (error, warning, info)
 severity_levels:
@@ -525,6 +556,7 @@ severity_levels:
   callback_query: warning
   pluck_to_array: warning        # Optimization
   delegation_n_plus_one: warning # Hidden delegation N+1
+  decorator_n_plus_one: warning  # Decorator/Presenter N+1
   missing_counter_cache: info    # Suggestion
 
 # Minimum severity to report (default: info)

data/lib/eager_eye/analyzer.rb

@@ -12,7 +12,8 @@ module EagerEye
       count_in_iteration: Detectors::CountInIteration,
       callback_query: Detectors::CallbackQuery,
       pluck_to_array: Detectors::PluckToArray,
-      delegation_n_plus_one: Detectors::DelegationNPlusOne
+      delegation_n_plus_one: Detectors::DelegationNPlusOne,
+      decorator_n_plus_one: Detectors::DecoratorNPlusOne
     }.freeze
 
     attr_reader :paths, :issues, :association_preloads, :delegation_maps
@@ -26,38 +27,30 @@ module EagerEye
 
     def run
       @issues = []
-      collect_association_preloads
-      collect_delegation_maps
-      analyze_files
+      collect_model_metadata
+      ruby_files.each { |file_path| analyze_file(file_path) }
       @issues
     end
 
     private
 
-    def collect_association_preloads
+    def collect_model_metadata
       model_files.each do |file_path|
         ast = parse_source(File.read(file_path))
         next unless ast
 
-        parser = AssociationParser.new
-        parser.parse_model(ast, extract_model_name(file_path))
-        @association_preloads.merge!(parser.preloaded_associations)
-      end
-    rescue StandardError
-      nil
-    end
+        model_name = extract_model_name(file_path)
 
-    def collect_delegation_maps
-      model_files.each do |file_path|
-        ast = parse_source(File.read(file_path))
-        next unless ast
+        assoc_parser = AssociationParser.new
+        assoc_parser.parse_model(ast, model_name)
+        @association_preloads.merge!(assoc_parser.preloaded_associations)
 
-        parser = DelegationParser.new
-        parser.parse_model(ast, extract_model_name(file_path))
-        @delegation_maps.merge!(parser.delegation_maps)
+        deleg_parser = DelegationParser.new
+        deleg_parser.parse_model(ast, model_name)
+        @delegation_maps.merge!(deleg_parser.delegation_maps)
+      rescue Errno::ENOENT, Errno::EACCES
+        next
       end
-    rescue StandardError
-      nil
     end
 
     def model_files
@@ -65,25 +58,19 @@ module EagerEye
     end
 
     def extract_model_name(file_path)
-      File.basename(file_path, ".rb").camelize
+      name = File.basename(file_path, ".rb")
+      name.respond_to?(:camelize) ? name.camelize : name.split("_").map(&:capitalize).join
     end
 
-    def analyze_files
-      ruby_files.each { |file_path| analyze_file(file_path) }
+    def ruby_files
+      paths.flat_map { |path| resolve_path(path) }.reject { |file| excluded?(file) }
     end
 
-    def ruby_files
-      all_files = paths.flat_map do |path|
-        if File.file?(path)
-          [path]
-        elsif File.directory?(path)
-          Dir.glob(File.join(path, "**", "*.rb"))
-        else
-          Dir.glob(path)
-        end
-      end
+    def resolve_path(path)
+      return [path] if File.file?(path)
+      return Dir.glob(File.join(path, "**", "*.rb")) if File.directory?(path)
 
-      all_files.reject { |file| excluded?(file) }
+      Dir.glob(path)
     end
 
     def excluded?(file_path)
@@ -102,9 +89,10 @@ module EagerEye
 
       enabled_detectors.each do |detector|
         file_issues = detector.detect(*detector_args(detector, ast, file_path))
-        file_issues.reject! { |issue| comment_parser.disabled_at?(issue.line_number, issue.detector) }
-        file_issues.select! { |issue| issue.meets_minimum_severity?(min_severity) }
-        @issues.concat(file_issues)
+        @issues.concat(file_issues.select do |issue|
+          !comment_parser.disabled_at?(issue.line_number, issue.detector) &&
+            issue.meets_minimum_severity?(min_severity)
+        end)
       end
     rescue Errno::ENOENT, Errno::EACCES => e
       warn "EagerEye: Could not read file #{file_path}: #{e.message}"
@@ -125,8 +113,7 @@ module EagerEye
 
     def enabled_detectors
       @enabled_detectors ||= EagerEye.configuration.enabled_detectors.filter_map do |name|
-        detector_class = DETECTOR_CLASSES[name]
-        detector_class&.new
+        DETECTOR_CLASSES[name]&.new
       end
     end
   end

data/lib/eager_eye/comment_parser.rb

@@ -5,7 +5,6 @@ module EagerEye
     FILE_DISABLE_PATTERN = /eager_eye:disable-file\s+(.+?)(?:\s+--|$)/i
     NEXT_LINE_PATTERN = /eager_eye:disable-next-line(?:\s+(.+?))?(?:\s+--|$)/i
     BLOCK_START_PATTERN = /eager_eye:disable-block(?:\s+(.+?))?(?:\s+--|$)/i
-    BLOCK_END_PATTERN = /eager_eye:enable-block(?:\s+(.+?))?(?:\s+--|$)/i
     INLINE_DISABLE_PATTERN = /eager_eye:disable\s+(.+?)(?:\s+--|$)/i
     ENABLE_PATTERN = /eager_eye:enable(?:\s+(.+?))?(?:\s+--|$)/i
 

data/lib/eager_eye/configuration.rb

@@ -8,7 +8,7 @@ module EagerEye
     DEFAULT_DETECTORS = %i[
       loop_association serializer_nesting missing_counter_cache
       custom_method_query count_in_iteration callback_query
-      pluck_to_array delegation_n_plus_one
+      pluck_to_array delegation_n_plus_one decorator_n_plus_one
     ].freeze
 
     DEFAULT_SEVERITY_LEVELS = {
@@ -19,7 +19,8 @@ module EagerEye
       count_in_iteration: :warning,
       callback_query: :warning,
       pluck_to_array: :warning,
-      delegation_n_plus_one: :warning
+      delegation_n_plus_one: :warning,
+      decorator_n_plus_one: :warning
     }.freeze
 
     VALID_SEVERITIES = %i[info warning error].freeze

data/lib/eager_eye/delegation_parser.rb

@@ -24,50 +24,42 @@ module EagerEye
     end
 
     def check_delegate(node, model_name)
-      return unless bare_delegate_call?(node)
+      return unless delegate_call?(node)
 
       args = node.children[2..]
-      methods = delegate_methods(args)
+      methods = extract_sym_args(args)
       return if methods.empty?
 
       to_target = extract_to_target(args)
       return unless to_target
 
-      register_delegates(model_name, methods, to_target)
+      @delegation_maps[model_name] ||= {}
+      methods.each { |m| @delegation_maps[model_name][m] = to_target }
     end
 
-    def bare_delegate_call?(node)
+    def delegate_call?(node)
       node.type == :send && node.children[0].nil? && node.children[1] == :delegate
     end
 
-    def delegate_methods(args)
+    def extract_sym_args(args)
       args.select { |a| a&.type == :sym }.map { |a| a.children[0] }
     end
 
-    def register_delegates(model_name, methods, to_target)
-      @delegation_maps[model_name] ||= {}
-      methods.each { |m| @delegation_maps[model_name][m] = to_target }
-    end
-
     def extract_to_target(args)
       hash_arg = args.find { |a| a&.type == :hash }
       return unless hash_arg
 
-      to_pair = hash_arg.children.find { |p| to_key_pair?(p) }
-      extract_sym_value(to_pair)
-    end
-
-    def extract_sym_value(node)
-      return unless node
+      to_pair = find_to_pair(hash_arg)
+      return unless to_pair
 
-      value = node.children[1]
+      value = to_pair.children[1]
       value.children[0] if value&.type == :sym
     end
 
-    def to_key_pair?(pair)
-      pair.type == :pair &&
-        pair.children[0]&.type == :sym &&
-        pair.children[0].children[0] == :to
+    def find_to_pair(hash_node)
+      hash_node.children.find do |p|
+        p.type == :pair && p.children[0]&.type == :sym && p.children[0].children[0] == :to
+      end
     end
   end
 end

data/lib/eager_eye/detectors/base.rb

@@ -22,13 +22,12 @@ module EagerEye
       protected
 
       def create_issue(file_path:, line_number:, message:, severity: nil, suggestion: nil)
-        resolved_severity = severity || configured_severity
         Issue.new(
           detector: self.class.detector_name,
           file_path: file_path,
           line_number: line_number,
           message: message,
-          severity: resolved_severity,
+          severity: severity || configured_severity,
           suggestion: suggestion
         )
       end
@@ -73,6 +72,34 @@ module EagerEye
           symbols.add(key.children[0]) if key&.type == :sym
         end
       end
+
+      def extract_block_variable(block_node)
+        args = block_node&.children&.[](1)
+        first_arg = args&.children&.first
+        first_arg&.type == :arg ? first_arg.children[0] : nil
+      end
+
+      def receiver_chain_starts_with?(node, target_var)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar then node.children[0] == target_var
+        when :send then receiver_chain_starts_with?(node.children[0], target_var)
+        else false
+        end
+      end
+
+      def reconstruct_chain(node)
+        return "" unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar then node.children[0].to_s
+        when :send
+          receiver_str = reconstruct_chain(node.children[0])
+          receiver_str.empty? ? node.children[1].to_s : "#{receiver_str}.#{node.children[1]}"
+        else ""
+        end
+      end
     end
   end
 end

data/lib/eager_eye/detectors/callback_query.rb

@@ -29,6 +29,9 @@ module EagerEye
       ITERATION_METHODS = %i[each map select find_all reject collect
                              find_each find_in_batches in_batches].freeze
       AR_BATCH_METHODS = %i[find_each find_in_batches in_batches].freeze
+      NON_AR_NAMESPACES = %w[Sidekiq Redis ActionCable ActionMailer Kafka].freeze
+      TRANSACTIONAL_CALLBACKS = %i[before_validation before_save before_create before_update before_destroy
+                                   around_save around_create around_update around_destroy].freeze
 
       def self.detector_name
         :callback_query
@@ -38,7 +41,6 @@ module EagerEye
         @issues = []
         @file_path = file_path
         @callback_methods = {}
-
         return @issues unless ast
 
         find_callback_definitions(ast)
@@ -64,9 +66,7 @@ module EagerEye
         node.children[2..].each do |arg|
           next unless arg.is_a?(Parser::AST::Node) && arg.type == :sym
 
-          method_name = arg.children[0]
-          callback_type = node.children[1]
-          @callback_methods[method_name] = callback_type
+          @callback_methods[arg.children[0]] = node.children[1]
         end
       end
 
@@ -74,9 +74,8 @@ module EagerEye
         return unless node.is_a?(Parser::AST::Node)
 
         if node.type == :def && @callback_methods.key?(node.children[0])
-          method_name = node.children[0]
           body = node.children[2]
-          find_iterations_with_queries(body, method_name, @callback_methods[method_name]) if body
+          find_iterations_with_queries(body, node.children[0], @callback_methods[node.children[0]]) if body
         end
 
         node.children.each { |child| check_callback_methods(child) }
@@ -87,7 +86,8 @@ module EagerEye
 
         if iteration_block?(node)
           block_var = extract_block_variable(node)
-          if block_var && contains_ar_query_on_variable?(node, block_var)
+          collection = node.children[0].children[0]
+          if block_var && !non_ar_collection?(collection) && contains_ar_query_on_variable?(node, block_var)
             add_iteration_issue(node, method_name, callback_type)
             find_query_calls_in_block(node, method_name, callback_type, block_var)
           end
@@ -127,47 +127,52 @@ module EagerEye
       end
 
       def add_query_issue(node, method_name, callback_type)
-        query_method = node.children[1]
+        suggestion = if transactional_callback?(callback_type)
+                       "Callbacks run on every save/create/update. Move the query outside the iteration or preload data"
+                     else
+                       "Callbacks run on every save/create/update. Consider moving to a background job"
+                     end
 
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "Query method `.#{query_method}` found in `#{callback_type}` callback `:#{method_name}`",
+          message: "Query method `.#{node.children[1]}` found in `#{callback_type}` callback `:#{method_name}`",
           severity: :warning,
-          suggestion: "Callbacks run on every save/create/update. Consider moving to a background job"
+          suggestion: suggestion
         )
       end
 
       def add_iteration_issue(node, method_name, callback_type)
+        suggestion = if transactional_callback?(callback_type)
+                       "Avoid DB queries in before_*/around_* callbacks. Preload data outside the iteration instead"
+                     else
+                       "Avoid iterations in callbacks. Use background jobs for bulk operations"
+                     end
+
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
           message: "Iteration found in `#{callback_type}` callback `:#{method_name}` - potential N+1",
           severity: :error,
-          suggestion: "Avoid iterations in callbacks. Use background jobs for bulk operations"
+          suggestion: suggestion
         )
       end
 
-      def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-
-        first_arg = args_node.children[0]
-        return nil unless first_arg&.type == :arg
+      def transactional_callback?(callback_type)
+        TRANSACTIONAL_CALLBACKS.include?(callback_type)
+      end
 
-        first_arg.children[0]
+      def non_ar_collection?(node)
+        ns = root_namespace(node)
+        ns && NON_AR_NAMESPACES.include?(ns)
       end
 
-      def receiver_chain_starts_with?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node)
+      def root_namespace(node)
+        return nil unless node.is_a?(Parser::AST::Node)
 
         case node.type
-        when :lvar
-          node.children[0] == block_var
-        when :send
-          receiver_chain_starts_with?(node.children[0], block_var)
-        else
-          false
+        when :const then node.children[0].nil? ? node.children[1].to_s : root_namespace(node.children[0])
+        when :send, :block then root_namespace(node.children[0])
         end
       end
 

data/lib/eager_eye/detectors/concerns/class_inspector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    module Concerns
+      module ClassInspector
+        HAS_MANY_ASSOCIATIONS = %w[
+          authors users owners creators admins members customers clients
+          posts articles comments categories tags children companies organizations
+          projects tasks items orders products accounts profiles settings
+          images avatars photos attachments documents
+        ].freeze
+
+        ACTIVE_STORAGE_METHODS = %i[
+          attached? attach attachment attachments blob blobs purge purge_later variant preview
+        ].freeze
+
+        private
+
+        def const_to_string(node)
+          return nil unless node&.type == :const
+
+          parts = []
+          current = node
+          while current&.type == :const
+            parts.unshift(current.children[1].to_s)
+            current = current.children[0]
+          end
+          parts.join("::")
+        end
+
+        def extract_class_name(class_node)
+          name_node = class_node.children[0]
+          name_node.children[1].to_s if name_node&.type == :const
+        end
+
+        def likely_association?(method_name)
+          HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
+        end
+
+        def collect_active_storage_lines(body)
+          lines = Set.new
+          traverse_ast(body) do |node|
+            lines << node.loc.line if node.type == :send && ACTIVE_STORAGE_METHODS.include?(node.children[1])
+          end
+          lines
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -6,6 +6,7 @@ module EagerEye
       COUNT_METHODS = %i[count].freeze
       ITERATION_METHODS = %i[each map select find_all reject collect each_with_index each_with_object flat_map
                              find_each find_in_batches in_batches].freeze
+      ARRAY_METHOD_SUFFIXES = %w[_ids _tags _types _codes _names _values].freeze
 
       def self.detector_name
         :count_in_iteration
@@ -14,7 +15,6 @@ module EagerEye
       def detect(ast, file_path)
         @issues = []
         @file_path = file_path
-
         return @issues unless ast
 
         find_iteration_blocks(ast) do |block_body, block_var|
@@ -52,63 +52,30 @@ module EagerEye
 
       def count_on_association?(node, block_var)
         node.type == :send && COUNT_METHODS.include?(node.children[1]) &&
+          !array_returning_method?(node.children[0]) &&
           association_call_on_block_var?(node.children[0], block_var)
       end
 
-      def association_call_on_block_var?(node, block_var)
+      def array_returning_method?(node)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
-        receiver = node.children[0]
-        return false unless receiver.is_a?(Parser::AST::Node)
-
-        return true if receiver.type == :lvar && receiver.children[0] == block_var
-
-        receiver.type == :send && chain_starts_with_block_var?(receiver, block_var)
-      end
-
-      def chain_starts_with_block_var?(node, block_var)
-        return false unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar then node.children[0] == block_var
-        when :send then chain_starts_with_block_var?(node.children[0], block_var)
-        else false
-        end
+        ARRAY_METHOD_SUFFIXES.any? { |suffix| node.children[1].to_s.end_with?(suffix) }
       end
 
-      def extract_block_variable(block_node)
-        args_node = block_node.children[1]
-        return nil unless args_node&.type == :args
-
-        first_arg = args_node.children[0]
-        first_arg&.type == :arg ? first_arg.children[0] : nil
+      def association_call_on_block_var?(node, block_var)
+        node.is_a?(Parser::AST::Node) && node.type == :send &&
+          receiver_chain_starts_with?(node.children[0], block_var)
       end
 
       def add_issue(node)
-        receiver_chain = reconstruct_chain(node.children[0])
-
+        chain = reconstruct_chain(node.children[0])
         @issues << create_issue(
           file_path: @file_path,
           line_number: node.loc.line,
-          message: "`.count` called on `#{receiver_chain}` inside iteration always executes a COUNT query",
+          message: "`.count` called on `#{chain}` inside iteration always executes a COUNT query",
           suggestion: "Use `.size` instead (uses loaded collection) or add `counter_cache: true`"
         )
       end
-
-      def reconstruct_chain(node)
-        return "" unless node.is_a?(Parser::AST::Node)
-
-        case node.type
-        when :lvar
-          node.children[0].to_s
-        when :send
-          receiver_str = reconstruct_chain(node.children[0])
-          method = node.children[1]
-          receiver_str.empty? ? method.to_s : "#{receiver_str}.#{method}"
-        else
-          ""
-        end
-      end
     end
   end
 end