Merge pull request #3 from tilo/towards-1.2.0

Towards 1.2.0

Author: tilo

.github/workflows/main.yml

@@ -38,4 +38,3 @@ jobs:
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: coverage/.resultset.json
-          verbose: true

.rubocop.yml

@@ -1,11 +1,14 @@
 AllCops:
   TargetRubyVersion: 2.5 # purposely an old Ruby version
 
-Style/StringLiterals:
-  EnforcedStyle: single_quotes
+Layout/LineLength:
+  Max: 180
 
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: single_quotes
+Lint/ConstantDefinitionInBlock:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
 
 Metrics/AbcSize:
   Enabled: false
@@ -22,9 +25,6 @@ Metrics/CyclomaticComplexity:
 Metrics/MethodLength:
   Enabled: false
 
-Lint/UnusedBlockArgument:
-  Enabled: false
-
 Naming/MethodParameterName:
   Enabled: false
 
@@ -34,8 +34,20 @@ Style/SafeNavigation:
 Style/Documentation:
   Enabled: false
 
+Style/IfUnlessModifier:
+  Enabled: false
+
 Style/RedundantSelf:
   Enabled: false
 
 Style/SingleLineMethods:
   Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Style/TrivialAccessors:
+  Enabled: false

CHANGELOG.md

@@ -1,6 +1,18 @@
 
 ## 📝 DepracateSoft Change Log
 
+## [1.2.0] - 2025-04-05
+### ✨ Added Support
+ - improving handling of class methods
+ - added deprecate_class_soft for class methods. Fixed [Issue #1](https://github.com/tilo/deprecate_soft/issues/1)
+ - support to define the method after the declaration
+### 🛠️ Internals
+ - stream-lined include DeprecateSoft
+### 📐 Deliberate Limitations
+ - Class methods need to be defined via `def self.method`, not in `class << self` blocks.
+   Simply move the to-be-deprecated method out of the `self << class` and declare it via `self.method_name`.
+   This also makes the to be deleted method stand out more.
+
 ## [1.1.0] - 2025-03-29
 ### ✨ Added Support
  - Errors in `before_hook` / `after_hook` do not prevent method execution.

README.md

@@ -58,6 +58,8 @@ Declare `deprecate_soft` **after** the method definition.
 
 ### For Instance Methods:
 
+use `deprecate_soft`
+
 ```ruby
 class MyService
   include DeprecateSoft
@@ -74,15 +76,17 @@ MyService.new.deprecated_method(1, 2) # will exercise the tracking hooks
 
 ### For Class Methods:
 
+use `deprecate_class_soft`
+
 ```ruby
 class MyService
-  extend DeprecateSoft
+  include DeprecateSoft
 
   def self.deprecated_method(a, b)
     puts "doing something with #{a} and #{b}"
   end
 
-  deprecate_soft :deprecated_method, "will be removed"
+  deprecate_class_soft :deprecated_method, "will be removed" # ⚠️
 end
 
 MyService.deprecated_method(1, 2) # will exercise the tracking hooks
@@ -330,6 +334,9 @@ end
 - 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).
+- Class methods need to be defined via `def self.method`, not in `class << self` blocks.
+  Simply move the to-be-deprecated method out of the `self << class` and declare it via `self.method_name`.
+  This also makes the to be deleted method stand out more.
 
 ---
 

lib/deprecate_soft.rb

@@ -1,24 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'deprecate_soft/version'
-
-require_relative 'deprecate_soft/method_wrapper'
+# require all files under lib/deprecate_soft
+Dir[File.join(__dir__, 'deprecate_soft', '*.rb')].sort.each do |file|
+  require file
+end
 
 module DeprecateSoft
-  def configure_base(base)
-    base.extend(ClassMethods)
-    base.extend(InstanceMethods)
-  end
-  module_function :configure_base
-
-  def included(base)
-    configure_base(base)
-  end
-
-  def extended(base)
-    configure_base(base)
-  end
-
   class << self
     attr_accessor :before_hook, :after_hook
     attr_writer :prefix, :suffix
@@ -34,23 +21,58 @@ def suffix
     def configure
       yield self
     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)
+    def prefixed_name(method_name)
+      "#{prefix}#{method_name}_#{suffix}".to_sym
+    end
+
+    def included(base)
+      base.extend(ClassMethods)
 
-      DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: false)
+      base.define_singleton_method(:method_added) do |method_name|
+        pending = base.instance_variable_get(:@__pending_soft_wraps)
+        if pending&.key?(method_name)
+          DeprecateSoft::MethodWrapper.wrap_method(base, method_name, pending.delete(method_name), is_class_method: false)
+        end
+        super(method_name) if defined?(super)
+      end
+
+      base.singleton_class.define_method(:singleton_method_added) do |method_name|
+        pending = instance_variable_get(:@_pending_soft_wraps)
+        if pending&.key?(method_name)
+          DeprecateSoft::MethodWrapper.wrap_method(base, method_name, pending.delete(method_name), is_class_method: true)
+        end
+        super(method_name) if defined?(super)
+      end
     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)
+    def deprecate_soft(method_name, message = nil)
+      hidden = DeprecateSoft.prefixed_name(method_name)
+
+      if method_defined?(method_name) || private_method_defined?(method_name)
+        return if method_defined?(hidden) || private_method_defined?(hidden)
+
+        DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: false)
+      else
+        @__pending_soft_wraps ||= {}
+        @__pending_soft_wraps[method_name] = message
+      end
+    end
+
+    def deprecate_class_soft(method_name, message = nil)
+      hidden = DeprecateSoft.prefixed_name(method_name)
+      target = singleton_class
+
+      if target.method_defined?(method_name) || target.private_method_defined?(method_name)
+        return if target.method_defined?(hidden) || target.private_method_defined?(hidden)
 
-      DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: true)
+        DeprecateSoft::MethodWrapper.wrap_method(self, method_name, message, is_class_method: true)
+      else
+        @_pending_soft_wraps ||= {}
+        @_pending_soft_wraps[method_name] = message
+      end
     end
   end
 end

lib/deprecate_soft/global_monkey_patch.rb

@@ -3,17 +3,13 @@
 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
+      extend DeprecateSoft::ClassMethods unless is_a?(DeprecateSoft::ClassMethods)
+      deprecate_soft(method_name, message)
+    end
+
+    def deprecate_class_soft(method_name, message = nil)
+      extend DeprecateSoft::ClassMethods unless is_a?(DeprecateSoft::ClassMethods)
+      deprecate_class_soft(method_name, message)
     end
   end
 end

lib/deprecate_soft/method_wrapper.rb

@@ -14,7 +14,8 @@ def self.wrap_method(context, method_name, message, is_class_method:)
         target.define_method(hidden_method_name, original_method)
 
         target.define_method(method_name) do |*args, &block|
-          full_name = "#{self.name}.#{method_name}"
+          klass_name = self.class.name || self.class.to_s
+          full_name = "#{klass_name}.#{method_name}"
 
           begin
             DeprecateSoft.before_hook&.call(full_name, message, args: args)
@@ -39,7 +40,8 @@ def self.wrap_method(context, method_name, message, is_class_method:)
         context.define_method(hidden_method_name, original_method)
 
         context.define_method(method_name) do |*args, &block|
-          full_name = "#{self.class}##{method_name}"
+          klass_name = self.class.name || self.to_s
+          full_name = "#{klass_name}.#{method_name}"
 
           begin
             DeprecateSoft.before_hook&.call(full_name, message, args: args)

lib/deprecate_soft/version.rb

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