eager_eye 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a432b16aece37497880140ff64a88cd3dabe6ae603846a513d21f71a8b11b5a1
-  data.tar.gz: 330aac1ef792a5ca24597dcd4128329e20f05959ea45437e244788b94f12026d
+  metadata.gz: 2dee00b4a1b227d3fe506af3663b4a00730c312d61f9a1db876c4a59e7cbbd62
+  data.tar.gz: 1ce8596e9752c3b2f4fc2fa2d9463fcb9eeca1f50f9031c9ef1acbaef95ba08f
 SHA512:
-  metadata.gz: 192aa6bb71494f09091ac64a44de11526db09ec389cf41db80229457d59d52f5e81c9b9ae05cc6892ec11c646078a12520c657940a986c47f6519af6b956526f
-  data.tar.gz: 3e18421c967675ea0c10ab19ff7f0426d2a2d8e2fcf969a20b6bc0571f0f32a40c8f515b16c464df57c67b447fe0e9c3b3087b22cee37bbda3bee89b1dd3d418
+  metadata.gz: 1c453c88107dfa5b3fbbdf1c66a2f2ca5fc2d2df3a99f91e27827f36a720e59d4974e9f880fad2668adf05116a81bcd69b8cdca6d3a0c0e24b8f3332f3c886a1
+  data.tar.gz: a1bc480d5b3d1d82eb8eccb7697ff50cab9ba94fbf127a08cd39f3278dfe90a95ebc14df28cf518e26bac86ad2ba59eaacdb5efc783e58caae8187d670b4f071

data/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.4] - 2026-02-21
+
+### Added
+
+- **New Detector: `DelegationNPlusOne`** - Detects hidden N+1 queries caused by `delegate :method, to: :association`
+  - `delegate :name, :email, to: :user` calls inside loops load the target association on each iteration
+  - EagerEye previously could not catch these because `order.name` looks like a plain attribute, not an association access
+  - Parses model files for `delegate` declarations and tracks delegated method → association mappings
+  - Detects delegated method calls in `each`, `map`, `select`, `flat_map`, `find_each`, and all other iteration methods
+  - Respects `includes`, `preload`, and `eager_load` — suppresses warnings when the target association is preloaded
+  - Supports both local (same-file) delegate declarations and cross-file detection via model parsing
+
+## [1.2.3] - 2026-02-15
+
+### Added
+
+- **Batch Iteration Support** - All detectors now recognize `find_each`, `find_in_batches`, and `in_batches`
+  - `LoopAssociation`: Detects association calls inside `find_each` blocks
+  - `CallbackQuery`: Detects query iterations inside `find_each` in callbacks
+  - `MissingCounterCache`: Detects `.count`/`.size`/`.length` inside `find_each` blocks
+  - `CountInIteration`: Detects `.count` inside `find_each` blocks
+  - `CustomMethodQuery`: Detects `.where`/`.find_by` etc. inside `find_each` blocks
+  - Previously, `User.find_each { |u| u.posts }` was not flagged — now correctly detected as N+1
+
 ## [1.2.2] - 2026-01-31
 
 ### Fixed

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.2-red.svg" alt="Gem Version"></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://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 7 types of N+1 problems:**
+✨ **Detects 8 types of N+1 problems:**
 - Loop associations (queries in iterations)
 - Serializer nesting issues
 - Missing counter caches
@@ -50,6 +50,7 @@
 - Count in iteration patterns
 - Callback query N+1s
 - Pluck to array misuse
+- Delegation N+1s (hidden via `delegate :method, to: :association`)
 
 🔧 **Developer-friendly:**
 - Inline suppression (like RuboCop)
@@ -339,6 +340,35 @@ Post.where(user_id: User.active.select(:id))
 - ⚠️ **Warning** - Scoped `.pluck(:id)` (two queries, memory overhead)
 - 🔴 **Error** - Unscoped `.all.pluck(:id)` (loads entire table)
 
+### 8. Delegation N+1
+
+Detects when methods delegated via `delegate :method, to: :association` are called inside loops without preloading the target association. These are invisible to `LoopAssociation` because `order.name` looks like a plain attribute, not an association access.
+
+```ruby
+# Model
+class Order < ApplicationRecord
+  belongs_to :user
+  delegate :full_name, :email, to: :user
+end
+
+# Bad - N+1 (each call hits the database for user)
+orders.each do |order|
+  order.full_name   # actually: order.user.full_name — loads user for each order!
+  order.email       # actually: order.user.email — another load!
+end
+
+# Good - Eager load the delegated-to association
+orders.includes(:user).each do |order|
+  order.full_name   # no N+1 — user is already loaded
+  order.email       # no N+1 — user is already loaded
+end
+```
+
+EagerEye detects these by:
+1. Scanning model files for `delegate :method, to: :assoc` declarations
+2. Tracking which methods delegate to which associations
+3. Flagging calls to those methods inside iteration blocks when the association is not preloaded
+
 ## Inline Suppression
 
 Suppress false positives using inline comments (RuboCop-style):
@@ -381,6 +411,7 @@ Both CamelCase and snake_case formats are accepted:
 | Count in Iteration | `CountInIteration` | `count_in_iteration` |
 | Callback Query | `CallbackQuery` | `callback_query` |
 | Pluck to Array | `PluckToArray` | `pluck_to_array` |
+| Delegation N+1 | `DelegationNPlusOne` | `delegation_n_plus_one` |
 | All Detectors | `all` | `all` |
 
 ## Auto-fix (Experimental)
@@ -483,6 +514,7 @@ enabled_detectors:
   - count_in_iteration
   - callback_query
   - pluck_to_array
+  - delegation_n_plus_one
 
 # Severity levels per detector (error, warning, info)
 severity_levels:
@@ -492,6 +524,7 @@ severity_levels:
   count_in_iteration: warning
   callback_query: warning
   pluck_to_array: warning        # Optimization
+  delegation_n_plus_one: warning # Hidden delegation N+1
   missing_counter_cache: info    # Suggestion
 
 # Minimum severity to report (default: info)

data/lib/eager_eye/analyzer.rb

@@ -11,20 +11,23 @@ module EagerEye
       custom_method_query: Detectors::CustomMethodQuery,
       count_in_iteration: Detectors::CountInIteration,
       callback_query: Detectors::CallbackQuery,
-      pluck_to_array: Detectors::PluckToArray
+      pluck_to_array: Detectors::PluckToArray,
+      delegation_n_plus_one: Detectors::DelegationNPlusOne
     }.freeze
 
-    attr_reader :paths, :issues, :association_preloads
+    attr_reader :paths, :issues, :association_preloads, :delegation_maps
 
     def initialize(paths: nil)
       @paths = Array(paths || EagerEye.configuration.app_path)
       @issues = []
       @association_preloads = {}
+      @delegation_maps = {}
     end
 
     def run
       @issues = []
       collect_association_preloads
+      collect_delegation_maps
       analyze_files
       @issues
     end
@@ -44,6 +47,19 @@ module EagerEye
       nil
     end
 
+    def collect_delegation_maps
+      model_files.each do |file_path|
+        ast = parse_source(File.read(file_path))
+        next unless ast
+
+        parser = DelegationParser.new
+        parser.parse_model(ast, extract_model_name(file_path))
+        @delegation_maps.merge!(parser.delegation_maps)
+      end
+    rescue StandardError
+      nil
+    end
+
     def model_files
       Dir.glob(File.join(@paths[0], "models", "**", "*.rb"))
     end
@@ -85,10 +101,7 @@ module EagerEye
       min_severity = EagerEye.configuration.min_severity
 
       enabled_detectors.each do |detector|
-        args = [ast, file_path]
-        args << @association_preloads if detector.is_a?(Detectors::LoopAssociation)
-
-        file_issues = detector.detect(*args)
+        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)
@@ -103,6 +116,13 @@ module EagerEye
       nil
     end
 
+    def detector_args(detector, ast, file_path)
+      args = [ast, file_path]
+      args << @association_preloads if detector.is_a?(Detectors::LoopAssociation)
+      args << @delegation_maps if detector.is_a?(Detectors::DelegationNPlusOne)
+      args
+    end
+
     def enabled_detectors
       @enabled_detectors ||= EagerEye.configuration.enabled_detectors.filter_map do |name|
         detector_class = DETECTOR_CLASSES[name]

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
+      pluck_to_array delegation_n_plus_one
     ].freeze
 
     DEFAULT_SEVERITY_LEVELS = {
@@ -18,7 +18,8 @@ module EagerEye
       custom_method_query: :warning,
       count_in_iteration: :warning,
       callback_query: :warning,
-      pluck_to_array: :warning
+      pluck_to_array: :warning,
+      delegation_n_plus_one: :warning
     }.freeze
 
     VALID_SEVERITIES = %i[info warning error].freeze

data/lib/eager_eye/delegation_parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module EagerEye
+  class DelegationParser
+    attr_reader :delegation_maps
+
+    def initialize
+      @delegation_maps = {}
+    end
+
+    def parse_model(ast, model_name)
+      return unless ast
+
+      traverse(ast, model_name)
+    end
+
+    private
+
+    def traverse(node, model_name)
+      return unless node.is_a?(Parser::AST::Node)
+
+      check_delegate(node, model_name)
+      node.children.each { |child| traverse(child, model_name) }
+    end
+
+    def check_delegate(node, model_name)
+      return unless bare_delegate_call?(node)
+
+      args = node.children[2..]
+      methods = delegate_methods(args)
+      return if methods.empty?
+
+      to_target = extract_to_target(args)
+      return unless to_target
+
+      register_delegates(model_name, methods, to_target)
+    end
+
+    def bare_delegate_call?(node)
+      node.type == :send && node.children[0].nil? && node.children[1] == :delegate
+    end
+
+    def delegate_methods(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
+
+      value = node.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
+    end
+  end
+end

data/lib/eager_eye/detectors/callback_query.rb

@@ -26,7 +26,9 @@ module EagerEye
         reload
       ].freeze
 
-      ITERATION_METHODS = %i[each map select find_all reject collect].freeze
+      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
 
       def self.detector_name
         :callback_query
@@ -110,7 +112,10 @@ module EagerEye
 
       def iteration_block?(node)
         return false unless node.type == :block && node.children[0]&.type == :send
-        return false unless ITERATION_METHODS.include?(node.children[0].children[1])
+
+        method_name = node.children[0].children[1]
+        return false unless ITERATION_METHODS.include?(method_name)
+        return true if AR_BATCH_METHODS.include?(method_name)
 
         !static_collection?(node.children[0].children[0])
       end

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -4,7 +4,8 @@ module EagerEye
   module Detectors
     class CountInIteration < Base
       COUNT_METHODS = %i[count].freeze
-      ITERATION_METHODS = %i[each map select find_all reject collect each_with_index each_with_object flat_map].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
 
       def self.detector_name
         :count_in_iteration

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -8,7 +8,8 @@ module EagerEye
       SAFE_QUERY_METHODS = %i[first last take count sum find size length ids].freeze
       SAFE_TRANSFORM_METHODS = %i[keys values split [] params sort pluck ids to_s to_a to_i chars bytes].freeze
       ARRAY_COLUMN_SUFFIXES = %w[_ids _tags _types _codes _names _values].freeze
-      ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
+      ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map
+                             find_each find_in_batches in_batches].freeze
 
       def self.detector_name
         :custom_method_query

data/lib/eager_eye/detectors/delegation_n_plus_one.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class DelegationNPlusOne < Base
+      ITERATION_METHODS = %i[
+        each map collect select find_all reject filter filter_map flat_map
+        find_each find_in_batches in_batches
+      ].freeze
+      PRELOAD_METHODS = %i[includes preload eager_load].freeze
+
+      def self.detector_name
+        :delegation_n_plus_one
+      end
+
+      def detect(ast, file_path, delegation_maps = {})
+        return [] unless ast
+
+        issues = []
+        local_delegates = collect_local_delegates(ast)
+
+        traverse_ast(ast) do |node|
+          next unless iteration_block?(node)
+
+          block_var = extract_block_variable(node)
+          next unless block_var
+
+          block_body = node.children[2]
+          next unless block_body
+
+          collection_node = node.children[0]
+          model_name = infer_model_name(collection_node)
+          delegates = build_delegates(model_name, delegation_maps, local_delegates)
+          next if delegates.empty?
+
+          included = extract_included_associations(collection_node)
+          find_delegated_calls(block_body, block_var, delegates, included, file_path, issues)
+        end
+
+        issues
+      end
+
+      private
+
+      def collect_local_delegates(ast)
+        delegates = {}
+        traverse_ast(ast) do |node|
+          next unless delegate_call?(node)
+
+          extract_delegate_info(node, delegates)
+        end
+        delegates
+      end
+
+      def delegate_call?(node)
+        node.type == :send && node.children[0].nil? && node.children[1] == :delegate
+      end
+
+      def extract_delegate_info(node, delegates)
+        args = node.children[2..]
+        methods = args.select { |a| a&.type == :sym }.map { |a| a.children[0] }
+        return if methods.empty?
+
+        to_target = extract_to_target(args)
+        return unless to_target
+
+        methods.each { |m| delegates[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
+
+        value = node.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
+      end
+
+      def build_delegates(model_name, delegation_maps, local_delegates)
+        cross_file = model_name ? (delegation_maps[model_name] || {}) : {}
+        cross_file.merge(local_delegates)
+      end
+
+      def iteration_block?(node)
+        node.type == :block &&
+          node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
+      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 infer_model_name(node)
+        root = find_root_receiver(node)
+        root&.type == :const ? root.children[1].to_s : nil
+      end
+
+      def find_root_receiver(node)
+        current = node
+        current = current.children[0] while current&.type == :send
+        current
+      end
+
+      def extract_included_associations(collection_node)
+        included = Set.new
+        return included unless collection_node&.type == :send
+
+        current = collection_node
+        while current&.type == :send
+          extract_from_preload(current, included) if PRELOAD_METHODS.include?(current.children[1])
+          current = current.children[0]
+        end
+        included
+      end
+
+      def extract_from_preload(method_node, included_set)
+        args = extract_method_args(method_node)
+        included_set.merge(extract_symbols_from_args(args))
+      end
+
+      def find_delegated_calls(block_body, block_var, delegates, included, file_path, issues)
+        reported = Set.new
+        traverse_ast(block_body) do |node|
+          target_assoc = delegation_target(node, block_var, delegates, included, reported)
+          next unless target_assoc
+
+          issues << create_delegation_issue(node, block_var, target_assoc, file_path)
+        end
+      end
+
+      def delegation_target(node, block_var, delegates, included, reported)
+        return unless node.type == :send
+        return unless block_var_receiver?(node, block_var)
+
+        method = node.children[1]
+        target_assoc = delegates[method]
+        return unless target_assoc
+        return if included.include?(target_assoc)
+        return unless reported.add?("#{node.loc.line}:#{method}")
+
+        target_assoc
+      end
+
+      def block_var_receiver?(node, block_var)
+        receiver = node.children[0]
+        receiver&.type == :lvar && receiver.children[0] == block_var
+      end
+
+      def create_delegation_issue(node, block_var, target_assoc, file_path)
+        method = node.children[1]
+        create_issue(
+          file_path: file_path,
+          line_number: node.loc.line,
+          message: "Potential N+1: `#{block_var}.#{method}` is delegated to `#{target_assoc}` — " \
+                   "loads `#{target_assoc}` on each iteration",
+          suggestion: "Use `includes(:#{target_assoc})` before iterating"
+        )
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/loop_association.rb

@@ -3,7 +3,8 @@
 module EagerEye
   module Detectors
     class LoopAssociation < Base
-      ITERATION_METHODS = %i[each map collect select find find_all reject filter filter_map flat_map].freeze
+      ITERATION_METHODS = %i[each map collect select find find_all reject filter filter_map flat_map
+                             find_each find_in_batches in_batches].freeze
       PRELOAD_METHODS = %i[includes preload eager_load].freeze
       SINGLE_RECORD_METHODS = %i[find find_by find_by! first first! last last! take take! second third fourth fifth
                                  forty_two sole find_sole_by].freeze

data/lib/eager_eye/detectors/missing_counter_cache.rb

@@ -10,7 +10,8 @@ module EagerEye
         likes favorites bookmarks votes children replies responses answers questions
       ].freeze
       ITERATION_METHODS = %i[each map collect select reject find_all filter filter_map flat_map
-                             each_with_index each_with_object reduce inject sum].freeze
+                             each_with_index each_with_object reduce inject sum
+                             find_each find_in_batches in_batches].freeze
 
       def self.detector_name
         :missing_counter_cache

data/lib/eager_eye/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EagerEye
-  VERSION = "1.2.2"
+  VERSION = "1.2.4"
 end

data/lib/eager_eye.rb

@@ -5,6 +5,7 @@ require_relative "eager_eye/version"
 require_relative "eager_eye/configuration"
 require_relative "eager_eye/issue"
 require_relative "eager_eye/association_parser"
+require_relative "eager_eye/delegation_parser"
 require_relative "eager_eye/detectors/base"
 require_relative "eager_eye/detectors/loop_association"
 require_relative "eager_eye/detectors/serializer_nesting"
@@ -13,6 +14,7 @@ require_relative "eager_eye/detectors/custom_method_query"
 require_relative "eager_eye/detectors/count_in_iteration"
 require_relative "eager_eye/detectors/callback_query"
 require_relative "eager_eye/detectors/pluck_to_array"
+require_relative "eager_eye/detectors/delegation_n_plus_one"
 require_relative "eager_eye/comment_parser"
 require_relative "eager_eye/analyzer"
 require_relative "eager_eye/fixers/base"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-01 00:00:00.000000000 Z
+date: 2026-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -64,11 +64,13 @@ files:
 - lib/eager_eye/cli.rb
 - lib/eager_eye/comment_parser.rb
 - lib/eager_eye/configuration.rb
+- lib/eager_eye/delegation_parser.rb
 - lib/eager_eye/detectors/base.rb
 - lib/eager_eye/detectors/callback_query.rb
 - lib/eager_eye/detectors/concerns/non_ar_source_detector.rb
 - lib/eager_eye/detectors/count_in_iteration.rb
 - lib/eager_eye/detectors/custom_method_query.rb
+- lib/eager_eye/detectors/delegation_n_plus_one.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb
 - lib/eager_eye/detectors/pluck_to_array.rb