eager_eye 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7ebed3daa9046b0b6bbda1cbb7a9cce182af014ac31334973b4d98a5a1059bc
-  data.tar.gz: 61e220f6737089f52ab495d422cac8b91bf4720d6551c6a42abad7801c7d3c79
+  metadata.gz: c0eccf7e9da999d8e273e9b41a11c96eb1284fdd944ce6af0e547f4201a3fbb9
+  data.tar.gz: 55b8ab8e753245bc5b638705bff5a0c10115c0f39f44d69f25f5b50dcb823ffa
 SHA512:
-  metadata.gz: 198f7d4c064f940a73e2ac41f401869274482f1388f9031f405c89cdeddd3e8e1cf829f8d107c7c3fa1a88fa1a5de07fe44a3d08acf4cb269aa063ebfafae729
-  data.tar.gz: 814ce257bfc024ca1d83b61cddd3df9b56ed877dfb40d9eaf5564c951bebf11f4351d0c4965ff1510509f62aad3f97af8f0e4933b5a23b4daf048b186d5c748b
+  metadata.gz: 9f41668f38474f848cffe0e70473c689c27eb9a102a20cdc932f1039a2c4dce71cb91eda4fa2bb1012136d48b93976cb33ad8455a3e01db2a2c400037a75420e
+  data.tar.gz: 2d8f591ee31948302c8a14fe2deef868bc98e2d7fd23083c39a6ee8e9242296e25080938f4e00cef24757c2d2ec6df512d7e6ef144945420de593168e0d71e96

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.6] - 2025-12-22
+
+### Fixed
+
+- Fixed false positive in `MissingCounterCache` detector for single `.count`/`.size`/`.length` calls
+  - Now only detects count calls **inside iterations** where N+1 queries actually occur
+  - Single calls like `post.comments.count` are no longer flagged (not N+1)
+  - Iteration patterns like `posts.each { |p| p.comments.count }` are correctly detected
+
+## [1.0.5] - 2025-12-21
+
+### Fixed
+
+- Fixed false positive N+1 warnings when iterating over a single record's associations
+  - Now correctly skips warnings for patterns like `User.find(id).posts.each { |p| p.comments }`
+  - Supports `find`, `find_by`, `find_by!`, `first`, `last`, `take`, `second`, `third`, etc.
+  - Works with both inline chains and variable assignments
+
 ## [1.0.4] - 2025-12-21
 
 ### Fixed

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.4-red.svg)](https://rubygems.org/gems/eager_eye)
+[![Gem Version](https://img.shields.io/badge/gem-v1.0.6-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)
@@ -114,6 +114,12 @@ end
 # Also works with preload and eager_load
 posts = Post.preload(:comments)
 posts.each { |post| post.comments.size }  # No warning
+
+# Single record context - no N+1 possible (also detected correctly!)
+@user = User.find(params[:id])
+@user.posts.each do |post|
+  post.comments  # No warning - single user, no N+1
+end
 ```
 
 ### 2. Serializer Nesting (N+1 in serializers)
@@ -144,19 +150,26 @@ Supports multiple serializer libraries:
 
 ### 3. Missing Counter Cache
 
-Detects `.count` or `.size` calls on associations that could benefit from counter caches.
+Detects `.count`, `.size`, or `.length` calls on associations **inside iterations** that could benefit from counter caches. Single calls outside loops are not flagged since they don't cause N+1 issues.
 
 ```ruby
-# Bad - COUNT query every time
-post.comments.count
-post.comments.size
+# Bad - COUNT query for each post in iteration
+posts.each do |post|
+  post.comments.count   # Detected: N+1 query!
+  post.likes.size       # Detected: N+1 query!
+end
 
-# Good - Add counter cache
+# OK - Single count call (not in iteration, no N+1)
+post.comments.count     # Not flagged - single query is fine
+
+# Good - Add counter cache for iteration use cases
 # In Comment model:
 belongs_to :post, counter_cache: true
 
 # Then this is a simple column read:
-post.comments_count
+posts.each do |post|
+  post.comments_count   # No query - just reads the column
+end
 ```
 
 ### 4. Custom Method Query (N+1 in query methods)

data/lib/eager_eye/detectors/loop_association.rb

@@ -5,22 +5,19 @@ module EagerEye
     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[
-        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
-      ].freeze
-
-      # Common plural association names (has_many pattern)
-      PLURAL_ASSOCIATIONS = %w[
-        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
-      ].freeze
+      # Methods that return a single record (not a collection)
+      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
+
+      # Common association names (belongs_to = singular, has_many = plural)
+      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
+      ]).freeze
 
       # Methods that should NOT be treated as associations
       EXCLUDED_METHODS = %i[
@@ -38,9 +35,7 @@ module EagerEye
         return [] unless ast
 
         issues = []
-
-        # Build a map of variable names to their preloaded associations
-        @variable_preloads = build_variable_preloads_map(ast)
+        build_variable_maps(ast)
 
         traverse_ast(ast) do |node|
           next unless iteration_block?(node)
@@ -51,15 +46,13 @@ module EagerEye
           block_body = node.children[2]
           next unless block_body
 
-          # 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)
+          next if single_record_iteration?(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)
+          included = extract_included_associations(collection_node)
+          included.merge(extract_variable_preloads(collection_node))
 
-          find_association_calls(block_body, block_var, file_path, issues, included_associations)
+          find_association_calls(block_body, block_var, file_path, issues, included)
         end
 
         issues
@@ -104,38 +97,28 @@ module EagerEye
         included
       end
 
-      def build_variable_preloads_map(ast)
-        preloads_map = {}
+      def build_variable_maps(ast)
+        @variable_preloads = {}
+        @single_record_variables = Set.new
 
         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
+          next unless %i[lvasgn ivasgn].include?(node.type)
 
-      def record_variable_preloads(preloads_map, var_type, node)
-        var_name = node.children[0]
-        value_node = node.children[1]
-        return unless value_node
+          var_type = node.type == :lvasgn ? :lvar : :ivar
+          var_name = node.children[0]
+          value_node = node.children[1]
+          next unless value_node
 
-        preloaded = extract_included_associations(value_node)
-        preloads_map[[var_type, var_name]] = preloaded unless preloaded.empty?
+          key = [var_type, var_name]
+          preloaded = extract_included_associations(value_node)
+          @variable_preloads[key] = preloaded unless preloaded.empty?
+          @single_record_variables.add(key) if single_record_query?(value_node)
+        end
       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
+      def extract_variable_preloads(node)
+        key = variable_key_for_node(node)
+        (key && @variable_preloads&.[](key)) || Set.new
       end
 
       def variable_key_for_node(node)
@@ -146,8 +129,19 @@ module EagerEye
         end
       end
 
-      def merge_preloads_for_key(preloads, key)
-        preloads.merge(@variable_preloads[key]) if @variable_preloads[key]
+      def single_record_query?(node)
+        current = node
+        while current&.type == :send && !SINGLE_RECORD_METHODS.include?(current.children[1])
+          current = current.children[0]
+        end
+        current&.type == :send && SINGLE_RECORD_METHODS.include?(current.children[1])
+      end
+
+      def single_record_iteration?(node)
+        return false unless node&.type == :send && (receiver = node.children[0])
+
+        key = variable_key_for_node(receiver)
+        (key && @single_record_variables&.include?(key)) || single_record_query?(receiver)
       end
 
       def extract_includes_from_method(method_node, included_set)
@@ -211,9 +205,7 @@ module EagerEye
       def likely_association?(method_name)
         return false if EXCLUDED_METHODS.include?(method_name)
 
-        name = method_name.to_s
-
-        SINGULAR_ASSOCIATIONS.include?(name) || PLURAL_ASSOCIATIONS.include?(name)
+        ASSOCIATION_NAMES.include?(method_name.to_s)
       end
     end
   end

data/lib/eager_eye/detectors/missing_counter_cache.rb

@@ -15,6 +15,11 @@ module EagerEye
         children replies responses answers questions
       ].freeze
 
+      # Iteration methods that indicate a loop context
+      ITERATION_METHODS = %i[each map collect select reject find_all
+                             filter filter_map flat_map each_with_index
+                             each_with_object reduce inject sum].freeze
+
       def self.detector_name
         :missing_counter_cache
       end
@@ -26,6 +31,7 @@ module EagerEye
 
         traverse_ast(ast) do |node|
           next unless count_on_association?(node)
+          next unless inside_iteration?(node)
 
           association_name = extract_association_name(node)
           next unless association_name
@@ -33,7 +39,7 @@ module EagerEye
           issues << create_issue(
             file_path: file_path,
             line_number: node.loc.line,
-            message: "`.#{node.children[1]}` called on `#{association_name}` may cause N+1 queries",
+            message: "`.#{node.children[1]}` called on `#{association_name}` inside iteration may cause N+1 queries",
             suggestion: "Consider adding `counter_cache: true` to the belongs_to association"
           )
         end
@@ -68,6 +74,46 @@ module EagerEye
 
         receiver.children[1].to_s
       end
+
+      # Check if the node is inside an iteration block
+      def inside_iteration?(node)
+        parent = node
+        while (parent = find_parent(parent))
+          return true if iteration_block?(parent)
+        end
+        false
+      end
+
+      def find_parent(node)
+        @parent_map ||= {}
+        @parent_map[node]
+      end
+
+      # Override traverse_ast to build parent map
+      def traverse_ast(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        @parent_map ||= {}
+
+        yield node
+
+        node.children.each do |child|
+          if child.is_a?(Parser::AST::Node)
+            @parent_map[child] = node
+            traverse_ast(child, &block)
+          end
+        end
+      end
+
+      def iteration_block?(node)
+        return false unless node.type == :block
+
+        send_node = node.children[0]
+        return false unless send_node&.type == :send
+
+        method_name = send_node.children[1]
+        ITERATION_METHODS.include?(method_name)
+      end
     end
   end
 end

data/lib/eager_eye/version.rb

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

metadata

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