eager_eye 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 037dbef0e4dc82641ae8c56bb8110f822900dd7afe76ddac6051b375bb547208
-  data.tar.gz: 1d0878ea0046406e264ddfa92d68ac0c9f1748aea4803d9a638554bb13ea77c9
+  metadata.gz: 031e0f3547538856718932cd6121ac990ad8c11a43682ec076f68bb591943d55
+  data.tar.gz: 433563980a743704c361304dff56866fe4cc9795a1d6f927cd0b4a8fc0367c8f
 SHA512:
-  metadata.gz: b97082ff4f9176c773a1007e9045305ad4c1d9ae46898bc1969eb66e6dd9bb42605bf567875ba7ba429693b1cd61385274587c51d6d0dc0397fc15f304d49af7
-  data.tar.gz: ca8e47200e8d140361dfb57f37fff56616d1c75c284b19de43afeb2c1f179cdf506731866ccaf4b531e867877fd2815de2e6082134b8f6754bfe861068647ff4
+  metadata.gz: 5c9f874001fb0c71eb8c1858ef2739181482992b7455925afc696acfa1b7bebfa91888d305936ab6189f64ea1542afd7844b95c4ba453218d0c706d40d17304b
+  data.tar.gz: 93750c566392f234cb5009d30873130182a4e80722b9f29402b662caacc0c961a31a8c109937c378f9a04b3d0f6e134326a0edeb0d138255debc2c9fb4ceb9a3

data/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
+
+- **New Detector: `CallbackQuery`** - Detects database queries and iterations inside ActiveRecord callbacks
+  - Identifies potential bulk operation performance issues
+  - Detects query methods (`.count`, `.sum`, `.update!`, etc.) in callbacks
+  - Detects iterations (`.each`, `.map`, etc.) in callbacks as errors
+  - Severity: `:error` for iterations in callbacks, `:warning` for query methods
+  - Suggests moving to background jobs or using conditional callbacks
+
+### Changed
+
+- Updated default `enabled_detectors` to include `:callback_query`
+- Updated README with new detector documentation
+
 ## [0.3.0] - 2025-12-15
 
 ### Added

data/README.md

@@ -205,6 +205,73 @@ user.posts_count  # Just reads the column
 | `.size` | Array#size | COUNT query |
 | `.length` | Array#length | Loads all, then counts |
 
+### 6. Callback Query Detection
+
+Detects database queries and iterations inside ActiveRecord callbacks. These become performance disasters during bulk operations.
+
+```ruby
+# Bad - Queries in callbacks
+class Article < ApplicationRecord
+  after_save :recalculate_stats
+
+  def recalculate_stats
+    author.articles.published.count  # Runs on EVERY save
+    category.update_article_count!   # Another query on EVERY save
+  end
+end
+
+# Disaster scenario
+Article.import(1000.times.map { |i| { title: "Post #{i}" } })
+# = 2000+ queries from callbacks!
+
+# Bad - N+1 in callback
+class Order < ApplicationRecord
+  after_create :notify_subscribers
+
+  def notify_subscribers
+    customer.followers.each do |follower|  # N+1!
+      NotificationMailer.new_order(follower).deliver_later
+    end
+  end
+end
+
+# Good - Use conditional callbacks
+after_save :recalculate_stats, if: :should_recalculate?
+
+# Good - Move to background job
+after_commit :schedule_stats_update, on: :create
+
+def schedule_stats_update
+  RecalculateStatsJob.perform_later(id)
+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 |
+
 ## Configuration
 
 ### Config File (.eager_eye.yml)
@@ -222,6 +289,8 @@ enabled_detectors:
   - missing_counter_cache
   - 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

@@ -9,7 +9,9 @@ module EagerEye
       serializer_nesting: Detectors::SerializerNesting,
       missing_counter_cache: Detectors::MissingCounterCache,
       custom_method_query: Detectors::CustomMethodQuery,
-      count_in_iteration: Detectors::CountInIteration
+      count_in_iteration: Detectors::CountInIteration,
+      callback_query: Detectors::CallbackQuery,
+      pluck_to_array: Detectors::PluckToArray
     }.freeze
 
     attr_reader :paths, :issues

data/lib/eager_eye/configuration.rb

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

data/lib/eager_eye/detectors/callback_query.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    class CallbackQuery < Base
+      CALLBACK_METHODS = %i[
+        before_validation after_validation
+        before_save after_save around_save
+        before_create after_create around_create
+        before_update after_update around_update
+        before_destroy after_destroy around_destroy
+        after_commit after_rollback
+        after_create_commit after_update_commit after_destroy_commit
+        after_save_commit
+      ].freeze
+
+      QUERY_INDICATORS = %i[
+        where find find_by find_by! first last take
+        exists? any? none? many? one?
+        count sum average minimum maximum
+        pluck ids select
+        update update_all update! update_attribute update_column update_columns
+        destroy destroy_all destroy! delete delete_all
+        create create! save save! insert insert_all insert! upsert upsert_all
+        increment! decrement! toggle!
+        reload
+      ].freeze
+
+      ITERATION_METHODS = %i[each map select find_all reject collect].freeze
+
+      def self.detector_name
+        :callback_query
+      end
+
+      def detect(ast, file_path)
+        @issues = []
+        @file_path = file_path
+        @callback_methods = {}
+
+        return @issues unless ast
+
+        find_callback_definitions(ast)
+        check_callback_methods(ast)
+
+        @issues
+      end
+
+      private
+
+      def find_callback_definitions(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        extract_callback_method_name(node) if callback_definition?(node)
+
+        node.children.each do |child|
+          find_callback_definitions(child)
+        end
+      end
+
+      def callback_definition?(node)
+        return false unless node.type == :send
+        return false unless node.children[0].nil?
+
+        method_name = node.children[1]
+        CALLBACK_METHODS.include?(method_name)
+      end
+
+      def extract_callback_method_name(node)
+        node.children[2..].each do |arg|
+          next unless arg.is_a?(Parser::AST::Node) && arg.type == :sym
+
+          method_name = arg.children[0]
+          callback_type = node.children[1]
+          @callback_methods[method_name] = callback_type
+        end
+      end
+
+      def check_callback_methods(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        if method_definition?(node)
+          method_name = node.children[0]
+          if @callback_methods.key?(method_name)
+            callback_type = @callback_methods[method_name]
+            check_method_body_for_queries(node, method_name, callback_type)
+          end
+        end
+
+        node.children.each do |child|
+          check_callback_methods(child)
+        end
+      end
+
+      def method_definition?(node)
+        node.type == :def
+      end
+
+      def check_method_body_for_queries(method_node, method_name, callback_type)
+        method_body = method_node.children[2]
+        return unless method_body
+
+        find_query_calls(method_body, method_name, callback_type)
+        find_iteration_with_queries(method_body, method_name, callback_type)
+      end
+
+      def find_query_calls(node, method_name, callback_type)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_query_issue(node, method_name, callback_type) if query_call?(node)
+
+        node.children.each do |child|
+          find_query_calls(child, method_name, callback_type)
+        end
+      end
+
+      def find_iteration_with_queries(node, method_name, callback_type)
+        return unless node.is_a?(Parser::AST::Node)
+
+        add_iteration_issue(node, method_name, callback_type) if iteration_block?(node)
+
+        node.children.each do |child|
+          find_iteration_with_queries(child, method_name, callback_type)
+        end
+      end
+
+      def query_call?(node)
+        return false unless node.type == :send
+
+        method = node.children[1]
+        QUERY_INDICATORS.include?(method)
+      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 add_query_issue(node, method_name, callback_type)
+        query_method = node.children[1]
+
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Query method `.#{query_method}` found in `#{callback_type}` callback `:#{method_name}`",
+          severity: :warning,
+          suggestion: "Callbacks run on every save/create/update. Consider moving to a background job"
+        )
+      end
+
+      def add_iteration_issue(node, method_name, callback_type)
+        @issues << create_issue(
+          file_path: @file_path,
+          line_number: node.loc.line,
+          message: "Iteration found in `#{callback_type}` callback `:#{method_name}` - potential N+1",
+          severity: :error,
+          suggestion: "Avoid iterations in callbacks. Use background jobs for bulk operations"
+        )
+      end
+    end
+  end
+end

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.3.0"
+  VERSION = "0.5.0"
 end

data/lib/eager_eye.rb

@@ -9,6 +9,8 @@ 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/detectors/callback_query"
+require_relative "eager_eye/detectors/pluck_to_array"
 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.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - hamzagedikkaya
@@ -61,10 +61,12 @@ files:
 - lib/eager_eye/cli.rb
 - lib/eager_eye/configuration.rb
 - lib/eager_eye/detectors/base.rb
+- lib/eager_eye/detectors/callback_query.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
+- 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