eager_eye 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6329285c3bdd39b8c99bbf665ffef121ac0dc5530b26b8e125d71ca04239a7a4
-  data.tar.gz: 78a608b043a06a58b22a54553d0c0b4ee459c2ee921405f01c5a216a77e801fb
+  metadata.gz: 037dbef0e4dc82641ae8c56bb8110f822900dd7afe76ddac6051b375bb547208
+  data.tar.gz: 1d0878ea0046406e264ddfa92d68ac0c9f1748aea4803d9a638554bb13ea77c9
 SHA512:
-  metadata.gz: 5d985342e6d3bc4a09dab284b153807b4cda7a7dce898c4dca9ca3e0223e6fb2f575b369426a2a04c30f4d04b557749be8091ee4ed23de4c4a86522d410867ec
-  data.tar.gz: 18ba07590dce273befec6295f0ce05702241ee46a727c05825dd573d44e3019839655f0da14dc9674f5ded7d56b7ee21d802b6264a2b2a85c5f6859928c887da
+  metadata.gz: b97082ff4f9176c773a1007e9045305ad4c1d9ae46898bc1969eb66e6dd9bb42605bf567875ba7ba429693b1cd61385274587c51d6d0dc0397fc15f304d49af7
+  data.tar.gz: ca8e47200e8d140361dfb57f37fff56616d1c75c284b19de43afeb2c1f179cdf506731866ccaf4b531e867877fd2815de2e6082134b8f6754bfe861068647ff4

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2025-12-15
+
+### Added
+
+- **New Detector: `CountInIteration`** - Detects `.count` usage inside iterations
+  - `.count` always executes a COUNT query, even on preloaded associations
+  - Suggests using `.size` instead (uses loaded collection when available)
+  - Suggests `counter_cache: true` for frequently accessed counts
+  - Helps prevent unnecessary COUNT queries when associations are already loaded
+
+### Changed
+
+- Updated default `enabled_detectors` to include `:count_in_iteration`
+- Updated README with new detector documentation and comparison table
+
 ## [0.2.0] - 2025-12-15
 
 ### Added

data/README.md

@@ -176,6 +176,35 @@ end
 
 **Detected methods:** `where`, `find_by`, `find_by!`, `exists?`, `find`, `first`, `last`, `take`, `pluck`, `ids`, `count`, `sum`, `average`, `minimum`, `maximum`
 
+### 5. Count in Iteration
+
+Detects `.count` called on associations inside loops. Unlike `.size`, `.count` always executes a COUNT query even when the association is preloaded.
+
+```ruby
+# Bad - COUNT query for each user, even with includes!
+@users = User.includes(:posts)
+@users.each do |user|
+  user.posts.count  # Executes: SELECT COUNT(*) FROM posts WHERE user_id = ?
+end
+
+# Good - Use .size (checks if loaded first)
+@users.each do |user|
+  user.posts.size   # No query - counts the loaded array
+end
+
+# Best - Use counter_cache for frequent counts
+# In Post model: belongs_to :user, counter_cache: true
+user.posts_count  # Just reads the column
+```
+
+**Key differences:**
+
+| Method | Loaded Collection | Not Loaded |
+|--------|------------------|------------|
+| `.count` | COUNT query | COUNT query |
+| `.size` | Array#size | COUNT query |
+| `.length` | Array#length | Loads all, then counts |
+
 ## Configuration
 
 ### Config File (.eager_eye.yml)
@@ -192,6 +221,7 @@ enabled_detectors:
   - serializer_nesting
   - missing_counter_cache
   - custom_method_query
+  - count_in_iteration
 
 # Base path to analyze (default: app)
 app_path: app

data/lib/eager_eye/analyzer.rb

@@ -8,7 +8,8 @@ module EagerEye
       loop_association: Detectors::LoopAssociation,
       serializer_nesting: Detectors::SerializerNesting,
       missing_counter_cache: Detectors::MissingCounterCache,
-      custom_method_query: Detectors::CustomMethodQuery
+      custom_method_query: Detectors::CustomMethodQuery,
+      count_in_iteration: Detectors::CountInIteration
     }.freeze
 
     attr_reader :paths, :issues

data/lib/eager_eye/configuration.rb

@@ -4,7 +4,10 @@ module EagerEye
   class Configuration
     attr_accessor :excluded_paths, :enabled_detectors, :app_path, :fail_on_issues
 
-    DEFAULT_DETECTORS = %i[loop_association serializer_nesting missing_counter_cache custom_method_query].freeze
+    DEFAULT_DETECTORS = %i[
+      loop_association serializer_nesting missing_counter_cache
+      custom_method_query count_in_iteration
+    ].freeze
 
     def initialize
       @excluded_paths = []

data/lib/eager_eye/detectors/count_in_iteration.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class CountInIteration < Base
+      # count always executes a COUNT query
+      # size and length use memory when collection is loaded
+      COUNT_METHODS = %i[count].freeze
+
+      ITERATION_METHODS = %i[
+        each map select find_all reject collect
+        each_with_index each_with_object flat_map
+      ].freeze
+
+      def self.detector_name
+        :count_in_iteration
+      end
+
+      def detect(ast, file_path)
+        @issues = []
+        @file_path = file_path
+
+        return @issues unless ast
+
+        find_iteration_blocks(ast) do |block_body, block_var|
+          check_for_count_calls(block_body, block_var)
+        end
+
+        @issues
+      end
+
+      private
+
+      def find_iteration_blocks(node, &block)
+        return unless node.is_a?(Parser::AST::Node)
+
+        if iteration_block?(node)
+          block_var = extract_block_variable(node)
+          block_body = extract_block_body(node)
+          yield(block_body, block_var) if block_var && block_body
+        end
+
+        node.children.each do |child|
+          find_iteration_blocks(child, &block)
+        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
+
+      def check_for_count_calls(node, block_var)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_issue(node) if count_on_association?(node, block_var)
+
+        node.children.each do |child|
+          check_for_count_calls(child, block_var)
+        end
+      end
+
+      def count_on_association?(node, block_var)
+        return false unless node.type == :send
+
+        method_name = node.children[1]
+        return false unless COUNT_METHODS.include?(method_name)
+
+        receiver = node.children[0]
+        association_call_on_block_var?(receiver, block_var)
+      end
+
+      def association_call_on_block_var?(node, block_var)
+        return false unless node.is_a?(Parser::AST::Node)
+        return false unless node.type == :send
+
+        receiver = node.children[0]
+        return false unless receiver.is_a?(Parser::AST::Node)
+
+        # post.comments.count -> receiver is post.comments
+        # post.comments -> receiver is post (lvar)
+        if receiver.type == :lvar && receiver.children[0] == block_var
+          true
+        elsif receiver.type == :send
+          # Nested: post.author.posts.count
+          chain_starts_with_block_var?(receiver, block_var)
+        else
+          false
+        end
+      end
+
+      def chain_starts_with_block_var?(node, block_var)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar
+          node.children[0] == block_var
+        when :send
+          chain_starts_with_block_var?(node.children[0], block_var)
+        else
+          false
+        end
+      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 extract_block_body(block_node)
+        block_node.children[2]
+      end
+
+      def add_issue(node)
+        receiver_chain = reconstruct_chain(node.children[0])
+
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "`.count` called on `#{receiver_chain}` inside iteration always executes a COUNT query",
+          severity: :warning,
+          suggestion: "Use `.size` instead (uses loaded collection) or add `counter_cache: true`"
+        )
+      end
+
+      def reconstruct_chain(node)
+        return "" unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar
+          node.children[0].to_s
+        when :send
+          receiver_str = reconstruct_chain(node.children[0])
+          method = node.children[1]
+          receiver_str.empty? ? method.to_s : "#{receiver_str}.#{method}"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -21,6 +21,9 @@ module EagerEye
         maximum
       ].freeze
 
+      # Array-only methods that should not be flagged when collection is clearly an array
+      ARRAY_METHODS = %i[first last take].freeze
+
       ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
 
       def self.detector_name
@@ -33,8 +36,9 @@ module EagerEye
         @issues = []
         @file_path = file_path
 
-        find_iteration_blocks(ast) do |block_body, block_var|
-          check_block_for_query_methods(block_body, block_var)
+        find_iteration_blocks(ast) do |block_body, block_var, collection|
+          is_array_collection = collection_is_array?(collection)
+          check_block_for_query_methods(block_body, block_var, is_array_collection)
         end
 
         @issues
@@ -48,7 +52,8 @@ module EagerEye
         if iteration_block?(node)
           block_var = extract_block_variable(node)
           block_body = extract_block_body(node)
-          yield(block_body, block_var) if block_var && block_body
+          collection = extract_collection(node)
+          yield(block_body, block_var, collection) if block_var && block_body
         end
 
         node.children.each do |child|
@@ -66,26 +71,40 @@ module EagerEye
         ITERATION_METHODS.include?(method_name)
       end
 
-      def check_block_for_query_methods(node, block_var)
+      def check_block_for_query_methods(node, block_var, is_array_collection = false) # rubocop:disable Style/OptionalBooleanParameter
         return unless node.is_a?(Parser::AST::Node)
 
-        add_issue(node) if query_chain_on_association?(node, block_var)
+        add_issue(node) if query_chain_on_association?(node, block_var, is_array_collection)
 
         node.children.each do |child|
-          check_block_for_query_methods(child, block_var)
+          check_block_for_query_methods(child, block_var, is_array_collection)
         end
       end
 
-      def query_chain_on_association?(node, block_var)
+      def query_chain_on_association?(node, block_var, is_array_collection = false) # rubocop:disable Style/OptionalBooleanParameter
         return false unless node.type == :send
 
         method_name = node.children[1]
         return false unless QUERY_METHODS.include?(method_name)
 
+        # Skip array-only methods when collection is clearly an array (.map result)
+        # AND the receiver is only the block variable (not chained)
+        if is_array_collection && ARRAY_METHODS.include?(method_name) &&
+           receiver_is_only_block_var?(node.children[0], block_var)
+          return false
+        end
+
         receiver = node.children[0]
         receiver_chain_starts_with?(receiver, block_var)
       end
 
+      def receiver_is_only_block_var?(node, block_var)
+        # Returns true only if receiver is EXACTLY the block variable, not a chain
+        node.is_a?(Parser::AST::Node) &&
+          node.type == :lvar &&
+          node.children[0] == block_var
+      end
+
       def receiver_chain_starts_with?(node, block_var)
         return false unless node.is_a?(Parser::AST::Node)
 
@@ -113,6 +132,31 @@ module EagerEye
         block_node.children[2]
       end
 
+      def extract_collection(block_node)
+        # Extract the collection being iterated on
+        # For: collection.each { |item| ... }
+        # Returns: the send node representing the collection method call
+        block_node.children[0]
+      end
+
+      def collection_is_array?(collection_node)
+        return false unless collection_node.is_a?(Parser::AST::Node)
+
+        case collection_node.type
+        when :array
+          # Literal array: [1, 2, 3].each { |item| ... }
+          true
+        when :send
+          # Only consider these methods as definitely returning arrays when iterating
+          method_name = collection_node.children[1]
+          # map, select, collect, etc. on anything return arrays for iteration
+          %i[map select collect flat_map to_a uniq compact].include?(method_name)
+        else
+          # Block variable itself won't tell us if it's an array
+          false
+        end
+      end
+
       def add_issue(node)
         method_name = node.children[1]
         association_chain = reconstruct_chain(node.children[0])

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -8,6 +8,7 @@ require_relative "eager_eye/detectors/loop_association"
 require_relative "eager_eye/detectors/serializer_nesting"
 require_relative "eager_eye/detectors/missing_counter_cache"
 require_relative "eager_eye/detectors/custom_method_query"
+require_relative "eager_eye/detectors/count_in_iteration"
 require_relative "eager_eye/analyzer"
 require_relative "eager_eye/reporters/base"
 require_relative "eager_eye/reporters/console"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - hamzagedikkaya
@@ -61,6 +61,7 @@ files:
 - lib/eager_eye/cli.rb
 - lib/eager_eye/configuration.rb
 - lib/eager_eye/detectors/base.rb
+- lib/eager_eye/detectors/count_in_iteration.rb
 - lib/eager_eye/detectors/custom_method_query.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb