deprecations 2.2.2 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 976d65184fd1442180e364ecd885aabf9202877f1bb7d11c1315eed9fe30b5ee
-  data.tar.gz: bf4ad1bc538b49878a6268321883d1d89a3cc3fe0627ef8c2d37200972c22ad2
+  metadata.gz: 8a9290e6b74cd3d108623f9b726b6f71b02a5108feb534114fb2d63160dfbfab
+  data.tar.gz: 9a554fb7d11c6d6e9c741f43c846c1d140705be8621540683ab94b3bb2bdc0bd
 SHA512:
-  metadata.gz: 29383bc82baad099e0597f6efb0c4a0e2d4bb7f87e2235c19e1ebd58e0611c287aa7b1f478c1e75fc942f43bd2078cfb09f80f90df72ab4d184012e2dee8a51d
-  data.tar.gz: 0636b27fc0c83e46df73364b669b6c59f0c2e844e424807a990ee45d8bf1957b93db289d744d63013b099317f8f23618aa92b979c468a200712608956bd220a7
+  metadata.gz: 66817f08bf5641c9c09404615a1290ec8fe037751e8f0157b91fb7d577f2f24c1818febc6920fc36216e2386cbf40e47d275f048a12fd31a0f20cdfe5129f075
+  data.tar.gz: a57b529946baec215bdb4998151a7dc695166eb629dbbc232a6296a24b31eb60f45a84fb68d82f67632bb256293536197b11328e8901d2a25d0ef3b19219e4fe

data/README.md

@@ -14,13 +14,13 @@ gem 'deprecations'
 
 and install it by running Bundler:
 
-```bash
-$ bundle
+```shell
+$ bundle add deprecations
 ```
 
 To install the gem globally use:
 
-```bash
+```shell
 $ gem install deprecations
 ```
 
@@ -36,7 +36,6 @@ you can specify which methods and classes are deprecated. To mark a method as de
 
 ```ruby
 class MySample
-
   def clear
     # something here
   end
@@ -46,7 +45,6 @@ class MySample
   end
 
   deprecated :clean, :clear, 'next version'
-
 end
 ```
 
@@ -72,16 +70,18 @@ Deprecations.behavior = :raise
 
 There are 3 pre-defined behaviors:
 
-- `:raise` will raise an `DeprecationException` when a deprecated method is called
+- `:raise` will raise an `Deprecations::Exception` when a deprecated method is called
 - `:silence` will do nothing (ignore the deprecation)
 - `:warn` will print a warning (default behavior)
+- `:deprecated` will print a warning when Ruby's warning category 'deprecated' is enabled
 
 Besides this you can implement your own:
 
 ```ruby
-Deprecations.behavior = proc do |subject, _alternative, _outdated|
-  SuperLogger.warning "deprecated: #{subject}"
-end
+Deprecations.behavior =
+  proc do |subject, _alternative, _outdated|
+    SuperLogger.warning "deprecated: #{subject}"
+  end
 ```
 
 Any object responding to `#call` will be accepted as a valid handler.
@@ -89,9 +89,7 @@ Any object responding to `#call` will be accepted as a valid handler.
 Whenever you need to temporary change the standard behavior (like e.g. in your specs) you can do this like
 
 ```ruby
-Deprecations.with_behavior(:silent) do
-  MyDeprecatedClass.new.do_some_magic
-end
+Deprecations.with_behavior(:silent) { MyDeprecatedClass.new.do_some_magic }
 ```
 
 Please have a look at the [specs](https://github.com/mblumtritt/deprecations/blob/master/spec/deprecations_spec.rb) for detailed information and more samples.

data/lib/deprecations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deprecations
-  VERSION = '2.2.2'
+  VERSION = '2.6.0'
 end

data/lib/deprecations.rb

@@ -1,18 +1,168 @@
 # frozen_string_literal: true
 
 module Deprecations
-  require_relative 'deprecations/version'
-  require_relative 'deprecations/extension'
-  require_relative 'deprecations/behavior'
-
   Error = Class.new(ScriptError)
 
-  def self.call(subject, alternative, outdated)
-    @behavior.call(subject, alternative, outdated)
-    self
+  class << self
+    def behavior = BEHAVIOR.key(@behavior) || @behavior
+
+    def behavior=(value)
+      @behavior = as_behavior(value)
+    end
+
+    def with_behavior(behavior)
+      current_behavior = @behavior
+      @behavior = as_behavior(behavior)
+      raise(ArgumentError, 'block expected') unless block_given?
+      yield
+    ensure
+      @behavior = current_behavior
+    end
+
+    alias set_behavior with_behavior
+
+    def call(subject, alternative, outdated)
+      @behavior.call(subject, alternative, outdated)
+      self
+    end
+
+    private
+
+    def as_behavior(arg)
+      return arg if defined?(arg.call)
+      BEHAVIOR.fetch(arg) do
+        raise(
+          ArgumentError,
+          "invalid parameter - behavior has to be #{
+            BEHAVIOR.keys.map(&:inspect).join(' | ')
+          } or need to respond to `#call`"
+        )
+      end
+    end
+
+    def name_error(exc)
+      exc.set_backtrace(exc.backtrace.drop_while { _1.start_with?(__FILE__) })
+      exc
+    end
+
+    module Raise
+      def self.call(subject, alternative, _outdated)
+        error =
+          Error.new(
+            "`#{subject}` is deprecated#{
+              " - use #{alternative} instead" if alternative
+            }"
+          )
+        error.set_backtrace(caller(3))
+        raise(error)
+      end
+    end
+
+    module WarnMessage
+      def message(subject, alternative, outdated)
+        "`#{subject}` is deprecated#{
+          outdated ? " and will be outdated #{outdated}." : '.'
+        }#{" Please use `#{alternative}` instead." if alternative}"
+      end
+    end
+
+    module Warn
+      extend WarnMessage
+      def self.call(*args) = ::Kernel.warn(message(*args), uplevel: 3)
+    end
+
+    module Deprecated
+      extend WarnMessage
+      def self.call(*args)
+        ::Kernel.warn(message(*args), uplevel: 3, category: :deprecated)
+      end
+    end
+
+    BEHAVIOR = {
+      silence: proc {},
+      raise: Raise,
+      warn: Warn,
+      deprecated: Deprecated
+    }.freeze
+
+    module ClassMethods
+      private
+
+      def deprecated(name, alt = nil, outdated = nil)
+        alias_name = "__deprecated__singleton_method__#{name}__"
+        return if private_method_defined?(alias_name)
+        begin
+          alias_method(alias_name, name)
+        rescue NameError => e
+          raise ::Deprecations.__send__(:name_error, e)
+        end
+        private(alias_name)
+        if alt.is_a?(Symbol)
+          begin
+            alt = instance_method(alt)
+          rescue NameError => e
+            raise ::Deprecations.__send__(:name_error, e)
+          end
+        end
+        define_method(name) do |*args, **kw_args, &b|
+          ::Deprecations.call(
+            "#{self}.#{::Kernel.__method__}",
+            (alt.is_a?(UnboundMethod) ? "#{self}.#{alt.name}" : alt),
+            outdated
+          )
+          __send__(alias_name, *args, **kw_args, &b)
+        end
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def deprecated(name, alt = nil, outdated = nil)
+        alias_name = "__deprecated__instance_method__#{name}__"
+        return if private_method_defined?(alias_name)
+        begin
+          alias_method(alias_name, name)
+        rescue NameError => e
+          ::Deprecations.__send__(:name_error, e)
+          return singleton_class.__send__(:deprecated, name, alt, outdated)
+        end
+        private(alias_name)
+        if alt.is_a?(Symbol)
+          begin
+            alt = instance_method(alt)
+          rescue NameError => e
+            raise ::Deprecations.__send__(:name_error, e)
+          end
+        end
+        define_method(name) do |*args, **kw_args, &b|
+          pref =
+            if defined?(self.class.name)
+              self.class.name
+            else
+              ::Kernel.instance_method(:class).bind(self).call
+            end
+          ::Deprecations.call(
+            "#{pref}##{::Kernel.__method__}",
+            (alt.is_a?(UnboundMethod) ? "#{pref}##{alt.name}" : alt),
+            outdated
+          )
+          __send__(alias_name, *args, **kw_args, &b)
+        end
+      end
+
+      def deprecated!(alternative = nil, outdated = nil)
+        org = method(:new)
+        define_singleton_method(:new) do |*args, **kw_args, &b|
+          ::Deprecations.call(name, alternative, outdated)
+          org.call(*args, **kw_args, &b)
+        end
+      end
+    end
+
+    Module.extend(ClassMethods)
+    Module.include(InstanceMethods)
   end
 
   self.behavior = :warn
 end
-
-DeprecationError = Deprecations::Error

metadata

@@ -1,19 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: deprecations
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.6.0
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-30 00:00:00.000000000 Z
+date: 2025-01-30 00:00:00.000000000 Z
 dependencies: []
 description: |
   This gem provides transparent declaration of deprecated methods and classes.
   It's easy, small, has no dependencies and no overhead.
-email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -21,15 +19,13 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/deprecations.rb
-- lib/deprecations/behavior.rb
-- lib/deprecations/extension.rb
 - lib/deprecations/version.rb
 homepage: https://github.com/mblumtritt/deprecations
 licenses: []
 metadata:
   source_code_uri: https://github.com/mblumtritt/deprecations
   bug_tracker_uri: https://github.com/mblumtritt/deprecations/issues
-post_install_message:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -37,15 +33,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Deprecation support for your project.
 test_files: []

data/lib/deprecations/behavior.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Deprecations
-  class << self
-    def behavior
-      BEHAVIOR.key(@behavior) || @behavior
-    end
-
-    def behavior=(value)
-      @behavior = as_behavior(value)
-    end
-
-    def with_behavior(behavior)
-      behavior = as_behavior(behavior)
-      raise(ArgumentError, 'block expected') unless block_given?
-      current_behavior = @behavior
-      begin
-        @behavior = behavior
-        yield
-      ensure
-        @behavior = current_behavior
-      end
-    end
-
-    alias set_behavior with_behavior
-
-    private
-
-    def as_behavior(arg)
-      return arg if defined?(arg.call)
-      BEHAVIOR.fetch(arg) do
-        raise(
-          ArgumentError,
-          'invalid parameter - behavior has to be ' \
-            "#{valid_behaviors} or need to respond to `call`"
-        )
-      end
-    end
-
-    def valid_behaviors
-      BEHAVIOR.keys.map(&:inspect).join(' | ')
-    end
-
-    module Raise
-      def self.call(subject, alternative, _outdated)
-        msg = "`#{subject}` is deprecated"
-        msg << " - use #{alternative} instead" if alternative
-        ex = Error.new(msg)
-        ex.set_backtrace(caller(3))
-        raise(ex)
-      end
-    end
-
-    module Warn
-      def self.call(subject, alternative, outdated)
-        msg = "`#{subject}` is deprecated"
-        msg << (outdated ? " and will be outdated #{outdated}." : '.')
-        msg << " Please use `#{alternative}` instead." if alternative
-        ::Kernel.warn(msg, uplevel: 3)
-      end
-    end
-
-    BEHAVIOR = { silence: proc {}, raise: Raise, warn: Warn }.freeze
-  end
-end

data/lib/deprecations/extension.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Deprecations
-  class << self
-    private
-
-    def infect(mod)
-      mod.extend(ClassMethods)
-      mod.send(:include, InstanceMethods)
-    end
-
-    module Helper
-      private
-
-      def __method(method_name)
-        begin
-          instance_method(method_name)
-        rescue StandardError
-          nil
-        end
-      end
-
-      def __method_deprecated!(method, alternative, outdated)
-        defining_context = self
-        undef_method(method.name)
-        define_method(method.name) do |*a, &b|
-          decorated = Class === self ? "#{self}." : "#{defining_context}#"
-          alternative = "#{decorated}#{alternative.name}" if UnboundMethod ===
-            alternative
-          Deprecations.call(
-            "#{decorated}#{::Kernel.__method__}",
-            alternative,
-            outdated
-          )
-          method.bind(self).call(*a, &b)
-        end
-      end
-
-      def __method_checked(method_name)
-        __method(method_name) or
-          raise(
-            NameError,
-            "undefined method `#{method_name}` for class `#{self}`"
-          )
-      end
-
-      def __method_alternative(alternative)
-        Symbol === alternative ? __method_checked(alternative) : alternative
-      end
-    end
-
-    module ClassMethods
-      private
-
-      include Helper
-
-      def deprecated(method_name, alternative = nil, outdated = nil)
-        __method_deprecated!(
-          __method_checked(method_name),
-          __method_alternative(alternative),
-          outdated
-        )
-      end
-    end
-
-    module InstanceMethods
-      private
-
-      include Helper
-
-      def deprecated(method_name, alternative = nil, outdated = nil)
-        m = __method(method_name) or
-          return(
-            singleton_class.send(
-              :deprecated,
-              method_name,
-              alternative,
-              outdated
-            )
-          )
-        __method_deprecated!(m, __method_alternative(alternative), outdated)
-      end
-
-      def deprecated!(alternative = nil, outdated = nil)
-        m = method(:new)
-        define_singleton_method(:new) do |*a, &b|
-          Deprecations.call(self, alternative, outdated)
-          m.call(*a, &b)
-        end
-      end
-    end
-  end
-
-  infect(Module)
-end