eager_eye 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a971d7fbafebc02b51a9767987541f67fdd216025ac04aa4bdf4f304cc3abad9
-  data.tar.gz: db6eeeb3e1f511856144c70031f63c5216c73b917c00a17a31dbcd44444757a8
+  metadata.gz: 34e0c9e78e18d9d8c9a6cad8ee96a91c89ac469d9dc662e43a51f09d361a3200
+  data.tar.gz: 90554fbbe09380116398c8139c6d09ca5851d1e12d2eb52c32cf85f8c8fdc76a
 SHA512:
-  metadata.gz: b847b72aff2e758f0a32effdf68057c499503f97251802263d5a1109e5eac3afd8841044d5d144a48b351c4c0909789e5528574f911101f3949e8f78d015dd0a
-  data.tar.gz: 3938004802489b63234cc75ec7cfc79c580a0cf263c004762a63fb2d4d1a09350f49f158ab9f4e99cbe4a11b9a8772766be61531c1909d958bed5b82141b407c
+  metadata.gz: 86605c1632ed47aaae05e26d810c6611dac2f356503502b71a94a389b1d58148cbb5146e5e6cbc5e9f809f4b6bf2b78d983cbf8484c0bab6d1e9a046ab0a242b
+  data.tar.gz: bb3e07e2b8e799067aa475f6b8ffea6a303e797e3eac252f46f597eec751f42451f91fd97eacf024aae8a6129267ef2b425fdd26163a6b893714cb22c2d9ddfa

data/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2025-12-15
+
+### Added
+
+- **Inline Suppression Comments** - RuboCop-style comment directives for suppressing false positives
+  - `# eager_eye:disable DetectorName` - Disable for single line (inline) or start block
+  - `# eager_eye:disable-next-line DetectorName` - Disable only the next line
+  - `# eager_eye:disable-file DetectorName` - Disable for entire file (must be in first 5 lines)
+  - `# eager_eye:enable DetectorName` - End a disable block
+  - Support for multiple detectors: `# eager_eye:disable LoopAssociation, CountInIteration`
+  - Support for reason comments: `# eager_eye:disable DetectorName -- reason here`
+  - `all` keyword to disable all detectors at once
+  - Both CamelCase (`LoopAssociation`) and snake_case (`loop_association`) detector names accepted
+
+### Changed
+
+- Updated README with inline suppression documentation
+- Added `CommentParser` module for parsing suppression directives
+
+## [0.5.0] - 2025-12-15
+
+### Added
+
+- **New Detector: `PluckToArray`** - Detects pluck/map results used in where clauses
+  - Catches `.pluck(:id)` and `.ids` results used in `where` clauses
+  - Catches `.map(&:id)` and `.collect(&:id)` patterns
+  - Suggests using `.select(:id)` subquery pattern for better performance
+  - Prevents two queries and memory overhead from holding IDs in arrays
+
+### Changed
+
+- Updated default `enabled_detectors` to include `:pluck_to_array`
+- Updated README with new detector documentation and performance comparison
+
 ## [0.4.0] - 2025-12-15
 
 ### Added

data/README.md

@@ -246,6 +246,76 @@ def schedule_stats_update
 end
 ```
 
+### 7. Pluck to Array Misuse
+
+Detects when `.pluck(:id)` or `.map(&:id)` results are used in `where` clauses instead of subqueries.
+
+```ruby
+# Bad - Two queries + memory overhead
+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
+
+# Bad - Same problem with map
+user_ids = users.map(&:id)
+Post.where(user_id: user_ids)
+
+# Good - Single subquery, no memory overhead
+Post.where(user_id: User.active.select(:id))
+# Single query: SELECT * FROM posts WHERE user_id IN (SELECT id FROM users WHERE active = true)
+```
+
+**Performance comparison with 10,000 users:**
+
+| Approach | Queries | Memory | Time |
+|----------|---------|--------|------|
+| `pluck` + `where` | 2 | ~80KB for IDs | ~45ms |
+| `select` subquery | 1 | None | ~20ms |
+
+## Inline Suppression
+
+Suppress false positives using inline comments (RuboCop-style):
+
+```ruby
+# Disable for single line
+user.posts.count  # eager_eye:disable CountInIteration
+
+# Disable for next line
+# eager_eye:disable-next-line LoopAssociation
+@users.each { |u| u.profile }
+
+# Disable block
+# eager_eye:disable LoopAssociation, SerializerNesting
+@users.each do |user|
+  user.posts.each { |p| p.author }
+end
+# eager_eye:enable LoopAssociation, SerializerNesting
+
+# Disable entire file (must be in first 5 lines)
+# eager_eye:disable-file CustomMethodQuery
+
+# With reason
+user.posts.count  # eager_eye:disable CountInIteration -- using counter_cache
+
+# Disable all detectors
+# eager_eye:disable all
+```
+
+### Available Detector Names
+
+Both CamelCase and snake_case formats are accepted:
+
+| Detector | CamelCase | snake_case |
+|----------|-----------|------------|
+| Loop Association | `LoopAssociation` | `loop_association` |
+| Serializer Nesting | `SerializerNesting` | `serializer_nesting` |
+| Missing Counter Cache | `MissingCounterCache` | `missing_counter_cache` |
+| Custom Method Query | `CustomMethodQuery` | `custom_method_query` |
+| Count in Iteration | `CountInIteration` | `count_in_iteration` |
+| Callback Query | `CallbackQuery` | `callback_query` |
+| Pluck to Array | `PluckToArray` | `pluck_to_array` |
+| All Detectors | `all` | `all` |
+
 ## Configuration
 
 ### Config File (.eager_eye.yml)
@@ -264,6 +334,7 @@ enabled_detectors:
   - custom_method_query
   - count_in_iteration
   - callback_query
+  - pluck_to_array
 
 # Base path to analyze (default: app)
 app_path: app

data/lib/eager_eye/analyzer.rb

@@ -10,7 +10,8 @@ module EagerEye
       missing_counter_cache: Detectors::MissingCounterCache,
       custom_method_query: Detectors::CustomMethodQuery,
       count_in_iteration: Detectors::CountInIteration,
-      callback_query: Detectors::CallbackQuery
+      callback_query: Detectors::CallbackQuery,
+      pluck_to_array: Detectors::PluckToArray
     }.freeze
 
     attr_reader :paths, :issues
@@ -57,8 +58,16 @@ module EagerEye
       ast = parse_source(source)
       return unless ast
 
+      comment_parser = CommentParser.new(source)
+
       enabled_detectors.each do |detector|
         file_issues = detector.detect(ast, file_path)
+
+        # Filter suppressed issues
+        file_issues.reject! do |issue|
+          comment_parser.disabled_at?(issue.line_number, issue.detector)
+        end
+
         @issues.concat(file_issues)
       end
     rescue Errno::ENOENT, Errno::EACCES => e

data/lib/eager_eye/comment_parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+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
+
+    def initialize(source_code)
+      @source_code = source_code
+      @lines = source_code.lines
+      @disabled_ranges = Hash.new { |h, k| h[k] = [] }
+      @file_disabled = Set.new
+      @current_disabled = Set.new
+      parse_comments
+    end
+
+    def disabled_at?(line_number, detector_name)
+      return true if @file_disabled.include?(detector_name.to_s)
+      return true if @file_disabled.include?("all")
+
+      detector = detector_name.to_s
+      @disabled_ranges[detector].any? { |range| range.cover?(line_number) } ||
+        @disabled_ranges["all"].any? { |range| range.cover?(line_number) }
+    end
+
+    private
+
+    def parse_comments
+      @lines.each_with_index do |line, index|
+        line_num = index + 1
+        process_line(line, line_num)
+      end
+
+      close_unclosed_blocks
+    end
+
+    def process_line(line, line_num)
+      directive = detect_directive(line, line_num)
+      apply_directive(directive, line_num) if directive
+    end
+
+    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)
+    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)) }
+    end
+
+    def detect_next_line_directive(line)
+      return unless line =~ NEXT_LINE_PATTERN
+
+      { type: :next_line, detectors: parse_detector_names(::Regexp.last_match(1)) }
+    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)
+      return unless line =~ ENABLE_PATTERN
+
+      { type: :block_end, detectors: parse_detector_names(::Regexp.last_match(1)) }
+    end
+
+    def detect_inline_directive(line)
+      return unless line =~ INLINE_DISABLE_PATTERN
+
+      { type: :inline, detectors: parse_detector_names(::Regexp.last_match(1)) }
+    end
+
+    def apply_directive(directive, line_num)
+      case directive[:type]
+      when :file then apply_file_disable(directive[:detectors])
+      when :next_line then apply_next_line_disable(directive[:detectors], line_num)
+      when :block_start then apply_block_start(directive[:detectors], line_num)
+      when :block_end then apply_block_end(directive[:detectors], line_num)
+      when :inline then apply_inline_disable(directive[:detectors], line_num)
+      end
+    end
+
+    def apply_file_disable(detectors)
+      @file_disabled.merge(detectors)
+    end
+
+    def apply_next_line_disable(detectors, line_num)
+      next_line = line_num + 1
+      detectors.each { |d| @disabled_ranges[d] << (next_line..next_line) }
+    end
+
+    def apply_block_start(detectors, line_num)
+      detectors.each { |d| @current_disabled << { detector: d, start: line_num } }
+    end
+
+    def apply_block_end(detectors, line_num)
+      detectors.each do |d|
+        entry = @current_disabled.find { |e| e[:detector] == d }
+        next unless entry
+
+        @disabled_ranges[d] << (entry[:start]..line_num)
+        @current_disabled.delete(entry)
+      end
+    end
+
+    def apply_inline_disable(detectors, line_num)
+      detectors.each { |d| @disabled_ranges[d] << (line_num..line_num) }
+    end
+
+    def close_unclosed_blocks
+      @current_disabled.each do |entry|
+        @disabled_ranges[entry[:detector]] << (entry[:start]..@lines.size)
+      end
+    end
+
+    def inline_disable?(line)
+      code_part = line.split("#").first
+      code_part && !code_part.strip.empty?
+    end
+
+    def parse_detector_names(str)
+      str.split(/[,\s]+/).map(&:strip).reject(&:empty?).map do |name|
+        normalize_detector_name(name)
+      end
+    end
+
+    def normalize_detector_name(name)
+      name.gsub(/([A-Z])/) { "_#{::Regexp.last_match(1).downcase}" }
+          .sub(/^_/, "")
+          .downcase
+    end
+  end
+end

data/lib/eager_eye/configuration.rb

@@ -7,6 +7,7 @@ module EagerEye
     DEFAULT_DETECTORS = %i[
       loop_association serializer_nesting missing_counter_cache
       custom_method_query count_in_iteration callback_query
+      pluck_to_array
     ].freeze
 
     def initialize

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class PluckToArray < Base
+      def self.detector_name
+        :pluck_to_array
+      end
+
+      def detect(ast, file_path)
+        @issues = []
+        @file_path = file_path
+        @pluck_variables = {}
+        @map_id_variables = {}
+
+        return @issues unless ast
+
+        collect_pluck_assignments(ast)
+        collect_map_id_assignments(ast)
+        find_where_with_pluck_var(ast)
+
+        @issues
+      end
+
+      private
+
+      def collect_pluck_assignments(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
+
+        node.children.each do |child|
+          collect_pluck_assignments(child)
+        end
+      end
+
+      def collect_map_id_assignments(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        if local_variable_assignment?(node)
+          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
+      end
+
+      def find_where_with_pluck_var(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_issue(node) if where_call_with_pluck_var?(node)
+
+        node.children.each do |child|
+          find_where_with_pluck_var(child)
+        end
+      end
+
+      def local_variable_assignment?(node)
+        node.type == :lvasgn
+      end
+
+      def pluck_call?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+        return false unless node.type == :send
+
+        method_name = node.children[1]
+        %i[pluck ids].include?(method_name)
+      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
+      end
+
+      def block_map_call?(node)
+        send_node = node.children[0]
+        return false unless 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)
+
+        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
+
+        sym_node = node.children[0]
+        return false unless sym_node&.type == :sym
+
+        %i[id to_i].include?(sym_node.children[0])
+      end
+
+      def where_call_with_pluck_var?(node)
+        return false unless node.type == :send
+        return false unless node.children[1] == :where
+
+        args = node.children[2..]
+        args.any? { |arg| hash_with_pluck_var?(arg) }
+      end
+
+      def hash_with_pluck_var?(node)
+        return false unless node.is_a?(Parser::AST::Node)
+        return false unless 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
+        end
+      end
+
+      def add_issue(node)
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Using plucked/mapped array in `where` causes two queries and holds IDs in memory",
+          severity: :warning,
+          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.condition.select(:id))`"
+        )
+      end
+    end
+  end
+end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -10,6 +10,8 @@ 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/detectors/callback_query"
+require_relative "eager_eye/detectors/pluck_to_array"
+require_relative "eager_eye/comment_parser"
 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.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - hamzagedikkaya
@@ -59,6 +59,7 @@ files:
 - lib/eager_eye.rb
 - lib/eager_eye/analyzer.rb
 - lib/eager_eye/cli.rb
+- lib/eager_eye/comment_parser.rb
 - lib/eager_eye/configuration.rb
 - lib/eager_eye/detectors/base.rb
 - lib/eager_eye/detectors/callback_query.rb
@@ -66,6 +67,7 @@ files:
 - lib/eager_eye/detectors/custom_method_query.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb
+- lib/eager_eye/detectors/pluck_to_array.rb
 - lib/eager_eye/detectors/serializer_nesting.rb
 - lib/eager_eye/generators/install_generator.rb
 - lib/eager_eye/issue.rb