eager_eye 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 717dbf77ddadff7da379108a74205cabaed1cdb2796ff8af8dce681fca07b1c9
-  data.tar.gz: 424b8b40da2e4bb69f54d58a5d2923346b016db3d1e69220c06e8bbde0dfa7c6
+  metadata.gz: a432b16aece37497880140ff64a88cd3dabe6ae603846a513d21f71a8b11b5a1
+  data.tar.gz: 330aac1ef792a5ca24597dcd4128329e20f05959ea45437e244788b94f12026d
 SHA512:
-  metadata.gz: efd5e760d3ea54457eb837011b538424553c532ca38a29660a3865c952a32a42ff82bbaeca5925fd423c56510800fc6bc961483a6c167e5a7b132eb06b2f93d3
-  data.tar.gz: 5d80c29a7a1648541377e10e990869293e9f1ba3c99490fec4aa4efab16b99ad56f7ac00b8ab5df9763c70dc41d3dbe2ee9984212f43e2d261f599c15aca8919
+  metadata.gz: 192aa6bb71494f09091ac64a44de11526db09ec389cf41db80229457d59d52f5e81c9b9ae05cc6892ec11c646078a12520c657940a986c47f6519af6b956526f
+  data.tar.gz: 3e18421c967675ea0c10ab19ff7f0426d2a2d8e2fcf969a20b6bc0571f0f32a40c8f515b16c464df57c67b447fe0e9c3b3087b22cee37bbda3bee89b1dd3d418

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,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.2] - 2026-01-31
+
+### Fixed
+
+- **CustomMethodQuery False Positive** - Skip PostgreSQL array column methods
+  - Methods ending with `_ids`, `_tags`, `_types`, `_codes`, `_names`, `_values` now recognized as array attributes
+  - `sector_subcategory_ids.first` no longer flagged (Ruby Array#first, not AR query)
+
+- **LoopAssociation False Positive** - Skip common non-association attribute methods
+  - Added `origin`, `priority`, `level`, `kind`, `label`, `code`, `reason`, `amount`, `price`, `quantity`, `url`, `path`, `email`, `phone`, `address`, `notes`, `memo`, `data`, `metadata`, `position`, `rank`, `score`, `rating`, `enabled`, `disabled`, `active`, `published`, `draft`, `archived`, `locked`, `visible`, `hidden` to excluded methods
+  - Note: `category` and `tag` remain detectable as they're common association names - use inline suppression if they're string attributes in your codebase
+
+- **PluckToArray False Positive** - Skip params-originated values
+  - `params[:ids].split(',').map(&:to_i)` no longer flagged
+  - `params` method now recognized as non-ActiveRecord source
+
+## [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.2-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 params].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/custom_method_query.rb

@@ -7,6 +7,7 @@ module EagerEye
                          maximum].freeze
       SAFE_QUERY_METHODS = %i[first last take count sum find size length ids].freeze
       SAFE_TRANSFORM_METHODS = %i[keys values split [] params sort pluck ids to_s to_a to_i chars bytes].freeze
+      ARRAY_COLUMN_SUFFIXES = %w[_ids _tags _types _codes _names _values].freeze
       ITERATION_METHODS = %i[each map select find_all reject collect detect find_index flat_map].freeze
 
       def self.detector_name
@@ -124,7 +125,13 @@ module EagerEye
       def receiver_ends_with_safe_transform_method?(node)
         return false unless node.is_a?(Parser::AST::Node) && node.type == :send
 
-        SAFE_TRANSFORM_METHODS.include?(node.children[1])
+        method_name = node.children[1]
+        SAFE_TRANSFORM_METHODS.include?(method_name) || array_column_method?(method_name)
+      end
+
+      def array_column_method?(method_name)
+        method_str = method_name.to_s
+        ARRAY_COLUMN_SUFFIXES.any? { |suffix| method_str.end_with?(suffix) }
       end
 
       def add_issue(node)

data/lib/eager_eye/detectors/loop_association.rb

@@ -19,7 +19,10 @@ module EagerEye
         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!
         valid? invalid? errors new? persisted? changed? frozen? name title body content text
-        description value key type status state created_at updated_at deleted_at
+        description value key type status state created_at updated_at deleted_at origin
+        priority level kind label code reason amount price quantity url path email phone
+        address notes memo data metadata position rank score rating enabled disabled active
+        published draft archived locked visible hidden
       ].freeze
 
       def self.detector_name

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.2"
 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.2
 platform: ruby
 authors:
 - hamzagedikkaya
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-18 00:00:00.000000000 Z
+date: 2026-02-01 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'