eager_eye 1.2.14 → 1.3.0

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/issue.rb

@@ -16,6 +16,18 @@ module EagerEye
       @suggestion = suggestion
     end
 
+    def self.from_h(hash)
+      h = hash.transform_keys(&:to_sym)
+      new(
+        detector: h.fetch(:detector).to_sym,
+        file_path: h.fetch(:file_path),
+        line_number: h.fetch(:line_number),
+        message: h.fetch(:message),
+        severity: (h[:severity] || :warning).to_sym,
+        suggestion: h[:suggestion]
+      )
+    end
+
     def severity_level
       SEVERITY_ORDER[severity]
     end
@@ -26,12 +38,12 @@ module EagerEye
 
     def to_h
       {
-        detector: detector,
-        file_path: file_path,
-        line_number: line_number,
-        message: message,
-        severity: severity,
-        suggestion: suggestion
+        detector:,
+        file_path:,
+        line_number:,
+        message:,
+        severity:,
+        suggestion:
       }
     end
 

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -4,6 +4,7 @@ require "set"
 require_relative "eager_eye/version"
 require_relative "eager_eye/configuration"
 require_relative "eager_eye/issue"
+require_relative "eager_eye/baseline"
 require_relative "eager_eye/association_parser"
 require_relative "eager_eye/delegation_parser"
 require_relative "eager_eye/scope_parser"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.14
+  version: 1.3.0
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-01 00:00:00.000000000 Z
+date: 2026-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -54,6 +54,7 @@ files:
 - CONTRIBUTING.md
 - LICENSE.txt
 - README.md
+- README.tr.md
 - Rakefile
 - SECURITY.md
 - exe/eager_eye
@@ -61,6 +62,7 @@ files:
 - lib/eager_eye/analyzer.rb
 - lib/eager_eye/association_parser.rb
 - lib/eager_eye/auto_fixer.rb
+- lib/eager_eye/baseline.rb
 - lib/eager_eye/cli.rb
 - lib/eager_eye/comment_parser.rb
 - lib/eager_eye/configuration.rb