eager_eye 1.2.13 → 1.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b4195fa833057ee04ef87d148e78de8463fdbca97e234ba9d5b08ecaab9afc
-  data.tar.gz: f5c45a109aba0f563866669c4b6a32ce0823990fe5de467d65f6baea8d405197
+  metadata.gz: 84a1f7a4156669772686b2138d5015bd82e5859ec09d5b1cce55b795a896c8fe
+  data.tar.gz: bc45520cd998ab972ee86c6654cd6ec111846eb417512eae4d588ace8135cab0
 SHA512:
-  metadata.gz: 8312903e2476381ad7d9fe8a5a22feb74eb97937c5d488efc96448df9b0f5973f9d612c35cccd5235900e2eb25011694c862bb1a45a5bdeb70b2a8e17be155e2
-  data.tar.gz: cc7b4336007a72b0d4131b311a2897d4dae9cf0b4ba18ceb4826f25931875f418067bd5a16e6d1fec472cbb29abd7d1f2d2f0b58cc943b871fdea4e9991fa623
+  metadata.gz: c3a621919af0c95f005ba215d6db440504fa235e33ede88326ad1813f826f851e77bf20a7066200df993a18bc535c024142cc79930aab714b7db80995f2578f4
+  data.tar.gz: 86702c9c9ad9b27dcd4fb0a581bdab8864f7eda953b983b4bb7c3a07e6d5f581f39544c2ddfdc0fdb3f4b7c71d84be73df608d02302df7e1db51e4c4eaa4294e

data/CHANGELOG.md

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.15] - 2026-05-01
+
+### Fixed
+
+- **Per-method scope for variable preload tracking** — `LoopAssociation` and
+  `CustomMethodQuery` now process each `:def`/`:defs` body as an independent
+  scope. Previously a later assignment in another method (e.g.
+  `invoices = Invoice.includes(:invoice_items).where(...)` inside one action)
+  could overwrite the preload set for the same variable name in an earlier
+  action, producing false N+1 warnings on associations that were actually
+  preloaded. Each scope now inherits a snapshot from the enclosing scope but
+  its own writes do not leak back out.
+- **Caller-method preload tracking** — `LoopAssociation` and
+  `CustomMethodQuery` now propagate preload/model context across method calls
+  within the same class. When `def index` does
+  `items = Foo.includes(:bar); prepare_data(items)` and `def prepare_data(items)`
+  iterates the parameter, the `:bar` association is now correctly recognized
+  as preloaded. Previously every helper method that received a relation by
+  parameter produced false positives because the parameter had no preload
+  context.
+- Sibling defs in the same scope are processed in two passes: first to capture
+  each `self`-call's argument context, then to seed the callee's parameters
+  before analyzing its body. Multiple call sites are merged permissively (any
+  caller preloading suppresses the warning) to avoid false positives at the
+  expense of potentially missing helpers that have BOTH preloaded and
+  unpreloaded callers.
+
+## [1.2.14] - 2026-05-01
+
+### Fixed (false-positive reduction pass)
+
+- **Pagy / multi-assignment preload tracking** — `LoopAssociation` and `CustomMethodQuery` now follow preloads through `@pagy, items = pagy(query)` patterns and through wrapper calls like `pagy(...)`, `paginate(...)`, etc. Previously the `.includes(...)` on the wrapped query was lost across the multi-assign, generating false N+1 warnings on every preloaded association.
+- **Preloads through conditional / variable chains** — `extract_included_associations_deep` now walks ternary branches and inlined begin-blocks, and resolves `:lvar`/`:ivar` receivers via the variable preload map. `base = cond ? Q.includes(...).where(...) : Q.none` no longer drops preloads.
+- **Per-model association scoping** — `LoopAssociation` now infers the model class of the iteration variable and, when known, only flags methods that are actually associations on that model. This eliminates false positives where column accessors collide with hardcoded names (e.g. `log.tag`, `log.image`) or with associations defined on unrelated models.
+- **Per-model `method_queries` lookup** — `LoopAssociation` and `CustomMethodQuery` no longer flag `obj.foo` just because *some other* model defines a `def foo` containing a query. The match is scoped to the receiver's model when known, and association names on that model are excluded from the query-method check.
+- **`update_all` / `delete_all` / `destroy_all` chains** — `LoopAssociation` no longer flags association access whose only purpose is a non-loading terminal write (e.g. `avm.merchant_branches.update_all(...)`), since these don't trigger a SELECT for the association.
+- **`PluckToArray` `.where(...).all.pluck(:id)` mis-classification** — only an *unscoped* `.all.pluck(:id)` is escalated to error severity ("loads entire table"); chains scoped by `where`/`joins`/`limit`/etc. are no longer misreported as table-scans.
+
+### Changed
+
+- `AssociationParser` now exposes `associations_by_model` (a per-model `Set` of association names). Models with no declared associations are still registered, so detectors can distinguish "no associations" from "model unknown".
+- Detector signatures: `LoopAssociation#detect` and `CustomMethodQuery#detect` accept an `associations_by_model` argument (defaults to `{}`).
+
+## [1.2.13] - 2026-03-23
+
+### Fixed
+
+- Fixed gem packaging issue where `CountToSize` and `AddIncludes` auto-fixer files were missing from the published gem
+
 ## [1.2.12] - 2026-03-20
 
 ### 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.12-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.15-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>

data/lib/eager_eye/analyzer.rb

@@ -19,24 +19,25 @@ module EagerEye
     }.freeze
 
     DETECTOR_EXTRA_ARGS = {
-      Detectors::LoopAssociation => %i[association_preloads association_names method_queries],
+      Detectors::LoopAssociation => %i[association_preloads association_names method_queries associations_by_model],
       Detectors::SerializerNesting => %i[association_names method_queries],
       Detectors::MissingCounterCache => %i[association_names],
       Detectors::DecoratorNPlusOne => %i[association_names method_queries],
-      Detectors::CustomMethodQuery => %i[method_queries],
+      Detectors::CustomMethodQuery => %i[method_queries associations_by_model],
       Detectors::DelegationNPlusOne => %i[delegation_maps],
       Detectors::ScopeChainNPlusOne => %i[scope_maps],
       Detectors::ValidationNPlusOne => %i[uniqueness_models]
     }.freeze
 
     attr_reader :paths, :issues, :association_preloads, :association_names, :method_queries, :delegation_maps,
-                :scope_maps, :uniqueness_models
+                :scope_maps, :uniqueness_models, :associations_by_model
 
     def initialize(paths: nil)
       @paths = Array(paths || EagerEye.configuration.app_path)
       @issues = []
       @association_preloads = {}
       @association_names = Set.new
+      @associations_by_model = {}
       @method_queries = {}
       @delegation_maps = {}
       @scope_maps = {}
@@ -63,6 +64,9 @@ module EagerEye
         assoc_parser.parse_model(ast, model_name)
         @association_preloads.merge!(assoc_parser.preloaded_associations)
         @association_names.merge(assoc_parser.association_names)
+        assoc_parser.associations_by_model.each do |m, set|
+          (@associations_by_model[m] ||= Set.new).merge(set)
+        end
 
         deleg_parser = DelegationParser.new
         deleg_parser.parse_model(ast, model_name)

data/lib/eager_eye/association_parser.rb

@@ -4,16 +4,20 @@ module EagerEye
   class AssociationParser
     ASSOCIATION_METHODS = %i[has_many has_one belongs_to has_and_belongs_to_many].freeze
 
-    attr_reader :preloaded_associations, :association_names
+    attr_reader :preloaded_associations, :association_names, :associations_by_model
 
     def initialize
       @preloaded_associations = {}
       @association_names = Set.new
+      @associations_by_model = {}
     end
 
     def parse_model(ast, model_name)
       return unless ast
 
+      # Register the model even if it declares no associations, so callers can
+      # distinguish "model has no associations" from "model unknown to parser".
+      @associations_by_model[model_name] ||= Set.new
       traverse(ast, model_name)
     end
 
@@ -37,6 +41,7 @@ module EagerEye
       return unless association_name
 
       @association_names << association_name
+      (@associations_by_model[model_name] ||= Set.new) << association_name
 
       preloaded = extract_preloaded_associations(node)
       return if preloaded.empty?

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    module Concerns
+      # Tracks the inferred model class behind a local/instance variable, by
+      # walking AST value-nodes down to a `:const` (e.g. `User.where(...)` →
+      # `"User"`). Recurses into argument lists of relation-wrapper methods
+      # (pagy, paginate, ...) so that `pagy(User.includes(...))` is still
+      # recognized as a User-relation.
+      module VariableModelInference
+        # Methods whose first positional argument is the underlying relation
+        # (Pagy/Kaminari/etc.). Walking into those args lets us see through
+        # the wrapper to the source query.
+        RELATION_WRAPPERS = %i[pagy paginate page kaminari with_pagy].freeze
+
+        # LHS names in `@pagy, items = pagy(query)`-style assignments that
+        # should not inherit the relation's model — they hold pagination
+        # metadata, not records.
+        PAGINATION_META_NAMES = %i[pagy paginator meta page_info pagination].freeze
+
+        private
+
+        def infer_model_from_value(node, depth = 0) # rubocop:disable Metrics/CyclomaticComplexity
+          return nil if depth > 10 || !node.is_a?(Parser::AST::Node)
+
+          case node.type
+          when :const then node.children[1].to_s
+          when :send  then infer_model_from_send(node, depth)
+          when :lvar, :ivar then variable_model_for(node)
+          when :if    then infer_model_from_branches(node, depth)
+          when :begin then infer_model_from_first(node.children, depth)
+          end
+        end
+
+        def infer_model_from_send(node, depth)
+          method = node.children[1]
+          if RELATION_WRAPPERS.include?(method) && node.children[2]
+            from_arg = infer_model_from_value(node.children[2], depth + 1)
+            return from_arg if from_arg
+          end
+          infer_model_from_value(node.children[0], depth + 1)
+        end
+
+        def infer_model_from_branches(node, depth)
+          infer_model_from_value(node.children[1], depth + 1) ||
+            infer_model_from_value(node.children[2], depth + 1)
+        end
+
+        def infer_model_from_first(children, depth)
+          children.each do |child|
+            result = infer_model_from_value(child, depth + 1)
+            return result if result
+          end
+          nil
+        end
+
+        def variable_model_for(node)
+          @variable_models&.[]([node.type == :ivar ? :ivar : :lvar, node.children[0]])
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "concerns/variable_model_inference"
+
 module EagerEye
   module Detectors
-    class CustomMethodQuery < Base
+    class CustomMethodQuery < Base # rubocop:disable Metrics/ClassLength
+      include Concerns::VariableModelInference
+
       QUERY_METHODS = %i[where find_by find_by! exists? find first last take pluck ids count sum average minimum
                          maximum].freeze
       SAFE_QUERY_METHODS = %i[first last take count sum find size length ids].freeze
@@ -16,34 +20,222 @@ module EagerEye
         :custom_method_query
       end
 
-      def detect(ast, file_path, method_queries = {})
+      def detect(ast, file_path, method_queries = {}, associations_by_model = {})
         return [] unless ast
 
         @issues = []
         @file_path = file_path
         @method_queries = method_queries
+        @associations_by_model = associations_by_model
 
-        find_iteration_blocks(ast) do |block_body, block_var, collection, definitions|
-          check_block_for_query_methods(block_body, block_var, collection_is_array?(collection, definitions))
-          check_block_for_model_query_methods(block_body, block_var)
-        end
+        # Process each method def as its own scope so variable models from one
+        # method don't bleed into another (e.g. `orders = Order.all` in #index
+        # vs `orders = Foo.where(...).all` in #report — global tracking would
+        # mis-attribute the iteration variable's class across scopes).
+        process_scope(ast, {})
 
         @issues
       end
 
       private
 
-      def find_iteration_blocks(node, definitions = {}, &block)
+      def process_scope(scope_node, definitions)
+        @variable_models ||= {}
+        scope_body = scope_body_for(scope_node)
+        return unless scope_body
+
+        find_iteration_blocks_in_scope(scope_body, definitions)
+
+        process_nested_defs(scope_body, definitions)
+      end
+
+      def process_nested_defs(scope_body, definitions)
+        nested_defs = []
+        each_nested_def(scope_body) { |d| nested_defs << d }
+        return if nested_defs.empty?
+
+        call_sites_by_callee = collect_sibling_call_sites(nested_defs)
+
+        nested_defs.each do |nested_def|
+          with_scope_snapshot do
+            seed_params_from_callers(nested_def, call_sites_by_callee)
+            process_scope(nested_def, definitions.dup)
+          end
+        end
+      end
+
+      # See LoopAssociation#collect_sibling_call_sites for the rationale.
+      def collect_sibling_call_sites(nested_defs)
+        sibling_names = nested_defs.filter_map { |d| def_name(d) }.to_set
+        result = Hash.new { |h, k| h[k] = [] }
+
+        nested_defs.each do |def_node|
+          def_body = scope_body_for(def_node)
+          next unless def_body
+
+          with_scope_snapshot do
+            each_node_in_scope(def_body) do |node|
+              record_definition(node, {})
+              next unless self_send_to_sibling?(node, sibling_names)
+
+              result[node.children[1]] << {
+                args: node.children[2..],
+                models: @variable_models.dup
+              }
+            end
+          end
+        end
+
+        result
+      end
+
+      def self_send_to_sibling?(node, sibling_names)
+        return false unless node.type == :send
+
+        receiver = node.children[0]
+        return false unless receiver.nil? || (receiver.is_a?(Parser::AST::Node) && receiver.type == :self)
+
+        sibling_names.include?(node.children[1])
+      end
+
+      def def_name(def_node)
+        case def_node.type
+        when :def  then def_node.children[0]
+        when :defs then def_node.children[1]
+        end
+      end
+
+      def seed_params_from_callers(def_node, call_sites_by_callee)
+        return unless def_node.type == :def
+
+        call_sites = call_sites_by_callee[def_name(def_node)]
+        return if call_sites.nil? || call_sites.empty?
+
+        extract_param_names(def_node).each_with_index do |param_name, idx|
+          model = first_arg_model(call_sites, idx)
+          @variable_models[[:lvar, param_name]] = model if model
+        end
+      end
+
+      def first_arg_model(call_sites, idx)
+        call_sites.each do |site|
+          arg = site[:args][idx]
+          next unless arg
+
+          saved = @variable_models
+          @variable_models = site[:models]
+          model = infer_model_from_value(arg)
+          @variable_models = saved
+          return model if model
+        end
+        nil
+      end
+
+      def extract_param_names(def_node)
+        args_node = def_node.children[1]
+        return [] unless args_node.is_a?(Parser::AST::Node) && args_node.type == :args
+
+        args_node.children.filter_map do |arg|
+          next unless arg.is_a?(Parser::AST::Node) && %i[arg optarg kwarg kwoptarg].include?(arg.type)
+
+          arg.children[0]
+        end
+      end
+
+      def scope_body_for(node)
+        return node unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :def  then node.children[2]
+        when :defs then node.children[3]
+        else node
+        end
+      end
+
+      def with_scope_snapshot
+        saved_models = @variable_models.dup
+        yield
+      ensure
+        @variable_models = saved_models
+      end
+
+      def each_node_in_scope(node, &block)
         return unless node.is_a?(Parser::AST::Node)
 
-        definitions[node.children[0]] = node.children[1] if node.type == :lvasgn
+        yield node
+
+        node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+          next if %i[def defs].include?(child.type)
+
+          each_node_in_scope(child, &block)
+        end
+      end
+
+      def each_nested_def(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+
+          if %i[def defs].include?(child.type)
+            yield child
+          else
+            each_nested_def(child, &block)
+          end
+        end
+      end
+
+      def find_iteration_blocks_in_scope(scope_body, definitions)
+        each_node_in_scope(scope_body) do |node|
+          record_definition(node, definitions)
+          next unless iteration_block?(node)
 
-        if iteration_block?(node)
           block_var = extract_iteration_variable(node)
           block_body = node.children[2]
-          yield(block_body, block_var, node.children[0], definitions) if block_var && block_body
+          next unless block_var && block_body
+
+          model_name = infer_model_from_value(node.children[0])
+          check_block_for_query_methods(block_body, block_var, collection_is_array?(node.children[0], definitions))
+          check_block_for_model_query_methods(block_body, block_var, model_name)
+        end
+      end
+
+      def record_definition(node, definitions)
+        case node.type
+        when :lvasgn then record_simple_definition(node, :lvar, definitions)
+        when :ivasgn then record_simple_definition(node, :ivar, nil)
+        when :masgn  then record_multi_definition(node, definitions)
         end
-        node.children.each { |child| find_iteration_blocks(child, definitions, &block) }
+      end
+
+      def record_simple_definition(node, var_type, definitions)
+        name = node.children[0]
+        value = node.children[1]
+        return unless name && value
+
+        definitions[name] = value if definitions
+        model = infer_model_from_value(value)
+        @variable_models[[var_type, name]] = model if model
+      end
+
+      def record_multi_definition(node, definitions)
+        mlhs, rhs = node.children
+        return unless mlhs && rhs
+
+        model = infer_model_from_value(rhs)
+        mlhs.children.each { |target| record_multi_target(target, rhs, model, definitions) }
+      end
+
+      def record_multi_target(target, rhs, model, definitions)
+        return unless %i[lvasgn ivasgn].include?(target&.type)
+
+        tname = target.children[0]
+        return if PAGINATION_META_NAMES.include?(tname)
+
+        var_type = target.type == :lvasgn ? :lvar : :ivar
+        @variable_models[[var_type, tname]] = model if model
+        definitions[tname] = rhs if target.type == :lvasgn
       end
 
       def iteration_block?(node)
@@ -115,10 +307,10 @@ module EagerEye
         node.is_a?(Parser::AST::Node) && node.type == :send && QUERY_METHODS.include?(node.children[1])
       end
 
-      def check_block_for_model_query_methods(node, block_var)
+      def check_block_for_model_query_methods(node, block_var, model_name)
         return unless node.is_a?(Parser::AST::Node)
 
-        if model_query_call?(node, block_var)
+        if model_query_call?(node, block_var, model_name)
           method = node.children[1]
           @issues << create_issue(
             file_path: @file_path,
@@ -127,17 +319,38 @@ module EagerEye
             suggestion: "This method executes a query on each iteration. Preload data or move the query outside."
           )
         end
-        node.children.each { |child| check_block_for_model_query_methods(child, block_var) }
+        node.children.each { |child| check_block_for_model_query_methods(child, block_var, model_name) }
       end
 
-      def model_query_call?(node, block_var)
-        return false unless node.type == :send
+      def model_query_call?(node, block_var, model_name)
+        return false unless block_var_immediate_send?(node, block_var)
 
-        receiver = node.children[0]
         method = node.children[1]
-        return false unless receiver&.type == :lvar && receiver.children[0] == block_var
+        # If we know the receiver model AND the method is one of its
+        # associations, treat it as an association access — not a query method.
+        return false if association_on_model?(method, model_name)
+
+        method_defined_as_query?(method, model_name)
+      end
+
+      def block_var_immediate_send?(node, block_var)
+        node.type == :send &&
+          (receiver = node.children[0])&.type == :lvar &&
+          receiver.children[0] == block_var
+      end
+
+      def association_on_model?(method, model_name)
+        model_name && @associations_by_model&.dig(model_name)&.include?(method)
+      end
 
-        @method_queries&.any? { |_model, methods| methods.include?(method) }
+      def method_defined_as_query?(method, model_name)
+        return false unless @method_queries
+
+        if model_name
+          @method_queries[model_name]&.include?(method) || false
+        else
+          @method_queries.any? { |_model, methods| methods.include?(method) }
+        end
       end
 
       def add_issue(node)

data/lib/eager_eye/detectors/loop_association.rb

@@ -1,21 +1,29 @@
 # frozen_string_literal: true
 
+require_relative "concerns/variable_model_inference"
+
 module EagerEye
   module Detectors
-    class LoopAssociation < Base
+    class LoopAssociation < Base # rubocop:disable Metrics/ClassLength
+      include Concerns::VariableModelInference
+
       ITERATION_METHODS = %i[each map collect select find find_all reject filter filter_map flat_map
                              each_with_index each_with_object reduce inject
                              find_each find_in_batches in_batches array!].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
+      # Terminal methods on an association that do NOT trigger a SELECT for
+      # loading the association — they translate directly to UPDATE/DELETE SQL
+      # against the association's foreign key.
+      NON_LOADING_TERMINAL_METHODS = %i[update_all delete_all destroy_all touch_all
+                                        increment_counter decrement_counter].freeze
       ASSOCIATION_NAMES = Set.new(%w[
-        author user owner creator admin member customer client post article comment category tag
-        parent company organization project task item order product account profile setting image
-        avatar photo attachment document 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
+        author user owner creator admin member customer client post article comment category
+        parent company organization project task item order product account profile
+        avatar photo authors users owners creators admins members customers
+        clients posts articles comments categories children companies organizations projects
+        tasks items orders products accounts profiles avatars photos
       ]).freeze
       EXCLUDED_METHODS = %i[
         id to_s to_h to_a to_json to_xml inspect class object_id nil? blank? present? empty?
@@ -24,96 +32,381 @@ module EagerEye
         description value key type status state created_at updated_at deleted_at origin
         priority level kind label code reason amount price quantity url path email phone
         address notes memo data metadata position rank score rating enabled disabled active
-        published draft archived locked visible hidden
+        published draft archived locked visible hidden tag image attachment document setting
       ].freeze
 
       def self.detector_name
         :loop_association
       end
 
-      def detect(ast, file_path, association_preloads = {}, association_names = Set.new, method_queries = {})
+      def detect(ast, file_path, association_preloads = {}, association_names = Set.new, # rubocop:disable Metrics/ParameterLists
+                 method_queries = {}, associations_by_model = {})
         return [] unless ast
 
-        issues = []
+        @issues = []
+        @file_path = file_path
         @association_preloads = association_preloads
         @dynamic_associations = association_names
         @method_queries = method_queries
-        build_variable_maps(ast)
-
-        traverse_ast(ast) do |node|
-          next unless iteration_block?(node)
-
-          block_var = extract_iteration_variable(node)
-          next unless block_var
-
-          block_body = node.children[2]
-          next unless block_body
+        @associations_by_model = associations_by_model
 
-          collection_node = node.children[0]
-          next if single_record_iteration?(collection_node)
+        # Variable preloads/models leak across methods if tracked globally
+        # (e.g. controller#index sets `invoices = Invoice.includes(...)`, then
+        # controller#auto_match overwrites with `invoices = Invoice.where(...)`
+        # — the second assignment would erase the first method's preload data).
+        # Process each method scope independently and inherit a snapshot from
+        # the enclosing scope (top-level / outer class body).
+        process_scope(ast)
 
-          included = extract_included_associations(collection_node)
-          included.merge(extract_variable_preloads(collection_node))
-          included.merge(get_association_preloads(infer_model_name_from_collection(collection_node)))
-
-          find_association_calls(block_body, block_var, file_path, issues, included)
-        end
-
-        issues
+        @issues
       end
 
       private
 
+      def collect_included_associations(collection_node)
+        included = extract_included_associations_deep(collection_node)
+        included.merge(extract_variable_preloads(collection_node))
+        included.merge(get_association_preloads(infer_model_from_value(collection_node)))
+        included
+      end
+
       def get_association_preloads(model_name)
         preloaded = Set.new
+        return preloaded unless model_name
+
         @association_preloads&.each do |key, assocs|
           preloaded.merge(assocs) if key.start_with?("#{model_name}#")
         end
         preloaded
       end
 
-      def infer_model_name_from_collection(node)
-        return nil unless node&.type == :send
-
-        receiver = node.children[0]
-        receiver.children[1].to_s if receiver&.type == :const
-      end
-
       def iteration_block?(node)
         node.type == :block && node.children[0]&.type == :send &&
           ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
-      def extract_included_associations(collection_node)
+      # Extract :includes/:preload/:eager_load arguments from a value node,
+      # walking BOTH the receiver chain and any method arguments. The arg
+      # recursion is what lets us see through wrappers like pagy(query, ...).
+      def extract_included_associations_deep(value_node, depth = 0)
         included = Set.new
-        return included unless collection_node&.type == :send
+        return included if depth > 10 || !value_node.is_a?(Parser::AST::Node)
 
-        current = collection_node
-        while current&.type == :send
+        current = walk_send_chain_for_preloads(value_node, included, depth)
+        merge_preloads_from_non_send(current, included, depth)
+        included
+      end
+
+      def walk_send_chain_for_preloads(node, included, depth)
+        current = node
+        while current.is_a?(Parser::AST::Node) && current.type == :send
           extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(current.children[1])
+          current.children[2..].each do |arg|
+            included.merge(extract_included_associations_deep(arg, depth + 1))
+          end
           current = current.children[0]
         end
-        included
+        current
       end
 
-      def build_variable_maps(ast)
-        @variable_preloads = {}
-        @single_record_variables = Set.new
+      def merge_preloads_from_non_send(node, included, depth)
+        case node&.type
+        when :if          then merge_branch_preloads(node, included, depth)
+        when :begin       then node.children.each do |c|
+          included.merge(extract_included_associations_deep(c, depth + 1))
+        end
+        when :lvar, :ivar then merge_variable_preloads(node, included)
+        end
+      end
+
+      def merge_branch_preloads(node, included, depth)
+        included.merge(extract_included_associations_deep(node.children[1], depth + 1))
+        included.merge(extract_included_associations_deep(node.children[2], depth + 1))
+      end
+
+      def merge_variable_preloads(node, included)
+        key = [node.type == :ivar ? :ivar : :lvar, node.children[0]]
+        included.merge(@variable_preloads[key]) if @variable_preloads&.key?(key)
+      end
 
-        traverse_ast(ast) { |node| process_variable_assignment(node) }
+      # Walk this scope's body, then recurse into nested method defs as fresh
+      # scopes. A method def inherits a snapshot of the enclosing scope's
+      # variable state (so top-level lets/instance vars stay visible), but its
+      # own changes do not leak back out. Nested defs are processed in two
+      # passes: first to collect call sites between siblings (so we know which
+      # arguments each method receives at call time), then to actually analyze
+      # each def with its parameters seeded from caller context.
+      def process_scope(scope_node)
+        @variable_preloads ||= {}
+        @variable_models ||= {}
+        @single_record_variables ||= Set.new
+
+        scope_body = scope_body_for(scope_node)
+        return unless scope_body
+
+        build_variable_maps_in_scope(scope_body)
+        find_iterations_in_scope(scope_body)
+
+        process_nested_defs(scope_body)
+      end
+
+      def process_nested_defs(scope_body)
+        nested_defs = collect_nested_defs(scope_body)
+        return if nested_defs.empty?
+
+        call_sites_by_callee = collect_sibling_call_sites(nested_defs)
+
+        nested_defs.each do |nested_def|
+          with_scope_snapshot do
+            seed_params_from_callers(nested_def, call_sites_by_callee)
+            process_scope(nested_def)
+          end
+        end
+      end
+
+      def collect_nested_defs(scope_body)
+        defs = []
+        each_nested_def(scope_body) { |d| defs << d }
+        defs
+      end
+
+      # For each sibling def in this class/module body, build its variable map
+      # in isolation and capture every self-send to ANOTHER sibling. The
+      # captured snapshot is the caller's variable state at the call site —
+      # later we re-evaluate the call's arg expressions against this snapshot
+      # to derive the callee's parameter contexts.
+      def collect_sibling_call_sites(nested_defs)
+        sibling_names = nested_defs.filter_map { |d| def_name(d) }.to_set
+        result = Hash.new { |h, k| h[k] = [] }
+
+        nested_defs.each do |def_node|
+          def_body = scope_body_for(def_node)
+          next unless def_body
+
+          with_scope_snapshot do
+            build_variable_maps_in_scope(def_body)
+            capture_calls_to_siblings(def_body, sibling_names, result)
+          end
+        end
+
+        result
+      end
+
+      def capture_calls_to_siblings(def_body, sibling_names, result)
+        each_node_in_scope(def_body) do |node|
+          next unless self_send_to_sibling?(node, sibling_names)
+
+          callee = node.children[1]
+          result[callee] << {
+            args: node.children[2..],
+            preloads: @variable_preloads.dup,
+            models: @variable_models.dup
+          }
+        end
+      end
+
+      def self_send_to_sibling?(node, sibling_names)
+        return false unless node.type == :send
+
+        receiver = node.children[0]
+        return false unless receiver.nil? || (receiver.is_a?(Parser::AST::Node) && receiver.type == :self)
+
+        sibling_names.include?(node.children[1])
+      end
+
+      def def_name(def_node)
+        case def_node.type
+        when :def  then def_node.children[0]
+        when :defs then def_node.children[1]
+        end
+      end
+
+      # If `def_node` is called by sibling defs in this class, evaluate each
+      # call site's arguments in that caller's context and bind the resulting
+      # preloads/model to the callee's parameter names. This is what eliminates
+      # the "helper method receives a preloaded relation" false positive.
+      def seed_params_from_callers(def_node, call_sites_by_callee)
+        return unless def_node.type == :def
+
+        name = def_name(def_node)
+        call_sites = call_sites_by_callee[name]
+        return if call_sites.nil? || call_sites.empty?
+
+        param_names = extract_param_names(def_node)
+        param_names.each_with_index do |param_name, idx|
+          seed_single_param(param_name, idx, call_sites)
+        end
+      end
+
+      def seed_single_param(param_name, idx, call_sites)
+        merged_preloads = Set.new
+        chosen_model = nil
+
+        call_sites.each do |site|
+          arg = site[:args][idx]
+          next unless arg
+
+          with_call_site_context(site) do
+            merged_preloads.merge(extract_included_associations_deep(arg))
+            chosen_model ||= infer_model_from_value(arg)
+          end
+        end
+
+        key = [:lvar, param_name]
+        @variable_preloads[key] = merged_preloads unless merged_preloads.empty?
+        @variable_models[key] = chosen_model if chosen_model
+      end
+
+      def with_call_site_context(site)
+        saved_preloads = @variable_preloads
+        saved_models = @variable_models
+        @variable_preloads = site[:preloads]
+        @variable_models = site[:models]
+        yield
+      ensure
+        @variable_preloads = saved_preloads
+        @variable_models = saved_models
+      end
+
+      def extract_param_names(def_node)
+        args_node = def_node.children[1]
+        return [] unless args_node.is_a?(Parser::AST::Node) && args_node.type == :args
+
+        args_node.children.filter_map do |arg|
+          next unless arg.is_a?(Parser::AST::Node)
+          # Skip blockarg/restarg/kwrestarg etc. — only positional/optional/kwarg names.
+          next unless %i[arg optarg kwarg kwoptarg].include?(arg.type)
+
+          arg.children[0]
+        end
+      end
+
+      def scope_body_for(node)
+        return node unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :def  then node.children[2]
+        when :defs then node.children[3]
+        else node
+        end
+      end
+
+      def with_scope_snapshot
+        saved_preloads = @variable_preloads.dup
+        saved_models = @variable_models.dup
+        saved_single = @single_record_variables.dup
+        yield
+      ensure
+        @variable_preloads = saved_preloads
+        @variable_models = saved_models
+        @single_record_variables = saved_single
+      end
+
+      # Yields every node inside `scope_body` but stops at any :def/:defs —
+      # those subtrees represent fresh scopes and are visited separately.
+      def each_node_in_scope(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        yield node
+
+        node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+          next if %i[def defs].include?(child.type)
+
+          each_node_in_scope(child, &block)
+        end
+      end
+
+      # Yields each immediately-nested :def/:defs (not deeper-nested ones —
+      # those are visited via that def's own process_scope call).
+      def each_nested_def(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        node.children.each do |child|
+          next unless child.is_a?(Parser::AST::Node)
+
+          if %i[def defs].include?(child.type)
+            yield child
+          else
+            each_nested_def(child, &block)
+          end
+        end
+      end
+
+      def build_variable_maps_in_scope(scope_body)
+        each_node_in_scope(scope_body) { |node| process_variable_assignment(node) }
+      end
+
+      def find_iterations_in_scope(scope_body)
+        each_node_in_scope(scope_body) do |node|
+          process_iteration_block(node) if iteration_block?(node)
+        end
+      end
+
+      def process_iteration_block(node)
+        block_var = extract_iteration_variable(node)
+        return unless block_var
+
+        block_body = node.children[2]
+        return unless block_body
+
+        collection_node = node.children[0]
+        return if single_record_iteration?(collection_node)
+
+        included = collect_included_associations(collection_node)
+        model_name = infer_model_from_value(collection_node)
+        skip_nodes = collect_non_loading_skip_set(block_body)
+
+        find_association_calls(block_body, block_var, @file_path, @issues, included, model_name, skip_nodes)
       end
 
       def process_variable_assignment(node)
-        return unless %i[lvasgn ivasgn].include?(node.type)
+        case node.type
+        when :lvasgn, :ivasgn then process_simple_assignment(node)
+        when :masgn then process_multi_assignment(node)
+        end
+      end
 
+      def process_simple_assignment(node)
         var_type = node.type == :lvasgn ? :lvar : :ivar
         var_name = node.children[0]
         value_node = node.children[1]
-        return unless value_node
+        return unless value_node && var_name
+
+        record_variable(var_type, var_name, value_node)
+      end
 
+      def process_multi_assignment(node)
+        mlhs, rhs = node.children
+        return unless mlhs && rhs
+
+        # mlhs.children is a list of lvasgn/ivasgn (LHS targets). RHS is
+        # typically a method call like `pagy(query)` returning [meta, records],
+        # or an array literal. We can't statically know which target gets which
+        # slot, so apply preloads/model to every LHS — except names that look
+        # like pagination metadata.
+        mlhs.children.each { |target| record_multi_target(target, rhs) }
+      end
+
+      def record_multi_target(target, rhs)
+        return unless %i[lvasgn ivasgn].include?(target&.type)
+
+        name = target.children[0]
+        return if PAGINATION_META_NAMES.include?(name)
+
+        var_type = target.type == :lvasgn ? :lvar : :ivar
+        record_variable(var_type, name, rhs)
+      end
+
+      def record_variable(var_type, var_name, value_node)
         key = [var_type, var_name]
-        preloaded = extract_included_associations(value_node)
+
+        preloaded = extract_included_associations_deep(value_node)
         @variable_preloads[key] = preloaded unless preloaded.empty?
+
+        model = infer_model_from_value(value_node)
+        @variable_models[key] = model if model
+
         @single_record_variables.add(key) if single_record_query?(value_node)
       end
 
@@ -156,10 +449,33 @@ module EagerEye
         included_set.merge(extract_symbols_from_args(extract_method_args(method_node)))
       end
 
-      def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
+      # Pre-scan: when an inner send like `block_var.assoc` is the receiver of a
+      # NON_LOADING_TERMINAL_METHODS call (e.g. `.update_all`), the assoc access
+      # does not trigger a SELECT. Track those receiver nodes so we don't flag them.
+      def collect_non_loading_skip_set(block_body)
+        skip = Set.new
+        traverse_ast(block_body) do |node|
+          next unless node.type == :send && NON_LOADING_TERMINAL_METHODS.include?(node.children[1])
+
+          receiver = node.children[0]
+          collect_chain_node_ids(receiver, skip)
+        end
+        skip
+      end
+
+      def collect_chain_node_ids(node, set)
+        return unless node.is_a?(Parser::AST::Node) && node.type == :send
+
+        set.add(node.object_id)
+        collect_chain_node_ids(node.children[0], set)
+      end
+
+      def find_association_calls(node, block_var, file_path, issues, included_associations, model_name, skip_nodes) # rubocop:disable Metrics/ParameterLists
         reported = Set.new
         traverse_ast(node) do |child|
-          if reportable_association_call?(child, block_var, reported, included_associations)
+          next if skip_nodes.include?(child.object_id)
+
+          if reportable_association_call?(child, block_var, reported, included_associations, model_name)
             method = child.children[1]
             issues << create_issue(
               file_path: file_path,
@@ -167,7 +483,7 @@ module EagerEye
               message: "Potential N+1 query: `#{block_var}.#{method}` called inside loop",
               suggestion: "Use `includes(:#{method})` before iterating"
             )
-          elsif reportable_method_query_call?(child, block_var, reported)
+          elsif reportable_method_query_call?(child, block_var, reported, model_name)
             method = child.children[1]
             issues << create_issue(
               file_path: file_path,
@@ -179,35 +495,56 @@ module EagerEye
         end
       end
 
-      def reportable_association_call?(node, block_var, reported, included)
+      def reportable_association_call?(node, block_var, reported, included, model_name)
         return false unless node.type == :send
 
         receiver = node.children[0]
         method = node.children[1]
         return false unless receiver&.type == :lvar && receiver.children[0] == block_var
-        return false if excluded_method?(method, included)
+        return false if excluded_method?(method, included, model_name)
 
         reported.add?("#{node.loc.line}:#{method}")
       end
 
-      def excluded_method?(method, included)
+      def excluded_method?(method, included, model_name)
         EXCLUDED_METHODS.include?(method) ||
-          !known_association?(method) ||
-          included.include?(method)
+          included.include?(method) ||
+          !known_association?(method, model_name)
       end
 
-      def known_association?(method)
+      # When we know the iteration variable's model AND have parsed that model's
+      # associations, trust that map exclusively — methods not in it are columns
+      # or scalar accessors, not associations. Otherwise fall back to heuristics
+      # (hardcoded common names + globally collected association names).
+      def known_association?(method, model_name)
+        if model_name && @associations_by_model&.key?(model_name)
+          return @associations_by_model[model_name].include?(method)
+        end
+
         ASSOCIATION_NAMES.include?(method.to_s) || @dynamic_associations.include?(method)
       end
 
-      def reportable_method_query_call?(node, block_var, reported)
+      def reportable_method_query_call?(node, block_var, reported, model_name)
         return false unless block_var_send?(node, block_var)
         return false if EXCLUDED_METHODS.include?(node.children[1])
-        return false unless @method_queries&.any? { |_, ms| ms.include?(node.children[1]) }
+        return false unless method_known_to_query?(node.children[1], model_name)
 
         reported.add?("#{node.loc.line}:#{node.children[1]}")
       end
 
+      # When the receiver model is known, only consider methods defined as a
+      # query on THAT model — not any model in the project. Without a known
+      # model, fall back to the global "any model has this method" heuristic.
+      def method_known_to_query?(method, model_name)
+        return false unless @method_queries
+
+        if model_name
+          @method_queries[model_name]&.include?(method) || false
+        else
+          @method_queries.any? { |_, ms| ms.include?(method) }
+        end
+      end
+
       def block_var_send?(node, block_var)
         node.type == :send && node.children[0]&.type == :lvar && node.children[0].children[0] == block_var
       end

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -4,10 +4,14 @@ require_relative "concerns/non_ar_source_detector"
 
 module EagerEye
   module Detectors
-    class PluckToArray < Base
+    class PluckToArray < Base # rubocop:disable Metrics/ClassLength
       include Concerns::NonArSourceDetector
 
       SMALL_COLLECTIONS = %w[tags settings options categories roles permissions statuses types priorities].freeze
+      SCOPING_METHODS = %i[where not limit offset order group having distinct
+                           joins left_joins left_outer_joins includes preload eager_load
+                           lock select from references unscope merge or rewhere reorder regroup
+                           in_order_of].freeze
 
       def self.detector_name
         :pluck_to_array
@@ -117,9 +121,31 @@ module EagerEye
         node.is_a?(Parser::AST::Node) && node.type == :send && %i[pluck ids].include?(node.children[1])
       end
 
+      # `.all.pluck(:id)` is "critical" only when the `.all` is unscoped — i.e.
+      # there's no `.where`/`.limit`/etc. earlier in the chain. Otherwise the
+      # query is already filtered and isn't loading the entire table.
       def all_pluck_call?(node)
-        pluck_call?(node) && node.children[0].is_a?(Parser::AST::Node) &&
-          node.children[0].type == :send && node.children[0].children[1] == :all
+        return false unless pluck_call?(node)
+
+        receiver = node.children[0]
+        return false unless receiver.is_a?(Parser::AST::Node) && receiver.type == :send
+        return false unless receiver.children[1] == :all
+
+        unscoped_all?(receiver)
+      end
+
+      def unscoped_all?(all_node)
+        receiver = all_node.children[0]
+        # `.all` with no receiver (just `all` in a model context) — treat as unscoped.
+        return true if receiver.nil?
+
+        while receiver.is_a?(Parser::AST::Node) && receiver.type == :send
+          return false if SCOPING_METHODS.include?(receiver.children[1])
+
+          receiver = receiver.children[0]
+        end
+
+        true
       end
 
       def small_collection_pluck?(node)

data/lib/eager_eye/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.13
+  version: 1.2.15
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -69,6 +69,7 @@ files:
 - lib/eager_eye/detectors/callback_query.rb
 - lib/eager_eye/detectors/concerns/class_inspector.rb
 - lib/eager_eye/detectors/concerns/non_ar_source_detector.rb
+- lib/eager_eye/detectors/concerns/variable_model_inference.rb
 - lib/eager_eye/detectors/count_in_iteration.rb
 - lib/eager_eye/detectors/custom_method_query.rb
 - lib/eager_eye/detectors/decorator_n_plus_one.rb