eager_eye 0.1.0

data/lib/eager_eye/issue.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module EagerEye
+  class Issue
+    attr_reader :detector, :file_path, :line_number, :message, :severity, :suggestion
+
+    VALID_SEVERITIES = %i[warning error].freeze
+
+    def initialize(detector:, file_path:, line_number:, message:, severity: :warning, suggestion: nil)
+      @detector = detector
+      @file_path = file_path
+      @line_number = line_number
+      @message = message
+      @severity = validate_severity(severity)
+      @suggestion = suggestion
+    end
+
+    def to_h
+      {
+        detector: detector,
+        file_path: file_path,
+        line_number: line_number,
+        message: message,
+        severity: severity,
+        suggestion: suggestion
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Issue)
+
+      detector == other.detector &&
+        file_path == other.file_path &&
+        line_number == other.line_number &&
+        message == other.message &&
+        severity == other.severity &&
+        suggestion == other.suggestion
+    end
+
+    alias eql? ==
+
+    def hash
+      [detector, file_path, line_number, message, severity, suggestion].hash
+    end
+
+    private
+
+    def validate_severity(severity)
+      return severity if VALID_SEVERITIES.include?(severity)
+
+      raise ArgumentError, "Invalid severity: #{severity}. Must be one of: #{VALID_SEVERITIES.join(", ")}"
+    end
+  end
+end

data/lib/eager_eye/railtie.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module EagerEye
+  class Railtie < Rails::Railtie
+    railtie_name :eager_eye
+
+    rake_tasks do
+      namespace :eager_eye do
+        desc "Analyze Rails application for N+1 query issues"
+        task analyze: :environment do
+          require "eager_eye"
+
+          load_config_file
+
+          analyzer = EagerEye::Analyzer.new
+          issues = analyzer.run
+
+          reporter = EagerEye::Reporters::Console.new(issues)
+          puts reporter.report
+
+          exit 1 if issues.any? && EagerEye.configuration.fail_on_issues
+        end
+
+        desc "Analyze and output results as JSON"
+        task json: :environment do
+          require "eager_eye"
+
+          load_config_file
+
+          analyzer = EagerEye::Analyzer.new
+          issues = analyzer.run
+
+          reporter = EagerEye::Reporters::Json.new(issues, pretty: true)
+          puts reporter.report
+
+          exit 1 if issues.any? && EagerEye.configuration.fail_on_issues
+        end
+
+        def load_config_file
+          config_file = Rails.root.join(".eager_eye.yml")
+          return unless File.exist?(config_file)
+
+          require "yaml"
+          config = YAML.load_file(config_file, symbolize_names: true)
+
+          EagerEye.configure do |c|
+            c.excluded_paths = config[:excluded_paths] if config[:excluded_paths]
+            c.enabled_detectors = config[:enabled_detectors].map(&:to_sym) if config[:enabled_detectors]
+            c.app_path = config[:app_path] if config[:app_path]
+            c.fail_on_issues = config[:fail_on_issues] if config.key?(:fail_on_issues)
+          end
+        end
+      end
+    end
+
+    # Generate initializer for configuration
+    generators do
+      require_relative "generators/install_generator"
+    end
+  end
+end

data/lib/eager_eye/reporters/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Reporters
+    class Base
+      attr_reader :issues
+
+      def initialize(issues)
+        @issues = issues
+      end
+
+      def report
+        raise NotImplementedError, "Subclasses must implement #report"
+      end
+
+      protected
+
+      def issues_by_file
+        issues.group_by(&:file_path)
+      end
+
+      def warning_count
+        issues.count { |i| i.severity == :warning }
+      end
+
+      def error_count
+        issues.count { |i| i.severity == :error }
+      end
+    end
+  end
+end

data/lib/eager_eye/reporters/console.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Reporters
+    class Console < Base
+      COLORS = {
+        red: "\e[31m",
+        yellow: "\e[33m",
+        green: "\e[32m",
+        cyan: "\e[36m",
+        reset: "\e[0m",
+        bold: "\e[1m"
+      }.freeze
+
+      def initialize(issues, colorize: true)
+        super(issues)
+        @colorize = colorize
+      end
+
+      def report
+        return no_issues_message if issues.empty?
+
+        output = []
+        output << header
+        output << ""
+
+        issues_by_file.each do |file_path, file_issues|
+          output << file_section(file_path, file_issues)
+        end
+
+        output << separator
+        output << summary
+        output.join("\n")
+      end
+
+      private
+
+      def no_issues_message
+        colorize("No issues detected!", :green)
+      end
+
+      def header
+        "#{colorize("EagerEye Analysis Results", :bold)}\n#{"=" * 25}"
+      end
+
+      def separator
+        "-" * 40
+      end
+
+      def file_section(file_path, file_issues)
+        lines = []
+        lines << colorize(file_path, :cyan)
+
+        file_issues.each do |issue|
+          lines << format_issue(issue)
+        end
+
+        lines << ""
+        lines.join("\n")
+      end
+
+      def format_issue(issue)
+        detector_label = format_detector(issue.detector)
+        severity_color = issue.severity == :error ? :red : :yellow
+
+        line = "  Line #{issue.line_number}: "
+        line += colorize("[#{detector_label}]", severity_color)
+        line += " #{issue.message}"
+
+        line += "\n           #{colorize("Suggestion:", :green)} #{issue.suggestion}" if issue.suggestion
+
+        line
+      end
+
+      def format_detector(detector)
+        detector.to_s.split("_").map(&:capitalize).join
+      end
+
+      def summary
+        total = issues.size
+        warnings = warning_count
+        errors = error_count
+
+        "Total: #{total} issue#{"s" unless total == 1} " \
+          "(#{warnings} warning#{"s" unless warnings == 1}, " \
+          "#{errors} error#{"s" unless errors == 1})"
+      end
+
+      def colorize(text, color)
+        return text unless @colorize
+
+        "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+      end
+    end
+  end
+end

data/lib/eager_eye/reporters/json.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "json"
+
+module EagerEye
+  module Reporters
+    class Json < Base
+      def initialize(issues, pretty: false)
+        super(issues)
+        @pretty = pretty
+      end
+
+      def report
+        result = {
+          summary: summary_hash,
+          issues: issues.map(&:to_h)
+        }
+
+        @pretty ? JSON.pretty_generate(result) : JSON.generate(result)
+      end
+
+      private
+
+      def summary_hash
+        {
+          total: issues.size,
+          warnings: warning_count,
+          errors: error_count,
+          files_affected: issues_by_file.keys.size
+        }
+      end
+    end
+  end
+end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "eager_eye/version"
+require_relative "eager_eye/configuration"
+require_relative "eager_eye/issue"
+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/analyzer"
+require_relative "eager_eye/reporters/base"
+require_relative "eager_eye/reporters/console"
+require_relative "eager_eye/reporters/json"
+require_relative "eager_eye/cli"
+
+module EagerEye
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+# Load Railtie only if Rails is defined
+require_relative "eager_eye/railtie" if defined?(Rails::Railtie)

data/sig/eager_eye.rbs

@@ -0,0 +1,4 @@
+module EagerEye
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: eager_eye
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- hamzagedikkaya
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: EagerEye detects N+1 query problems using AST analysis without running
+  your code.
+email:
+- gedikkayahamza@gmail.com
+executables:
+- eager_eye
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/github_action.yml
+- exe/eager_eye
+- lib/eager_eye.rb
+- lib/eager_eye/analyzer.rb
+- lib/eager_eye/cli.rb
+- lib/eager_eye/configuration.rb
+- lib/eager_eye/detectors/base.rb
+- lib/eager_eye/detectors/loop_association.rb
+- lib/eager_eye/detectors/missing_counter_cache.rb
+- lib/eager_eye/detectors/serializer_nesting.rb
+- lib/eager_eye/generators/install_generator.rb
+- lib/eager_eye/issue.rb
+- lib/eager_eye/railtie.rb
+- lib/eager_eye/reporters/base.rb
+- lib/eager_eye/reporters/console.rb
+- lib/eager_eye/reporters/json.rb
+- lib/eager_eye/version.rb
+- sig/eager_eye.rbs
+homepage: https://github.com/hamzagedikkaya/eager_eye
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/hamzagedikkaya/eager_eye
+  source_code_uri: https://github.com/hamzagedikkaya/eager_eye
+  changelog_uri: https://github.com/hamzagedikkaya/eager_eye/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Static analysis tool for detecting N+1 queries in Rails applications
+test_files: []