eager_eye 1.2.9 → 1.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cedfbe1ec9b556f757e9b161f896d96986bfc2dac8bf865c6e1bc289f6777b8
-  data.tar.gz: 8c0dc65a55e21c5d4e122f51293ac480f01435af2b719a262efe6ccdfa04603c
+  metadata.gz: 6f108cfabf63f2311f76b96145ea91535ef022703c3d10f73f04cbf6132110ba
+  data.tar.gz: ee909d0893f862770c3e481adf5e9041da306c86e821458dd5c069404738ff1a
 SHA512:
-  metadata.gz: 64d29ba207011df8fee0e11e6557de652ad5e3ed87c140e68cbedebb44988a477da0e2d5842fe28460811ebcc53db974f5403f4d73dd9de2653980a329e9a10c
-  data.tar.gz: f1dc481bc8b85c6e03443edee9508216ffd111d49c09c0aabf021ef9250e42bc8a84ca95ab7fa6afb808ab9c041736fb75af40bbb8acdd2efd4f5ac060f879b7
+  metadata.gz: 387702e5516001bd86637e039c999dbb52cf30e1d20ec293afd23c70a4b591be34f0aa245bc96eb6d5bec4e1e34a3a9bc9e09295525db53550b2df6833a3a06c
+  data.tar.gz: 605eec5df28fdaf038d77c95c564e8ee3eb4768be9e900be58c96b99a0b715ad4d28b286c65a2c7844f61906146db39168761744386f73ce5f61e1e77fe7c4cb

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.11] - 2026-03-17
+
+### Added
+
+- **`each_with_object` / `reduce` / `inject` Support** - `LoopAssociation` and `CustomMethodQuery` detectors now recognize these iteration methods
+  - `each_with_object` and `each_with_index` blocks are detected (item is first param)
+  - `reduce` and `inject` blocks are detected with correct variable extraction (item is second param: `|memo, item|`)
+  - `extract_iteration_variable` helper added to `Base` for reuse across detectors
+
+## [1.2.10] - 2026-03-16
+
+### Added
+
+- **Cross-File Analysis** - Model methods containing queries are now detected when called from other files
+  - New `MethodQueryParser` scans model files for methods that execute queries (`.where`, `.find_by`, `.count`, `.pluck`, etc.)
+  - `LoopAssociation` detects cross-file query methods called inside loops (e.g. `user.active_orders` in a controller)
+  - `CustomMethodQuery` detects model query methods called inside iterations
+  - `SerializerNesting` detects model query methods called in serializer attribute blocks
+  - `DecoratorNPlusOne` detects model query methods called in decorator methods
+  - Two-pass architecture: first pass collects method signatures, second pass detects cross-file N+1 patterns
+
 ## [1.2.9] - 2026-03-13
 
 ### Changed

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.9-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.11-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>
@@ -739,6 +739,7 @@ EagerEye uses static analysis, which means:
 - **No runtime context** - Cannot know if associations are already eager loaded elsewhere
 - **Heuristic-based** - Uses naming conventions to identify associations (may have false positives)
 - **Ruby code only** - Does not analyze SQL queries or ActiveRecord internals
+- **Cross-file scope** - Cross-file analysis is limited to model-defined methods; controller-to-view or service-to-service patterns are not yet tracked
 
 For best results, use EagerEye alongside runtime tools like Bullet for comprehensive N+1 detection.
 

data/lib/eager_eye/analyzer.rb

@@ -19,23 +19,25 @@ module EagerEye
     }.freeze
 
     DETECTOR_EXTRA_ARGS = {
-      Detectors::LoopAssociation => %i[association_preloads association_names],
-      Detectors::SerializerNesting => %i[association_names],
+      Detectors::LoopAssociation => %i[association_preloads association_names method_queries],
+      Detectors::SerializerNesting => %i[association_names method_queries],
       Detectors::MissingCounterCache => %i[association_names],
-      Detectors::DecoratorNPlusOne => %i[association_names],
+      Detectors::DecoratorNPlusOne => %i[association_names method_queries],
+      Detectors::CustomMethodQuery => %i[method_queries],
       Detectors::DelegationNPlusOne => %i[delegation_maps],
       Detectors::ScopeChainNPlusOne => %i[scope_maps],
       Detectors::ValidationNPlusOne => %i[uniqueness_models]
     }.freeze
 
-    attr_reader :paths, :issues, :association_preloads, :association_names, :delegation_maps, :scope_maps,
-                :uniqueness_models
+    attr_reader :paths, :issues, :association_preloads, :association_names, :method_queries, :delegation_maps,
+                :scope_maps, :uniqueness_models
 
     def initialize(paths: nil)
       @paths = Array(paths || EagerEye.configuration.app_path)
       @issues = []
       @association_preloads = {}
       @association_names = Set.new
+      @method_queries = {}
       @delegation_maps = {}
       @scope_maps = {}
       @uniqueness_models = Set.new
@@ -73,6 +75,10 @@ module EagerEye
         validation_parser = ValidationParser.new
         validation_parser.parse_model(ast, model_name)
         @uniqueness_models.merge(validation_parser.uniqueness_models)
+
+        method_query_parser = MethodQueryParser.new
+        method_query_parser.parse_model(ast, model_name)
+        @method_queries.merge!(method_query_parser.method_queries)
       rescue Errno::ENOENT, Errno::EACCES
         next
       end

data/lib/eager_eye/detectors/base.rb

@@ -73,12 +73,24 @@ module EagerEye
         end
       end
 
+      ACCUMULATOR_FIRST_METHODS = %i[reduce inject].freeze
+
       def extract_block_variable(block_node)
         args = block_node&.children&.[](1)
         first_arg = args&.children&.first
         first_arg&.type == :arg ? first_arg.children[0] : nil
       end
 
+      def extract_iteration_variable(block_node)
+        idx = accumulator_first?(block_node) ? 1 : 0
+        arg = block_node.children[1]&.children&.[](idx)
+        arg&.type == :arg ? arg.children[0] : nil
+      end
+
+      def accumulator_first?(block_node)
+        ACCUMULATOR_FIRST_METHODS.include?(block_node.children[0]&.children&.[](1))
+      end
+
       def receiver_chain_starts_with?(node, target_var)
         return false unless node.is_a?(Parser::AST::Node)
 

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -9,20 +9,23 @@ module EagerEye
       SAFE_TRANSFORM_METHODS = %i[keys values split [] params sort pluck ids to_s to_a to_i chars bytes].freeze
       ARRAY_COLUMN_SUFFIXES = %w[_ids _tags _types _codes _names _values _arr].freeze
       ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map
+                             each_with_index each_with_object reduce inject
                              find_each find_in_batches in_batches].freeze
 
       def self.detector_name
         :custom_method_query
       end
 
-      def detect(ast, file_path)
+      def detect(ast, file_path, method_queries = {})
         return [] unless ast
 
         @issues = []
         @file_path = file_path
+        @method_queries = method_queries
 
         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
 
         @issues
@@ -36,7 +39,7 @@ module EagerEye
         definitions[node.children[0]] = node.children[1] if node.type == :lvasgn
 
         if iteration_block?(node)
-          block_var = extract_block_variable(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
         end
@@ -112,6 +115,31 @@ 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)
+        return unless node.is_a?(Parser::AST::Node)
+
+        if model_query_call?(node, block_var)
+          method = node.children[1]
+          @issues << create_issue(
+            file_path: @file_path,
+            line_number: node.loc.line,
+            message: "Model method `.#{method}` contains a query and is called inside iteration",
+            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) }
+      end
+
+      def model_query_call?(node, block_var)
+        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
+
+        @method_queries&.any? { |_model, methods| methods.include?(method) }
+      end
+
       def add_issue(node)
         chain = reconstruct_chain(node.children[0])
         @issues << create_issue(

data/lib/eager_eye/detectors/decorator_n_plus_one.rb

@@ -14,10 +14,11 @@ module EagerEye
         :decorator_n_plus_one
       end
 
-      def detect(ast, file_path, association_names = Set.new)
+      def detect(ast, file_path, association_names = Set.new, method_queries = {})
         return [] unless ast
 
         @dynamic_associations = association_names
+        @method_queries = method_queries
         issues = []
         traverse_ast(ast) do |node|
           next unless node.type == :class && decorator_class?(node)
@@ -65,21 +66,34 @@ module EagerEye
 
           receiver = node.children[0]
           method_name = node.children[1]
-          next unless object_reference?(receiver) && likely_association?(method_name)
+          next unless object_reference?(receiver)
 
           ref = receiver.children[1]
-          issues << create_issue(
-            file_path: file_path,
-            line_number: node.loc.line,
-            message: "N+1 in decorator: `#{ref}.#{method_name}` loads association on each decorated object",
-            suggestion: "Eager load :#{method_name} in the controller before decorating the collection"
-          )
+          if likely_association?(method_name)
+            issues << create_issue(
+              file_path: file_path,
+              line_number: node.loc.line,
+              message: "N+1 in decorator: `#{ref}.#{method_name}` loads association on each decorated object",
+              suggestion: "Eager load :#{method_name} in the controller before decorating the collection"
+            )
+          elsif model_query_method?(method_name)
+            issues << create_issue(
+              file_path: file_path,
+              line_number: node.loc.line,
+              message: "N+1 in decorator: `#{ref}.#{method_name}` calls a query method defined in the model",
+              suggestion: "Preload the data in the controller before decorating the collection"
+            )
+          end
         end
       end
 
       def object_reference?(node)
         node&.type == :send && node.children[0].nil? && OBJECT_REFS.include?(node.children[1])
       end
+
+      def model_query_method?(method_name)
+        @method_queries&.any? { |_model, methods| methods.include?(method_name) }
+      end
     end
   end
 end

data/lib/eager_eye/detectors/loop_association.rb

@@ -4,6 +4,7 @@ module EagerEye
   module Detectors
     class LoopAssociation < Base
       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].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
@@ -30,18 +31,19 @@ module EagerEye
         :loop_association
       end
 
-      def detect(ast, file_path, association_preloads = {}, association_names = Set.new)
+      def detect(ast, file_path, association_preloads = {}, association_names = Set.new, method_queries = {})
         return [] unless ast
 
         issues = []
         @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_block_variable(node)
+          block_var = extract_iteration_variable(node)
           next unless block_var
 
           block_body = node.children[2]
@@ -157,15 +159,23 @@ module EagerEye
       def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
         reported = Set.new
         traverse_ast(node) do |child|
-          next unless reportable_association_call?(child, block_var, reported, included_associations)
-
-          method = child.children[1]
-          issues << create_issue(
-            file_path: file_path,
-            line_number: child.loc.line,
-            message: "Potential N+1 query: `#{block_var}.#{method}` called inside loop",
-            suggestion: "Use `includes(:#{method})` before iterating"
-          )
+          if reportable_association_call?(child, block_var, reported, included_associations)
+            method = child.children[1]
+            issues << create_issue(
+              file_path: file_path,
+              line_number: child.loc.line,
+              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)
+            method = child.children[1]
+            issues << create_issue(
+              file_path: file_path,
+              line_number: child.loc.line,
+              message: "Potential N+1 query: `#{block_var}.#{method}` calls a query method defined in the model",
+              suggestion: "Preload the data or restructure to avoid per-record queries"
+            )
+          end
         end
       end
 
@@ -189,6 +199,18 @@ module EagerEye
       def known_association?(method)
         ASSOCIATION_NAMES.include?(method.to_s) || @dynamic_associations.include?(method)
       end
+
+      def reportable_method_query_call?(node, block_var, reported)
+        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]) }
+
+        reported.add?("#{node.loc.line}:#{node.children[1]}")
+      end
+
+      def block_var_send?(node, block_var)
+        node.type == :send && node.children[0]&.type == :lvar && node.children[0].children[0] == block_var
+      end
     end
   end
 end

data/lib/eager_eye/detectors/serializer_nesting.rb

@@ -15,10 +15,11 @@ module EagerEye
         :serializer_nesting
       end
 
-      def detect(ast, file_path, association_names = Set.new)
+      def detect(ast, file_path, association_names = Set.new, method_queries = {})
         return [] unless ast
 
         @dynamic_associations = association_names
+        @method_queries = method_queries
         issues = []
         traverse_ast(ast) do |node|
           next unless node.type == :class && serializer_class?(node)
@@ -86,14 +87,23 @@ module EagerEye
 
           receiver = node.children[0]
           method_name = node.children[1]
-          next unless object_reference?(receiver) && likely_association?(method_name)
-
-          issues << create_issue(
-            file_path: file_path,
-            line_number: node.loc.line,
-            message: "Nested association `#{receiver_name(receiver)}.#{method_name}` in serializer attribute",
-            suggestion: "Eager load :#{method_name} in controller or use association serializer"
-          )
+          next unless object_reference?(receiver)
+
+          if likely_association?(method_name)
+            issues << create_issue(
+              file_path: file_path,
+              line_number: node.loc.line,
+              message: "Nested association `#{receiver_name(receiver)}.#{method_name}` in serializer attribute",
+              suggestion: "Eager load :#{method_name} in controller or use association serializer"
+            )
+          elsif model_query_method?(method_name)
+            issues << create_issue(
+              file_path: file_path,
+              line_number: node.loc.line,
+              message: "Model method `#{receiver_name(receiver)}.#{method_name}` contains a query in serializer",
+              suggestion: "This method executes a query per serialized object. Preload or cache the data."
+            )
+          end
         end
       end
 
@@ -114,6 +124,10 @@ module EagerEye
         else "object"
         end
       end
+
+      def model_query_method?(method_name)
+        @method_queries&.any? { |_model, methods| methods.include?(method_name) }
+      end
     end
   end
 end

data/lib/eager_eye/method_query_parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module EagerEye
+  class MethodQueryParser
+    QUERY_METHODS = %i[where find find_by find_by! exists? any? none? many? one?
+                       count sum average minimum maximum
+                       pluck ids select
+                       update_all delete_all destroy_all
+                       create create! save save!
+                       first last take].freeze
+
+    ASSOCIATION_METHODS = %i[has_many has_one belongs_to has_and_belongs_to_many].freeze
+
+    attr_reader :method_queries
+
+    def initialize
+      @method_queries = {}
+    end
+
+    def parse_model(ast, model_name)
+      return unless ast
+
+      traverse(ast, model_name)
+    end
+
+    private
+
+    def traverse(node, model_name)
+      return unless node.is_a?(Parser::AST::Node)
+
+      check_method(node, model_name)
+      node.children.each { |child| traverse(child, model_name) }
+    end
+
+    def check_method(node, model_name)
+      return unless instance_method_def?(node)
+
+      method_name = node.children[0]
+      body = node.children[2]
+      return unless body && contains_query?(body)
+
+      @method_queries[model_name] ||= Set.new
+      @method_queries[model_name] << method_name
+    end
+
+    def instance_method_def?(node)
+      node.type == :def
+    end
+
+    def contains_query?(node)
+      return false unless node.is_a?(Parser::AST::Node)
+      return true if query_call?(node)
+
+      node.children.any? { |child| contains_query?(child) }
+    end
+
+    def query_call?(node)
+      node.type == :send && QUERY_METHODS.include?(node.children[1])
+    end
+  end
+end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -8,6 +8,7 @@ require_relative "eager_eye/association_parser"
 require_relative "eager_eye/delegation_parser"
 require_relative "eager_eye/scope_parser"
 require_relative "eager_eye/validation_parser"
+require_relative "eager_eye/method_query_parser"
 require_relative "eager_eye/detectors/base"
 require_relative "eager_eye/detectors/loop_association"
 require_relative "eager_eye/detectors/serializer_nesting"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.2.11
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-16 00:00:00.000000000 Z
+date: 2026-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -84,6 +84,7 @@ files:
 - lib/eager_eye/fixers/pluck_to_select.rb
 - lib/eager_eye/generators/install_generator.rb
 - lib/eager_eye/issue.rb
+- lib/eager_eye/method_query_parser.rb
 - lib/eager_eye/railtie.rb
 - lib/eager_eye/reporters/base.rb
 - lib/eager_eye/reporters/console.rb