eager_eye 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 717dbf77ddadff7da379108a74205cabaed1cdb2796ff8af8dce681fca07b1c9
-  data.tar.gz: 424b8b40da2e4bb69f54d58a5d2923346b016db3d1e69220c06e8bbde0dfa7c6
+  metadata.gz: 2e098f00c3f4cffd7e4450d5fd8e2adaa01d9e1fca4d7180d996e6b9c646a448
+  data.tar.gz: 4a2abc06d7986eaa0629e076ffc7950dfe0a7af81f051bee9faee608ee5f0779
 SHA512:
-  metadata.gz: efd5e760d3ea54457eb837011b538424553c532ca38a29660a3865c952a32a42ff82bbaeca5925fd423c56510800fc6bc961483a6c167e5a7b132eb06b2f93d3
-  data.tar.gz: 5d80c29a7a1648541377e10e990869293e9f1ba3c99490fec4aa4efab16b99ad56f7ac00b8ab5df9763c70dc41d3dbe2ee9984212f43e2d261f599c15aca8919
+  metadata.gz: b7683c5e0209f89058a99a0e4fd438f2253c231df17646baf7cfe59a18c2b617ebe9664ef10cc7e0243ae0cd863056940ba792ba82c671c908b757f5774ac04f
+  data.tar.gz: 489810690ff2bef7ccb7c36c55367ffacbedbe9191393d0b27eeb7133457d896096f54d593133944b6f265f97d4aadec96464811975bcaea7ab0f3108d2ce3b5

data/.rubocop.yml

@@ -20,7 +20,7 @@ Metrics/BlockLength:
     - "lib/eager_eye/railtie.rb"
 
 Metrics/ClassLength:
-  Max: 155
+  Max: 165
 
 Metrics/ParameterLists:
   Max: 6

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.1] - 2026-01-31
+
+### Fixed
+
+- **PluckToArray False Positives** - Major improvements to reduce false positives:
+  - Skip when variable is used in multiple places (e.g., for ordering with `array_position`)
+  - Skip non-ActiveRecord sources: Sidekiq, Redis, Resque, DelayedJob
+  - Skip `.to_sql` usage patterns (UNION queries can't use subqueries)
+  - Skip non-AR `.where` receivers (Sidekiq::Queue, Redis, etc.)
+  - Differentiate message between `.pluck()` and `.map(&:id)` patterns
+  - Skip block maps like `.map { |u| u[:id] }` (likely Hash/Array access)
+
 ## [1.2.0] - 2026-01-18
 
 ### Features

data/README.md

@@ -10,7 +10,7 @@
 
 <p align="center">
   <a href="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml"><img src="https://github.com/hamzagedikkaya/eager_eye/actions/workflows/main.yml/badge.svg" alt="CI"></a>
-  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.0-red.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/eager_eye"><img src="https://img.shields.io/badge/gem-v1.2.1-red.svg" alt="Gem Version"></a>
   <a href="https://github.com/hamzagedikkaya/eager_eye"><img src="https://img.shields.io/badge/coverage-95%25-brightgreen.svg" alt="Coverage"></a>
   <a href="https://www.ruby-lang.org/"><img src="https://img.shields.io/badge/ruby-%3E%3D%203.1-ruby.svg" alt="Ruby"></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>

data/lib/eager_eye/detectors/concerns/non_ar_source_detector.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module EagerEye
+  module Detectors
+    module Concerns
+      module NonArSourceDetector
+        NON_AR_RECEIVERS = %w[Sidekiq Redis Resque DelayedJob Queue Job Hash Array Set].freeze
+        NON_DB_SOURCE_METHODS = %i[smembers sinter sunion sdiff zrange zrangebyscore lrange hkeys hvals hgetall
+                                   keys values entries args].freeze
+
+        private
+
+        def ar_receiver?(node)
+          receiver = node.children[0]
+          return true unless receiver.is_a?(Parser::AST::Node)
+
+          !non_ar_class?(receiver)
+        end
+
+        def non_ar_class?(node)
+          return false unless node.is_a?(Parser::AST::Node)
+          return NON_AR_RECEIVERS.any? { |r| extract_const_name(node).include?(r) } if node.type == :const
+          return non_ar_class?(node.children[0]) if node.type == :send && node.children[0].is_a?(Parser::AST::Node)
+
+          false
+        end
+
+        def extract_const_name(node)
+          return "" unless node.is_a?(Parser::AST::Node) && node.type == :const
+
+          parent_name = extract_const_name(node.children[0])
+          name = node.children[1].to_s
+          parent_name.empty? ? name : "#{parent_name}::#{name}"
+        end
+
+        def non_db_source?(node)
+          return false unless node.is_a?(Parser::AST::Node)
+          return false unless %i[send block].include?(node.type)
+
+          send_node = node.type == :block ? node.children[0] : node
+          send_node.is_a?(Parser::AST::Node) && non_db_method_chain?(send_node)
+        end
+
+        def non_db_method_chain?(node)
+          return false unless node.is_a?(Parser::AST::Node) && node.type == :send
+          return true if NON_DB_SOURCE_METHODS.include?(node.children[1])
+
+          receiver = node.children[0]
+          return non_ar_class?(receiver) || non_db_method_chain?(receiver) if receiver.is_a?(Parser::AST::Node)
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/eager_eye/detectors/pluck_to_array.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative "concerns/non_ar_source_detector"
+
 module EagerEye
   module Detectors
     class PluckToArray < Base
+      include Concerns::NonArSourceDetector
+
       SMALL_COLLECTIONS = %w[tags settings options categories roles permissions statuses types priorities].freeze
 
       def self.detector_name
@@ -12,53 +16,100 @@ module EagerEye
       def detect(ast, file_path)
         @issues = []
         @file_path = file_path
-        @pluck_variables = {}
-        @map_id_variables = {}
-        @critical_pluck_variables = {}
-        @small_collection_variables = {}
+        reset_tracking_variables
 
         return @issues unless ast
 
-        visit(ast)
+        collect_all_info(ast)
+        check_ast(ast)
+
         @issues
       end
 
       private
 
-      def visit(node)
+      def reset_tracking_variables
+        @pluck_variables = {}
+        @map_id_variables = {}
+        @critical_pluck_variables = {}
+        @small_collection_variables = {}
+        @variable_usages = Hash.new(0)
+        @to_sql_variables = {}
+      end
+
+      def collect_all_info(node)
         return unless node.is_a?(Parser::AST::Node)
 
         collect_assignments(node)
-        check_where_calls(node)
+        collect_variable_usage(node)
+        collect_to_sql_usage(node)
 
-        node.children.each { |child| visit(child) }
+        node.children.each { |child| collect_all_info(child) }
+      end
+
+      def check_ast(node)
+        return unless node.is_a?(Parser::AST::Node)
+
+        check_where_calls(node)
+        node.children.each { |child| check_ast(child) }
       end
 
       def collect_assignments(node)
-        return unless local_variable_assignment?(node)
+        return unless node.type == :lvasgn
 
         var_name = node.children[0]
         value = node.children[1]
 
-        @critical_pluck_variables[var_name] = node.loc.line if all_pluck_call?(value)
-        @small_collection_variables[var_name] = node.loc.line if small_collection_pluck?(value)
-        @pluck_variables[var_name] = node.loc.line if pluck_call?(value)
-        @map_id_variables[var_name] = node.loc.line if map_id_call?(value)
+        return if non_db_source?(value)
+
+        track_variable_type(var_name, value, node.loc.line)
+      end
+
+      def track_variable_type(var_name, value, line)
+        @critical_pluck_variables[var_name] = line if all_pluck_call?(value)
+        @small_collection_variables[var_name] = line if small_collection_pluck?(value)
+        @pluck_variables[var_name] = line if pluck_call?(value)
+        @map_id_variables[var_name] = line if map_id_call?(value)
+      end
+
+      def collect_variable_usage(node)
+        return unless node.is_a?(Parser::AST::Node) && node.type == :lvar
+
+        @variable_usages[node.children[0]] += 1
+      end
+
+      def collect_to_sql_usage(node)
+        return unless node.is_a?(Parser::AST::Node) && node.type == :send && node.children[1] == :to_sql
+
+        find_variables_in_chain(node).each { |var_name| @to_sql_variables[var_name] = true }
+      end
+
+      def find_variables_in_chain(node)
+        return [] unless node.is_a?(Parser::AST::Node)
+        return [node.children[0]] if node.type == :lvar
+
+        node.children.flat_map { |child| find_variables_in_chain(child) }
       end
 
       def check_where_calls(node)
-        return unless where_call?(node)
-
-        if critical_pluck?(node)
-          add_critical_issue(node)
-        elsif small_collection?(node)
-          add_info_issue(node)
-        elsif regular_pluck?(node)
-          add_issue(node)
+        return unless where_call?(node) && ar_receiver?(node)
+
+        process_where_call(node)
+      end
+
+      def process_where_call(node)
+        if critical_pluck?(node) then add_critical_issue(node)
+        elsif small_collection?(node) then add_info_issue(node)
+        elsif regular_pluck?(node) then check_regular_pluck(node)
         end
       end
 
-      def local_variable_assignment?(node) = node.type == :lvasgn
+      def check_regular_pluck(node)
+        var_name = find_pluck_var_in_where(node)
+        return if var_name && (multi_use_variable?(var_name) || @to_sql_variables[var_name])
+
+        add_issue(node, var_name)
+      end
 
       def where_call?(node) = node.type == :send && node.children[1] == :where
 
@@ -67,108 +118,103 @@ module EagerEye
       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
+        pluck_call?(node) && node.children[0].is_a?(Parser::AST::Node) &&
+          node.children[0].type == :send && node.children[0].children[1] == :all
       end
 
       def small_collection_pluck?(node)
         return false unless pluck_call?(node)
 
         receiver = node.children[0]
-        return false unless receiver.is_a?(Parser::AST::Node) && receiver.type == :send
-
-        method_name = receiver.children[1].to_s
-        SMALL_COLLECTIONS.any? { |c| method_name.include?(c) }
+        receiver.is_a?(Parser::AST::Node) && receiver.type == :send &&
+          SMALL_COLLECTIONS.any? { |c| receiver.children[1].to_s.include?(c) }
       end
 
       def map_id_call?(node)
-        node.is_a?(Parser::AST::Node) && (block_map?(node) || send_map?(node))
+        node.is_a?(Parser::AST::Node) && node.type == :send && %i[map collect].include?(node.children[1]) &&
+          node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
       end
 
-      def block_map?(node)
-        node.type == :block && node.children[0]&.type == :send &&
-          %i[map collect].include?(node.children[0].children[1])
+      def symbol_to_proc_id?(node)
+        node.is_a?(Parser::AST::Node) && node.type == :block_pass &&
+          node.children[0]&.type == :sym && %i[id to_i].include?(node.children[0].children[0])
       end
 
-      def send_map?(node)
-        node.type == :send && %i[map collect].include?(node.children[1]) &&
-          node.children[2..].any? { |arg| symbol_to_proc_id?(arg) }
-      end
+      def regular_pluck?(node) = node.children[2..].any? { |arg| pluck_var_in_hash?(arg) }
+      def critical_pluck?(node) = node.children[2..].any? { |arg| critical_pluck_in_hash?(arg) }
+      def small_collection?(node) = node.children[2..].any? { |arg| small_collection_in_hash?(arg) }
 
-      def symbol_to_proc_id?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :block_pass
+      def pluck_var_in_hash?(node) = hash_with_value?(node) { |v| pluck_value?(v) }
+      def critical_pluck_in_hash?(node) = hash_with_value?(node) { |v| critical_value?(v) }
+      def small_collection_in_hash?(node) = hash_with_value?(node) { |v| small_collection_value?(v) }
 
-        node.children[0]&.type == :sym && %i[id to_i].include?(node.children[0].children[0])
-      end
+      def hash_with_value?(node, &block)
+        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
 
-      def regular_pluck?(node)
-        node.children[2..].any? { |arg| pluck_var_in_hash?(arg) }
+        node.children.any? { |pair| pair.type == :pair && block.call(pair.children[1]) }
       end
 
-      def critical_pluck?(node)
-        node.children[2..].any? { |arg| critical_pluck_in_hash?(arg) }
+      def pluck_value?(val)
+        val.type == :lvar && (@pluck_variables.key?(val.children[0]) || @map_id_variables.key?(val.children[0]))
       end
 
-      def small_collection?(node)
-        node.children[2..].any? { |arg| small_collection_in_hash?(arg) }
+      def critical_value?(val)
+        val.type == :lvar ? @critical_pluck_variables.key?(val.children[0]) : all_pluck_call?(val)
       end
 
-      def pluck_var_in_hash?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
-
-        node.children.any? { |pair| pair.type == :pair && pluck_value?(pair.children[1]) }
+      def small_collection_value?(val)
+        val.type == :lvar && @small_collection_variables.key?(val.children[0])
       end
 
-      def critical_pluck_in_hash?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
+      def find_pluck_var_in_where(node)
+        node.children[2..].each do |arg|
+          next unless arg.is_a?(Parser::AST::Node) && arg.type == :hash
 
-        node.children.any? { |pair| pair.type == :pair && critical_value?(pair.children[1]) }
+          var = find_pluck_var_in_hash(arg)
+          return var if var
+        end
+        nil
       end
 
-      def small_collection_in_hash?(node)
-        return false unless node.is_a?(Parser::AST::Node) && node.type == :hash
-
-        node.children.any? { |pair| pair.type == :pair && small_collection_value?(pair.children[1]) }
-      end
+      def find_pluck_var_in_hash(hash_node)
+        hash_node.children.each do |pair|
+          next unless pair.type == :pair && pair.children[1].type == :lvar
 
-      def pluck_value?(value)
-        value.type == :lvar && (@pluck_variables.key?(value.children[0]) || @map_id_variables.key?(value.children[0]))
+          var_name = pair.children[1].children[0]
+          return var_name if @pluck_variables.key?(var_name) || @map_id_variables.key?(var_name)
+        end
+        nil
       end
 
-      def critical_value?(value)
-        value.type == :lvar ? @critical_pluck_variables.key?(value.children[0]) : all_pluck_call?(value)
-      end
+      def multi_use_variable?(var_name) = @variable_usages[var_name] > 1
+      def map_variable?(var_name) = @map_id_variables.key?(var_name)
 
-      def small_collection_value?(value)
-        value.type == :lvar && @small_collection_variables.key?(value.children[0])
+      def add_issue(node, var_name = nil)
+        message, suggestion = issue_content(var_name)
+        @issues << create_issue(file_path: @file_path, line_number: node.loc.line,
+                                message: message, suggestion: suggestion, severity: :warning)
       end
 
-      def add_issue(node)
-        @issues << create_issue(
-          file_path: @file_path,
-          line_number: node.loc.line,
-          message: "Using plucked array in `where` causes two queries and memory overhead",
-          suggestion: "Use `.select(:id)` subquery instead: `Model.where(col: OtherModel.select(:id))`",
-          severity: :warning
-        )
+      def issue_content(var_name)
+        if var_name && map_variable?(var_name)
+          ["Using ID array from `.map(&:id)` in `where` causes two queries",
+           "If source is ActiveRecord, use `.select(:id)` subquery instead"]
+        else
+          ["Using plucked array in `where` causes two queries and memory overhead",
+           "Use `.select(:id)` subquery instead: `Model.where(col: OtherModel.select(:id))`"]
+        end
       end
 
       def add_critical_issue(node)
-        @issues << create_issue(
-          file_path: @file_path,
-          line_number: node.loc.line,
-          message: "Using `.all.pluck(:id)` loads entire table into memory - highly inefficient",
-          suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.select(:id))`",
-          severity: :error
-        )
+        @issues << create_issue(file_path: @file_path, line_number: node.loc.line,
+                                message: "Using `.all.pluck(:id)` loads entire table into memory - highly inefficient",
+                                suggestion: "Use `.select(:id)` subquery: `Model.where(col: OtherModel.select(:id))`",
+                                severity: :error)
       end
 
       def add_info_issue(node)
         @issues << create_issue(
-          file_path: @file_path,
-          line_number: node.loc.line,
+          file_path: @file_path, line_number: node.loc.line,
           message: "Small collection pluck may be acceptable for few records",
           suggestion: "Consider `.select(:id)` for consistency, but pluck is fine for small collections",
           severity: :info

data/lib/eager_eye/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eager_eye
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-18 00:00:00.000000000 Z
+date: 2026-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -66,6 +66,7 @@ files:
 - lib/eager_eye/configuration.rb
 - lib/eager_eye/detectors/base.rb
 - lib/eager_eye/detectors/callback_query.rb
+- lib/eager_eye/detectors/concerns/non_ar_source_detector.rb
 - lib/eager_eye/detectors/count_in_iteration.rb
 - lib/eager_eye/detectors/custom_method_query.rb
 - lib/eager_eye/detectors/loop_association.rb
@@ -90,7 +91,6 @@ 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'