deprecool 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 959b5cdb23ec0d5eef80f87185fb7a31a5646cf991cced0030d4d839fb835906
-  data.tar.gz: 87eac39b80c35af2e3bc868ab99b03d534f46f06e0f6ef6945381e5d00e8798b
+  metadata.gz: 354619cb58b3d0b43f1aaffbd90720589a350d8d31f9f52a7c8cab5db4ee8125
+  data.tar.gz: b9ae44fa91e1c5c7815902810596f82c115981f35982ac3c1bedc89b78f8d7ce
 SHA512:
-  metadata.gz: d6da4e681409697beeaad714e669ad6854000a66a9086a8bf593ded61016e3741beb5147d616a42d99c3e19b3d51ad886f432d056ba58db2e56a559b0188ae87
-  data.tar.gz: cd41a34a6787fb74f7985e9180893d46a765a19d369b90c09d23738a378ee645bce9d02109fda4e7806195f82bc94f9b0d2ac300ec6c69bf6d0ccb65c9e41e9a
+  metadata.gz: 84eb84064dfa7230addf8dec40fad61affc9050747f22b3dc2e938e9545a20d58f6d42d567b7c85189d4421d52f57a2a42572eee36fef5624fb46da77a8eee6e
+  data.tar.gz: fc44486aab2d15112a99f04136dda227896a728f9e75032fd2450d18471904d60469538fc6714e4350d3621dedeac9770bde1b8d5474e4609da62116ba326f52

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Deprecool
 
+## [0.1.4] - 2026-09-20
+### deprecations
+ - Rails 8.2.0 deprecation of ActiveRecord#uniq!
+ - Ruby 4.0's deprecation of the limit argument to JSON.dump
+
+### gem internals
+ - Finder Test Helper change from `assert_no_offense` to `assert_no_offenses`
+ - auto-inclusion of a gem's helper method class to Finders under a gem's namespace
+ - support gemspec parsing
+ - better file finding and error handling
+
+## [0.1.3] - 2026-08-24
+ - Added Finder for: "Passing `binds` as a positional argument to `insert` deprecated", see [original commit](https://github.com/rails/rails/commit/2dca5457ab2097626481fdbec233ea56d3fb9ee3)
+ - Added `effort` to the CLI output
+
 ## [0.1.2] - 2026-08-14
 
 - Add Finder for Rails's deprecation of `write_attribute(:id, value)`

data/lib/deprecool/cli.rb

@@ -24,7 +24,7 @@ module Deprecool
         option :gems, type: :array, desc: 'Specify gem name(s) to list which versions have deprecation tracking available'
 
         def call(gems:)
-          CLI.list_finders(Finder.registry)
+          CLI.list_finders(Finder.subclasses)
 
           # TODO: REPL to filter through the available finders?
         end
@@ -34,38 +34,57 @@ module Deprecool
         desc 'Scan files or directories for known deprecations'
 
         argument :paths, type: :array, desc: 'Files or directories to scan'
-        option :lockfile, default: 'Gemfile.lock', desc: 'Path to Gemfile.lock, defaults to current directory'
-        option :gems, type: :array, desc: 'Gems to scan for: --gems=ruby,rails'
-        option :format, default: 'text', values: %w[text json], desc: 'Output format'
-        option :all, type: :boolean, default: false, desc: 'Run every finder regardless of version'
 
-        def call(paths:, format:, gems: [], all:, lockfile:, **)
+        option :format,
+               default: 'text',
+               values: %w[text json],
+               desc: 'Output format'
+
+        option :gems,
+               type: :array,
+               desc: 'Gems to scan for: --gems=ruby,rails'
+
+        option :lockfile,
+               default: 'Gemfile.lock',
+               desc: 'Path to Gemfile.lock, defaults to current directory'
+
+        option :all,
+               type: :boolean,
+               default: false,
+               desc: 'Run every finder regardless of version'
+
+        def call(paths:, format:, gems: [], lockfile:, all:, **)
           json_output = format == 'json'
-          files   = CLI.ruby_files(paths)
+          files = CLI.ruby_files(paths)
 
-          if files.empty?
-            if paths.empty?
-              warn CLI.colorize('deprecool: please supply a path/to/file/or/directory', :red)
-              exit 2
-            end
+          if paths.empty?
+            puts 'No path given, using \'.\' as the path' unless json_output
+          end
 
-            warn CLI.colorize("deprecool: no Ruby files found in #{paths.join(', ')}", :red)
-            exit 2
+          # TODO: detect when deprecool is run on too many projects at once
+          # i.e. if you run it on a ~/Documents folder and it finds
+          # a ton of files from different projects it doesn't know what finders
+          # to use and finds nothing
+          if files.empty?
+            warn "No ruby files found in #{paths.join(', ')}"
+            exit 1
           end
 
-          if gems.any?
-            puts "Scanning for deprecations from: #{gems.join(', ')}" unless json_output
-            # we won't be scanning a lockfile
-            gem_versions = []
-          elsif all
-            gem_versions = []
-            gems = []
-          else
-            puts "Scanning #{lockfile}..." unless json_output
-            gem_versions = LockfileParser.parse!(lockfile)
-
-            # we don't need to look for individual gems when scanning gemfiles
-            gems = []
+          dependency_files = CLI.find_dependency_files
+          gem_versions = []
+          gems ||= []
+
+          # if the user supplied "all" then we don't worry about finding gem versions
+          if !all
+            # next we need to find where the dependencies come from, or we could match
+            # offenses from not applicable versions of gems
+            if dependency_files.any?
+              puts "Scanning #{dependency_files.join(', ')} ..."
+              gem_versions = DependencyParser.parse_all(dependency_files)
+              if gems.any?
+                puts "Scanning for deprecations from: #{gems.join(', ')}" unless json_output
+              end
+            end
           end
 
           finders  = Registry.applicable(gems:, gem_versions:, include_all: all)
@@ -92,17 +111,28 @@ module Deprecool
 
       def ruby_files(paths)
         paths = paths.empty? ? ['.'] : paths
+        begin
+          files = paths.flat_map do |path|
+            if File.directory?(path)
+              Dir[File.join(path, '**', '*.rb')]
+            elsif File.file?(path)
+              [path]
+            else
+              warn "deprecool: no such file or directory: #{path}"
+              []
+            end
+          end.uniq.sort
+        rescue SystemCallError => err
+          warn "deprecool: An error occurred - #{err}"
+        ensure
+          files ||= []
 
-        paths.flat_map do |path|
-          if File.directory?(path)
-            Dir[File.join(path, '**', '*.rb')]
-          elsif File.file?(path)
-            [path]
-          else
-            warn "deprecool: no such file or directory: #{path}"
-            []
-          end
-        end.uniq.sort
+          return files
+        end
+      end
+
+      def find_dependency_files
+        Dir["*.gemspec", "Gemfile.lock"]
       end
 
       def report(offenses, format, finders)
@@ -116,7 +146,7 @@ module Deprecool
       def text_report(offenses, finders)
         if offenses.empty?
           puts colorize('No deprecations found.', :green)
-          puts "(#{finders.size} finder#{'s' unless finders.size == 1} active)"
+          puts "(#{finders&.size || 0} finder(s) active)"
           return
         end
 
@@ -125,10 +155,13 @@ module Deprecool
         offenses.each_value do |offense_array|
           offense = offense_array.first
 
-          puts "\n#{colorize(offense.title, :bold)}\n"
+          puts "\n#{offense.gem} #{offense.deprecated_in} - #{colorize(offense.title, :bold)}"
+          puts
           puts " * #{offense.summary}"
-          puts "  #{colorize('fix:', :green)} #{offense.suggestion}" if offense.suggestion
-          puts "  #{colorize('source:', :green)} #{offense.reference}" if offense.reference
+          puts
+          puts "  #{colorize('effort:', :green).ljust(19)} #{colorize_effort(offense.effort)}"
+          puts "  #{colorize('fix:', :green).ljust(19)} #{offense.suggestion}"   if offense.suggestion
+          puts "  #{colorize('source(s):', :green).ljust(19)} #{offense.reference}" if offense.reference
           puts '  Found At:'
           offense_array.each do |o|
             offense_count   += 1
@@ -147,8 +180,8 @@ module Deprecool
 
       def list_finders(finders)
         puts 'Active finders:'
-        finders.sort_by { [it.gem.to_s, it.deprecated_in.to_s, it.id.to_s] }.each do
-          puts " - #{it.classname.ljust(35)} (#{it.gem} #{it.deprecated_in.to_s}) — #{it.title}"
+        finders.sort_by { |f| [f.gem.to_s, f.deprecated_in.to_s, f.id.to_s] }.each do
+          puts " - #{f.classname.ljust(35)} (#{f.gem} #{f.deprecated_in.to_s}) — #{f.title}"
         end
         puts '  (none)' if finders.empty?
       end
@@ -158,6 +191,17 @@ module Deprecool
 
         "\e[#{colors.fetch(color, nil)}m#{text}\e[0m"
       end
+
+      def colorize_effort(effort)
+        # the effort method raises if you set anything but these
+        # values so it's safe to assume, it would also be a hassle
+        # to remove duplication here so oh well
+        effort_colors = { low:    :green,
+                          medium: :yellow,
+                          high: :red }
+
+        colorize(effort, effort_colors[effort])
+      end
     end
   end
 end

data/lib/deprecool/dependency_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'dependency_parsers/gemspec_parser'
+require_relative 'dependency_parsers/lockfile_parser'
+require_relative 'dependency_parsers/null_parser'
+
+module Deprecool
+  module DependencyParser
+    extend self
+
+    def parse_all(dependency_files)
+      files = Array(dependency_files)
+
+      dependencies = GemVersions.new
+
+      files.each do |file|
+        dependencies.add_all!(parser_for_file(file).parse!(file))
+      end
+
+      dependencies
+    end
+
+    def parser_for_file(dependency_file)
+      case File.extname(dependency_file)
+      when '.lock'    then DependencyParsers::LockfileParser
+      when '.gemspec' then DependencyParsers::GemspecParser
+      else
+        DependencyParsers::NullParser
+      end
+    end
+  end
+end

data/lib/deprecool/dependency_parsers/gemspec_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Deprecool
+  module DependencyParsers
+    module GemspecParser
+      extend self
+
+      def parse!(gemspec_file_path)
+        raise FileNotFound.new('.gemspec') unless File.exist? gemspec_file_path
+
+        parsed = Gem::Specification.load(gemspec_file_path)
+
+        raise InvalidGemspec.new(gemspec_file_path) if parsed.nil?
+
+        gem_versions = GemVersions.new
+
+        parsed.dependencies.each do |dep|
+          gem_versions.add(gem: dep.name, version: minimum_version(dep.requirement))
+        end
+
+        gem_versions.add(gem: 'ruby', version: minimum_version(parsed.required_ruby_version))
+
+        gem_versions.gem_versions
+      end
+
+      private
+
+      def minimum_version(requirement)
+        lower_bounds = requirement.requirements.filter_map { |req| lower_bound(*req) }
+
+        lower_bounds.min || Gem::Version.new(0)
+      end
+
+      def lower_bound(operator, version)
+        case operator
+        when '=', '>=', '>', '~>' then version
+        end
+      end
+    end
+  end
+end

data/lib/deprecool/dependency_parsers/lockfile_parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bundler'
+
+module Deprecool
+  module DependencyParsers
+    module LockfileParser
+      extend self
+
+      def parse!(path_to_gemfile_lock = 'Gemfile.lock', parser: Bundler::LockfileParser)
+        raise FileNotFound.new('.lock') unless File.exist? path_to_gemfile_lock
+
+        parsed = parser.new(File.read(path_to_gemfile_lock))
+        lockfile_gem_versions = GemVersions.new
+
+        parsed.specs.map do |spec|
+          lockfile_gem_versions.add(gem: spec.name, version: spec.version)
+        end
+
+        if parsed.ruby_version
+          gem, version = parsed.ruby_version.split
+          lockfile_gem_versions.add(gem:, version: without_patchlevel(version))
+        else
+          puts "No Ruby version found"
+        end
+
+        lockfile_gem_versions.gem_versions
+      end
+
+      private
+
+      def without_patchlevel(version) = version[/\d+(\.\d+)*/]
+    end
+  end
+end

data/lib/deprecool/dependency_parsers/null_parser.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Deprecool
+  module DependencyParsers
+    module NullParser
+      extend self
+
+      def parse!(file)
+        warn "Attempted to parse #{file} for dependencies, but deprecool does not support #{File.extname(file)} yet."
+
+        []
+      end
+    end
+  end
+end

data/lib/deprecool/errors.rb

@@ -0,0 +1,23 @@
+# lib/errors.rb
+
+module Deprecool
+  class Error < StandardError; end
+
+  class FileNotFound < Error
+    def initialize(filetype)
+      super("No ruby files found in '#{filetype}'")
+    end
+  end
+
+  class InvalidGemspec < Error
+    def initialize(path)
+      super("Could not load a gem specification from '#{path}'")
+    end
+  end
+
+  class NoPathGiven < Error
+    def initialize(_msg = nil)
+      super("No path given, and no ruby files found under '.'")
+    end
+  end
+end

data/lib/deprecool/finder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'helpers/prism_helpers'
-
 module Deprecool
   # Base class for every deprecation finder.
   #
@@ -31,15 +29,13 @@ module Deprecool
   class Finder
     include PrismHelpers
 
-    @registry = []
-
     class << self
-      # All finder subclasses, in definition order.
-      attr_reader :registry
-
+      # automatically include GemHelpers into the classes for the Gem
       def inherited(subclass)
-        Finder.registry << subclass
-        super
+        gem_name = subclass.name.split("::")[2]
+        return if gem_name == "Ruby"
+
+        subclass.send(:include, const_get("#{gem_name}Helpers"))
       end
 
       # defines class methods that set instance variables
@@ -130,9 +126,11 @@ module Deprecool
 
     # Record a deprecation at the given node's location.
     #
-    # confidence - [:high, :low], but currently the only check for this is
-    #              from the CLI outputting red or yellow depending on confidence
+    # confidence - [:high, :low, :none], returns early if :none
+    #              to save each finder the effort of checking for :none
     def add_offense(node, confidence: :high)
+      return if confidence == :none
+
       location = node.location # a Prism::Location
 
       @offenses << Offense.new(

data/lib/deprecool/finders/rails/v8.2.0/active_record_relation_uniq.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Deprecool
+  module Finders
+    module Rails
+      module V8_2_0
+        class ActiveRecordRelationUniq < Deprecool::Finder
+          gem           :rails
+          deprecated_in '8.2.0'
+          removed_in    '9.0.0'
+          title         'ActiveRecord::Relation#uniq! is deprecated'
+          summary       'Since Rails 6.1 you have been able to use Relation#uniq! to remove duplicate fields ' \
+                        'on a query. This was originally because grouping by the same field twice resulted in ' \
+                        'duplicated results. Since Rails 7.0 though, this has been de-duplicated automatically ' \
+                        'and this method has been a near no-op'
+          suggestion    'Remove the call to #uniq!, don\'t just find and replace though ' \
+                        'because `uniq!` is also an Array method. Make sure you have tests ' \
+                        'backing these changes, as always.'
+          reference     'uniq! added in: https://github.com/rails/rails/pull/39358, ' \
+                        'uniq! deprecated in: https://github.com/rails/rails/pull/58525'
+          effort        :low
+
+          def on_call_node(node)
+            return unless node.name == :uniq!
+            return unless args = unwrap_arguments(node.arguments)
+
+            # neither Array.uniq! or ActiveRecord's uniq! take
+            # more than one argument,
+            #
+            # Array only accepts an optional block
+            # AR receives a string or symbol
+            return unless args.count == 1
+
+            confidence = :none
+            confidence = :high if [Prism::SymbolNode, Prism::StringNode].include?(args.first.class)
+
+            # if uniq! is called on a variable like:
+            # some_query.uniq!(:somehting)
+            # then it's still probably a deprecation, but we are a little less sure
+            confidence = :low if receiver_is_bare_variable(node.receiver)
+
+
+            add_offense(node, confidence:)
+          end
+
+          def receiver_is_bare_variable(receiver)
+            receiver.is_a?(Prism::CallNode) && receiver.variable_call?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deprecool/finders/rails/v8.2.0/no_binds_to_insert_update_delete.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Deprecool
+  module Finders
+    module Rails
+      module V8_2_0
+        class InsertUpdateDeleteBinds < Deprecool::Finder
+          gem           :rails
+          deprecated_in '8.2.0'
+          removed_in    '9.0.0'
+          title         'Binds being bassed to Insert Update Delete is deprecated'
+          summary       ' Now that `Arel.sql(sql_with_placeholders, *binds)` wraps SQL and its binds ' \
+                        'together as an `Arel::Nodes::BoundSqlLiteral`, just like ' \
+                        '`Model.where("... = ?", value)`, the separate positional is no longer needed'
+          suggestion    'Old: `connection.insert("INSERT INTO topics (title) VALUES (?)", nil, nil, ["hello"])` ' \
+                        'New: `connection.insert(Arel.sql("INSERT INTO topics (title) VALUES (?)", "hello"))`'
+          reference     'Original Commit: https://github.com/rails/rails/commit/2dca5457ab2097626481fdbec233ea56d3fb9ee3'
+          effort        :low
+
+          def on_call_node(node)
+            return unless %i[insert update delete].include?(node.name)
+            return if node.receiver.nil? # bare `delete :foo, on: :member` in a routes file, etc.
+            return unless arguments = unwrap_arguments(node.arguments)
+            return unless arguments.length > 1
+
+            confidence = confidence_from_arguments(arguments)
+
+            add_offense(node, confidence: confidence)
+          end
+
+          private
+
+          def confidence_from_arguments(arguments)
+            first = arguments[0]
+
+            # if first argument is string node that starts with "INSERT" "UPDATE" "DELETE" then :high
+            # if first argument is a variable then :low confidence
+            # it it's a Prism::CallNode, and not a variable call, then I don't know what it is here,
+            # maybe it's like 'connection.update(generate_sql(some_arg), ["name"])' and if you are doing that
+            # then good luck?
+            case first
+            when Prism::CallNode
+              # can't tell what's stored in the variable, https://docs.ruby-lang.org/en/master/Prism/CallNode.html#method-i-variable_call-3F
+              first.variable_call? ? :low : :none
+            when Prism::StringNode
+              first.unescaped.match?(/\A\s*(INSERT|UPDATE|DELETE)\s/i) ? :high : :none
+            else
+              :none
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deprecool/finders/ruby/v4.0.0/json_dump_limit.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Deprecool
+  module Finders
+    module Ruby
+      module V4_0_0
+        class JsonDumpLimit < Deprecool::Finder
+          gem           :ruby
+          deprecated_in '4.0.0'
+          removed_in    '4.1.0'
+          title         'Passing a positional limit argument to JSON.dump is deprecated'
+          summary       'JSON.dump(obj, io, limit) accepted a nesting limit as a positional argument. ' \
+                        'Parsing that argument is awful and costly, so it is now named _deprecated_limit ' \
+                        'instead of fully removing because updating rdoc is costly.'
+          suggestion    'Pass the :max_nesting option instead, e.g. JSON.dump(obj, io, max_nesting: 10)'
+          reference     'https://github.com/ruby/json/commit/566bd7c108 ' \
+                        'https://github.com/ruby/ruby/commit/d98d7978dc0dd777756ba737295d9cec482f84a3'
+          effort        :low
+
+          def on_call_node(node)
+            # we only care if the call is JSON.dump
+            return unless node.name == :dump
+            return unless json_receiver?(node.receiver)
+
+            # bare keyword options and blocks aren't positional arguments
+            positional = positional_args_from(node.arguments)
+
+            # :high because the receiver is JSON and the limit is only detected when it
+            # can't be anything else (a non-nil, non-hash third argument or an integer in place of io)
+            add_offense(node, confidence: :high) if passes_limit_arg?(positional)
+          end
+
+          private
+
+          def json_receiver?(receiver)
+            case receiver
+            when Prism::ConstantReadNode then receiver.name == :JSON
+            # ::JSON.dump
+            when Prism::ConstantPathNode then receiver.parent.nil? && receiver.name == :JSON
+            else false
+            end
+          end
+
+          # follows the same steps JSON.dump uses to decide which argument is the limit
+          def passes_limit_arg?(positional)
+            # the positional param will dereference into all 3 variables only if
+            # all three are actually passed.
+            _obj, io, limit = positional
+
+            # if a third argument is passed, but it's a {hash} or nil
+            # then set the third arg to nil in case the second argument is being used
+            # as the limit i.e. (JSON.dump(obj, 1, strict: true))
+            limit = nil if limit.is_a?(Prism::HashNode) || limit.is_a?(Prism::NilNode)
+
+            # in the case the third arg was nil or a hash/nil then check if the second arg
+            # is an integer, this is similar to what the `dump` method does in ruby 4
+            limit = io if limit.nil? && integer?(io)
+
+
+            !limit.nil?
+          end
+
+          def integer?(node) = node.is_a?(Prism::IntegerNode)
+        end
+      end
+    end
+  end
+end

data/lib/deprecool/finders/ruby/v4.0.0/object_space_id2ref.rb

@@ -27,9 +27,9 @@ module Deprecool
             # I don't think we need much more than this
             # I'm open to be wrong though, maybe lots of people are subclassing
             # ObjectSpace or defining '_id2ref' on custom classes
-            confidence = node.receiver.name == :ObjectSpace ? :high : nil
+            confidence = node.receiver.name == :ObjectSpace ? :high : :none
+
 
-            return unless confidence
 
             add_offense node, confidence: confidence
           end

data/lib/deprecool/finders/ruby/v4.0.0/to_set_arguments.rb

@@ -10,9 +10,10 @@ module Deprecool
           removed_in    '4.1.0'
           title         'Passing arguments to #to_set is deprecated'
           summary       'Since Ruby 4.0, passing arguments to Set#to_set / Enumerable#to_set ' \
-                        'is deprecated and will be removed.'
-          suggestion    'Call #to_set with no arguments. If you were building a ' \
-                        'Set subclass, construct it explicitly instead.'
+                        'is deprecated and will be removed because it allowed for results that didn\'t make sense. ' \
+                        'For example: `enumerable.to_set(StandardError)`'
+          suggestion    'Call #to_set with no arguments. If you want an instance of a subclass of Set ' \
+                        'from an enumerable construct it explicitly instead: MySetSubclass.new(enumerable)'
           reference     'https://bugs.ruby-lang.org/issues/21390 https://github.com/ruby/ruby/pull/13489'
           effort        :low
 
@@ -21,7 +22,7 @@ module Deprecool
             return unless node.arguments
 
             confidence = confidence_from_receiver_node(node.receiver)
-            return unless confidence
+
 
             add_offense(node, confidence:)
           end
@@ -35,12 +36,12 @@ module Deprecool
             # a plain `to_set(x)` call to the current scope's own
             # method. This is probably not Enumerable#to_set unless someone has
             # monkeypatched Enumerable and is using to_set with an argument, I guess
-            when nil then nil
+            when nil then :none
             when Prism::ConstantReadNode, Prism::ConstantPathNode
               # These nodes can constants like:
               # MY_DATA.to_set(arg) => likely an array, but can't be sure so :low
               # MyClass.to_set(arg) => has lowercase letters so it's a class method
-              receiver&.name&.match?(/[a-z]/) ? nil : :low
+              receiver&.name&.match?(/[a-z]/) ? :none : :low
             else
               # this branch is when the receiver is some
               # local var, instance variable, method chain, safe navigation, etc.

data/lib/deprecool/gem_versions.rb

@@ -0,0 +1,26 @@
+# lib/gem_versions.rb
+
+module Deprecool
+  class GemVersions
+    include Enumerable
+
+    attr_reader :gem_versions
+
+    def initialize
+      @gem_versions = []
+    end
+
+    def add(gem:, version:)
+      @gem_versions << { gem: gem.to_sym,
+                         version: Gem::Version.new(version.to_s) }
+    end
+
+    def add_all!(gemversions)
+      Array(gemversions).each { |gv| add(gem: gv[:gem], version: gv[:version]) }
+    end
+
+    def each(&block)
+      @gem_versions.each(&block)
+    end
+  end
+end

data/lib/deprecool/helpers/prism_helpers.rb

@@ -18,6 +18,12 @@ module PrismHelpers
     node.arguments
   end
 
+  def positional_args_from(arguments)
+    unwrap_arguments(arguments).to_a.reject do |arg|
+      arg.is_a?(Prism::KeywordHashNode) || arg.is_a?(Prism::BlockArgumentNode)
+    end
+  end
+
   # https://docs.ruby-lang.org/en/master/Prism/ArrayNode.html
   def unwrap_array(node)
     return node unless node.is_a?(Prism::ArrayNode)

data/lib/deprecool/helpers/rails_helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsHelpers
+  def active_record_query_method_names
+    # this is as of 8.1.3.1
+    # https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html
+    %i[
+      and annotate create_with distinct
+      eager_load excluding extending extract_associated
+      from group having in_order_of includes invert_where
+      joins left_joins left_outer_joins limit lock
+      none offset optimizer_hints or order preload
+      readonly references regroup reorder reselect reverse_order rewhere
+      select strict_loading structurally_compatible?
+      uniq! unscope
+      where with with_recursive without
+      ]
+  end
+end

data/lib/deprecool/registry.rb

@@ -7,7 +7,7 @@ module Deprecool
 
     # All the subclasses of Finder
     def all_finders
-      Finder.registry
+      @all ||= Finder.subclasses
     end
 
     # Gets finders that apply to the given versions.
@@ -22,7 +22,7 @@ module Deprecool
     def finders_by_gem(gems)
       targets = []
       gems.each do |gem|
-        targets << all_finders.select { it.to_s.match(/#{gem.capitalize}/) }
+        targets << all_finders.select { |finder| finder.to_s.match(/#{gem.capitalize}/) }
       end
       targets.flatten
     end

data/lib/deprecool/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Deprecool
-  VERSION = '0.1.2'
+  VERSION = '0.1.4'
 end
 

data/lib/deprecool.rb

@@ -2,20 +2,23 @@
 
 require 'prism'
 
-module Deprecool
-  class Error < StandardError; end
+module Deprecool; end
+
+Dir["#{__dir__}/deprecool/helpers/*.rb"].each do |helper|
+  require helper
 end
 
+require_relative 'deprecool/errors'
 require_relative 'deprecool/version'
+require_relative 'deprecool/gem_versions'
 require_relative 'deprecool/finder'
 require_relative 'deprecool/registry'
 require_relative 'deprecool/scanner'
-require_relative 'deprecool/lockfile_parser'
+require_relative 'deprecool/dependency_parser'
 require_relative 'deprecool/cli'
 
 # TODO: Scan gemfiles and then only require relevant finders instead of all
 # of them
-Dir[File.join(__dir__, 'deprecool', 'finders', '**', '*.rb')].each do |finder|
+Dir["#{__dir__}/deprecool/finders/**/*.rb"].each do |finder|
   require finder
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: deprecool
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Zac Radford
@@ -54,15 +54,24 @@ files:
 - exe/deprecool
 - lib/deprecool.rb
 - lib/deprecool/cli.rb
+- lib/deprecool/dependency_parser.rb
+- lib/deprecool/dependency_parsers/gemspec_parser.rb
+- lib/deprecool/dependency_parsers/lockfile_parser.rb
+- lib/deprecool/dependency_parsers/null_parser.rb
+- lib/deprecool/errors.rb
 - lib/deprecool/finder.rb
 - lib/deprecool/finders/rails/v7.1.0/serializer_positional_class_argument.rb
+- lib/deprecool/finders/rails/v8.2.0/active_record_relation_uniq.rb
+- lib/deprecool/finders/rails/v8.2.0/no_binds_to_insert_update_delete.rb
 - lib/deprecool/finders/rails/v8.2.0/redis_cache_store_default_redis_options.rb
 - lib/deprecool/finders/rails/v8.2.0/to_sql_binds.rb
 - lib/deprecool/finders/rails/v8.2.0/write_attribute_id.rb
+- lib/deprecool/finders/ruby/v4.0.0/json_dump_limit.rb
 - lib/deprecool/finders/ruby/v4.0.0/object_space_id2ref.rb
 - lib/deprecool/finders/ruby/v4.0.0/to_set_arguments.rb
+- lib/deprecool/gem_versions.rb
 - lib/deprecool/helpers/prism_helpers.rb
-- lib/deprecool/lockfile_parser.rb
+- lib/deprecool/helpers/rails_helpers.rb
 - lib/deprecool/registry.rb
 - lib/deprecool/scanner.rb
 - lib/deprecool/version.rb

data/lib/deprecool/lockfile_parser.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler'
-
-module Deprecool
-  module LockfileParser
-    extend self
-
-    def parse!(path_to_gemfile_lock = 'Gemfile.lock', parser: Bundler::LockfileParser)
-      lockfile = File.read(path_to_gemfile_lock)
-
-      parsed = parser.new(lockfile)
-
-      versions = parsed.specs.map do |spec|
-        { gem: spec.name, version: spec.version.to_s }
-      end
-
-      gem, version = parsed.ruby_version.split
-      versions << { gem:, version: }
-    end
-  end
-end