eager_eye 1.2.13 → 1.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b4195fa833057ee04ef87d148e78de8463fdbca97e234ba9d5b08ecaab9afc
-  data.tar.gz: f5c45a109aba0f563866669c4b6a32ce0823990fe5de467d65f6baea8d405197
+  metadata.gz: 102d5299d625a885f2916d113d68a966cfb6c261bcebb8e5caf53f7d497c2a97
+  data.tar.gz: 64e954f730dc260001a80540e6304aeed6c0838e6f003ea6c39dd166b93850ae
 SHA512:
-  metadata.gz: 8312903e2476381ad7d9fe8a5a22feb74eb97937c5d488efc96448df9b0f5973f9d612c35cccd5235900e2eb25011694c862bb1a45a5bdeb70b2a8e17be155e2
-  data.tar.gz: cc7b4336007a72b0d4131b311a2897d4dae9cf0b4ba18ceb4826f25931875f418067bd5a16e6d1fec472cbb29abd7d1f2d2f0b58cc943b871fdea4e9991fa623
+  metadata.gz: 39a182c18271764a2258a2d5f416cd1c44dba5c1d18c11b74fd2ab6025d36569cf28778320cf66cb2c935f501e3310f8fdae7b74e550b6bdf24f9e28e2680c83
+  data.tar.gz: 85297df8068df3aa88d2a69be379d8139850b82841cb98f90899e418fdff93cd360ea54f5c94a0d6722ab81b315cc3805c13bb66645d7f64a58e9f9dff6e826c

data/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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.14-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
+      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,16 +20,19 @@ 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
+        @variable_models = {}
 
         find_iteration_blocks(ast) do |block_body, block_var, collection, definitions|
+          model_name = infer_model_from_value(collection)
           check_block_for_query_methods(block_body, block_var, collection_is_array?(collection, definitions))
-          check_block_for_model_query_methods(block_body, block_var)
+          check_block_for_model_query_methods(block_body, block_var, model_name)
         end
 
         @issues
@@ -36,7 +43,7 @@ module EagerEye
       def find_iteration_blocks(node, definitions = {}, &block)
         return unless node.is_a?(Parser::AST::Node)
 
-        definitions[node.children[0]] = node.children[1] if node.type == :lvasgn
+        record_definition(node, definitions)
 
         if iteration_block?(node)
           block_var = extract_iteration_variable(node)
@@ -46,6 +53,43 @@ module EagerEye
         node.children.each { |child| find_iteration_blocks(child, definitions, &block) }
       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
+      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)
         node.type == :block && node.children[0]&.type == :send &&
           ITERATION_METHODS.include?(node.children[0].children[1])
@@ -115,10 +159,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 +171,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
 
-        @method_queries&.any? { |_model, methods| methods.include?(method) }
+      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
+
+      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,20 +32,22 @@ 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 = []
         @association_preloads = association_preloads
         @dynamic_associations = association_names
         @method_queries = method_queries
+        @associations_by_model = associations_by_model
         build_variable_maps(ast)
 
         traverse_ast(ast) do |node|
@@ -52,11 +62,11 @@ module EagerEye
           collection_node = node.children[0]
           next if single_record_iteration?(collection_node)
 
-          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)))
+          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)
+          find_association_calls(block_body, block_var, file_path, issues, included, model_name, skip_nodes)
         end
 
         issues
@@ -64,56 +74,127 @@ module EagerEye
 
       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 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
 
       def build_variable_maps(ast)
         @variable_preloads = {}
+        @variable_models = {}
         @single_record_variables = Set.new
 
         traverse_ast(ast) { |node| process_variable_assignment(node) }
       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 +237,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 +271,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 +283,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.14"
 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.14
 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