eager_eye 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dce399f8b8160530246911ddbd4c9c5a9fb6cad487d409924c6e520993ff37cc
-  data.tar.gz: 3be96cbcf42c206f0348c63a91991c1a872addd775d5054be9e3dc44cc8b4f52
+  metadata.gz: 2c1781e66205a83557a9751b64f19c44d70f90efbd04423d63e847d4e4a06c6e
+  data.tar.gz: eac8bb2e4a8b86017804b2c9662074ece08346a5303b5760bdba6dc7d939b3d9
 SHA512:
-  metadata.gz: 23923fe65f0f51de105b9a6df93a8a115d9ceb40042dedc9d112ccfbdc48a324935cd48f18306944708ca355cb463caad4b97b994f619dff24d8c6cf475180c0
-  data.tar.gz: efc5cfe923e04b55b3e5f2a9a6b201298176e4370a5cac92825bd01649ec528ea978fb378151ea7b74c2a82ce6194a02df6ce8c52018725f86bd83736410b71d
+  metadata.gz: 9a9fec60ec826824ef8b331f95f33918265f51ea027b43f60852656a0b1420622b9405a78f0fdc4ba3e32c9a30159deb5104fe7432b35fdf9bdea8e5325aa120
+  data.tar.gz: fe4032176ada8b10c84ee56c48a8ee60aadbf7c6547e98e0f36def0226a119a7383e6258a060a197b4b6276667fd65f30707dbaeda155ff9410551b2111167ed

data/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2025-12-15
+
+### Added
+
+- **New Detector: `CustomMethodQuery`** - Detects query methods called inside iteration blocks
+  - Catches `.where`, `.find_by`, `.find_by!`, `.exists?` patterns that Bullet cannot detect
+  - Detects `.find`, `.first`, `.last`, `.take` inside loops
+  - Detects aggregation methods: `.pluck`, `.ids`, `.count`, `.sum`, `.average`, `.minimum`, `.maximum`
+  - Provides suggestions for preloading data before loops
+
+### Changed
+
+- Updated default `enabled_detectors` to include `:custom_method_query`
+- Updated README with new detector documentation and comparison table
+
 ## [0.1.0] - 2025-12-15
 
 ### Added

data/README.md

@@ -14,7 +14,7 @@ EagerEye analyzes your Ruby code without running it, using AST (Abstract Syntax
 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 and missing counter caches
+- **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 |
@@ -23,6 +23,7 @@ Unlike runtime tools like Bullet, EagerEye:
 | 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 |
 
@@ -146,6 +147,35 @@ belongs_to :post, counter_cache: true
 post.comments_count
 ```
 
+### 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.**
+
+```ruby
+# Bad - Bullet CANNOT catch this
+class User < ApplicationRecord
+  def supports?(team_name)
+    teams.where(name: team_name).exists?
+  end
+end
+
+@users.each do |user|
+  user.supports?("Lakers")  # Query for each user!
+end
+
+# Bad - find_by inside loop
+@orders.each do |order|
+  order.line_items.find_by(featured: true)
+end
+
+# Good - Preload and filter in Ruby
+@users.includes(:teams).each do |user|
+  user.teams.any? { |t| t.name == "Lakers" }
+end
+```
+
+**Detected methods:** `where`, `find_by`, `find_by!`, `exists?`, `find`, `first`, `last`, `take`, `pluck`, `ids`, `count`, `sum`, `average`, `minimum`, `maximum`
+
 ## Configuration
 
 ### Config File (.eager_eye.yml)
@@ -161,6 +191,7 @@ enabled_detectors:
   - loop_association
   - serializer_nesting
   - missing_counter_cache
+  - custom_method_query
 
 # Base path to analyze (default: app)
 app_path: app

data/lib/eager_eye/analyzer.rb

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

data/lib/eager_eye/configuration.rb

@@ -4,7 +4,7 @@ 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].freeze
+    DEFAULT_DETECTORS = %i[loop_association serializer_nesting missing_counter_cache custom_method_query].freeze
 
     def initialize
       @excluded_paths = []

data/lib/eager_eye/detectors/custom_method_query.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class CustomMethodQuery < Base
+      QUERY_METHODS = %i[
+        where
+        find_by
+        find_by!
+        exists?
+        find
+        first
+        last
+        take
+        pluck
+        ids
+        count
+        sum
+        average
+        minimum
+        maximum
+      ].freeze
+
+      ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
+
+      def self.detector_name
+        :custom_method_query
+      end
+
+      def detect(ast, file_path)
+        return [] unless ast
+
+        @issues = []
+        @file_path = file_path
+
+        find_iteration_blocks(ast) do |block_body, block_var|
+          check_block_for_query_methods(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_block_for_query_methods(node, block_var)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_issue(node) if query_chain_on_association?(node, block_var)
+
+        node.children.each do |child|
+          check_block_for_query_methods(child, block_var)
+        end
+      end
+
+      def query_chain_on_association?(node, block_var)
+        return false unless node.type == :send
+
+        method_name = node.children[1]
+        return false unless QUERY_METHODS.include?(method_name)
+
+        receiver = node.children[0]
+        receiver_chain_starts_with?(receiver, block_var)
+      end
+
+      def receiver_chain_starts_with?(node, block_var)
+        return false unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :lvar
+          node.children[0] == block_var
+        when :send
+          receiver_chain_starts_with?(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)
+        method_name = node.children[1]
+        association_chain = reconstruct_chain(node.children[0])
+
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Query method `.#{method_name}` called on `#{association_chain}` inside iteration",
+          severity: :warning,
+          suggestion: "This query executes on each iteration. Consider preloading data or restructuring the query."
+        )
+      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/version.rb

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

data/lib/eager_eye.rb

@@ -7,6 +7,7 @@ require_relative "eager_eye/detectors/base"
 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/analyzer"
 require_relative "eager_eye/reporters/base"
 require_relative "eager_eye/reporters/console"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-14 00:00:00.000000000 Z
+date: 2025-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -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/custom_method_query.rb
 - lib/eager_eye/detectors/loop_association.rb
 - lib/eager_eye/detectors/missing_counter_cache.rb
 - lib/eager_eye/detectors/serializer_nesting.rb