eager_eye 1.0.9 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44b2f46a77bcc0bb742c6d169cebb7be6b9a8b722b64044b153397fcf7686872
-  data.tar.gz: 25a589c3401fe25248b6fe429e0255e5d2d9ada9b50bd7bbf467ada161e0ca95
+  metadata.gz: 27aed443ecc5e83aeb4fe0baa9aa9ccbcec462df45767c8294d867562c9066b5
+  data.tar.gz: f2a9f245154a8fe043d9a9f0f68edaf940a5c3f8e2bd3f0255962603ef48d4d3
 SHA512:
-  metadata.gz: 2ea1baa8c98a5362527e991d3712c0a3c0d821307a99e1b8b1a9a0ac76fbff5d4adcf4f4cd512990971956fcc3bd61ef97fb8c047d0b44609e4bd55ca385bfb4
-  data.tar.gz: 8d1590b243420e3ea3534290f15725a0aa70f3ea537aa7da05cd4648521fe284718965d27e4b00ac77ea277d4ca400107e49a18a7759780dd532c560ef1b91b3
+  metadata.gz: f6f769f5d65827fd4059671674f8947f172b1ef9ff72a82375c25ac3e31c35c81099384e79de97036b8c867613343fd2e078f7c23f59fd68bf5daac8cd8a8a19
+  data.tar.gz: f6c0743373d769ec6d147ccb1045b6a667d6015551a705b31eaefe6fc511568ecf06683cb99d7034f2d59cd83997732096d8e7c12b732b42c6ee460b9d152b5c

data/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.10] - 2025-12-26
+
+### Changed
+
+- **PluckToArray Severity Levels** - Differentiate between scoped and unscoped pluck usage
+  - Scoped `.pluck(:id)` (e.g., `User.active.pluck(:id)`) → **Warning** (default)
+  - Unscoped `.all.pluck(:id)` → **Error** (loads entire table into memory)
+  - Small arrays with scoped pluck may be acceptable - users can suppress with comments
+
+### Added
+
+- **Improved PluckToArray Detection** - Now detects and prioritizes `.all.pluck` patterns
+  - Tracks `.all.pluck(:id)` as critical issues (error severity)
+  - Detects both variable assignments and inline usage
+  - Better suggestions for high-priority cases
+
 ## [1.0.9] - 2025-12-26
 
 ### Added
@@ -19,12 +35,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Supports both CamelCase and snake_case detector names
   - Can disable all detectors with `all` keyword
 
-### Improved
-
-- Enhanced README with table of contents and better organization
-- Improved code readability and documentation structure
-- Updated version badge to v1.0.9
-
 ## [1.0.8] - 2025-12-25
 
 ### Added

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.0.9-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.0.10-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>
@@ -24,7 +24,6 @@
 ---
 
 ## Table of Contents
-- [Why EagerEye?](#why-eagereye)
 - [Features](#features)
 - [Installation](#installation)
 - [Quick Start](#quick-start)
@@ -41,31 +40,13 @@
 - [Development](#development)
 - [Contributing](#contributing)
 
-## Why EagerEye?
-
-Unlike runtime tools like Bullet, EagerEye:
-
-- **Runs without executing code** - Works in CI pipelines without a test suite
-- **Catches more patterns** - Detects serializer N+1s, missing counter caches, and query methods in loops
-- **Proactive detection** - Finds issues at code review time, not after deployment
-
-| Feature | EagerEye | Bullet |
-|---------|----------|--------|
-| Detection method | Static analysis | Runtime |
-| Requires test suite | No | Yes |
-| Serializer N+1 detection | Yes | Limited |
-| Counter cache suggestions | Yes | No |
-| Query methods in loops | Yes | No |
-| CI integration | Native | Requires tests |
-| False positive rate | Higher | Lower |
-
 ## Features
 
 ✨ **Detects 7 types of N+1 problems:**
 - Loop associations (queries in iterations)
 - Serializer nesting issues
 - Missing counter caches
-- Custom method queries (invisible to Bullet)
+- Custom method queries
 - Count in iteration patterns
 - Callback query N+1s
 - Pluck to array misuse
@@ -226,10 +207,10 @@ end
 
 ### 4. Custom Method Query (N+1 in query methods)
 
-Detects query methods (`.where`, `.find_by`, `.exists?`, etc.) called on associations inside loops. **These patterns are invisible to Bullet.**
+Detects query methods (`.where`, `.find_by`, `.exists?`, etc.) called on associations inside loops.
 
 ```ruby
-# Bad - Bullet CANNOT catch this
+# Bad - where inside loop
 class User < ApplicationRecord
   def supports?(team_name)
     teams.where(name: team_name).exists?
@@ -336,6 +317,10 @@ user_ids = User.active.pluck(:id)  # Query 1: SELECT id FROM users
 Post.where(user_id: user_ids)      # Query 2: SELECT * FROM posts WHERE user_id IN (1,2,3...)
 # Also holds potentially thousands of IDs in memory
 
+# Worse - Loads entire table into memory! (REPORTED AS ERROR)
+user_ids = User.all.pluck(:id)     # Query 1: SELECT id FROM users -- ENTIRE TABLE!
+Post.where(user_id: user_ids)      # Query 2: SELECT * FROM posts WHERE user_id IN (...)
+
 # Bad - Same problem with map
 user_ids = users.map(&:id)
 Post.where(user_id: user_ids)
@@ -345,11 +330,22 @@ Post.where(user_id: User.active.select(:id))
 # Single query: SELECT * FROM posts WHERE user_id IN (SELECT id FROM users WHERE active = true)
 ```
 
+**Severity Levels:**
+
+- ⚠️ **Warning (default)** - Scoped `.pluck(:id)` (e.g., `User.active.pluck(:id)`)
+  - Two queries and memory overhead with moderately-sized arrays
+  - Small arrays may be acceptable
+  
+- 🔴 **Error** - Unscoped `.all.pluck(:id)` (e.g., `User.all.pluck(:id)`)
+  - Loads entire table into memory
+  - Highly inefficient and should always be refactored
+
 **Performance comparison with 10,000 users:**
 
 | Approach | Queries | Memory | Time |
 |----------|---------|--------|------|
 | `pluck` + `where` | 2 | ~80KB for IDs | ~45ms |
+| `.all.pluck` + `where` | 2 | ~40KB+ for all IDs | ~100ms+ |
 | `select` subquery | 1 | None | ~20ms |
 
 ## Inline Suppression

data/lib/eager_eye/comment_parser.rb

@@ -72,22 +72,18 @@ module EagerEye
     end
 
     def detect_block_or_inline_directive(line)
-      # Check for eager_eye:disable-block explicitly
       if line =~ BLOCK_START_PATTERN && !code_before_comment?(line)
         detectors = parse_detector_names(::Regexp.last_match(1) || "all")
         return { type: :block_start, detectors: detectors }
       end
 
-      # Check for eager_eye:disable (either inline or block start)
       return unless line =~ INLINE_DISABLE_PATTERN
 
       detectors = parse_detector_names(::Regexp.last_match(1) || "all")
 
-      # If there's code before the comment, it's inline (same line only)
       if code_before_comment?(line)
         { type: :inline, detectors: detectors }
       else
-        # No code before comment, so it's a block start
         { type: :block_start, detectors: detectors }
       end
     end

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -12,126 +12,136 @@ module EagerEye
         @file_path = file_path
         @pluck_variables = {}
         @map_id_variables = {}
+        @critical_pluck_variables = {}
 
         return @issues unless ast
 
-        collect_pluck_assignments(ast)
-        collect_map_id_assignments(ast)
-        find_where_with_pluck_var(ast)
-
+        visit(ast)
         @issues
       end
 
       private
 
-      def collect_pluck_assignments(node)
+      def visit(node)
         return unless node.is_a?(Parser::AST::Node)
 
-        if local_variable_assignment?(node)
-          var_name = node.children[0]
-          value = node.children[1]
-
-          @pluck_variables[var_name] = node.loc.line if pluck_call?(value)
-        end
+        collect_assignments(node)
+        check_where_calls(node)
 
-        node.children.each do |child|
-          collect_pluck_assignments(child)
-        end
+        node.children.each { |child| visit(child) }
       end
 
-      def collect_map_id_assignments(node)
-        return unless node.is_a?(Parser::AST::Node)
+      def collect_assignments(node)
+        return unless local_variable_assignment?(node)
 
-        if local_variable_assignment?(node)
-          var_name = node.children[0]
-          value = node.children[1]
+        var_name = node.children[0]
+        value = node.children[1]
 
-          @map_id_variables[var_name] = node.loc.line if map_id_call?(value)
-        end
-
-        node.children.each do |child|
-          collect_map_id_assignments(child)
-        end
+        @critical_pluck_variables[var_name] = node.loc.line if all_pluck_call?(value)
+        @pluck_variables[var_name] = node.loc.line if pluck_call?(value)
+        @map_id_variables[var_name] = node.loc.line if map_id_call?(value)
       end
 
-      def find_where_with_pluck_var(node)
-        return unless node.is_a?(Parser::AST::Node)
+      def check_where_calls(node)
+        return unless where_call?(node)
 
-        add_issue(node) if where_call_with_pluck_var?(node)
-
-        node.children.each do |child|
-          find_where_with_pluck_var(child)
-        end
+        add_critical_issue(node) if critical_pluck?(node)
+        add_issue(node) if regular_pluck?(node)
       end
 
       def local_variable_assignment?(node)
         node.type == :lvasgn
       end
 
+      def where_call?(node)
+        node.type == :send && node.children[1] == :where
+      end
+
       def pluck_call?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :send
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
-        method_name = node.children[1]
-        %i[pluck ids].include?(method_name)
+        method = node.children[1]
+        %i[pluck ids].include?(method)
+      end
+
+      def all_pluck_call?(node)
+        return false unless pluck_call?(node)
+
+        receiver = node.children[0]
+        receiver.is_a?(Parser::AST::Node) && receiver.type == :send &&
+          receiver.children[1] == :all
       end
 
       def map_id_call?(node)
         return false unless node.is_a?(Parser::AST::Node)
 
-        case node.type
-        when :block then block_map_call?(node)
-        when :send then send_map_id_call?(node)
-        else false
-        end
+        block_map?(node) || send_map?(node)
       end
 
-      def block_map_call?(node)
-        send_node = node.children[0]
-        return false unless send_node&.type == :send
+      def block_map?(node)
+        return false unless node.type == :block
 
-        %i[map collect].include?(send_node.children[1])
+        send_node = node.children[0]
+        send_node&.type == :send && %i[map collect].include?(send_node.children[1])
       end
 
-      def send_map_id_call?(node)
-        method_name = node.children[1]
-        return false unless %i[map collect].include?(method_name)
+      def send_map?(node)
+        return false unless node.type == :send
 
-        node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
+        method = node.children[1]
+        %i[map collect].include?(method) &&
+          node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
       end
 
       def symbol_to_proc_id?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :block_pass
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :block_pass
 
-        sym_node = node.children[0]
-        return false unless sym_node&.type == :sym
+        sym = node.children[0]
+        sym&.type == :sym && %i[id to_i].include?(sym.children[0])
+      end
 
-        %i[id to_i].include?(sym_node.children[0])
+      def regular_pluck?(node)
+        where_args = node.children[2..]
+        where_args.any? { |arg| pluck_var_in_hash?(arg) }
       end
 
-      def where_call_with_pluck_var?(node)
-        return false unless node.type == :send
-        return false unless node.children[1] == :where
+      def critical_pluck?(node)
+        where_args = node.children[2..]
+        where_args.any? { |arg| critical_pluck_in_hash?(arg) }
+      end
+
+      def pluck_var_in_hash?(node)
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
-        args = node.children[2..]
-        args.any? { |arg| hash_with_pluck_var?(arg) }
+        node.children.any? do |pair|
+          next false unless pair.type == :pair
+
+          pluck_value?(pair.children[1])
+        end
       end
 
-      def hash_with_pluck_var?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-        return false unless node.type == :hash
+      def critical_pluck_in_hash?(node)
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
         node.children.any? do |pair|
           next false unless pair.type == :pair
 
-          value = pair.children[1]
-          if value.type == :lvar
-            var_name = value.children[0]
-            @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
-          else
-            false
-          end
+          critical_value?(pair.children[1])
+        end
+      end
+
+      def pluck_value?(value)
+        return false unless value.type == :lvar
+
+        var_name = value.children[0]
+        @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
+      end
+
+      def critical_value?(value)
+        if value.type == :lvar
+          @critical_pluck_variables.key?(value.children[0])
+        else
+          all_pluck_call?(value)
         end
       end
 
@@ -140,7 +150,18 @@ module EagerEye
           file_path: @file_path,
           line_number: node.loc.line,
           message: "Using plucked/mapped array in `where` causes two queries and holds IDs in memory",
-          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.condition.select(:id))`"
+          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.condition.select(:id))`",
+          severity: :warning
+        )
+      end
+
+      def add_critical_issue(node)
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Using `.all.pluck(:id)` in `where` loads entire table into memory and is highly inefficient",
+          suggestion: "Use `.select(:id)` subquery instead: `Model.where(col: OtherModel.select(:id))`",
+          severity: :error
         )
       end
     end

data/lib/eager_eye/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.10
 platform: ruby
 authors:
 - hamzagedikkaya