deprecation_toolkit 1.5.1 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eca1e15cbf4dde5f24f61b66b118b7e1c5e532794e639aab745716f479c3ed8b
-  data.tar.gz: fbdc94772c27097404d9e815e4b0885c4106f697e5b865e300eea0c88c1d5c79
+  metadata.gz: 7b57fe6f900e79cc13938de52e802aaff9ab51dfe546d5f9e1cdc0a9ec6c4648
+  data.tar.gz: 61ca80ab4fd5d2337b83cba6af0d53dd1af734957487fcf78d1677ca6b2205d0
 SHA512:
-  metadata.gz: 9d8b667e37f01a1ae8bb9b458b96d0f01da9710eea1b2dee2273b3624f21d3a6f6158188469da164b7136341d8f57d0cc21e8dd525eb37d8ade6ac8ae24b7ae2
-  data.tar.gz: 8576131199145519aedd34382d8dbed2e14cb9135a4fe12b2c3f9a22d14fdb8fb43b84f19477b94ef5c14a0511d43218cc16bae4e8d1da177b2217b7b86766cf
+  metadata.gz: cff2de2f59cb48d1d96b4f39c5c4cdc601d2fdf512d990794e09cf791ef49c7ca8ada4effaa1c19ce0cecc53d535cace10a32eb443abc2a04ac5ca831118dc4c
+  data.tar.gz: 9fc7fda9a92dd4f73af1297200b81c20825b5f37529ce8f808c2a3b6e1f777586d0fba83b5982d978222c8f90b9a24e473107456d39d8758df91d775ac821d7b

data/README.md

@@ -6,10 +6,9 @@ Deprecation Toolkit is a gem that helps you get rid of deprecations in your code
 Having deprecations in your application usually means that something will break whenever you upgrade third-party dependencies. The sooner the better to fix them!
 Fixing all deprecations at once might be tough depending on the size of your app and the number of deprecations. You might have to progressively resolve them while making sure your team doesn't add new ones. This is where this gem comes handy!
 
-
 ## How it works
 
-The Deprecation Toolkit gem works by using a [shitlist approach](https://confreaks.tv/videos/reddotrubyconf2017-shitlist-driven-development-and-other-tricks-for-working-on-large-codebases).
+The Deprecation Toolkit gem works by using a [shitlist approach](https://www.youtube.com/watch?v=20pj_ajDBOg).
 First, the gem records all existing deprecations into `.yml` files. When running a test that have non-recorded deprecations after the initial recording, Deprecation Toolkit triggers a behavior of your choice (by default it raises an error).
 
 ## Recording Deprecations
@@ -44,15 +43,13 @@ end
 
 Behaviors define what happens when non-recorded deprecations are encountered.
 
-Behaviors are classes that have a `.trigger` class method.
-
-This gem provides 3 behaviors, the default one being `DeprecationToolkit::Behaviors::Raise`.
+This gem provides 4 behaviors, the default one being `DeprecationToolkit::Behaviors::Raise`.
 
 * `DeprecationToolkit::Behaviors::Raise` will raise either:
-  - `DeprecationToolkit::DeprecationIntroduced` error if a new deprecation is introduced.
-  - `DeprecationToolkit::DeprecationRemoved` error if a deprecation was removed (compare to the one recorded in the shitlist).
+  - `DeprecationToolkit::Behaviors::DeprecationIntroduced` error if a new deprecation is introduced.
+  - `DeprecationToolkit::Behaviors::DeprecationRemoved` error if a deprecation was removed (compare to the one recorded in the shitlist).
 * `DeprecationToolkit::Behaviors::Record` will record deprecations.
-* `DeprecationToolkit::Behaviors::CIRecordHelper` See separated explanation below.
+* `DeprecationToolkit::Behaviors::CIRecordHelper` See separate explanation below.
 * `DeprecationToolkit::Behaviors::Disabled` will do nothing.
   - This is useful if you want to disable this gem for a moment without removing the gem from your Gemfile.
 
@@ -60,25 +57,25 @@ This gem provides 3 behaviors, the default one being `DeprecationToolkit::Behavi
 DeprecationToolkit::Configuration.behavior = DeprecationToolkit::Behaviors::Record
 ```
 
-You can also create your own behavior class and perform the logic you want. Your behavior needs to respond to `.trigger`.
+You can also create your own behavior object and perform the logic you want. Your behavior needs to respond to `trigger`.
 
 ```ruby
 class StatsdBehavior
-  def self.trigger(test, deprecations, recorded_deprecations)
+  def trigger(test, deprecations, recorded_deprecations)
      # Could send some statsd event for example
   end
 end
 
-DeprecationToolkit::Configuration.behavior = StatsdBehavior
+DeprecationToolkit::Configuration.behavior = StatsdBehavior.new
 ```
 
-##### DeprecationToolkit::Behaviors::CIRecordHelper
+#### DeprecationToolkit::Behaviors::CIRecordHelper
 
 This is a special type of behaviour meant to help you record deprecations if you have a lof of them.
 Imagine if you have thousands of tests and need to record deprecations for each on your machine, this is going to take ages.
 Recording deprecations on CI with the regular `Record` behavior isn't possible because of the way CI parallelize test in multiple container (Multiple tests from the same file runs in parallel in diferrent machines, the deprecation files that get created are then splitted. Regrouping them is a nightmare.)
 
-This behaviour will output a JSON representation of your deprecations. Your CI should have a way to download the log generated from the test run. Download it on your locale machine. Finally run the rake task `FILEPATH=<path_to_downloaded_log> deprecation_toolkit:record_from_ci_output`.
+This behavior will output a JSON representation of your deprecations. Your CI should have a way to download the log generated from the test run. Download it on your locale machine. Finally run the rake task `FILEPATH=<path_to_downloaded_log> deprecation_toolkit:record_from_ci_output`.
 This task will parse your CI log and grab the output generated by the DeprecationToolkit and will finally convert everything back to YML files.
 
 ### 🔨 `#DeprecationToolkit::Configuration#allowed_deprecations`
@@ -114,6 +111,44 @@ a message in the console.
 Deprecation Toolkit allows you to configure which warnings should be treated as deprecations in order for you
 to keep track of them as if they were regular deprecations.
 
+This setting accepts an array of regular expressions. To match on all warnings, you can provide a empty regex:
+
+```ruby
+DeprecationToolkit::Configuration.warnings_treated_as_deprecation = [//]
+```
+
+In addition to regexps, anything that responds to `===` can be a matcher, for instance a proc:
+
+```ruby
+DeprecationToolkit::Configuration.warnings_treated_as_deprecation = [
+  ->(warning) { !warning.match?(/not a deprecation/)}
+]
+```
+
+### 🔨 `#DeprecationToolkit::Configuration#deprecation_file_path_format`
+
+DeprecationToolkit allows you to choose the file path format for deprecation files.
+
+For Minitest, it defaults to using class name so the following code would correspond to `#{deprecation_path}/deprecation_toolkit/behaviors/raise_test.yml`
+
+```ruby
+module DeprecationToolkit
+  module Behaviors
+    class RaiseTest < ActiveSupport::TestCase
+    end
+  end
+end
+```
+
+For rspec if defaults to the file location with spec removed. `/spec/models/user_spec.rb` would correspond to `/models/user.yml`.
+
+If you have a specific use case you can configure this with a custom format using a proc. The proc is called with an instance of the test.
+
+```ruby
+Configuration.deprecation_file_path_format = -> (test) do
+  Kernel.const_source_location(test.class.name)[0].sub(%r{^./test/}, "").sub(/_test.rb$/, "")
+end
+```
 
 ## RSpec
 
@@ -135,6 +170,25 @@ It's possible to record deprecations while running your specs by adding an ENV['
 DEPRECATION_BEHAVIOR="record" bundle exec rspec path/to/file_spec.rb
 ```
 
+## Usage without Rails
+
+Without Rails, you'll need to make sure your `ActiveSupport::Deprecation` instances use the [`:notify` behavior](https://api.rubyonrails.org/classes/ActiveSupport/Deprecation/Behavior.html#method-i-behavior-3D) and the `attach_to` is the underscored version of the deprecator's `gem_name` (this is how the `:notify` behavior works):
+
+```ruby
+# defined in the gem:
+MyGem.deprecator = ActiveSupport::Deprecation.new("2.0", "MyGem::Something")
+
+# in the test helper:
+MyGem.deprecator.behavior = :notify
+
+DeprecationToolkit::Configuration.configure do |config|
+  config.attach_to = MyGem.deprecator.gem_name.underscore.tr("/", "_")
+  # or more simply
+  # config.attach_to = "my_gem_something"
+  config.behavior = :notify
+end
+```
+
 ## License
 
 Deprecation Toolkit is licensed under the [MIT license](LICENSE.txt).

data/lib/deprecation_toolkit/behaviors/ci_record_helper.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module DeprecationToolkit
   module Behaviors
-    class CIRecordHelper
+    module CIRecordHelper
+      extend self
       extend ReadWriteHelper
 
-      HEADER = '[DeprecationToolkit]'
+      HEADER = "[DeprecationToolkit]"
 
-      def self.trigger(test, current_deprecations, _recorded_deprecations)
+      def trigger(test, current_deprecations, _recorded_deprecations)
         filename = recorded_deprecations_path(test)
 
         to_output = {

data/lib/deprecation_toolkit/behaviors/disabled.rb

@@ -2,8 +2,10 @@
 
 module DeprecationToolkit
   module Behaviors
-    class Disabled
-      def self.trigger(*)
+    module Disabled
+      extend self
+
+      def trigger(*)
       end
     end
   end

data/lib/deprecation_toolkit/behaviors/raise.rb

@@ -2,8 +2,10 @@
 
 module DeprecationToolkit
   module Behaviors
-    class Raise
-      def self.trigger(_test, current_deprecations, recorded_deprecations)
+    module Raise
+      extend self
+
+      def trigger(_test, current_deprecations, recorded_deprecations)
         error_class = if current_deprecations.size > recorded_deprecations.size
           DeprecationIntroduced
         elsif current_deprecations.size < recorded_deprecations.size
@@ -32,7 +34,9 @@ module DeprecationToolkit
           You have introduced new deprecations in the codebase. Fix or record them in order to discard this error.
           #{record_message}
 
+          ******* The following deprecations were added: *******
           #{introduced_deprecations.join("\n")}
+          ******************************************************
         EOM
 
         super(message)
@@ -55,7 +59,9 @@ module DeprecationToolkit
           The recorded deprecations needs to be updated to reflect your changes.
           #{record_message}
 
+          ****** The following deprecations were removed: ******
           #{removed_deprecations.join("\n")}
+          ******************************************************
         EOM
 
         super(message)
@@ -77,9 +83,9 @@ module DeprecationToolkit
           #{record_message}
 
           ===== Expected
-          #{recorded_deprecations.deprecations.join("\n")}
+          #{recorded_deprecations.deprecations_without_stacktrace.join("\n")}
           ===== Actual
-          #{current_deprecations.deprecations.join("\n")}
+          #{current_deprecations.deprecations_without_stacktrace.join("\n")}
         EOM
 
         super(message)

data/lib/deprecation_toolkit/behaviors/record.rb

@@ -2,10 +2,11 @@
 
 module DeprecationToolkit
   module Behaviors
-    class Record
+    module Record
+      extend self
       extend ReadWriteHelper
 
-      def self.trigger(test, collector, _)
+      def trigger(test, collector, _)
         deprecation_file = recorded_deprecations_path(test)
 
         write(deprecation_file, test_name(test) => collector.deprecations_without_stacktrace)

data/lib/deprecation_toolkit/collector.rb

@@ -35,11 +35,9 @@ module DeprecationToolkit
 
     def deprecations_without_stacktrace
       deprecations.map do |deprecation|
-        if ActiveSupport.gem_version.to_s < "5.0"
-          deprecation.sub(/\W\s\(called from .*\)$/, "")
-        else
-          deprecation.sub(/ \(called from .*\)$/, "")
-        end
+        deprecation
+          .sub(*active_support_deprecation_sub_params)
+          .sub(*gem_deprecate_sub_params)
       end
     end
 
@@ -61,7 +59,17 @@ module DeprecationToolkit
     end
 
     def flaky?
-      size == 1 && deprecations.first['flaky'] == true
+      size == 1 && deprecations.first["flaky"] == true
+    end
+
+    private
+
+    def active_support_deprecation_sub_params
+      [/ \(called from .*\)$/, ""]
+    end
+
+    def gem_deprecate_sub_params
+      [/NOTE: (.*is deprecated.*)\n.* called from.*:\d+\.\n/, "\\1"]
     end
   end
 end

data/lib/deprecation_toolkit/configuration.rb

@@ -12,5 +12,14 @@ module DeprecationToolkit
     config_accessor(:deprecation_path) { "test/deprecations" }
     config_accessor(:test_runner) { :minitest }
     config_accessor(:warnings_treated_as_deprecation) { [] }
+    config_accessor(:deprecation_file_path_format) do
+      proc do |test|
+        if DeprecationToolkit::Configuration.test_runner == :rspec
+          test.example_group.file_path.sub(%r{^./spec/}, "").sub(/_spec.rb$/, "")
+        else
+          test.class.name.underscore
+        end
+      end
+    end
   end
 end

data/lib/deprecation_toolkit/deprecation_subscriber.rb

@@ -4,8 +4,56 @@ require "active_support/subscriber"
 
 module DeprecationToolkit
   class DeprecationSubscriber < ActiveSupport::Subscriber
-    def self.already_attached?
-      notifier != nil
+    class << self
+      def attach_to(gem_name, subscriber = new, notifier = ActiveSupport::Notifications, inherit_all: false)
+        return if already_attached_to?(gem_name)
+
+        super(gem_name, subscriber, notifier, inherit_all: inherit_all)
+      end
+
+      def detach_from(gem_name, notifier = ActiveSupport::Notifications)
+        @namespace  = gem_name
+        @subscriber = find_attached_subscriber(gem_name)
+        @notifier = notifier
+
+        return unless subscriber
+
+        subscribers.delete(subscriber)
+
+        # Remove event subscribers of all existing methods on the class.
+        fetch_public_methods(subscriber, true).each do |event|
+          remove_event_subscriber(event)
+        end
+
+        @notifier = nil unless any_subscribers_attached?
+      end
+
+      private
+
+      def already_attached_to?(gem_name)
+        subscribers.any? do |subscriber|
+          attached_subscriber?(subscriber, gem_name)
+        end
+      end
+
+      def any_subscribers_attached?
+        subscribers.any? do |subscriber|
+          subscriber.is_a?(self)
+        end
+      end
+
+      def find_attached_subscriber(gem_name)
+        subscribers.find do |attached_subscriber|
+          attached_subscriber?(attached_subscriber, gem_name)
+        end
+      end
+
+      def attached_subscriber?(subscriber, gem_name)
+        subscriber.is_a?(self) &&
+          subscriber.patterns.keys.any? do |pattern|
+            pattern.end_with?(".#{gem_name}")
+          end
+      end
     end
 
     def deprecation(event)
@@ -17,10 +65,13 @@ module DeprecationToolkit
     private
 
     def deprecation_allowed?(payload)
-      allowed_deprecations, procs = Configuration.allowed_deprecations.partition { |el| el.is_a?(Regexp) }
-
-      allowed_deprecations.any? { |regex| regex =~ payload[:message] } ||
-      procs.any? { |proc| proc.call(payload[:message], payload[:callstack]) }
+      Configuration.allowed_deprecations.any? do |rule|
+        if rule.is_a?(Regexp)
+          rule.match?(payload[:message])
+        else
+          rule.call(payload[:message], payload[:callstack])
+        end
+      end
     end
   end
 end

data/lib/deprecation_toolkit/read_write_helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/string/filters"
 require "bundler"
 require "yaml"
 
@@ -47,18 +48,13 @@ module DeprecationToolkit
         Configuration.deprecation_path
       end
 
-      path =
-        if DeprecationToolkit::Configuration.test_runner == :rspec
-          test.example_group.file_path.sub(%r{^./spec/}, "").sub(/_spec.rb$/, "")
-        else
-          test.class.name.underscore
-        end
+      path = Configuration.deprecation_file_path_format.call(test)
 
       Pathname(deprecation_folder).join("#{path}.yml")
     end
 
     def test_location(test)
-      test.method(test_name(test)).source_location[0]
+      Kernel.const_source_location(test.class.name)[0]
     rescue NameError
       "unknown"
     end

data/lib/deprecation_toolkit/rspec_plugin.rb

@@ -2,16 +2,22 @@
 
 module DeprecationToolkit
   module RSpecPlugin
+    extend self
+
     RSpec.configure do |config|
       config.before(:suite) do
-        case ENV['DEPRECATION_BEHAVIOR']
-        when "r", "record", "record-deprecations"
-          DeprecationToolkit::Configuration.behavior = DeprecationToolkit::Behaviors::Record
-        end
+        RSpecPlugin.before_suite
+      end
+    end
 
-        DeprecationToolkit.add_notify_behavior
-        DeprecationToolkit.attach_subscriber
+    def before_suite
+      case ENV["DEPRECATION_BEHAVIOR"]
+      when "r", "record", "record-deprecations"
+        DeprecationToolkit::Configuration.behavior = DeprecationToolkit::Behaviors::Record
       end
+
+      DeprecationToolkit.add_notify_behavior
+      DeprecationToolkit.attach_subscriber
     end
   end
 end

data/lib/deprecation_toolkit/test_triggerer.rb

@@ -2,7 +2,9 @@
 
 module DeprecationToolkit
   module TestTriggerer
-    def self.trigger_deprecation_toolkit_behavior(test)
+    extend self
+
+    def trigger_deprecation_toolkit_behavior(test)
       current_deprecations = DeprecationToolkit::Collector.new(DeprecationToolkit::Collector.deprecations)
       recorded_deprecations = DeprecationToolkit::Collector.load(test)
       if !recorded_deprecations.flaky? && current_deprecations != recorded_deprecations

data/lib/deprecation_toolkit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeprecationToolkit
-  VERSION = "1.5.1"
+  VERSION = "2.2.3"
 end

data/lib/deprecation_toolkit/warning.rb

@@ -38,48 +38,34 @@ module DeprecationToolkit
     end
 
     def deprecation_triggered?(str)
-      DeprecationToolkit::Configuration.warnings_treated_as_deprecation.any? { |warning| warning =~ str }
+      DeprecationToolkit::Configuration.warnings_treated_as_deprecation.any? { |warning| warning === str }
     end
-  end
-end
-
-# Warning is a new feature in ruby 2.5, so support older versions
-# Note that the `Warning` module exists in Ruby 2.4 but has a bug https://bugs.ruby-lang.org/issues/12944
-if RUBY_VERSION < '2.5.0' && RUBY_ENGINE == 'ruby'
-  module Kernel
-    class << self
-      alias_method :__original_warn, :warn
 
-      def warn(*messages)
-        message = messages.join("\n")
-        message += "\n" unless message.end_with?("\n")
-
-        if DeprecationToolkit::Warning.deprecation_triggered?(message)
-          ActiveSupport::Deprecation.warn(message)
-        else
-          __original_warn(messages)
-        end
+    def deprecator
+      @deprecator ||= ActiveSupport::Deprecation.new("next", "DeprecationToolkit::Warning").tap do |deprecator|
+        deprecator.behavior = :notify
+        DeprecationSubscriber.attach_to(:deprecation_toolkit_warning)
       end
     end
-
-    def warn(*messages)
-      Kernel.warn(messages)
-    end
   end
-else
-  module DeprecationToolkit
-    module WarningPatch
-      def warn(str)
-        str = DeprecationToolkit::Warning.handle_multipart(str)
-        return unless str
 
-        if DeprecationToolkit::Warning.deprecation_triggered?(str)
-          ActiveSupport::Deprecation.warn(str)
-        else
-          super
-        end
+  module WarningPatch
+    def warn(str, *)
+      if Configuration.warnings_treated_as_deprecation.empty?
+        return super
+      end
+
+      str = DeprecationToolkit::Warning.handle_multipart(str)
+      return unless str
+
+      if DeprecationToolkit::Warning.deprecation_triggered?(str)
+        DeprecationToolkit::Warning.deprecator.warn(str)
+      else
+        super
       end
     end
+    ruby2_keywords :warn
   end
-  Warning.singleton_class.prepend(DeprecationToolkit::WarningPatch)
+
+  ::Warning.singleton_class.prepend(WarningPatch)
 end

data/lib/deprecation_toolkit.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-load('tasks/ci_recorder.rake')
+require "active_support"
+
+load("tasks/ci_recorder.rake")
 
 module DeprecationToolkit
   autoload :DeprecationSubscriber,     "deprecation_toolkit/deprecation_subscriber"
@@ -14,28 +16,41 @@ module DeprecationToolkit
     autoload :Raise,                   "deprecation_toolkit/behaviors/raise"
     autoload :Record,                  "deprecation_toolkit/behaviors/record"
     autoload :CIRecordHelper,          "deprecation_toolkit/behaviors/ci_record_helper"
+    autoload :DeprecationIntroduced,   "deprecation_toolkit/behaviors/raise"
+    autoload :DeprecationRemoved,      "deprecation_toolkit/behaviors/raise"
+    autoload :DeprecationMismatch,     "deprecation_toolkit/behaviors/raise"
   end
 
-  def self.add_notify_behavior
-    notify = ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[:notify]
-    behaviors = ActiveSupport::Deprecation.behavior
+  class << self
+    def add_notify_behavior
+      notify = ActiveSupport::Deprecation::DEFAULT_BEHAVIORS[:notify]
+
+      each_deprecator do |deprecator|
+        behaviors = deprecator.behavior
 
-    unless behaviors.find { |behavior| behavior == notify }
-      ActiveSupport::Deprecation.behavior = behaviors << notify
+        unless behaviors.find { |behavior| behavior == notify }
+          deprecator.behavior = (behaviors << notify)
+        end
+      end
     end
-  end
 
-  def self.attach_subscriber
-    return if DeprecationSubscriber.already_attached?
+    def attach_subscriber
+      Configuration.attach_to.each do |gem_name|
+        DeprecationSubscriber.attach_to(gem_name)
+      end
+    end
 
-    Configuration.attach_to.each do |gem_name|
-      DeprecationSubscriber.attach_to(gem_name)
+    private
+
+    def each_deprecator(&block)
+      if defined?(Rails.application) && Rails.application.respond_to?(:deprecators)
+        Rails.application.deprecators.each(&block)
+      elsif ActiveSupport::Deprecation.respond_to?(:behavior)
+        block.call(ActiveSupport::Deprecation)
+      end
     end
   end
 end
 
-unless defined?(RSpec)
-  require "deprecation_toolkit/minitest_hook"
-end
-
+require "deprecation_toolkit/minitest_hook" unless defined? RSpec
 require "deprecation_toolkit/warning"

data/lib/minitest/deprecation_toolkit_plugin.rb

@@ -12,7 +12,12 @@ module Minitest
   def plugin_deprecation_toolkit_init(options)
     return unless using_bundler?
 
-    require 'deprecation_toolkit'
+    require "deprecation_toolkit"
+
+    setup_deprecation_toolkit(options)
+  end
+
+  def setup_deprecation_toolkit(options)
     if options[:record_deprecations]
       DeprecationToolkit::Configuration.behavior = DeprecationToolkit::Behaviors::Record
     end
@@ -24,6 +29,6 @@ module Minitest
   private
 
   def using_bundler?
-    ENV['BUNDLE_GEMFILE']
+    ENV["BUNDLE_GEMFILE"]
   end
 end

data/lib/tasks/ci_recorder.rake

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-require 'tempfile'
-require 'json'
-require 'active_support/core_ext/hash'
-require 'rake'
-require_relative '../deprecation_toolkit/read_write_helper'
+require "tempfile"
+require "json"
+require "active_support/core_ext/hash"
+require "rake"
+require_relative "../deprecation_toolkit/read_write_helper"
 
 class CIRecorder
   include Rake::DSL
   include DeprecationToolkit::ReadWriteHelper
 
   def initialize
-    namespace :deprecation_toolkit do
-      desc 'Parse a file generated with the CIOutputHelper and generate deprecations out of it'
-      task :record_from_ci_output do
-        raw_file = ENV.fetch('FILEPATH')
+    namespace(:deprecation_toolkit) do
+      desc("Parse a file generated with the CIOutputHelper and generate deprecations out of it")
+      task(:record_from_ci_output) do
+        raw_file = ENV.fetch("FILEPATH")
 
         deprecations = extract_deprecations_output(raw_file) do |file|
           parse_file(file)
@@ -32,6 +32,7 @@ class CIRecorder
     shell_command = "cat #{file} | sed -n -e 's/^.* \\[DeprecationToolkit\\] \\(.*\\)/\\1/p' > #{tmp_file.path}"
 
     raise "Couldn't extract deprecations from output" unless system(shell_command)
+
     yield(tmp_file)
   ensure
     tmp_file.delete