eager_eye 1.1.0 → 1.1.1

data/lib/eager_eye/detectors/loop_association.rb

@@ -5,11 +5,8 @@ module EagerEye
     class LoopAssociation < Base
       ITERATION_METHODS = %i[each map collect select find find_all reject filter filter_map flat_map].freeze
       PRELOAD_METHODS = %i[includes preload eager_load].freeze
-      # Methods that return a single record (not a collection)
       SINGLE_RECORD_METHODS = %i[find find_by find_by! first first! last last! take take! second third fourth fifth
                                  forty_two sole find_sole_by].freeze
-
-      # Common association names (belongs_to = singular, has_many = plural)
       ASSOCIATION_NAMES = Set.new(%w[
         author user owner creator admin member customer client post article comment category tag
         parent company organization project task item order product account profile setting image
@@ -18,8 +15,6 @@ module EagerEye
         tasks items orders products accounts profiles settings images avatars photos attachments
         documents
       ]).freeze
-
-      # Methods that should NOT be treated as associations
       EXCLUDED_METHODS = %i[
         id to_s to_h to_a to_json to_xml inspect class object_id nil? blank? present? empty?
         any? none? size count length save save! update update! destroy destroy! delete delete!
@@ -73,46 +68,32 @@ module EagerEye
       end
 
       def infer_model_name_from_collection(node)
-        # Infer model name from collection (posts -> Post, users -> User)
         return nil unless node&.type == :send
 
-        # Handle: Model.includes, @var.method calls
         receiver = node.children[0]
-        case receiver&.type
-        when :const
-          receiver.children[1].to_s
-        end
+        receiver.children[1].to_s if receiver&.type == :const
       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)
+        node.type == :block && node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
       end
 
       def extract_block_variable(block_node)
-        args = block_node&.children&.fetch(1, nil)
-        first_child = args&.children&.first
-        first_child&.type == :arg ? first_child.children[0] : nil
+        args = block_node&.children&.[](1)
+        first_arg = args&.children&.first
+        first_arg&.type == :arg ? first_arg.children[0] : nil
       end
 
       def extract_included_associations(collection_node)
         included = Set.new
         return included unless collection_node&.type == :send
 
-        # Traverse through chained method calls to find includes/preload/eager_load
         current = collection_node
         while current&.type == :send
-          method_name = current.children[1]
-          extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(method_name)
-
+          extract_includes_from_method(current, included) if PRELOAD_METHODS.include?(current.children[1])
           current = current.children[0]
         end
-
         included
       end
 
@@ -177,10 +158,6 @@ module EagerEye
         included_set.merge(extract_symbols_from_args(args))
       end
 
-      def extract_from_hash(hash_node, included_set)
-        extract_symbols_from_hash(hash_node, included_set)
-      end
-
       def find_association_calls(node, block_var, file_path, issues, included_associations = Set.new)
         reported = Set.new
         traverse_ast(node) do |child|

data/lib/eager_eye/detectors/missing_counter_cache.rb

@@ -3,22 +3,14 @@
 module EagerEye
   module Detectors
     class MissingCounterCache < Base
-      # Methods that trigger COUNT queries
       COUNT_METHODS = %i[count size length].freeze
-
-      # Common has_many association names (plural)
       PLURAL_ASSOCIATIONS = %w[
-        posts comments tags categories articles users members
-        items orders products tasks projects images attachments
-        documents files messages notifications reviews ratings
-        followers followings likes favorites bookmarks votes
-        children replies responses answers questions
+        posts comments tags categories articles users members items orders products tasks projects
+        images attachments documents files messages notifications reviews ratings followers followings
+        likes favorites bookmarks votes children replies responses answers questions
       ].freeze
-
-      # Iteration methods that indicate a loop context
-      ITERATION_METHODS = %i[each map collect select reject find_all
-                             filter filter_map flat_map each_with_index
-                             each_with_object reduce inject sum].freeze
+      ITERATION_METHODS = %i[each map collect select reject find_all filter filter_map flat_map
+                             each_with_index each_with_object reduce inject sum].freeze
 
       def self.detector_name
         :missing_counter_cache
@@ -51,68 +43,45 @@ module EagerEye
 
       def count_on_association?(node)
         return false unless node.type == :send
-
-        method_name = node.children[1]
-        return false unless COUNT_METHODS.include?(method_name)
+        return false unless COUNT_METHODS.include?(node.children[1])
 
         receiver = node.children[0]
-        return false unless receiver
-
-        likely_association_receiver?(receiver)
+        receiver && likely_association_receiver?(receiver)
       end
 
       def likely_association_receiver?(node)
-        return false unless node.type == :send
-
-        method_name = node.children[1]
-        PLURAL_ASSOCIATIONS.include?(method_name.to_s)
+        node.type == :send && PLURAL_ASSOCIATIONS.include?(node.children[1].to_s)
       end
 
       def extract_association_name(node)
         receiver = node.children[0]
-        return nil unless receiver&.type == :send
-
-        receiver.children[1].to_s
+        receiver.children[1].to_s if receiver&.type == :send
       end
 
-      # Check if the node is inside an iteration block
       def inside_iteration?(node)
         parent = node
-        while (parent = find_parent(parent))
+        while (parent = @parent_map[parent])
           return true if iteration_block?(parent)
         end
         false
       end
 
-      def find_parent(node)
-        @parent_map ||= {}
-        @parent_map[node]
-      end
-
-      # Override traverse_ast to build parent map
       def traverse_ast(node, &block)
         return unless node.is_a?(Parser::AST::Node)
 
         @parent_map ||= {}
-
         yield node
-
         node.children.each do |child|
-          if child.is_a?(Parser::AST::Node)
-            @parent_map[child] = node
-            traverse_ast(child, &block)
-          end
+          next unless child.is_a?(Parser::AST::Node)
+
+          @parent_map[child] = node
+          traverse_ast(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)
+        node.type == :block && node.children[0]&.type == :send &&
+          ITERATION_METHODS.include?(node.children[0].children[1])
       end
     end
   end

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -49,100 +49,67 @@ module EagerEye
         add_issue(node) if regular_pluck?(node)
       end
 
-      def local_variable_assignment?(node)
-        node.type == :lvasgn
-      end
+      def local_variable_assignment?(node) = node.type == :lvasgn
 
-      def where_call?(node)
-        node.type == :send && node.children[1] == :where
-      end
+      def where_call?(node) = node.type == :send && node.children[1] == :where
 
       def pluck_call?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :send
-
-        method = node.children[1]
-        %i[pluck ids].include?(method)
+        node.is_a?(Parser::AST::Node) && node.type == :send && %i[pluck ids].include?(node.children[1])
       end
 
       def all_pluck_call?(node)
         return false unless pluck_call?(node)
 
         receiver = node.children[0]
-        receiver.is_a?(Parser::AST::Node) && receiver.type == :send &&
-          receiver.children[1] == :all
+        receiver.is_a?(Parser::AST::Node) && receiver.type == :send && receiver.children[1] == :all
       end
 
       def map_id_call?(node)
-        return false unless node.is_a?(Parser::AST::Node)
-
-        block_map?(node) || send_map?(node)
+        node.is_a?(Parser::AST::Node) && (block_map?(node) || send_map?(node))
       end
 
       def block_map?(node)
-        return false unless node.type == :block
-
-        send_node = node.children[0]
-        send_node&.type == :send && %i[map collect].include?(send_node.children[1])
+        node.type == :block && node.children[0]&.type == :send &&
+          %i[map collect].include?(node.children[0].children[1])
       end
 
       def send_map?(node)
-        return false unless node.type == :send
-
-        method = node.children[1]
-        %i[map collect].include?(method) &&
+        node.type == :send && %i[map collect].include?(node.children[1]) &&
           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) && node.type == :block_pass
 
-        sym = node.children[0]
-        sym&.type == :sym && %i[id to_i].include?(sym.children[0])
+        node.children[0]&.type == :sym && %i[id to_i].include?(node.children[0].children[0])
       end
 
       def regular_pluck?(node)
-        where_args = node.children[2..]
-        where_args.any? { |arg| pluck_var_in_hash?(arg) }
+        node.children[2..].any? { |arg| pluck_var_in_hash?(arg) }
       end
 
       def critical_pluck?(node)
-        where_args = node.children[2..]
-        where_args.any? { |arg| critical_pluck_in_hash?(arg) }
+        node.children[2..].any? { |arg| critical_pluck_in_hash?(arg) }
       end
 
       def pluck_var_in_hash?(node)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
-        node.children.any? do |pair|
-          next false unless pair.type == :pair
-
-          pluck_value?(pair.children[1])
-        end
+        node.children.any? { |pair| pair.type == :pair && pluck_value?(pair.children[1]) }
       end
 
       def critical_pluck_in_hash?(node)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
-        node.children.any? do |pair|
-          next false unless pair.type == :pair
-
-          critical_value?(pair.children[1])
-        end
+        node.children.any? { |pair| pair.type == :pair && critical_value?(pair.children[1]) }
       end
 
       def pluck_value?(value)
-        return false unless value.type == :lvar
-
-        var_name = value.children[0]
-        @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
+        value.type == :lvar && (@pluck_variables.key?(value.children[0]) || @map_id_variables.key?(value.children[0]))
       end
 
       def critical_value?(value)
-        if value.type == :lvar
-          @critical_pluck_variables.key?(value.children[0])
-        else
-          all_pluck_call?(value)
-        end
+        value.type == :lvar ? @critical_pluck_variables.key?(value.children[0]) : all_pluck_call?(value)
       end
 
       def add_issue(node)

data/lib/eager_eye/detectors/serializer_nesting.rb

@@ -3,26 +3,10 @@
 module EagerEye
   module Detectors
     class SerializerNesting < Base
-      # Serializer base classes to detect
-      SERIALIZER_PATTERNS = [
-        "ActiveModel::Serializer",
-        "ActiveModelSerializers::Model",
-        "Blueprinter::Base",
-        "Alba::Resource"
-      ].freeze
-
-      # Method names that define attributes in serializers
+      SERIALIZER_PATTERNS = %w[ActiveModel::Serializer ActiveModelSerializers::Model Blueprinter::Base Alba::Resource].freeze
       ATTRIBUTE_METHODS = %i[attribute field attributes].freeze
-
-      # Object reference names in serializers
       OBJECT_REFS = %i[object record resource].freeze
-
-      # Common association names (same as LoopAssociation)
-      ASSOCIATION_NAMES = %w[
-        author user owner creator admin member customer client
-        post article comment category tag parent company organization
-        project task item order product account profile setting
-        image avatar photo attachment document
+      HAS_MANY_ASSOCIATIONS = %w[
         authors users owners creators admins members customers clients
         posts articles comments categories tags children companies organizations
         projects tasks items orders products accounts profiles settings
@@ -52,21 +36,16 @@ module EagerEye
       def serializer_class?(node)
         return false unless node.type == :class
 
-        # Check class name ends with Serializer, Blueprint, or Resource
         class_name = extract_class_name(node)
         return false unless class_name
 
         class_name.end_with?("Serializer", "Blueprint", "Resource") ||
-          inherits_from_serializer?(node) ||
-          includes_serializer_module?(node)
+          inherits_from_serializer?(node) || includes_serializer_module?(node)
       end
 
       def extract_class_name(class_node)
         name_node = class_node.children[0]
-        return nil unless name_node
-        return nil unless name_node.type == :const
-
-        name_node.children[1].to_s
+        name_node.children[1].to_s if name_node&.type == :const
       end
 
       def inherits_from_serializer?(class_node)
@@ -74,7 +53,7 @@ module EagerEye
         return false unless parent_node
 
         parent_name = const_to_string(parent_node)
-        SERIALIZER_PATTERNS.any? { |pattern| parent_name&.include?(pattern.split("::").last) }
+        SERIALIZER_PATTERNS.any? { |p| parent_name&.include?(p.split("::").last) }
       end
 
       def includes_serializer_module?(class_node)
@@ -82,20 +61,14 @@ module EagerEye
         return false unless body
 
         traverse_ast(body) do |node|
-          next unless node.type == :send
-
-          method = node.children[1]
-          return true if method == :include && alba_resource?(node)
+          return true if node.type == :send && node.children[1] == :include && alba_resource?(node)
         end
-
         false
       end
 
       def alba_resource?(include_node)
         arg = include_node.children[2]
-        return false unless arg
-
-        const_to_string(arg)&.include?("Alba")
+        arg && const_to_string(arg)&.include?("Alba")
       end
 
       def const_to_string(node)
@@ -103,12 +76,10 @@ module EagerEye
 
         parts = []
         current = node
-
         while current&.type == :const
           parts.unshift(current.children[1].to_s)
           current = current.children[0]
         end
-
         parts.join("::")
       end
 
@@ -117,34 +88,24 @@ module EagerEye
         return unless body
 
         traverse_ast(body) do |node|
-          next unless attribute_block?(node)
-
-          block_body = node.children[2]
-          next unless block_body
+          next unless attribute_block?(node) && node.children[2]
 
-          find_association_in_block(block_body, node, file_path, issues)
+          find_association_in_block(node.children[2], file_path, issues)
         end
       end
 
       def attribute_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]
-        ATTRIBUTE_METHODS.include?(method_name)
+        node.type == :block && node.children[0]&.type == :send &&
+          ATTRIBUTE_METHODS.include?(node.children[0].children[1])
       end
 
-      def find_association_in_block(block_body, _block_node, file_path, issues)
+      def find_association_in_block(block_body, file_path, issues)
         traverse_ast(block_body) do |node|
           next unless node.type == :send
 
           receiver = node.children[0]
           method_name = node.children[1]
-
-          next unless object_reference?(receiver)
-          next unless likely_association?(method_name)
+          next unless object_reference?(receiver) && likely_association?(method_name)
 
           issues << create_issue(
             file_path: file_path,
@@ -159,33 +120,22 @@ module EagerEye
         return false unless node
 
         case node.type
-        when :send
-          # object.something or record.something
-          receiver = node.children[0]
-          method = node.children[1]
-
-          receiver.nil? && OBJECT_REFS.include?(method)
-        when :lvar
-          # Block variable like |post|
-          true
-        else
-          false
+        when :send then node.children[0].nil? && OBJECT_REFS.include?(node.children[1])
+        when :lvar then true
+        else false
         end
       end
 
       def receiver_name(node)
         case node.type
-        when :send
-          node.children[1].to_s
-        when :lvar
-          node.children[0].to_s
-        else
-          "object"
+        when :send then node.children[1].to_s
+        when :lvar then node.children[0].to_s
+        else "object"
         end
       end
 
       def likely_association?(method_name)
-        ASSOCIATION_NAMES.include?(method_name.to_s)
+        HAS_MANY_ASSOCIATIONS.include?(method_name.to_s)
       end
     end
   end

data/lib/eager_eye/fixers/pluck_to_select.rb

@@ -3,27 +3,20 @@
 module EagerEye
   module Fixers
     class PluckToSelect < Base
-      # This fixer only works for single-line pluck + where patterns
-      # Two-line patterns are too complex to fix automatically
-
       def fixable?
-        issue.detector == :pluck_to_array &&
-          single_line_pattern?
+        issue.detector == :pluck_to_array && single_line_pattern?
       end
 
       protected
 
       def fixed_content
-        # Model.where(col: OtherModel.pluck(:id)) -> Model.where(col: OtherModel.select(:id))
         line_content.gsub(/\.pluck\((:\w+)\)/, '.select(\1)')
       end
 
       private
 
       def single_line_pattern?
-        return false unless line_content
-
-        line_content.include?(".pluck(") && line_content.include?(".where(")
+        line_content&.include?(".pluck(") && line_content.include?(".where(")
       end
     end
   end

data/lib/eager_eye/issue.rb

@@ -40,20 +40,13 @@ module EagerEye
     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
+      other.is_a?(Issue) && to_h == other.to_h
     end
 
     alias eql? ==
 
     def hash
-      [detector, file_path, line_number, message, severity, suggestion].hash
+      to_h.hash
     end
 
     private

data/lib/eager_eye/railtie.rb

@@ -10,32 +10,20 @@ module EagerEye
       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
+          puts run_analysis(EagerEye::Reporters::Console)
         end
 
         desc "Analyze and output results as JSON"
         task json: :environment do
-          require "eager_eye"
+          puts run_analysis(EagerEye::Reporters::Json, pretty: true)
+        end
 
+        def run_analysis(reporter_class, **opts)
+          require "eager_eye"
           load_config_file
-
-          analyzer = EagerEye::Analyzer.new
-          issues = analyzer.run
-
-          reporter = EagerEye::Reporters::Json.new(issues, pretty: true)
-          puts reporter.report
-
+          issues = EagerEye::Analyzer.new.run
           exit 1 if issues.any? && EagerEye.configuration.fail_on_issues
+          reporter_class.new(issues, **opts).report
         end
 
         def load_config_file
@@ -55,7 +43,6 @@ module EagerEye
       end
     end
 
-    # Generate initializer for configuration
     generators do
       require_relative "generators/install_generator"
     end

data/lib/eager_eye/reporters/console.rb

@@ -48,15 +48,7 @@ module EagerEye
       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")
+        [colorize(file_path, :cyan), *file_issues.map { |i| format_issue(i) }, ""].join("\n")
       end
 
       def format_issue(issue)
@@ -81,15 +73,12 @@ module EagerEye
       end
 
       def summary
-        total = issues.size
-        errors = error_count
-        warnings = warning_count
-        infos = info_count
-
-        "Total: #{total} issue#{"s" unless total == 1} " \
-          "(#{errors} error#{"s" unless errors == 1}, " \
-          "#{warnings} warning#{"s" unless warnings == 1}, " \
-          "#{infos} info)"
+        t = issues.size
+        e = error_count
+        w = warning_count
+        i = info_count
+        "Total: #{t} issue#{"s" unless t == 1} " \
+          "(#{e} error#{"s" unless e == 1}, #{w} warning#{"s" unless w == 1}, #{i} info)"
       end
 
       def colorize(text, color)

data/lib/eager_eye/rspec/matchers.rb

@@ -19,8 +19,7 @@ module EagerEye
         def matches?(path)
           @path = path
           configure_eager_eye
-          analyzer = build_analyzer
-          @issues = analyzer.run
+          @issues = EagerEye::Analyzer.new(paths: [@path]).run
           @issues.count <= @max_issues
         end
 
@@ -61,10 +60,6 @@ module EagerEye
             config.fail_on_issues = false
           end
         end
-
-        def build_analyzer
-          EagerEye::Analyzer.new(paths: [@path])
-        end
       end
     end
   end

data/lib/eager_eye/version.rb

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

data/lib/eager_eye.rb

@@ -41,5 +41,4 @@ module EagerEye
   end
 end
 
-# Load Railtie only if Rails is defined
 require_relative "eager_eye/railtie" if defined?(Rails::Railtie)

data/sig/eager_eye.rbs

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