deprecate_soft 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f38db5179c81ba2e97d0a09bebeea87648eed96271b87a0089c3e444d122c9f5
+  data.tar.gz: fba061e831a26a0cf0be6bd99970cf84dd4130d3d93b6e53fbe01f5fa0b2846d
+SHA512:
+  metadata.gz: 5d5d5ed40760cb78b41399924db249e93c585eef04f2f5d370c2cbfcfcfd5ae1621cea064c1b681e3ab90a16f63b814afe48c50ed5c4f4d32144602e7288ee49
+  data.tar.gz: 0124ae4b6a825c3a5920b2bee96417e73a44b9c19f527797cc35e7c852e43b5867369b04c0167a2efa2728eed8b7e99c894e9d74464ca09b36a8aef3c98bce64

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,38 @@
+AllCops:
+  TargetRubyVersion: 2.5 # purposely an old Ruby version
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## DepracateSoft Change Log
+
+## [1.0.0] - 2025-03-24
+ - Initial release
+## [0.0.1] - 2025-03-22
+ - pre-release
+ 

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Tilo Sloboda
+
+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,308 @@
+
+# DeprecateSoft
+
+DeprecateSoft is a lightweight and flexible Ruby gem designed to help you gracefully and safely deprecate methods.
+
+It was inspired by the need to track deprecated method usage in large codebases before safely removing old code — with zero disruption and flexible metrics support.
+
+This gem lets you wrap existing methods with before and after hooks to track usage patterns without changing the method's behavior, and without any impact on production systems.
+
+It’s ideal for monitoring deprecated method usage across your application using non-blocking, low-latency tools such as Redis, DataDog, Prometheus, or logs.
+
+Once tracking confirms that a deprecated method is no longer in use, you can confidently delete it from your codebase.
+
+---
+
+## ✨ Features
+
+- Lightweight method wrapper for deprecation tracking
+- Works with instance methods in any class or module
+- Works with class or module methods in any class or module
+- System-wide hook configuration (before and after)
+- No monkey-patching or global pollution
+- Fully compatible with Rails or plain Ruby apps
+
+---
+
+## 🚀 Installation
+
+Add this to your Gemfile:
+
+```ruby
+gem 'deprecate_soft'
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+---
+
+## ⚙️ Configuration
+
+Create an initializer in your Rails app (or load manually in a non-Rails project):
+
+```ruby
+# frozen_string_literal: true
+
+require "deprecate_soft"
+
+# Optional: set up your tracking solution
+
+# require 'redis'
+# redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+
+# require 'datadog/statsd'
+# statsd = Datadog::Statsd.new
+
+DeprecateSoft.configure do |config|
+  # Required: define a before_hook to track method usage
+  #
+  # You can use Redis, StatsD, DataDog, Prometheus, etc.
+  config.before_hook = lambda do |method, message, args:|
+    # Track via Redis:
+    # redis_key = "deprecate_soft:#{method.gsub('#', ':')}"
+    # redis.incr("#{redis_key}")
+    # or:
+    # redis.incr("#{redis_key}:#{Date.today.cweek}") # weekly count
+
+    # Track via DataDog (StatsD):
+    # metric_name = "deprecate_soft.#{method.tr('#', '.').downcase}"
+    # statsd.increment(metric_name)
+
+    # Or just log it:
+    # Rails.logger.warn "DEPRECATED: #{method} – #{message}"
+  end
+
+  # Optional: define an after_hook for additional metrics/logging
+  #
+  # config.after_hook = lambda do |method, message, result:|
+  #   # Optional: Logging or more metrics
+  #   puts "[DD] #{method} completed after deprecated call"
+  # end
+
+  # Optional: customize how the original method is renamed internally
+  #
+  # For example, if you deprecate `foo`, this affects what the internal
+  # renamed method will be called. These names should be unlikely to conflict.
+  #
+  # Default is "__" and "deprecated", which becomes: "__foo_deprecated"
+  # config.prefix = "__"
+  # config.suffix = "deprecated"
+end
+```
+
+This setup ensures you can plug in **any tracking backend** you like — without polluting the global namespace.
+
+### 🔧 Customizing Method Name Wrapping
+
+When `deprecate_soft` wraps a method, it renames the original method internally to preserve its behavior. You can customize how that internal method is named by configuring a `prefix` and `suffix`.
+
+By default, the original method:
+
+```ruby
+def foo
+end
+
+deprecate_soft :foo, "Use #bar instead"
+```
+
+...will be renamed to:
+
+```ruby
+__foo_deprecated
+```
+
+You can change the naming convention:
+
+```ruby
+DeprecateSoft.configure do |config|
+  config.prefix = "legacy_"   # or "" to disable
+  config.suffix = "old"       # or nil to disable
+end
+```
+
+This gives you full control over how deprecated methods are renamed internally.
+
+#### 📝 Naming Examples
+
+| Prefix      | Suffix       | Method Name   | Hidden Method Name        |
+|-------------|--------------|---------------|----------------------------|
+| `"__"`      | `"deprecated"` | `foo`         | `__foo_deprecated`        |
+| `""`        | `"old"`        | `foo`         | `foo_old`                 |
+| `"legacy_"` | `""`           | `foo`         | `legacy_foo`              |
+| `"_"`       | `"__"`         | `foo`         | `_foo__`                  |
+
+These names are never called directly — they're used internally to wrap and preserve the original method logic.
+
+
+---
+
+## 🧩 Usage
+
+🚨 Always declare `deprecate_soft` **after** the method definition!
+
+### For Instance Methods:
+
+```ruby
+class MyService
+  include DeprecateSoft
+
+  def deprecated_method(a, b)
+    puts "doing something with #{a} and #{b}"
+  end
+
+  deprecate_soft :deprecated_method, "Use #new_method instead"
+end
+
+MyService.new.deprecated_method(1, 2) # will exercise the tracking hooks
+```
+
+### For Class Methods:
+
+```ruby
+class MyService
+  extend DeprecateSoft
+
+  def self.deprecated_method(a, b)
+    puts "doing something with #{a} and #{b}"
+  end
+
+  deprecate_soft :deprecated_method, "will be removed"
+end
+
+MyService.deprecated_method(1, 2) # will exercise the tracking hooks
+
+```
+
+---
+
+## 🔐 What It Does Under the Hood
+
+When you call `deprecate_soft :method_name, "reason"`:
+
+1. It renames the original method to `__method_name_deprecated`.
+2. It defines a new method with the original name that:
+   - Calls the configured `before_hook` (if set)
+   - Delegates to the original method
+   - Calls the configured `after_hook` (if set)
+3. The optional `message` with the reason can help identifying alternatives.
+
+This ensures consistent tracking, clean method resolution, and avoids accidental bypassing.
+
+---
+
+## 🧪 Example Hook Logic
+
+You can track usage using whatever backend you like. Here are some quick examples:
+
+### Redis:
+
+```ruby
+config.before_hook = lambda do |method, message, args:|
+  redis_key = "deprecate_soft:#{method.gsub('#', ':')}"
+  redis.incr("#{redis_key}:#{Date.today}")
+end
+```
+
+### DataDog:
+
+```ruby
+config.before_hook = lambda do |method, message, args:|
+  metric_name = "deprecate_soft.#{method.tr('#', '.').downcase}"
+  statsd.increment(metric_name)
+end
+```
+
+### Log only:
+
+```ruby
+config.before_hook = ->(method, message, args:) {
+  Rails.logger.warn "DEPRECATED: #{method} - #{message}"
+}
+```
+
+## 🧪🧪🧪 Advaned Hook with Caller Tracking:
+
+You can also track callers, so you can identify where you still have to fix your source code:
+
+
+### Redis:
+
+```ruby
+# config/initializers/deprecate_soft.rb
+
+require "deprecate_soft"
+require 'redis'
+
+# Configure your redis client instance
+redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+
+DeprecateSoft.configure do |config|
+  config.before_hook = lambda do |method, message, args:|
+    # Get the direct caller of the deprecated method
+    caller_info = caller_locations(1, 1).first
+
+    caller_key = if caller_info
+      "#{caller_info.path}:#{caller_info.lineno}"
+    else
+      "unknown"
+    end
+
+    # Track a global usage counter
+    redis.incr("deprecate_soft:#{method}")
+
+    # Track usage by caller location
+    redis.incr("deprecate_soft:#{method}:caller:#{caller_key}")
+
+    # Log the usage by caller location
+    Rails.logger.info("Deprecated #{method} called from #{caller_key}")
+  end
+end
+```
+
+If `Klass#legacy_method` is called from `app/services/foo.rb:42`, and `app/jobs/cleanup_job.rb:88`, you get:
+
+```
+Klass#legacy_method → 7
+Klass#legacy_method:caller:app/services/foo.rb:42 → 3
+Klass#legacy_method:caller:app/jobs/cleanup_job.rb:88 → 4
+```
+
+💡 Now you not only know that the method is still used -- you know where from, and how often -- so you can fix your code.
+
+---
+
+## 🛡 Best Practices
+
+- Use `deprecate_soft` for methods you plan to remove but want to confirm they are no longer used.
+- Integrate with your observability platform for tracking.
+- Review usage stats before deleting deprecated methods from your code.
+- 🚨 Always declare `deprecate_soft` **after** the method definition! 🚨
+
+---
+
+## 🧰 Limitations / Notes
+
+- Make sure hooks do not raise or interfere with production behavior.
+- Only use non-blocking, low-latency methods for tracking!
+- Currently assumes Ruby 2.5+ (for `&.` and keyword args support).
+- Currently keeps the visibility of the renamed original method the same (does not make it private).
+
+---
+
+## 📬 Contributing
+
+Feel free to open issues or pull requests if you'd like to:
+
+- Add support for class methods
+- Add Railtie for automatic setup
+- Add built-in backends (e.g. Redis, StatsD)
+
+---
+
+## 📜 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/config/initializers/deprecate_soft.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'deprecate_soft'
+
+# Optional: set up your tracking solution
+
+# require 'redis'
+# redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+
+# require 'datadog/statsd'
+# statsd = Datadog::Statsd.new
+
+DeprecateSoft.configure do |config|
+  # Required: define a before_hook to track method usage
+  #
+  # You can use Redis, StatsD, DataDog, Prometheus, etc.
+  config.before_hook = lambda do |method, message, args:|
+    # Track via Redis:
+    # redis_key = "deprecate_soft:#{method.gsub('#', ':')}"
+    # redis.incr("#{redis_key}")
+    # or:
+    # redis.incr("#{redis_key}:#{Date.today.cweek}") # weekly count
+
+    # Track via DataDog (StatsD):
+    # metric_name = "deprecate_soft.#{method.tr('#', '.').downcase}"
+    # statsd.increment(metric_name)
+
+    # Or just log it:
+    # Rails.logger.warn "DEPRECATED: #{method} – #{message}"
+  end
+
+  # Optional: define an after_hook for additional metrics/logging
+  #
+  # config.after_hook = lambda do |method, message, result:|
+  #   # Optional: Logging or more metrics
+  #   puts "[DD] #{method} completed after deprecated call"
+  # end
+
+  # Optional: customize how the original method is renamed internally
+  #
+  # For example, if you deprecate `foo`, this affects what the internal
+  # renamed method will be called. These names should be unlikely to conflict.
+  #
+  # Default is "__" and "deprecated", which becomes: "__foo_deprecated"
+  # config.prefix = "__"
+  # config.suffix = "deprecated"
+end

data/lib/deprecate_soft/global_monkey_patch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DeprecateSoft
+  module GlobalMonkeyPatch
+    def deprecate_soft(method_name, message)
+      if self.singleton_class.method_defined?(method_name) || self.singleton_class.private_method_defined?(method_name)
+        # Class method
+        DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: true)
+      elsif self.instance_methods.include?(method_name) || self.private_instance_methods.include?(method_name)
+        # Instance method
+        DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: false)
+      else # rubocop:disable Style/EmptyElse
+        #  protect against declaring deprecate_soft before method is defined
+        #
+        # Do nothing — fail-safe in production
+      end
+    end
+  end
+end

data/lib/deprecate_soft/method_wrapper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DeprecateSoft
+  module MethodWrapper
+    def self.wrap_method(context, method_name, message, is_class_method:)
+      hidden_method_name = "#{DeprecateSoft.prefix}#{method_name}_#{DeprecateSoft.suffix}"
+
+      if is_class_method
+        original_method = context.method(method_name)
+
+        context.singleton_class.define_method(hidden_method_name, original_method)
+
+        context.singleton_class.define_method(method_name) do |*args, &block|
+          full_name = "#{self.name}.#{method_name}"
+          DeprecateSoft.before_hook&.call(full_name, message, args: args) if defined?(DeprecateSoft.before_hook)
+          result = send(hidden_method_name, *args, &block)
+          DeprecateSoft.after_hook&.call(full_name, message, result: result) if defined?(DeprecateSoft.after_hook)
+          result
+        end
+      else
+        original_method = context.instance_method(method_name)
+
+        context.define_method(hidden_method_name, original_method)
+
+        context.define_method(method_name) do |*args, &block|
+          full_name = "#{self.class}##{method_name}"
+          DeprecateSoft.before_hook&.call(full_name, message, args: args) if defined?(DeprecateSoft.before_hook)
+          result = send(hidden_method_name, *args, &block)
+          DeprecateSoft.after_hook&.call(full_name, message, result: result) if defined?(DeprecateSoft.after_hook)
+          result
+        end
+      end
+    end
+  end
+end

data/lib/deprecate_soft/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeprecateSoft
+  VERSION = '1.0.0'
+end

data/lib/deprecate_soft.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'deprecate_soft/version'
+
+require_relative 'deprecate_soft/method_wrapper'
+
+module DeprecateSoft
+  class << self
+    attr_accessor :before_hook, :after_hook
+    attr_writer :prefix, :suffix
+
+    def prefix
+      @prefix || '__'
+    end
+
+    def suffix
+      @suffix || 'deprecated'
+    end
+
+    def configure
+      yield self
+    end
+
+    def included(base)
+      base.extend InstanceMethods
+    end
+
+    def extended(base)
+      base.extend ClassMethods
+    end
+  end
+
+  module InstanceMethods
+    def deprecate_soft(method_name, message)
+      #  protect against declaring deprecate_soft before method is defined
+      return unless method_defined?(method_name) || private_method_defined?(method_name)
+
+      DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: false)
+    end
+  end
+
+  module ClassMethods
+    def deprecate_soft(method_name, message)
+      #  protect against declaring deprecate_soft before method is defined
+      return unless singleton_class.method_defined?(method_name) || singleton_class.private_method_defined?(method_name)
+
+      DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: true)
+    end
+  end
+end

data/sig/deprecate_soft.rbs

@@ -0,0 +1,4 @@
+module DeprecateSoft
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: deprecate_soft
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tilo Sloboda
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dogstatsd-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+description: |
+  DeprecateSoft is a lightweight Ruby gem that lets you gracefully deprecate methods
+  in your codebase without breaking functionality. It wraps existing instance or
+  class methods and lets you plug in custom before/after hooks for tracking usage
+  via logging, Redis, DataDog, or any other observability tools.
+
+  Once you verify in your tracking that a method is no longer called,
+  you can remove it safely from your code base.
+
+  This is especially useful in large codebases where you want to safely remove
+  legacy methods, but first need insight into whether and where they're still
+  being called.
+
+  Hooks are configured once globally and apply project-wide. Fully compatible
+  with Rails or plain Ruby applications.
+email:
+- tilo.sloboda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/initializers/deprecate_soft.rb
+- lib/deprecate_soft.rb
+- lib/deprecate_soft/global_monkey_patch.rb
+- lib/deprecate_soft/method_wrapper.rb
+- lib/deprecate_soft/version.rb
+- sig/deprecate_soft.rbs
+homepage: https://github.com/tilo/deprecate_soft
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/tilo/deprecate_soft
+  source_code_uri: https://github.com/tilo/deprecate_soft
+  changelog_uri: https://github.com/tilo/deprecate_soft/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.4
+signing_key:
+specification_version: 4
+summary: Gracefully deprecate and safely delete Ruby methods from your code
+test_files: []