eager_eye 1.2.14 → 1.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 102d5299d625a885f2916d113d68a966cfb6c261bcebb8e5caf53f7d497c2a97
-  data.tar.gz: 64e954f730dc260001a80540e6304aeed6c0838e6f003ea6c39dd166b93850ae
+  metadata.gz: 84a1f7a4156669772686b2138d5015bd82e5859ec09d5b1cce55b795a896c8fe
+  data.tar.gz: bc45520cd998ab972ee86c6654cd6ec111846eb417512eae4d588ace8135cab0
 SHA512:
-  metadata.gz: 39a182c18271764a2258a2d5f416cd1c44dba5c1d18c11b74fd2ab6025d36569cf28778320cf66cb2c935f501e3310f8fdae7b74e550b6bdf24f9e28e2680c83
-  data.tar.gz: 85297df8068df3aa88d2a69be379d8139850b82841cb98f90899e418fdff93cd360ea54f5c94a0d6722ab81b315cc3805c13bb66645d7f64a58e9f9dff6e826c
+  metadata.gz: c3a621919af0c95f005ba215d6db440504fa235e33ede88326ad1813f826f851e77bf20a7066200df993a18bc535c024142cc79930aab714b7db80995f2578f4
+  data.tar.gz: 86702c9c9ad9b27dcd4fb0a581bdab8864f7eda953b983b4bb7c3a07e6d5f581f39544c2ddfdc0fdb3f4b7c71d84be73df608d02302df7e1db51e4c4eaa4294e

data/CHANGELOG.md

@@ -7,6 +7,33 @@ 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)

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.14-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/detectors/custom_method_query.rb

@@ -4,7 +4,7 @@ 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
@@ -27,30 +27,178 @@ module EagerEye
         @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, model_name)
-        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)
+
+        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)
 
-        record_definition(node, definitions)
+        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
-        node.children.each { |child| find_iteration_blocks(child, definitions, &block) }
       end
 
       def record_definition(node, definitions)

data/lib/eager_eye/detectors/loop_association.rb

@@ -43,33 +43,22 @@ module EagerEye
                  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
         @associations_by_model = associations_by_model
-        build_variable_maps(ast)
 
-        traverse_ast(ast) do |node|
-          next unless iteration_block?(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)
 
-          block_var = extract_iteration_variable(node)
-          next unless block_var
-
-          block_body = node.children[2]
-          next unless block_body
-
-          collection_node = node.children[0]
-          next 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
-
-        issues
+        @issues
       end
 
       private
@@ -140,12 +129,235 @@ module EagerEye
         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
+      # 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)
 
-        traverse_ast(ast) { |node| process_variable_assignment(node) }
+        find_association_calls(block_body, block_var, @file_path, @issues, included, model_name, skip_nodes)
       end
 
       def process_variable_assignment(node)

data/lib/eager_eye/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.14
+  version: 1.2.15
 platform: ruby
 authors:
 - hamzagedikkaya