deprecool 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca3a279e6790babeed0e659c1093f1b1a9086d9695a637460dda7cfa69d7182
-  data.tar.gz: a9a735cbd4232f568e002c643370c42491bad699a4ee1cfdd8eaae8e8493c723
+  metadata.gz: 354619cb58b3d0b43f1aaffbd90720589a350d8d31f9f52a7c8cab5db4ee8125
+  data.tar.gz: b9ae44fa91e1c5c7815902810596f82c115981f35982ac3c1bedc89b78f8d7ce
 SHA512:
-  metadata.gz: e8ce7b248608aecf4281f836bedc94c5cc6b493a9581145b22d01a9fee87266a304ce389193841dba4c5e1e5e0029af6fb63397b61e7ca877b4bf19e81b974db
-  data.tar.gz: 37d39d356843be3105baff39d2f4021b48f9edbf31816b241e715a43f19d489d0b72f3f5abe04de8e4c23749409158c5b5d05470608f3788b618c907faf6c572
+  metadata.gz: 84eb84064dfa7230addf8dec40fad61affc9050747f22b3dc2e938e9545a20d58f6d42d567b7c85189d4421d52f57a2a42572eee36fef5624fb46da77a8eee6e
+  data.tar.gz: fc44486aab2d15112a99f04136dda227896a728f9e75032fd2450d18471904d60469538fc6714e4350d3621dedeac9770bde1b8d5474e4609da62116ba326f52

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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

data/lib/deprecool/cli.rb

@@ -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) active)"
+          puts "(#{finders&.size || 0} finder(s) active)"
           return
         end
 
@@ -125,13 +155,13 @@ module Deprecool
         offenses.each_value do |offense_array|
           offense = offense_array.first
 
-          puts "\n#{colorize(offense.title, :bold)}"
+          puts "\n#{offense.gem} #{offense.deprecated_in} - #{colorize(offense.title, :bold)}"
           puts
           puts " * #{offense.summary}"
           puts
-          puts "  #{colorize('effort:', :green).ljust(16)} #{colorize_effort(offense.effort)}"
-          puts "  #{colorize('fix:', :green).ljust(16)} #{offense.suggestion}"   if offense.suggestion
-          puts "  #{colorize('source(s):', :green).ljust(16)} #{offense.reference}" if offense.reference
+          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
@@ -150,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

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.
   #
@@ -32,6 +30,14 @@ module Deprecool
     include PrismHelpers
 
     class << self
+      # automatically include GemHelpers into the classes for the Gem
+      def inherited(subclass)
+        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
       %i[gem title summary suggestion reference].each do |attribute|
         define_method(attribute) do |value = (getter = true)|
@@ -120,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

@@ -9,7 +9,7 @@ module Deprecool
           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' \
+          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"])` ' \
@@ -19,11 +19,11 @@ module Deprecool
 
           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)
-            return if confidence == :none
 
             add_offense(node, confidence: confidence)
           end
@@ -38,11 +38,12 @@ module Deprecool
             # 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?
-            if first.is_a?(Prism::CallNode)
-              return :low if first.variable_call? # can't tell what's stored in the variable, https://docs.ruby-lang.org/en/master/Prism/CallNode.html#method-i-variable_call-3F
-              :none
-            elsif %w[INSERT UPDATE DELETE].include?(first.unescaped[..5].upcase)
-              :high
+            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

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

@@ -29,7 +29,7 @@ module Deprecool
             # ObjectSpace or defining '_id2ref' on custom classes
             confidence = node.receiver.name == :ObjectSpace ? :high : :none
 
-            return if confidence == :none
+
 
             add_offense node, confidence: confidence
           end

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

@@ -10,8 +10,9 @@ 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 want an instance of a subclass of Set' \
+                        '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 if confidence == :none
+
 
             add_offense(node, confidence:)
           end

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

@@ -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.3'
+  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.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Zac Radford
@@ -54,16 +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