tiny_hooks 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5d6e7ef3a23f548af13f1f6497d5ac5eedcf833d8090380b085a9c85bddf37a
-  data.tar.gz: 6992a9ce9f85531803f35f009817b0b7c0b140088e64b9f38c67f4b0225e7d0d
+  metadata.gz: '094f25167ea774a8c2019e04a891a1056a4fcfaa6036ebf04712deb38a4de83f'
+  data.tar.gz: 624dc86d41d19ef506b1867e5ccacf197107baeb09f43fb2376814c33f42af50
 SHA512:
-  metadata.gz: 9dfd1ec6b94c48b2309bf4f713dccdd7d8ae572b6ea42615ebb891238306c84224b15657f9fe77d1f3f6ae8a7f45b26c6ac347183d7bde7750e0a6d6a0879a38
-  data.tar.gz: 109d45de44c9309ad233b8a819550306016e6dacb33a7f2a8980de4fddda7562839e6f7463c9c2b0a730544322941d21acfba1b77ea50bb6e7dbc18cdf62dffb
+  metadata.gz: e745e65d785c7a7a52e68be47b9a5f0d8b43103adddf39dd152a9d23b4b175f3c7edf7540f2da3ff2d383c3b817d2b34ebf6a7b9671c29abee799add67e1122e
+  data.tar.gz: 3268e19a06ee31caab8971785d72a112e8adfb68acd898e8845e887ce1fb84769d668e8b7b235508c0a25af965ecd89405d3089f26470e63250901aba12028e8

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [2.0.0] - 2021-07-12
+
+- Add ability to specify hook method with name
+- TinyHooks now works on class methods
+
 ## [1.0.0] - 2021-05-09
 
 - Support halting

data/README.md

@@ -1,3 +1,5 @@
+[![Ruby](https://github.com/okuramasafumi/tiny_hooks/actions/workflows/main.yml/badge.svg)](https://github.com/okuramasafumi/tiny_hooks/actions/workflows/main.yml)
+
 # TinyHooks
 
 A tiny gem to define hooks.
@@ -39,6 +41,46 @@ MyClass.new.my_method
 # => "my before hook\nmy method\n"
 ```
 
+You can also call `define_hook` with method name as a third argument.
+
+```ruby
+class MyClass
+  include TinyHooks
+
+  def my_method
+    puts 'my method'
+  end
+
+  def my_before_hook
+    puts 'my before hook'
+  end
+
+  define_hook :before, :my_method, :my_before_hook
+end
+
+MyClass.new.my_method
+# => "my before hook\nmy method\n"
+```
+
+You can define hooks for class methods as well.
+
+```ruby
+class MyClass
+  include TinyHooks
+
+  def self.my_method
+    puts 'my method'
+  end
+
+  define_hook :before, :my_method, class_method: true do
+    puts 'my before hook'
+  end
+end
+
+MyClass.my_method
+# => "my before hook\nmy method\n"
+```
+
 TinyHooks shines when the class/module is the base class/module of your library and your users will inherit/include it. In these cases, end users can define hooks to the methods you provide. The only thing you have to do is to provide the list of methods.
 
 ### Halting

data/lib/tiny_hooks.rb

@@ -21,6 +21,7 @@ module TinyHooks
   def self.included(base)
     base.class_eval do
       @_originals = {}
+      @_class_originals = {}
       @_targets = UNDEFINED_TARGETS
       @_public_only = false
     end
@@ -46,37 +47,70 @@ module TinyHooks
     #
     # @param [Symbol, String] kind the kind of the hook, possible values are: :before, :after and :around
     # @param [Symbol, String] target the name of the targeted method
+    # @param hook_method_name [Symbol, String] the name of a method which should be called as a hook
     # @param [Symbol] terminator choice for terminating execution, default is throwing abort symbol
     # @param [Symbol] if condition to determine if it should define callback. Block is evaluated in context of self
-    def define_hook(kind, target, terminator: :abort, if: nil, &block) # rubocop:disable Naming/MethodParameterName
-      raise ArgumentError, 'You must provide a block' unless block
+    # @param class_method [Boolean] treat target as class method
+    def define_hook(kind, target, hook_method_name = nil, terminator: :abort, if: nil, class_method: false, &block) # rubocop:disable Naming/MethodParameterName
+      raise ArgumentError, 'You must provide a block or hook_method_name' unless block || hook_method_name
       raise ArgumentError, 'terminator must be one of the following: :abort or :return_false' unless %i[abort return_false].include? terminator.to_sym
       raise TinyHooks::TargetError, "Hook for #{target} is not allowed" if @_targets != UNDEFINED_TARGETS && !@_targets.include?(target)
 
-      is_private = private_instance_methods.include?(target.to_sym)
+      if class_method
+        is_private = private_methods.include?(target.to_sym)
 
-      begin
-        original_method = @_public_only ? public_instance_method(target) : instance_method(target)
-      rescue NameError => e
-        raise unless e.message.include?('private')
+        begin
+          original_method = @_public_only ? public_method(target) : method(target)
+        rescue NameError => e
+          raise unless e.message.include?('private')
 
-        raise TinyHooks::PrivateError, "Public only mode is on and hooks for private methods (#{target} for this time) are not available."
-      end
-      @_originals[target.to_sym] = original_method unless @_originals[target.to_sym]
+          raise TinyHooks::PrivateError, "Public only mode is on and hooks for private methods (#{target} for this time) are not available."
+        end
+        @_class_originals[target.to_sym] = original_method unless @_class_originals[target.to_sym]
+
+        block ||= -> { __send__(hook_method_name) }
+        body = method_body(kind, original_method, terminator, binding.local_variable_get(:if), &block)
+        singleton_class.class_eval do
+          undef_method(target)
+          define_method(target, &body)
+          private target if is_private
+        end
+      else # instance method
+        is_private = private_instance_methods.include?(target.to_sym)
+
+        begin
+          original_method = @_public_only ? public_instance_method(target) : instance_method(target)
+        rescue NameError => e
+          raise unless e.message.include?('private')
+
+          raise TinyHooks::PrivateError, "Public only mode is on and hooks for private methods (#{target} for this time) are not available."
+        end
+        @_originals[target.to_sym] = original_method unless @_originals[target.to_sym]
+
+        block ||= -> { __send__(hook_method_name) }
 
-      undef_method(target)
-      define_method(target, &method_body(kind, original_method, terminator, binding.local_variable_get(:if), &block))
-      private target if is_private
+        undef_method(target)
+        define_method(target, &method_body(kind, original_method, terminator, binding.local_variable_get(:if), &block))
+        private target if is_private
+      end
     end
 
     # Restore original method
     #
     # @param [Symbol, String] target
-    def restore_original(target)
-      original_method = @_originals[target.to_sym] || instance_method(target)
-
-      undef_method(target)
-      define_method(target, original_method)
+    # @param class_method [Boolean] treat target as class method
+    def restore_original(target, class_method: false)
+      if class_method
+        original_method = @_class_originals[target.to_sym] || method(target)
+        singleton_class.class_eval do
+          undef_method(target)
+          define_method(target, original_method)
+        end
+      else
+        original_method = @_originals[target.to_sym] || instance_method(target)
+        undef_method(target)
+        define_method(target, original_method)
+      end
     end
 
     # Defines target for hooks
@@ -86,6 +120,7 @@ module TinyHooks
       raise ArgumentError if include_pattern.nil? && exclude_pattern.nil?
 
       candidates = @_public_only ? instance_methods : instance_methods + private_instance_methods
+      candidates += @public_only ? methods : methods + private_methods
       @_targets = if include_pattern && exclude_pattern
                     targets = candidates.grep(include_pattern)
                     targets.grep_v(exclude_pattern)
@@ -131,7 +166,7 @@ module TinyHooks
             return if hook_result == false && terminator == :return_false
           end
 
-          original_method.bind_call(self, *args, **kwargs, &blk)
+          original_method.is_a?(UnboundMethod) ? original_method.bind_call(self, *args, **kwargs, &blk) : original_method.call(*args, **kwargs, &blk)
         end
       else
         proc do |*args, &blk|
@@ -145,7 +180,8 @@ module TinyHooks
             return if hook_result == false && terminator == :return_false
           end
 
-          original_method.bind(self).call(*args, &blk)
+          original_method = original_method.bind(self) if original_method.is_a?(UnboundMethod)
+          original_method.call(*args, &blk)
         end
       end
     end
@@ -153,12 +189,13 @@ module TinyHooks
     def _after(original_method, if_proc:, &block)
       if RUBY_VERSION >= '2.7'
         proc do |*args, **kwargs, &blk|
-          original_method.bind_call(self, *args, **kwargs, &blk)
+          original_method.is_a?(UnboundMethod) ? original_method.bind_call(self, *args, **kwargs, &blk) : original_method.call(*args, **kwargs, &blk)
           instance_exec(*args, **kwargs, &block) if if_proc.nil? || instance_exec(&if_proc) != false
         end
       else
         proc do |*args, &blk|
-          original_method.bind(self).call(*args, &blk)
+          original_method = original_method.bind(self) if original_method.is_a?(UnboundMethod)
+          original_method.call(*args, &blk)
           instance_exec(*args, &block) if if_proc.nil? || instance_exec(&if_proc) != false
         end
       end
@@ -167,12 +204,17 @@ module TinyHooks
     def _around(original_method, if_proc:, &block)
       if RUBY_VERSION >= '2.7'
         proc do |*args, **kwargs, &blk|
-          wrapper = -> { original_method.bind_call(self, *args, **kwargs, &blk) }
+          wrapper = lambda do
+            original_method.is_a?(UnboundMethod) ? original_method.bind_call(self, *args, **kwargs, &blk) : original_method.call(*args, **kwargs, &blk)
+          end
           instance_exec(wrapper, *args, **kwargs, &block) if if_proc.nil? || instance_exec(&if_proc) != false
         end
       else
         proc do |*args, &blk|
-          wrapper = -> { original_method.bind(self).call(*args, &blk) }
+          wrapper = lambda do
+            original_method = original_method.bind(self) if original_method.is_a?(UnboundMethod)
+            original_method.call(*args, &blk)
+          end
           instance_exec(wrapper, *args, &block) if if_proc.nil? || instance_exec(&if_proc) != false
         end
       end
@@ -181,6 +223,7 @@ module TinyHooks
     def inherited(subclass)
       super
       subclass.instance_variable_set(:@_originals, instance_variable_get(:@_originals).clone)
+      subclass.instance_variable_set(:@_class_originals, instance_variable_get(:@_class_originals).clone)
       subclass.instance_variable_set(:@_targets, instance_variable_get(:@_targets).clone)
       subclass.instance_variable_set(:@_public_only, instance_variable_get(:@_public_only).clone)
     end

data/lib/tiny_hooks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiny_hooks
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - OKURA Masafumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-09 00:00:00.000000000 Z
+date: 2021-07-12 00:00:00.000000000 Z
 dependencies: []
 description: Simple, tiny and general hooks control.
 email: