eager_eye 1.0.8 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b2e83de186394077d36507bd9c14dbb356777bddff49689c602b43dc8d74b80
-  data.tar.gz: 5ee79306b8bd9f602e9f09ed1c62bf5adb5920d57104c486d8799a757458eb6f
+  metadata.gz: 27aed443ecc5e83aeb4fe0baa9aa9ccbcec462df45767c8294d867562c9066b5
+  data.tar.gz: f2a9f245154a8fe043d9a9f0f68edaf940a5c3f8e2bd3f0255962603ef48d4d3
 SHA512:
-  metadata.gz: 36d9dabec10f32dcf21c88efdd5125e5f7146cf61e0e500adc4f3c5b57608303cf0002d7ac48c32eb87b8f163fa6c3125d53bce4e052e9c1dd178f244b69e2a3
-  data.tar.gz: 6bc77a99dd29179c9179010ff1c6bb195048115b3b72e545ec51d1af1d286a430a35b223a138fc78e66dbb0172d9e2ff2f39c9f9639be9edc97a47eb928e3df6
+  metadata.gz: f6f769f5d65827fd4059671674f8947f172b1ef9ff72a82375c25ac3e31c35c81099384e79de97036b8c867613343fd2e078f7c23f59fd68bf5daac8cd8a8a19
+  data.tar.gz: f6c0743373d769ec6d147ccb1045b6a667d6015551a705b31eaefe6fc511568ecf06683cb99d7034f2d59cd83997732096d8e7c12b732b42c6ee460b9d152b5c

data/CHANGELOG.md

@@ -7,6 +7,34 @@ 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
+
+- **Inline Suppression Comments** - Suppress specific warnings with RuboCop-style inline comments
+  - `# eager_eye:disable-next-line` - Suppress next line
+  - `# eager_eye:disable CallbackQuery` - Suppress specific detector inline
+  - `# eager_eye:disable-block` / `# eager_eye:enable-block` - Suppress block of code
+  - `# eager_eye:disable-file DetectorName` - Suppress entire file
+  - Supports both CamelCase and snake_case detector names
+  - Can disable all detectors with `all` keyword
+
 ## [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.8-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>
@@ -23,23 +23,44 @@
 
 ---
 
-## 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 |
+## Table of Contents
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Detected Issues](#detected-issues)
+- [Inline Suppression](#inline-suppression)
+- [Auto-fix](#auto-fix-experimental)
+- [RSpec Integration](#rspec-integration)
+- [Configuration](#configuration)
+- [CI Integration](#ci-integration)
+- [CLI Reference](#cli-reference)
+- [Output Formats](#output-formats)
+- [Limitations](#limitations)
+- [VS Code Extension](#vs-code-extension)
+- [Development](#development)
+- [Contributing](#contributing)
+
+## Features
+
+✨ **Detects 7 types of N+1 problems:**
+- Loop associations (queries in iterations)
+- Serializer nesting issues
+- Missing counter caches
+- Custom method queries
+- Count in iteration patterns
+- Callback query N+1s
+- Pluck to array misuse
+
+🔧 **Developer-friendly:**
+- Inline suppression (like RuboCop)
+- Auto-fix support (experimental)
+- JSON/Console output formats
+- RSpec integration
+
+🚀 **CI-ready:**
+- No test suite required
+- GitHub Actions examples included
+- Severity levels and filtering
 
 ## Installation
 
@@ -186,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?
@@ -296,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)
@@ -305,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

@@ -2,12 +2,12 @@
 
 module EagerEye
   class CommentParser
-    DISABLE_PATTERN = /eager_eye:disable(?:-next-line|-file)?\s+(.+?)(?:\s+--|$)/i
-    ENABLE_PATTERN = /eager_eye:enable\s+(.+?)(?:\s+--|$)/i
-    INLINE_DISABLE_PATTERN = /eager_eye:disable\s+(.+?)(?:\s+--|$)/i
     FILE_DISABLE_PATTERN = /eager_eye:disable-file\s+(.+?)(?:\s+--|$)/i
-    NEXT_LINE_PATTERN = /eager_eye:disable-next-line\s+(.+?)(?:\s+--|$)/i
-    BLOCK_DISABLE_PATTERN = /eager_eye:disable\s+(.+?)(?:\s+--|$)/i
+    NEXT_LINE_PATTERN = /eager_eye:disable-next-line(?:\s+(.+?))?(?:\s+--|$)/i
+    BLOCK_START_PATTERN = /eager_eye:disable-block(?:\s+(.+?))?(?:\s+--|$)/i
+    BLOCK_END_PATTERN = /eager_eye:enable-block(?:\s+(.+?))?(?:\s+--|$)/i
+    INLINE_DISABLE_PATTERN = /eager_eye:disable\s+(.+?)(?:\s+--|$)/i
+    ENABLE_PATTERN = /eager_eye:enable(?:\s+(.+?))?(?:\s+--|$)/i
 
     def initialize(source_code)
       @source_code = source_code.encode("UTF-8", invalid: :replace, undef: :replace)
@@ -46,39 +46,46 @@ module EagerEye
     def detect_directive(line, line_num)
       detect_file_directive(line, line_num) ||
         detect_next_line_directive(line) ||
-        detect_block_directive(line) ||
-        detect_enable_directive(line) ||
-        detect_inline_directive(line)
+        detect_block_end_directive(line) ||
+        detect_block_or_inline_directive(line)
     end
 
     def detect_file_directive(line, line_num)
       return unless line_num <= 5 && line =~ FILE_DISABLE_PATTERN
 
-      { type: :file, detectors: parse_detector_names(::Regexp.last_match(1)) }
+      detectors = parse_detector_names(::Regexp.last_match(1) || "all")
+      { type: :file, detectors: detectors }
     end
 
     def detect_next_line_directive(line)
       return unless line =~ NEXT_LINE_PATTERN
 
-      { type: :next_line, detectors: parse_detector_names(::Regexp.last_match(1)) }
+      detectors = parse_detector_names(::Regexp.last_match(1) || "all")
+      { type: :next_line, detectors: detectors }
     end
 
-    def detect_block_directive(line)
-      return unless line =~ BLOCK_DISABLE_PATTERN && !inline_disable?(line)
-
-      { type: :block_start, detectors: parse_detector_names(::Regexp.last_match(1)) }
-    end
-
-    def detect_enable_directive(line)
+    def detect_block_end_directive(line)
       return unless line =~ ENABLE_PATTERN
 
-      { type: :block_end, detectors: parse_detector_names(::Regexp.last_match(1)) }
+      detectors = parse_detector_names(::Regexp.last_match(1) || "all")
+      { type: :block_end, detectors: detectors }
     end
 
-    def detect_inline_directive(line)
+    def detect_block_or_inline_directive(line)
+      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
+
       return unless line =~ INLINE_DISABLE_PATTERN
 
-      { type: :inline, detectors: parse_detector_names(::Regexp.last_match(1)) }
+      detectors = parse_detector_names(::Regexp.last_match(1) || "all")
+
+      if code_before_comment?(line)
+        { type: :inline, detectors: detectors }
+      else
+        { type: :block_start, detectors: detectors }
+      end
     end
 
     def apply_directive(directive, line_num)
@@ -129,7 +136,14 @@ module EagerEye
       code_part && !code_part.strip.empty?
     end
 
+    def code_before_comment?(line)
+      code_part = line.split("#").first
+      code_part && !code_part.strip.empty?
+    end
+
     def parse_detector_names(str)
+      return ["all"] if str.nil? || str.strip.empty?
+
       str.split(/[,\s]+/).map(&:strip).reject(&:empty?).map do |name|
         normalize_detector_name(name)
       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.8"
+  VERSION = "1.0.10"
 end

metadata

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