deprecation_helper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e69bb4ef93cda5c44fba549cfd072e0965c9fa8f323a44c96a87be315ad021be
+  data.tar.gz: 220dc767f5dde12538c03f3be75a9ce88c7321ef2a2ee701f15c2cc49edc5c53
+SHA512:
+  metadata.gz: 7fcf096afe79fd910d4d07d39b1770094a7eaa48def28d0cdf030b6843d8c23f7e5ab203431b43c760a0d3ad6e84d380b8e50f6960921c066a09ba74bee2927b
+  data.tar.gz: 7bd9162f156db65ede8358265ba9b3820357d799f9bf0f057bc854dd330cfcf0daf2c7bea84d59ccd2a3331a82a2f6d66c5d2ae9eed5d393fee6f5c38442f778

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in deprecation_helper.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    deprecation_helper (1.0.0.pre.gusto.pre.pre)
+      sorbet-runtime (~> 0.5.6293)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+    sorbet (0.5.6293)
+      sorbet-static (= 0.5.6293)
+    sorbet-runtime (0.5.6293)
+    sorbet-static (0.5.6293-universal-darwin-17)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-17
+
+DEPENDENCIES
+  deprecation_helper!
+  rspec (~> 3.0)
+  sorbet (~> 0.5.6293)
+
+BUNDLED WITH
+   2.2.4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Gusto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,211 @@
+# DeprecationHelper
+
+[![Build status](https://badge.buildkite.com/ca0732598feeb90c404e6883a2d79ad32610ff356020f11639.svg?branch=main)](https://buildkite.com/gusto/deprecationhelper)
+
+The purpose of this gem is to help Ruby developers change code safely. It provides a basic framework for deprecating code. Since Ruby is an untyped language, you can't be sure when ceratin types of changes you're trying to make, such as deleting or renaming a method, will break production. This gem is provides an opinionated roadmap for deprecating code.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deprecation_helper'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install deprecation_helper
+
+## Usage
+### Configuration
+First, you'll need to configure `DeprecationHelper`.
+
+Here is an example configuration:
+```ruby
+DeprecationHelper.configure do |config|
+  if Rails.env.test? || Rails.env.development?
+    config.deprecation_strategies = [
+      DeprecationHelper::Strategies::LogError.new(logger: Rails.logger),
+      DeprecationHelper::Strategies::RaiseError.new,
+    ]
+  else
+    config.deprecation_strategies = [
+      DeprecationHelper::Strategies::LogError.new(logger: Rails.logger),
+      MyCustomStrategy.new, # See more on this below
+    ]
+  end
+end
+```
+
+In this configuration, we always log an error in any environment. In the test environment, this allows to generate TODO lists of code that is exercised by your test suite that is using deprecated methods. These TODO lists can then be passed into the allow list (see below). In test and development, an error is raised as well, which in this configuration forces users to either add the deprecations to the TODO list or to address them prior to landing the deprecation.
+
+Note that global configuration is optional -- you can also pass in `deprecation_strategies` directly to your `deprecate!` call (see the advanced usage section below).
+
+### Deprecating Code
+There is one main method which is called with a string
+```ruby
+DeprecationHelper.deprecate!('your message value')
+```
+
+By inlining these into your code, when the deprecation is called, it will apply the strategies that you've configured.
+
+### Allow lists
+The main method accept an `allow_list` argument, as such:
+```ruby
+DeprecationHelper.deprecate!('your message value', allow_list: [/your/, /allow/, /list/]))
+```
+
+If your callstack (determined by `Kernel#caller`) matches *any* element in the allow list, then no deprecation strategy will be invoked -- the deprecation will be skipped. It is recommended to use `allow_list` primarily as a TODO list.
+
+Note also that your allow list entries should be as specific to avoid unintended matches, especially if the entries represent a todo list of specific lines from specific files.
+
+**Examples of allow lists**
+
+Here are a couple of examples of `allow_list` values that you might want:
+- `bin/rails` - Perhaps you want to permit everything that happens in your rails console
+- `my_method_wrapper` - In some cases, you want to just use this gem to help you find all places that use the code and wrap them in something that makes it safe to use the deprecated method, but easier to grep for. Perhaps you have a class like:
+```ruby
+class MyDeprecator
+  def self.my_method_wrapper
+    yield
+  end
+end
+```
+This class doesn't do anything, but now you can call `MyDeprecator.my_method_wrapper { my_deprecated_code }` and it will be allow-listed using `my_method_wrapper` as the allow-list value.
+- `some_exempt_folder` - Perhaps you'd like an entire folder to be exempt from this deprecation for the time being, for whatever reason
+- `factory_bot` - Perhaps a gem like `factory_bot` or another test only piece of code is using your deprecated functionality and you don't mind permitting it to unblock other tests.
+
+### Deprecation Strategies
+There are several strategies, here's what they do:
+
+**Strategy: Do nothing on use of deprecated code**
+
+Where to find it: Configure `deprecation_strategies` to be an empty list (this is also the default)
+This might be useful if you want to take no action in certain environments.
+
+**Strategy: Raising on use of deprecated code**
+
+Where to find it: `DeprecationHelper::Strategies::RaiseError`
+
+This is useful if you believe you've already addressed all deprecations in the environment that uses this strategy OR perhaps if the use of the deprecated code is more negatively impactful than raising.
+
+Note that this strategy will construct a `DeprecationHelper::DeprecationException` with the message equal to the input value to `deprecate!` and raise that error.
+
+**Strategy: Logging on use of deprecated code**
+
+Where to find it: `DeprecationHelper::Strategies::LogError`
+
+This is useful if you want to generate an allow list to stop the bleeding.
+
+**Strategy: Report to your bug tracking tool on use of deprecated code**
+
+Where to find it: This you'll need to create yourself, since it has a dependency on bugsnag.
+One option is to use the `ThrottledBugsnag` or `Bugsnag` gem, by creating your own deprecation strategy (see advanced usage below).
+
+### Advanced Usage
+**Overriding global configuration**
+
+You can pass in an array of `deprecation_strategies` to `deprecate!` if you'd like to override the global configuration for `DeprecationHelper`.
+
+**Creating your own deprecation strategies**
+
+You can construct your own deprecation strategies by implementing any `StrategyInterface` class, which means including the class and implementing the method(s) it requires.
+
+Here are the interfaces you can include to construct your own strategies:
+- `DeprecationHelper::Strategies::ErrorStrategyInterface`
+- `DeprecationHelper::Strategies::BaseStrategyInterface`
+
+Here is an example of them being used:
+```ruby
+class SlackNotifierDeprecationStrategy
+  include DeprecationHelper::Strategies::BaseStrategyInterface
+  extend T::Sig
+
+  sig { override.params(message: String, logger: T.nilable(Logger)).void }
+  def apply!(message, logger: nil)
+    # This takes in an exception that is message equal to the message passed into `deprecate!`
+    SlackNotifier.notify(message)
+  end
+end
+
+class BugsnagDeprecationStrategy
+  include DeprecationHelper::Strategies::ErrorStrategyInterface
+  extend T::Sig
+
+  sig { override.params(exception: StandardError, logger: T.nilable(Logger)).void }
+  def apply_to_exception!(exception, logger: nil)
+    # This takes in an exception that is a `DeprecationHelper::DeprecationException`
+    # with a `message` value equal to the message passed into `deprecate!`
+    Bugsnag.notify(exception)
+  end
+end
+```
+You can create your own deprecation strategy by including StrategyInterface and implementing the method `apply!` that takes in an `exception` and an optional `logger`.
+
+Here is an example:
+```ruby
+class BugsnagDeprecationStrategy
+  include DeprecationHelper::Strategies::BaseStrategyInterface
+  extend T::Sig
+  sig { override.params(exception: StandardError).void }
+  def apply!(exception)
+    ThrottledBugsnag.notify(exception) # or Bugsnag.notify(exception)
+  end
+end
+```
+
+This is useful to report instances of use of deprecated code in production without actually raising an error in production. The use of ThrottledBugsnag is recommended in case there are high-frequency, untested code paths that use the deprecated code to prevent sampling or throttling issues in your bug tracking tool.
+
+## Types of things to deprecate
+There are endless things you might deprecate, here are some examples
+- Public API change - A method call. You might want to deprecate a method, either deleting it entirely or renaming it. Tossing a `deprecate!` call in there will let clients know when they need to migrate.
+- Public API change - arguments. You might want to change an optional argument to be required, add or remove an argument, or change an argument's type. You can check for future incompatibility and use this gem when a client is invoking deprecated behavior.
+- A product scenario. You might want to deprecate when a query method returns `nil` when the thing you are looking for, such as a `User`, should always exist.
+- A database condition. Perhaps you want to add a `non-nil` column, but aren't positive that `nil` is never persisted into that column (when querying the column is not enough, because `nil` could happen in a non-terminal condition in an ongoing request). If you use something like `ActiveRecord`, you could create a validator for this:
+```ruby
+# Usage:
+#
+# class User < ApplicationRecord
+#   validates_with PresenceOfColumnSoftValidator, columns: [:name]
+# end
+#
+class PresenceOfColumnSoftValidator < ActiveModel::Validator
+  extend T::Sig
+
+  sig { params(model: T.untyped).returns(T::Boolean) }
+  def validate(model)
+    columns_to_validate = options[:columns]
+    columns_to_validate.each do |column|
+      next unless model.public_send(column).nil?
+      DeprecationHelper.deprecate!(
+        "#{model.class.name}##{column} should never be nil",
+      )
+    end
+
+    true
+  end
+end
+```
+- A graceful exit. A place in your code might `rescue` some arbitrary condition, and you'd like to later on stop rescuing. You can use `deprecate!` as a safe way to remove that rescue.
+- Any general assumption. You might want to make a simplifying change to your application, but that change relies on a hard-to-statically-verify assumption in your system, such as some other state in the system, or some sequence of operations. You can use `deprecate!` as a general way to verify assumptions, and call `deprecate!` when your assumption turns out to be false.
+
+## Why you might not want to use this gem
+In an ideal world, we could "deprecate" by simply calling `raise "This is deprecated"`, and we've fully covered all supported scenarios in our test suite, and running our test suite would reveal all deprecations before we go to production
+
+In another ideal world, we recognize our test suite isn't perfect, but as a forcing function, we continue to `raise` and backfill tests as errors come into production.
+
+However if your application is like the one I work in, a lot of supported and critical scenarios are in fact untested. This means applying this approach will potentially have negative customer impact.
+
+When using this gem, it is generally recommended to backfill test coverage for any deprecation that isn't caught by your test suite. Ultimately, when this gem is used, it means you cannot fully trust your test suite. As a long-term goal, it might be advantageous to move towards getting to a place where you can confidently just call `raise` in your codebase and rely on your test suite. Another better systematic approach is to statically type your code base, in which case certain types of deprecations, such as removing a method, can be caught before going to production even without a test suite.
+
+## Development
+
+Run `bundle exec rspec` to run all tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/deprecation_helper.

data/deprecation_helper.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'deprecation_helper'
+  spec.version       = '0.1.0'
+  spec.authors       = ['Alex Evanczuk']
+  spec.email         = ['alex.evanczuk@gusto.com']
+
+  spec.summary       = 'This is a simple, low-dependency gem for managing deprecations.'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\u0000").reject { |f| f.match(%r{A(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sorbet-runtime', '~> 0.5.6293'
+
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'sorbet', '~> 0.5.6293'
+end

data/lib/deprecation_helper.rb

@@ -0,0 +1,60 @@
+# typed: strict
+
+require 'logger'
+require 'sorbet-runtime'
+require 'deprecation_helper/private'
+require 'deprecation_helper/private/configuration'
+require 'deprecation_helper/private/allow_list'
+
+require 'deprecation_helper/strategies/base_strategy_interface'
+require 'deprecation_helper/strategies/error_strategy_interface'
+require 'deprecation_helper/strategies/raise_error'
+require 'deprecation_helper/strategies/log_error'
+
+require 'deprecation_helper/deprecation_exception'
+
+module DeprecationHelper
+  extend T::Sig
+
+  ################################################################################################
+  #### PUBLIC API
+  ################################################################################################
+  sig { params(blk: T.proc.params(arg0: Private::Configuration).void).void }
+  def self.configure(&blk)
+    blk.call config
+  end
+
+  sig do
+    params(
+      message: String,
+      allow_list: T::Array[Regexp],
+      deprecation_strategies: T.nilable(T::Array[Strategies::BaseStrategyInterface]),
+    ).void
+  end
+  def self.deprecate!(message, allow_list: [], deprecation_strategies: nil)
+    backtrace = caller
+    return if Private::AllowList.allowed?(allow_list, backtrace)
+    (deprecation_strategies || config.deprecation_strategies).each do |strategy|
+      strategy.apply!(message, backtrace)
+    end
+  end
+
+  # This method is exposed as it might be useful for other systems that want to
+  # reuse the global configuration more explicitly
+  sig { returns(T::Array[Strategies::BaseStrategyInterface]) }
+  def self.deprecation_strategies
+    config.deprecation_strategies
+  end
+
+  ################################################################################################
+  #### PRIVATE API
+  ################################################################################################
+
+  sig { returns(Private::Configuration) }
+  def self.config
+    @config = T.let(@config, T.nilable(Private::Configuration))
+    @config ||= Private::Configuration.new
+  end
+
+  private_class_method :config
+end

data/lib/deprecation_helper/deprecation_exception.rb

@@ -0,0 +1,12 @@
+# typed: strict
+
+module DeprecationHelper
+  class DeprecationException < StandardError
+    extend T::Sig
+
+    sig { params(message: String).void }
+    def initialize(message)
+      super message
+    end
+  end
+end

data/lib/deprecation_helper/private.rb

@@ -0,0 +1,8 @@
+# typed: strong
+
+module DeprecationHelper
+  module Private
+  end
+
+  private_constant :Private
+end

data/lib/deprecation_helper/private/allow_list.rb

@@ -0,0 +1,18 @@
+# typed: strict
+
+module DeprecationHelper
+  module Private
+    class AllowList
+      extend T::Sig
+
+      sig { params(allowable_frames: T::Array[Regexp], exception_frames: T::Array[String]).returns(T::Boolean) }
+      def self.allowed?(allowable_frames, exception_frames)
+        allowable_frames.any? do |allowable_frame|
+          exception_frames.any? do |exception_frame|
+            exception_frame.match?(allowable_frame)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/deprecation_helper/private/configuration.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+module DeprecationHelper
+  module Private
+    class Configuration
+      extend T::Sig
+
+      sig { params(deprecation_strategies: T::Array[DeprecationHelper::Strategies::BaseStrategyInterface]).void }
+      attr_writer :deprecation_strategies
+
+      sig { void }
+      def initialize
+        @deprecation_strategies = T.let(@deprecation_strategies, T.nilable(T::Array[DeprecationHelper::Strategies::BaseStrategyInterface]))
+      end
+
+      sig { returns(T::Array[DeprecationHelper::Strategies::BaseStrategyInterface]) }
+      def deprecation_strategies
+        @deprecation_strategies || []
+      end
+    end
+  end
+end

data/lib/deprecation_helper/strategies/base_strategy_interface.rb

@@ -0,0 +1,17 @@
+# typed: strict
+
+module DeprecationHelper
+  module Strategies
+    # This is the interface for all strategies
+    module BaseStrategyInterface
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(message: String, backtrace: T::Array[String]).void }
+      def apply!(message, backtrace)
+      end
+    end
+  end
+end

data/lib/deprecation_helper/strategies/error_strategy_interface.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+module DeprecationHelper
+  module Strategies
+    module ErrorStrategyInterface
+      extend T::Sig
+      extend T::Helpers
+      include BaseStrategyInterface
+
+      abstract!
+
+      sig { override.params(message: String, backtrace: T::Array[String]).void }
+      def apply!(message, backtrace)
+        exception = DeprecationException.new(message)
+        exception.set_backtrace(backtrace)
+        apply_to_exception!(exception)
+      end
+
+      sig { abstract.params(exception: StandardError).void }
+      def apply_to_exception!(exception)
+      end
+    end
+  end
+end

data/lib/deprecation_helper/strategies/log_error.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+module DeprecationHelper
+  module Strategies
+    # This strategy does nothing
+    class LogError
+      include BaseStrategyInterface
+
+      extend T::Sig
+
+      sig { params(logger: T.nilable(Logger)).void }
+      def initialize(logger: nil)
+        @logger = T.let(logger || Logger.new(STDOUT), Logger)
+      end
+
+      sig { override.params(message: String, backtrace: T::Array[String]).void }
+      def apply!(message, backtrace) # rubocop:disable Lint/UnusedMethodArgument
+        @logger.warn(message)
+      end
+    end
+  end
+end

data/lib/deprecation_helper/strategies/raise_error.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+module DeprecationHelper
+  module Strategies
+    # This strategy raises the original error
+    class RaiseError
+      include BaseStrategyInterface
+
+      extend T::Sig
+
+      sig { override.params(message: String, backtrace: T::Array[String]).void }
+      def apply!(message, backtrace)
+        exception = DeprecationException.new(message)
+        exception.set_backtrace(backtrace)
+        raise exception
+      end
+    end
+  end
+end

data/spec/deprecation_helper_spec.rb

@@ -0,0 +1,129 @@
+RSpec.describe DeprecationHelper do
+  describe 'deprecate!' do
+    subject { DeprecationHelper.deprecate!(input_parameter) }
+
+    let(:error_backtrace) do
+      ['frame0', 'frame1', 'frame2', 'some_special_complicated_frame']
+    end
+    let(:expected_exception_class) { DeprecationHelper::DeprecationException }
+    let(:message) { 'This thing is deprecated' }
+    let(:input_parameter) { message }
+
+    let(:logger) { sorbet_double(Logger, warn: nil) }
+
+    before do
+      allow(Logger).to receive(:new).with(STDOUT).and_return(logger)
+      allow(DeprecationHelper).to receive(:caller).and_return(error_backtrace)
+    end
+
+    shared_examples 'it raises the error' do |expected_message|
+      it do
+        expect { subject }.to raise_error(expected_exception_class, expected_message)
+      end
+    end
+
+    shared_examples 'it does not raise an error' do
+      it do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'configured to do nothing' do
+      before do
+        DeprecationHelper.configure do |config|
+          config.deprecation_strategies = []
+        end
+      end
+
+      it_behaves_like 'it does not raise an error'
+    end
+
+    context 'configured to raise' do
+      before do
+        DeprecationHelper.configure do |config|
+          config.deprecation_strategies = [DeprecationHelper::Strategies::RaiseError.new]
+        end
+      end
+
+      context 'allow list is not passed in' do
+        it_behaves_like 'it raises the error', 'This thing is deprecated'
+      end
+
+      context 'allow list is passed in' do
+        before { allow(DeprecationHelper).to receive(:caller).and_return(['frame0', 'frame1', 'frame2', 'some_special_complicated_frame']) }
+
+        subject { DeprecationHelper.deprecate!(input_parameter, allow_list: allow_list) }
+
+        context 'allow list is passed in, but empty' do
+          let(:allow_list) { [] }
+
+          it_behaves_like 'it raises the error', 'This thing is deprecated'
+        end
+
+        context 'allow list is passed in, but does not cover permit this exception' do
+          let(:allow_list) { ['frame10'] }
+
+          it_behaves_like 'it raises the error', 'This thing is deprecated'
+        end
+
+        context 'allow list permits this exception with a simple string match list' do
+          let(:allow_list) { ['frame1'] }
+
+          it_behaves_like 'it does not raise an error'
+        end
+
+        context 'allow list permits this exception with a simple regexp match list' do
+          let(:allow_list) { [/frame1/] }
+
+          it_behaves_like 'it does not raise an error'
+        end
+
+        context 'allow list permits this exception with a more complex regexp match list' do
+          let(:allow_list) { [/special.*?frame/] }
+
+          it_behaves_like 'it does not raise an error'
+        end
+      end
+    end
+
+    context 'configured to do log' do
+      before do
+        DeprecationHelper.configure do |config|
+          config.deprecation_strategies = [DeprecationHelper::Strategies::LogError.new]
+        end
+      end
+
+      context 'logger is not set' do
+        before do
+          DeprecationHelper.configure do |config|
+            config.deprecation_strategies = [DeprecationHelper::Strategies::LogError.new]
+          end
+        end
+
+        it_behaves_like 'it does not raise an error'
+
+        it 'logs an error' do
+          expect(logger).to receive(:warn).with('This thing is deprecated')
+          subject
+        end
+      end
+    end
+
+    context 'configured for multiple purposes' do
+      let(:logger) { Logger.new(STDOUT) }
+
+      before do
+        DeprecationHelper.configure do |config|
+          config.deprecation_strategies = [DeprecationHelper::Strategies::LogError.new(logger: logger), DeprecationHelper::Strategies::RaiseError.new]
+        end
+      end
+
+      it_behaves_like 'it raises the error', 'This thing is deprecated'
+
+      it 'logs an error' do
+        expect(logger).to receive(:warn).with('This thing is deprecated')
+        expect { subject }.to raise_error(StandardError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'deprecation_helper'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before do
+    # Reset the config to defaults prior to each test
+    DeprecationHelper.configure do |helper_config|
+      helper_config.deprecation_strategies = []
+    end
+  end
+end
+
+def sorbet_double(stubbed_class, attr_map = {})
+  instance_double(stubbed_class, attr_map).tap do |dbl|
+    allow(dbl).to receive(:is_a?) { |tested_class| stubbed_class.ancestors.include?(tested_class) }
+  end
+end

data/test.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+bundle check || bundle install --retry 1
+bundle exec rspec
+STATUS=$?
+
+popd
+
+exit $STATUS

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: deprecation_helper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Evanczuk
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6293
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6293
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6293
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6293
+description: 
+email:
+- alex.evanczuk@gusto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- deprecation_helper.gemspec
+- lib/deprecation_helper.rb
+- lib/deprecation_helper/deprecation_exception.rb
+- lib/deprecation_helper/private.rb
+- lib/deprecation_helper/private/allow_list.rb
+- lib/deprecation_helper/private/configuration.rb
+- lib/deprecation_helper/strategies/base_strategy_interface.rb
+- lib/deprecation_helper/strategies/error_strategy_interface.rb
+- lib/deprecation_helper/strategies/log_error.rb
+- lib/deprecation_helper/strategies/raise_error.rb
+- spec/deprecation_helper_spec.rb
+- spec/spec_helper.rb
+- test.sh
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: This is a simple, low-dependency gem for managing deprecations.
+test_files: []