EagerEye

# Gemfile
gem "eager_eye", group: :development

# Bad
posts.each { |post| post.author.name }   # query per post

# Good — chained
posts.includes(:author).each { |post| post.author.name }

# Good — separate line (preload tracked across assignment)
@posts = Post.includes(:author)
@posts.each { |post| post.author.name }

# Good — single record (no N+1 possible)
@user = User.find(params[:id])
@user.posts.each { |post| post.comments }

# Bad
class PostSerializer < Blueprinter::Base
  field :author_name { |post| post.author.name }   # query per serialized post
end

# Good — preload in controller
@posts = Post.includes(:author)
render json: PostSerializer.render(@posts)

# Bad — COUNT query for each post
posts.each { |post| post.comments.count }

# Good — counter cache (Comment: belongs_to :post, counter_cache: true)
posts.each { |post| post.comments_count }   # column read, no query

# Bad — where inside loop
@users.each { |user| user.teams.where(name: "Lakers").exists? }

# Good — preload + filter in Ruby
@users.includes(:teams).each { |user| user.teams.any? { |t| t.name == "Lakers" } }

# Bad — .count always queries, even with includes
@users = User.includes(:posts)
@users.each { |user| user.posts.count }   # SELECT COUNT(*) per user

# Good — .size uses the preload
@users.each { |user| user.posts.size }

# Bad — N+1 inside callback
class Order < ApplicationRecord
  after_create :notify_subscribers

  def notify_subscribers
    customer.followers.each { |f| f.notifications.create!(...) }   # N inserts + N queries
  end
end

# Good — defer to background job
after_commit :schedule_notifications, on: :create
def schedule_notifications
  NotifySubscribersJob.perform_later(id)
end

# Warning — two queries + memory overhead
user_ids = User.active.pluck(:id)
Post.where(user_id: user_ids)

# Error — loads entire table
user_ids = User.all.pluck(:id)
Post.where(user_id: user_ids)

# Good — single subquery
Post.where(user_id: User.active.select(:id))

class Order < ApplicationRecord
  belongs_to :user
  delegate :full_name, :email, to: :user
end

# Bad — looks like attribute access, actually loads user per order
orders.each { |o| o.full_name }

# Good
orders.includes(:user).each { |o| o.full_name }

class PostDecorator < Draper::Decorator
  def comment_summary
    object.comments.map(&:body).join(", ")   # query per decorated post
  end
end

# Bad
@posts = Post.all.decorate

# Good
@posts = Post.includes(:comments).all.decorate

class Comment < ApplicationRecord
  scope :recent, -> { where("created_at > ?", 1.week.ago) }
end

# Bad — scope call per iteration
posts.each { |post| post.comments.recent }

# Good — preload + filter
posts.includes(:comments).each { |post| post.comments.select { |c| c.created_at > 1.week.ago } }

class User < ApplicationRecord
  validates :email, uniqueness: true
end

# Bad — SELECT + INSERT per record
params[:users].each { |p| User.create!(p) }

# Good — single bulk INSERT, DB enforces uniqueness via index
User.insert_all(params[:users])

# Single line
user.posts.count  # eager_eye:disable CountInIteration

# Next line
# eager_eye:disable-next-line LoopAssociation
@users.each { |u| u.profile }

# Block
# eager_eye:disable LoopAssociation, SerializerNesting
@users.each { |u| u.posts.each { |p| p.author } }
# eager_eye:enable LoopAssociation, SerializerNesting

# Whole 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 everything
# eager_eye:disable all

# spec/rails_helper.rb
require "eager_eye/rspec"

# spec/eager_eye_spec.rb
RSpec.describe "EagerEye Analysis" do
  it "controllers have no N+1 issues" do
    expect("app/controllers").to pass_eager_eye
  end

  it "serializers are clean" do
    expect("app/serializers").to pass_eager_eye(only: [:serializer_nesting])
  end

  # Allow some during migration
  it "legacy code is acceptable" do
    expect("app/services/legacy").to pass_eager_eye(max_issues: 10)
  end
end

EagerEye.configure do |config|
  config.excluded_paths = ["app/legacy/**"]
  config.enabled_detectors = [:loop_association, :serializer_nesting]
  config.min_severity = :warning
  config.fail_on_issues = true
end