eager_eye 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a37ac20117548282deb586bacdab0deab006b41581efa0810d3b64ffdcf1465
-  data.tar.gz: fa2dc1e3b2fa8582c0b48606ee88a75de9f7d6638593ea3404493b1383ad9512
+  metadata.gz: f7ebed3daa9046b0b6bbda1cbb7a9cce182af014ac31334973b4d98a5a1059bc
+  data.tar.gz: 61e220f6737089f52ab495d422cac8b91bf4720d6551c6a42abad7801c7d3c79
 SHA512:
-  metadata.gz: 8d4c41a777a9d79da47c9b0a5ce467acd951fdf1e72682e0ea235b5cc10329c403177c039ee7beb42a2f0b025796e6484d5e412f0e7697ad66902961f1348c2c
-  data.tar.gz: e293e6c338bc7413d922e3d0daad30e0033477b7819f5b95b551dd8aebe53d0efd350615ece1ff6cadabc03267fcce7aaa08814deb8fb16620f0974daa41a597
+  metadata.gz: 198f7d4c064f940a73e2ac41f401869274482f1388f9031f405c89cdeddd3e8e1cf829f8d107c7c3fa1a88fa1a5de07fe44a3d08acf4cb269aa063ebfafae729
+  data.tar.gz: 814ce257bfc024ca1d83b61cddd3df9b56ed877dfb40d9eaf5564c951bebf11f4351d0c4965ff1510509f62aad3f97af8f0e4933b5a23b4daf048b186d5c748b

data/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.4] - 2025-12-21
+
+### Fixed
+
+- Fixed false positive N+1 warnings when associations are preloaded via `includes`, `preload`, or `eager_load` on a separate line
+  - Now correctly tracks variable assignments with preload methods (e.g., `posts = Post.includes(:author)`)
+  - Supports both local variables and instance variables
+  - Works with all three preload methods: `includes`, `preload`, `eager_load`
+
+## [1.0.3] - 2025-12-20
+
+### Fixed
+
+- Only flag queries in callbacks where the iteration variable is the receiver (reduces false positives)
+- Updated README callback query documentation to accurately reflect current behavior
+
+## [1.0.2] - 2025-12-19
+
+### Fixed
+
+- Only detect queries inside iterations in callback detector
+
 ## [1.0.1] - 2025-12-16
 
 ### Changed

data/README.md

@@ -1,7 +1,7 @@
 # EagerEye
 
 [![CI](https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml/badge.svg)](https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml)
-[![Gem Version](https://img.shields.io/badge/gem-v1.0.1-red.svg)](https://rubygems.org/gems/eager_eye)
+[![Gem Version](https://img.shields.io/badge/gem-v1.0.4-red.svg)](https://rubygems.org/gems/eager_eye)
 [![Coverage](https://img.shields.io/badge/coverage-95%25-brightgreen.svg)](https://github.com/hamzagedikkaya/eager_eye)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.1-ruby.svg)](https://www.ruby-lang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -99,11 +99,21 @@ posts.each do |post|
   post.comments.count   # Another query for each post!
 end
 
-# Good - Eager load associations
+# Good - Eager load associations (chained)
 posts.includes(:author, :comments).each do |post|
   post.author.name      # No additional query
   post.comments.count   # No additional query
 end
+
+# Good - Eager load on separate line (also detected correctly!)
+@posts = Post.includes(:author)
+@posts.each do |post|
+  post.author.name      # No warning - EagerEye tracks the preload
+end
+
+# Also works with preload and eager_load
+posts = Post.preload(:comments)
+posts.each { |post| post.comments.size }  # No warning
 ```
 
 ### 2. Serializer Nesting (N+1 in serializers)
@@ -209,42 +219,45 @@ user.posts_count  # Just reads the column
 
 ### 6. Callback Query Detection
 
-Detects database queries and iterations inside ActiveRecord callbacks. These become performance disasters during bulk operations.
+Detects N+1 patterns inside ActiveRecord callbacks - specifically iterations that execute queries on each loop.
 
 ```ruby
-# Bad - Queries in callbacks
-class Article < ApplicationRecord
-  after_save :recalculate_stats
+# Bad - N+1 in callback (DETECTED)
+class Order < ApplicationRecord
+  after_create :notify_subscribers
 
-  def recalculate_stats
-    author.articles.published.count  # Runs on EVERY save
-    category.update_article_count!   # Another query on EVERY save
+  def notify_subscribers
+    customer.followers.each do |follower|  # Error: Iteration in callback
+      follower.notifications.create!(...)  # Warning: Query on iteration variable
+    end
   end
 end
 
-# Disaster scenario
-Article.import(1000.times.map { |i| { title: "Post #{i}" } })
-# = 2000+ queries from callbacks!
+# OK - Single query in callback (NOT flagged - not N+1)
+class Article < ApplicationRecord
+  after_save :update_stats
 
-# Bad - N+1 in callback
-class Order < ApplicationRecord
-  after_create :notify_subscribers
+  def update_stats
+    author.articles.count  # Single query, acceptable
+  end
+end
 
-  def notify_subscribers
-    customer.followers.each do |follower|  # N+1!
-      NotificationMailer.new_order(follower).deliver_later
+# OK - Query not on iteration variable (NOT flagged)
+class Post < ApplicationRecord
+  after_save :process_items
+
+  def process_items
+    items.each do |item|
+      OtherModel.where(name: item.name).first  # OtherModel is receiver, not item
     end
   end
 end
 
-# Good - Use conditional callbacks
-after_save :recalculate_stats, if: :should_recalculate?
-
-# Good - Move to background job
-after_commit :schedule_stats_update, on: :create
+# Good - Move iterations to background job
+after_commit :schedule_notifications, on: :create
 
-def schedule_stats_update
-  RecalculateStatsJob.perform_later(id)
+def schedule_notifications
+  NotifySubscribersJob.perform_later(id)
 end
 ```
 

data/lib/eager_eye/detectors/callback_query.rb

@@ -106,8 +106,9 @@ module EagerEye
         return unless node.is_a?(Parser::AST::Node)
 
         if iteration_block?(node)
+          block_var = extract_block_variable(node)
           add_iteration_issue(node, method_name, callback_type)
-          find_query_calls_in_block(node, method_name, callback_type)
+          find_query_calls_in_block(node, method_name, callback_type, block_var) if block_var
         end
 
         node.children.each do |child|
@@ -115,13 +116,15 @@ module EagerEye
         end
       end
 
-      def find_query_calls_in_block(node, method_name, callback_type)
+      def find_query_calls_in_block(node, method_name, callback_type, block_var)
         return unless node.is_a?(Parser::AST::Node)
 
-        add_query_issue(node, method_name, callback_type) if query_call?(node)
+        if query_call?(node) && receiver_chain_starts_with?(node.children[0], block_var)
+          add_query_issue(node, method_name, callback_type)
+        end
 
         node.children.each do |child|
-          find_query_calls_in_block(child, method_name, callback_type)
+          find_query_calls_in_block(child, method_name, callback_type, block_var)
         end
       end
 
@@ -163,6 +166,29 @@ module EagerEye
           suggestion: "Avoid iterations in callbacks. Use background jobs for bulk operations"
         )
       end
+
+      def extract_block_variable(block_node)
+        args_node = block_node.children[1]
+        return nil unless args_node&.type == :args
+
+        first_arg = args_node.children[0]
+        return nil unless first_arg&.type == :arg
+
+        first_arg.children[0]
+      end
+
+      def receiver_chain_starts_with?(node, block_var)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar
+          node.children[0] == block_var
+        when :send
+          receiver_chain_starts_with?(node.children[0], block_var)
+        else
+          false
+        end
+      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].freeze
+      PRELOAD_METHODS = %i[includes preload eager_load].freeze
 
       # Common singular association names (belongs_to pattern)
       SINGULAR_ASSOCIATIONS = %w[
@@ -23,12 +24,10 @@ module EagerEye
 
       # Methods that should NOT be treated as associations
       EXCLUDED_METHODS = %i[
-        id to_s to_h to_a to_json to_xml inspect class object_id
-        nil? blank? present? empty? any? none? size count length
-        save save! update update! destroy destroy! delete delete!
-        valid? invalid? errors new? persisted? changed? frozen?
-        name title body content text description value key type status state
-        created_at updated_at deleted_at
+        id to_s to_h to_a to_json to_xml inspect class object_id nil? blank? present? empty?
+        any? none? size count length save save! update update! destroy destroy! delete delete!
+        valid? invalid? errors new? persisted? changed? frozen? name title body content text
+        description value key type status state created_at updated_at deleted_at
       ].freeze
 
       def self.detector_name
@@ -40,6 +39,9 @@ module EagerEye
 
         issues = []
 
+        # Build a map of variable names to their preloaded associations
+        @variable_preloads = build_variable_preloads_map(ast)
+
         traverse_ast(ast) do |node|
           next unless iteration_block?(node)
 
@@ -49,10 +51,14 @@ module EagerEye
           block_body = node.children[2]
           next unless block_body
 
-          # Check if the collection already has includes
+          # Check if the collection already has includes (both chained and from variable assignment)
           collection_node = node.children[0]
           included_associations = extract_included_associations(collection_node)
 
+          # Also check if the collection comes from a variable that was assigned with preloads
+          variable_preloads = extract_variable_preloads(collection_node)
+          included_associations.merge(variable_preloads)
+
           find_association_calls(block_body, block_var, file_path, issues, included_associations)
         end
 
@@ -86,11 +92,11 @@ module EagerEye
         included = Set.new
         return included unless collection_node&.type == :send
 
-        # Traverse through chained method calls to find includes()
+        # Traverse through chained method calls to find includes/preload/eager_load
         current = collection_node
         while current&.type == :send
           method_name = current.children[1]
-          extract_includes_from_method(current, included) if method_name == :includes
+          extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(method_name)
 
           current = current.children[0]
         end
@@ -98,6 +104,52 @@ module EagerEye
         included
       end
 
+      def build_variable_preloads_map(ast)
+        preloads_map = {}
+
+        traverse_ast(ast) do |node|
+          case node.type
+          when :lvasgn
+            record_variable_preloads(preloads_map, :lvar, node)
+          when :ivasgn
+            record_variable_preloads(preloads_map, :ivar, node)
+          end
+        end
+
+        preloads_map
+      end
+
+      def record_variable_preloads(preloads_map, var_type, node)
+        var_name = node.children[0]
+        value_node = node.children[1]
+        return unless value_node
+
+        preloaded = extract_included_associations(value_node)
+        preloads_map[[var_type, var_name]] = preloaded unless preloaded.empty?
+      end
+
+      def extract_variable_preloads(collection_node)
+        preloads = Set.new
+        return preloads unless @variable_preloads
+
+        key = variable_key_for_node(collection_node)
+        merge_preloads_for_key(preloads, key) if key
+
+        preloads
+      end
+
+      def variable_key_for_node(node)
+        case node&.type
+        when :lvar then [:lvar, node.children[0]]
+        when :ivar then [:ivar, node.children[0]]
+        when :send then variable_key_for_node(node.children[0])
+        end
+      end
+
+      def merge_preloads_for_key(preloads, key)
+        preloads.merge(@variable_preloads[key]) if @variable_preloads[key]
+      end
+
       def extract_includes_from_method(method_node, included_set)
         args = method_node.children[2..]
         args&.each do |arg|

data/lib/eager_eye/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-19 00:00:00.000000000 Z
+date: 2025-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast