activefunction-core 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7598948c858b823027e2c33a190a17920f466ce55ea96138bc9a01ac75899e74
-  data.tar.gz: 57b9189b07f384420404db190dcea2cd2b7aa40e714f732713f252fddb34590d
+  metadata.gz: 0b2cfe13205db0147f98083ea9d83b4f6ee0a1a1baaec08f848bf7a650a6e844
+  data.tar.gz: 136a5559b4c123ba50c384cfaf4beb05a5a9dca14ae398866e9a98a32d72338c
 SHA512:
-  metadata.gz: 10c87d5b48dcbb1fc3e0aa0711d4dcc4125f6210bbd0b1f96d081e4aadb6bf0feb6028abc0161fa69ca3fd380b5001ec044bc833cc83f5da9479772da16ad133
-  data.tar.gz: 124281e35afce65ca63ca07a4e80ac32167b97104f2c22ab70578fdf280989ef75fc1131dbeef003991857f1462dd0f9eb87b5c00197080573c1cd71ed3a7f09
+  metadata.gz: 5b2a5470029dc54aab1677f6d08af01d1eaca7673d38003745630a82355e44d810085a66c4f4dbafe50409fb4f2e730e3cacc17384883093943e97169ed4ddfe
+  data.tar.gz: 8865302a689494285e6ffc23ba6197aca98b2ae6ee3049364c8c0084bfeb3a5507df4e5d3d674277037e5b0621b1a42afacad08d94d2604b13c30a7f496af26c

data/CHANGELOG.md

@@ -5,3 +5,9 @@
 ## [0.1.1]
 
 - Bump ruby-next to 1.0.0 
+
+## [0.2.0]
+
+- Added Plugins support
+- Added Hooks plugin - refactored ActiveFunction::Functions::Callbacks implementation.
+

data/README.md

@@ -1,143 +1,112 @@
-# ActiveFunction
+# ActiveFunction Core
 
-rails/action_controller like gem which provides lightweight callbacks, strong parameters & rendering features. It's designed to be used with AWS Lambda functions, but can be also used with any Ruby application. 
+Inspired by the structure of the AWS SDK gem, `activefunction-core` seamlessly integrates with the `activefunction` library family, offering a unified interface. It's also designed to operate as a standalone solution.
 
-Implemented with some of ruby 3.x features, but also supports ruby 2.6.x thanks to [RubyNext](https://github.com/ruby-next/ruby-next) transpiler. Type safety achieved by RBS and [Steep](https://github.com/soutaro/steep).
+## Features
 
+- **Ruby-Next Integration:** Enables ruby-next auto-transpiling mode. This allows to use latest Ruby syntax while maintaining compatibility with older versions.
+- **Plugins:** Extends functionality via plugin capabilities, including a callbacks DSL for `before_action` and `after_action` implementation within classes.
 
-## A Short Example
 
-Here's a simple example of a function that uses ActiveFunction:
+## Plugins
 
-```ruby
-require 'active_function'
-
-class AppFunction < ActiveFunction::Base
-  def index 
-    render json: SomeTable.all
-  end 
-end
-```
+### Hooks
 
-Use `#process` method to proceed the request:
+Provides ActiveSupport::Callbacks like DSL for hooks through `::define_hooks_for` to define `before_[method_name]` & `after_[method_name]` callbacks and redefined #method_name to execute callbacks around it. 
 
-```ruby 
-AppFunction.process(:index) # processes index action of AppFunction instance
-```
-Also check extended [example](https://github.com/DanilMaximov/activefunction/tree/master/active_function_example)
-## Callbacks 
-ActiveFunction supports simple callbacks `:before` and `:after` which runs around provided action in `#process`. 
+### Usage
 
 ```ruby
-class AppFunction < ActiveFunction::Base
-  before_action :set_user 
-  after_action :log_response
-  
-  # some action ...
+class YourClass
+  include ActiveFunction::Core::Plugins::Hooks
 
-  private 
+  define_hooks_for :your_method
 
-  def set_user 
-    @user = User.first
-  end 
+  before_your_method :do_something_before
+  after_your_method :do_something_after
 
-  def log_response 
-    Logger.info @response 
+  def your_method
+    # Method implementation here...
+  end
+
+  private
+
+  def do_something_before
+    # Callback logic to execute before your_method
+  end
+
+  def do_something_after
+    # Callback logic to execute after your_method
   end
 end
-```
+``` 
 
-Callbacks also can be user  with `only: Array[Symbol]` and `if: Symbol` options.
+### Hook Method Alias
+
+If you need to alias the method name, you can do so by passing the `:name` option.
 
 ```ruby
-class AppFunction < ActiveFunction::Base
-  before_action :set_user, only: %i[show update destroy], if: :request_valid?
-  
-  # some actions ...
-  
-  private def request_valid? = true
-end
+define_hooks_for :your_method, name: :your_method_alias
+before_your_method_alias :do_something_before
 ```
 
-Callbacks are inheritable so all callbacks calls will be inherited from base class
+### Options
+
+Supports options for `before_[method_name]` & `after_[method_name]` callbacks. Each option is a Proc that return a Bool. By default, `:if` & `:unless` options are vailable, accepting method name.
+
 ```ruby
-class BaseFunction < ActiveFunction::Base
-  before_action :set_current_user
 
-  def set_current_user
-    @current_user = User.first
-  end 
-end
+class YourClass
+  include ActiveFunction::Core::Plugins::Hooks
 
-class PostsFunction < BaseFunction
-  def index
-    render json: @current_user
+  define_hooks_for :your_method
+
+  before_your_method :do_something_before, if: :condition_met?
+  after_your_method :do_something_after, unless: :condition_met?
+
+  def your_method
+    # Method implementation here...
   end
-end
-```
-## Strong Parameters
-ActiveFunction supports strong parameters which can be accessed by `#params` instance method. Strong parameters hash can be passed in `#process` as second argument.
 
-```ruby
-PostFunction.process(:index, data: { id: 1, name: "Pupa" })
-```
+  private
 
-Simple usage:
-```ruby
-class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: permitted_params
-  end 
-
-  def permitted_params = params
-    .require(:data)
-    .permit(:id, :name)
-    .to_h
-end 
-```
-Strong params supports nested attributes
-```ruby 
-params.permit(:id, :name, :address => [:city, :street])
-```
+  def condition_met?
+    # Condition logic here...
+  end
 
-## Rendering
-ActiveFunction supports rendering of JSON. Rendering is obligatory for any function naction and can be done by `#render` method.
-```ruby
-class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: { id: 1, name: "Pupa" }
-  end 
-end
-```
-default status code is 200, but it can be changed by `:status` option
-```ruby
-class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: { id: 1, name: "Pupa" }, status: 201
-  end 
+  def do_something_before
+    # Callback logic to execute before your_method
+  end
+
+  def do_something_after
+    # Callback logic to execute after your_method
+  end
 end
 ```
-Headers can be passed by `:headers` option. Default headers are `{"Content-Type" => "application/json"}`.
+
+Using `::set_callback_options` method, you can define your own options. This method accepts a single attribute Hash where the key is the option name and the value is a Proc that returns a Bool. Specify `context:` keyword argument for proc to access current class instance.
+
 ```ruby
-class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: { id: 1, name: "Pupa" }, headers: { "X-Request-Id" => "123" }
-  end 
-end
-```
+class YourClass
+  include ActiveFunction::Core::Plugins::Hooks
 
+  set_callback_options only: ->(only_methods, context:) { only_methods.include?(context.action) }
 
-## Installation
+  define_hooks_for :your_method
 
-Add this line to your application's Gemfile:
+  before_your_method :do_something_before, only: %[foo bar]
 
-```ruby
-gem 'activefunction', git: "https://github.com/DanilMaximov/activefunction.git"
+  def action = "foo"
+end
 ```
 
+### Callbacks Inheritance
+
+Callbacks are inheritable so all callbacks calls will be inherited from base class.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/rake test` to run the tests and `bin/rake steep` to run type checker. 
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/rake test:all` to run the tests and `bin/rake steep` to run type checker. 
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/lib/.rbnext/2.7/plugins/hooks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+# TODO: remove with new ruby-next release
+if RUBY_VERSION < "3.2"
+  Data.define_singleton_method(:inherited) do |subclass|
+    subclass.instance_variable_set(:@members, members)
+  end
+end
+
+module ActiveFunctionCore
+  module Plugins
+    module Hooks
+      class Hook < Data.define(:method_name, :callbacks)
+        DEFAULT_CALLBACK_OPTIONS = {
+          if:     ->(v, context:) { context.send(v) if context.respond_to?(v, true) },
+          unless: ->(v, context:) { !context.send(v) if context.respond_to?(v, true) }
+        }.freeze
+        SUPPORTED_CALLBACKS      = %i[before after].freeze
+
+        Callback = Data.define(:options, :target) do
+          def run(context)
+            raise ArgumentError, "Callback target #{target} is not defined" unless context.respond_to?(target, true)
+            raise ArgumentError, ":callback_options is not defined in #{context.class}" unless context.class.respond_to?(:callback_options)
+
+            context.instance_exec(target, normalized_options(options, context)) do |target, options|
+              method(target).call if options.all?(&:call)
+            end
+          end
+
+          private def normalized_options(options, context)
+            options.map do |option|
+              name, arg = option.first
+              -> { context.class.callback_options[name].call(arg, context: context) }
+            end
+          end
+        end
+
+        def initialize(callbacks: SUPPORTED_CALLBACKS.dup, **__kwrest__)
+          super(callbacks: callbacks.to_h { |_1| [_1, []] }, **__kwrest__)
+        end
+
+        def add_callback(type:, target:, options: {})
+          callbacks[type] << Callback[options, target].tap do |callback|
+            next unless callbacks[type].map(&:hash).to_set === callback.hash
+
+            raise(ArgumentError, "Callback already defined")
+          end
+        end
+
+        def run_callbacks(context, &block)
+          callbacks[:before].each { |it| it.run(context) }
+
+          yield_result = yield
+
+          callbacks[:after].each { |it| it.run(context) }
+
+          yield_result
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def hooks            ;  @__hooks ||= {}; end
+        def callback_options ;  @__callback_options ||= Hook::DEFAULT_CALLBACK_OPTIONS.dup; end
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__hooks, Marshal.load(Marshal.dump(hooks)))
+          subclass.instance_variable_set(:@__callback_options, callback_options.dup)
+        end
+
+        # Redefines method providing callbacks calls around it.
+        # Defines `before_[name]` and `after_[name]` methods for setting callbacks.
+        #
+        # @param method [Symbol] the name of the callbackable method.
+        # @param name [Symbol] alias for hooked method before_[name] & after_[name] methods.
+        def define_hooks_for(method, name: method)
+          raise(ArgumentError, "Hook for #{method} are already defined") if hooks.key?(method)
+          raise(ArgumentError, "Method #{method} is not defined") unless method_defined?(method)
+
+          hooks[name] = Hook.new(name)
+
+          define_singleton_method(:"before_#{name}") do |target, options = {}|
+            set_callback(:before, name, target, options)
+          end
+
+          define_singleton_method(:"after_#{name}") do |target, options = {}|
+            set_callback(:after, name, target, options)
+          end
+
+          define_method(method) do |*args, &block|
+            self.class.hooks[name].run_callbacks(self) do
+              super(*args, &block)
+            end
+          end
+        end
+
+        # Sets a callback for an existing hook'ed method.
+        #
+        # @param type [Symbol] the type of callback, `:before` or `:after`
+        # @param method_name [Symbol] the name of the callbackable method.
+        # @param target [Symbol] the name of the callback method.
+        # @param options [Hash] the options for the callback.
+        # @options options [Symbol] :if the name of the method to check before executing the callback.
+        def set_callback(type, method_name, target, options = {})
+          raise(ArgumentError, "Hook for :#{method_name} is not defined") unless hooks.key?(method_name)
+          raise(ArgumentError, "Hook Callback accepts only #{options.keys} options") if (options.keys - callback_options.keys).any?
+
+          hooks[method_name].add_callback(type: type, target: target, options: options)
+        end
+
+        # Sets a custom callback option.
+        #
+        # @param name [Symbol] the name of the option.
+        # @yield [*attrs, context:] the block to call.
+        # @yieldparam attrs [*] the attributes passed to the option.
+        # @yieldparam context [Object] the instance context (optional).
+        # @yieldreturn [Boolean].
+        def set_callback_options(option)
+          name, block            = option.first
+          callback_options[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/3.0/plugins/hooks.rb

@@ -1,136 +1,128 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
+# TODO: remove with new ruby-next release
+if RUBY_VERSION < "3.2"
+  Data.define_singleton_method(:inherited) do |subclass|
+    subclass.instance_variable_set(:@members, members)
+  end
+end
+
 module ActiveFunctionCore
   module Plugins
     module Hooks
-      class MissingCallbackContext < Error
-        MESSAGE_TEMPLATE = "Missing callback context: %s"
-
-        attr_reader :message
+      class Hook < Data.define(:method_name, :callbacks)
+        DEFAULT_CALLBACK_OPTIONS = {
+          if:     ->(v, context:) { context.send(v) if context.respond_to?(v, true) },
+          unless: ->(v, context:) { !context.send(v) if context.respond_to?(v, true) }
+        }.freeze
+        SUPPORTED_CALLBACKS      = %i[before after].freeze
+
+        Callback = Data.define(:options, :target) do
+          def run(context)
+            raise ArgumentError, "Callback target #{target} is not defined" unless context.respond_to?(target, true)
+            raise ArgumentError, ":callback_options is not defined in #{context.class}" unless context.class.respond_to?(:callback_options)
+
+            context.instance_exec(target, normalized_options(options, context)) do |target, options|
+              method(target).call if options.all?(&:call)
+            end
+          end
 
-        def initialize(context)
-          @message = MESSAGE_TEMPLATE % context
+          private def normalized_options(options, context)
+            options.map do |option|
+              name, arg = option.first
+              -> { context.class.callback_options[name].call(arg, context: context) }
+            end
+          end
         end
-      end
 
-      class MissingHookableMethod < Error
-        MESSAGE_TEMPLATE = "Method %s is not defined"
-
-        attr_reader :message
-
-        def initialize(method_name)
-          @message = MESSAGE_TEMPLATE % method_name
+        def initialize(callbacks: SUPPORTED_CALLBACKS.dup, **__kwrest__)
+          super(callbacks: callbacks.to_h { [_1, []] }, **__kwrest__)
         end
-      end
 
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      module InstanceMethods
-        private
-
-        def with_callbacks(method_name, &block)
-          callbacks = _callbacks(method_name)
-
-          _run_callbacks(callbacks.before)
-
-          result = yield
+        def add_callback(type:, target:, options: {})
+          callbacks[type] << Callback[options, target].tap do |callback|
+            next unless callbacks[type].map(&:hash).to_set === callback.hash
 
-          _run_callbacks(callbacks.after)
-
-          result
-        end
-
-        def _callbacks(method_name)
-          self.class.hooks[method_name].callbacks
+            raise(ArgumentError, "Callback already defined")
+          end
         end
 
-        def _run_callbacks(callbacks)
-          callbacks.each do |callback|
-            raise(MissingCallbackContext, callback) unless respond_to?(callback.target, true)
+        def run_callbacks(context, &block)
+          callbacks[:before].each { |it| it.run(context) }
 
-            send(callback.target) if _executable?(callback.options)
-          end
-        end
+          yield_result = yield
 
-        def _executable?(options)
-          return false if options[:if] && !send(options[:if])
+          callbacks[:after].each { |it| it.run(context) }
 
-          true
+          yield_result
         end
       end
 
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
       module ClassMethods
-        TYPES = %i[before after].freeze
-        # rubocop:disable Lint/ConstantDefinitionInBlock
-        Hooks = Data.define(:hooks) do
-          def initialize(hooks: {}) ;  super; end
-          def deep_dup ;  Marshal.load(Marshal.dump(self)); end
-          def all ;  hooks; end
-          def [](method_name) ;  hooks[method_name]; end
-
-          def add_hook(method_name)
-            hooks[method_name] = Hook[method_name]
-          end
+        def hooks            ;  @__hooks ||= {}; end
+        def callback_options ;  @__callback_options ||= Hook::DEFAULT_CALLBACK_OPTIONS.dup; end
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__hooks, Marshal.load(Marshal.dump(hooks)))
+          subclass.instance_variable_set(:@__callback_options, callback_options.dup)
         end
 
-        Hook = Data.define(:method_name, :callbacks) do
-          Callbacks = Data.define(:before, :after) do
-            def initialize(before: [], after: []) ;  super; end
-            def [](type) ;  public_send(type); end
-          end
-          Callback = Data.define(:target, :options)
+        # Redefines method providing callbacks calls around it.
+        # Defines `before_[name]` and `after_[name]` methods for setting callbacks.
+        #
+        # @param method [Symbol] the name of the callbackable method.
+        # @param name [Symbol] alias for hooked method before_[name] & after_[name] methods.
+        def define_hooks_for(method, name: method)
+          raise(ArgumentError, "Hook for #{method} are already defined") if hooks.key?(method)
+          raise(ArgumentError, "Method #{method} is not defined") unless method_defined?(method)
 
-          def initialize(method_name:, callbacks: Callbacks.new) ;  super; end
-          def hashes(type) ;  Set.new callbacks[type].map(&:hash); end
+          hooks[name] = Hook.new(name)
 
-          def add_callback(type:, target:, options: {})
-            new_callbacks = Callback[target, options]
-            callbacks[type] << new_callbacks unless hashes(type) === new_callbacks.hash
+          define_singleton_method(:"before_#{name}") do |target, options = {}|
+            set_callback(:before, name, target, options)
           end
-        end
-        # rubocop:enable Lint/ConstantDefinitionInBlock
-
-        def define_hooks_for(*method_names)
-          method_names.each do |method_name|
-            override_hookable_method(method_name)
 
-            hooks.add_hook(method_name)
+          define_singleton_method(:"after_#{name}") do |target, options = {}|
+            set_callback(:after, name, target, options)
+          end
 
-            define_callback_methods_for(method_name)
+          define_method(method) do |*args, &block|
+            self.class.hooks[name].run_callbacks(self) do
+              super(*args, &block)
+            end
           end
         end
 
+        # Sets a callback for an existing hook'ed method.
+        #
+        # @param type [Symbol] the type of callback, `:before` or `:after`
+        # @param method_name [Symbol] the name of the callbackable method.
+        # @param target [Symbol] the name of the callback method.
+        # @param options [Hash] the options for the callback.
+        # @options options [Symbol] :if the name of the method to check before executing the callback.
         def set_callback(type, method_name, target, options = {})
-          hooks[method_name].add_callback(type: type, target: target, options: options)
-        end
-
-        def hooks
-          @__hooks ||= Hooks.new
-        end
-
-        private
-
-        def inherited(subclass)
-          subclass.instance_variable_set(:@__hooks, @__hooks.deep_dup)
-        end
-
-        def override_hookable_method(method_name)
-          raise(MissingHookableMethod, method_name) unless method_defined?(method_name)
+          raise(ArgumentError, "Hook for :#{method_name} is not defined") unless hooks.key?(method_name)
+          raise(ArgumentError, "Hook Callback accepts only #{options.keys} options") if (options.keys - callback_options.keys).any?
 
-          define_method(method_name) do |*args|
-            with_callbacks(method_name) { super(*args) }
-          end
+          hooks[method_name].add_callback(type: type, target: target, options: options)
         end
 
-        def define_callback_methods_for(method_name)
-          TYPES.each do |type|
-            define_singleton_method("#{type}_#{method_name}") do |target, options = {}|
-              set_callback(type, method_name, target, options)
-            end
-          end
+        # Sets a custom callback option.
+        #
+        # @param name [Symbol] the name of the option.
+        # @yield [*attrs, context:] the block to call.
+        # @yieldparam attrs [*] the attributes passed to the option.
+        # @yieldparam context [Object] the instance context (optional).
+        # @yieldreturn [Boolean].
+        def set_callback_options(option)
+          name, block            = option.first
+          callback_options[name] = block
         end
       end
     end

data/lib/.rbnext/3.1/plugins/hooks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+# TODO: remove with new ruby-next release
+if RUBY_VERSION < "3.2"
+  Data.define_singleton_method(:inherited) do |subclass|
+    subclass.instance_variable_set(:@members, members)
+  end
+end
+
+module ActiveFunctionCore
+  module Plugins
+    module Hooks
+      class Hook < Data.define(:method_name, :callbacks)
+        DEFAULT_CALLBACK_OPTIONS = {
+          if:     ->(v, context:) { context.send(v) if context.respond_to?(v, true) },
+          unless: ->(v, context:) { !context.send(v) if context.respond_to?(v, true) }
+        }.freeze
+        SUPPORTED_CALLBACKS      = %i[before after].freeze
+
+        Callback = Data.define(:options, :target) do
+          def run(context)
+            raise ArgumentError, "Callback target #{target} is not defined" unless context.respond_to?(target, true)
+            raise ArgumentError, ":callback_options is not defined in #{context.class}" unless context.class.respond_to?(:callback_options)
+
+            context.instance_exec(target, normalized_options(options, context)) do |target, options|
+              method(target).call if options.all?(&:call)
+            end
+          end
+
+          private def normalized_options(options, context)
+            options.map do |option|
+              name, arg = option.first
+              -> { context.class.callback_options[name].call(arg, context: context) }
+            end
+          end
+        end
+
+        def initialize(callbacks: SUPPORTED_CALLBACKS.dup, **__kwrest__)
+          super(callbacks: callbacks.to_h { [_1, []] }, **__kwrest__)
+        end
+
+        def add_callback(type:, target:, options: {})
+          callbacks[type] << Callback[options, target].tap do |callback|
+            next unless callbacks[type].map(&:hash).to_set === callback.hash
+
+            raise(ArgumentError, "Callback already defined")
+          end
+        end
+
+        def run_callbacks(context, &block)
+          callbacks[:before].each { |it| it.run(context) }
+
+          yield_result = yield
+
+          callbacks[:after].each { |it| it.run(context) }
+
+          yield_result
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def hooks            = @__hooks ||= {}
+        def callback_options = @__callback_options ||= Hook::DEFAULT_CALLBACK_OPTIONS.dup
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__hooks, Marshal.load(Marshal.dump(hooks)))
+          subclass.instance_variable_set(:@__callback_options, callback_options.dup)
+        end
+
+        # Redefines method providing callbacks calls around it.
+        # Defines `before_[name]` and `after_[name]` methods for setting callbacks.
+        #
+        # @param method [Symbol] the name of the callbackable method.
+        # @param name [Symbol] alias for hooked method before_[name] & after_[name] methods.
+        def define_hooks_for(method, name: method)
+          raise(ArgumentError, "Hook for #{method} are already defined") if hooks.key?(method)
+          raise(ArgumentError, "Method #{method} is not defined") unless method_defined?(method)
+
+          hooks[name] = Hook.new(name)
+
+          define_singleton_method(:"before_#{name}") do |target, options = {}|
+            set_callback(:before, name, target, options)
+          end
+
+          define_singleton_method(:"after_#{name}") do |target, options = {}|
+            set_callback(:after, name, target, options)
+          end
+
+          define_method(method) do |*args, &block|
+            self.class.hooks[name].run_callbacks(self) do
+              super(*args, &block)
+            end
+          end
+        end
+
+        # Sets a callback for an existing hook'ed method.
+        #
+        # @param type [Symbol] the type of callback, `:before` or `:after`
+        # @param method_name [Symbol] the name of the callbackable method.
+        # @param target [Symbol] the name of the callback method.
+        # @param options [Hash] the options for the callback.
+        # @options options [Symbol] :if the name of the method to check before executing the callback.
+        def set_callback(type, method_name, target, options = {})
+          raise(ArgumentError, "Hook for :#{method_name} is not defined") unless hooks.key?(method_name)
+          raise(ArgumentError, "Hook Callback accepts only #{options.keys} options") if (options.keys - callback_options.keys).any?
+
+          hooks[method_name].add_callback(type: type, target: target, options: options)
+        end
+
+        # Sets a custom callback option.
+        #
+        # @param name [Symbol] the name of the option.
+        # @yield [*attrs, context:] the block to call.
+        # @yieldparam attrs [*] the attributes passed to the option.
+        # @yieldparam context [Object] the instance context (optional).
+        # @yieldreturn [Boolean].
+        def set_callback_options(option)
+          name, block            = option.first
+          callback_options[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/3.2/plugins/hooks.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+# TODO: remove with new ruby-next release
+if RUBY_VERSION < "3.2"
+  Data.define_singleton_method(:inherited) do |subclass|
+    subclass.instance_variable_set(:@members, members)
+  end
+end
+
+module ActiveFunctionCore
+  module Plugins
+    module Hooks
+      class Hook < Data.define(:method_name, :callbacks)
+        DEFAULT_CALLBACK_OPTIONS = {
+          if:     ->(v, context:) { context.send(v) if context.respond_to?(v, true) },
+          unless: ->(v, context:) { !context.send(v) if context.respond_to?(v, true) }
+        }.freeze
+        SUPPORTED_CALLBACKS      = %i[before after].freeze
+
+        Callback = Data.define(:options, :target) do
+          def run(context)
+            raise ArgumentError, "Callback target #{target} is not defined" unless context.respond_to?(target, true)
+            raise ArgumentError, ":callback_options is not defined in #{context.class}" unless context.class.respond_to?(:callback_options)
+
+            context.instance_exec(target, normalized_options(options, context)) do |target, options|
+              method(target).call if options.all?(&:call)
+            end
+          end
+
+          private def normalized_options(options, context)
+            options.map do |option|
+              name, arg = option.first
+              -> { context.class.callback_options[name].call(arg, context:) }
+            end
+          end
+        end
+
+        def initialize(callbacks: SUPPORTED_CALLBACKS.dup, **__kwrest__)
+          super(callbacks: callbacks.to_h { [_1, []] }, **__kwrest__)
+        end
+
+        def add_callback(type:, target:, options: {})
+          callbacks[type] << Callback[options, target].tap do |callback|
+            next unless callbacks[type].map(&:hash).to_set === callback.hash
+
+            raise(ArgumentError, "Callback already defined")
+          end
+        end
+
+        def run_callbacks(context, &block)
+          callbacks[:before].each { |it| it.run(context) }
+
+          yield_result = yield
+
+          callbacks[:after].each { |it| it.run(context) }
+
+          yield_result
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def hooks            = @__hooks ||= {}
+        def callback_options = @__callback_options ||= Hook::DEFAULT_CALLBACK_OPTIONS.dup
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__hooks, Marshal.load(Marshal.dump(hooks)))
+          subclass.instance_variable_set(:@__callback_options, callback_options.dup)
+        end
+
+        # Redefines method providing callbacks calls around it.
+        # Defines `before_[name]` and `after_[name]` methods for setting callbacks.
+        #
+        # @param method [Symbol] the name of the callbackable method.
+        # @param name [Symbol] alias for hooked method before_[name] & after_[name] methods.
+        def define_hooks_for(method, name: method)
+          raise(ArgumentError, "Hook for #{method} are already defined") if hooks.key?(method)
+          raise(ArgumentError, "Method #{method} is not defined") unless method_defined?(method)
+
+          hooks[name] = Hook.new(name)
+
+          define_singleton_method(:"before_#{name}") do |target, options = {}|
+            set_callback(:before, name, target, options)
+          end
+
+          define_singleton_method(:"after_#{name}") do |target, options = {}|
+            set_callback(:after, name, target, options)
+          end
+
+          define_method(method) do |*args, &block|
+            self.class.hooks[name].run_callbacks(self) do
+              super(*args, &block)
+            end
+          end
+        end
+
+        # Sets a callback for an existing hook'ed method.
+        #
+        # @param type [Symbol] the type of callback, `:before` or `:after`
+        # @param method_name [Symbol] the name of the callbackable method.
+        # @param target [Symbol] the name of the callback method.
+        # @param options [Hash] the options for the callback.
+        # @options options [Symbol] :if the name of the method to check before executing the callback.
+        def set_callback(type, method_name, target, options = {})
+          raise(ArgumentError, "Hook for :#{method_name} is not defined") unless hooks.key?(method_name)
+          raise(ArgumentError, "Hook Callback accepts only #{options.keys} options") if (options.keys - callback_options.keys).any?
+
+          hooks[method_name].add_callback(type:, target:, options:)
+        end
+
+        # Sets a custom callback option.
+        #
+        # @param name [Symbol] the name of the option.
+        # @yield [*attrs, context:] the block to call.
+        # @yieldparam attrs [*] the attributes passed to the option.
+        # @yieldparam context [Object] the instance context (optional).
+        # @yieldreturn [Boolean].
+        def set_callback_options(option)
+          name, block            = option.first
+          callback_options[name] = block
+        end
+      end
+    end
+  end
+end

data/lib/active_function_core/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveFunctionCore
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/active_function_core.rb

@@ -5,7 +5,7 @@ require "ruby-next/language/setup"
 RubyNext::Language.setup_gem_load_path(transpile: true)
 
 module ActiveFunctionCore
-  class Error < StandardError; end
+  Error = Class.new(StandardError)
 
   require "plugins/hooks"
 

data/lib/plugins/hooks.rb

@@ -1,136 +1,128 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
+# TODO: remove with new ruby-next release
+if RUBY_VERSION < "3.2"
+  Data.define_singleton_method(:inherited) do |subclass|
+    subclass.instance_variable_set(:@members, members)
+  end
+end
+
 module ActiveFunctionCore
   module Plugins
     module Hooks
-      class MissingCallbackContext < Error
-        MESSAGE_TEMPLATE = "Missing callback context: %s"
-
-        attr_reader :message
+      class Hook < Data.define(:method_name, :callbacks)
+        DEFAULT_CALLBACK_OPTIONS = {
+          if:     ->(v, context:) { context.send(v) if context.respond_to?(v, true) },
+          unless: ->(v, context:) { !context.send(v) if context.respond_to?(v, true) }
+        }.freeze
+        SUPPORTED_CALLBACKS      = %i[before after].freeze
+
+        Callback = Data.define(:options, :target) do
+          def run(context)
+            raise ArgumentError, "Callback target #{target} is not defined" unless context.respond_to?(target, true)
+            raise ArgumentError, ":callback_options is not defined in #{context.class}" unless context.class.respond_to?(:callback_options)
+
+            context.instance_exec(target, normalized_options(options, context)) do |target, options|
+              method(target).call if options.all?(&:call)
+            end
+          end
 
-        def initialize(context)
-          @message = MESSAGE_TEMPLATE % context
+          private def normalized_options(options, context)
+            options.map do |option|
+              name, arg = option.first
+              -> { context.class.callback_options[name].call(arg, context:) }
+            end
+          end
         end
-      end
 
-      class MissingHookableMethod < Error
-        MESSAGE_TEMPLATE = "Method %s is not defined"
-
-        attr_reader :message
-
-        def initialize(method_name)
-          @message = MESSAGE_TEMPLATE % method_name
+        def initialize(callbacks: SUPPORTED_CALLBACKS.dup, **)
+          super(callbacks: callbacks.to_h { [_1, []] }, **)
         end
-      end
 
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      module InstanceMethods
-        private
-
-        def with_callbacks(method_name, &block)
-          callbacks = _callbacks(method_name)
-
-          _run_callbacks(callbacks.before)
+        def add_callback(type:, target:, options: {})
+          callbacks[type] << Callback[options, target].tap do |callback|
+            next unless callbacks[type].map(&:hash).to_set === callback.hash
 
-          result = yield
-
-          _run_callbacks(callbacks.after)
-
-          result
+            raise(ArgumentError, "Callback already defined")
+          end
         end
 
-        def _callbacks(method_name)
-          self.class.hooks[method_name].callbacks
-        end
+        def run_callbacks(context, &block)
+          callbacks[:before].each { |it| it.run(context) }
 
-        def _run_callbacks(callbacks)
-          callbacks.each do |callback|
-            raise(MissingCallbackContext, callback) unless respond_to?(callback.target, true)
+          yield_result = yield
 
-            send(callback.target) if _executable?(callback.options)
-          end
-        end
+          callbacks[:after].each { |it| it.run(context) }
 
-        def _executable?(options)
-          return false if options[:if] && !send(options[:if])
-
-          true
+          yield_result
         end
       end
 
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
       module ClassMethods
-        TYPES = %i[before after].freeze
-        # rubocop:disable Lint/ConstantDefinitionInBlock
-        Hooks = Data.define(:hooks) do
-          def initialize(hooks: {}) = super
-          def deep_dup = Marshal.load(Marshal.dump(self))
-          def all = hooks
-          def [](method_name) = hooks[method_name]
-
-          def add_hook(method_name)
-            hooks[method_name] = Hook[method_name]
-          end
+        def hooks            = @__hooks ||= {}
+        def callback_options = @__callback_options ||= Hook::DEFAULT_CALLBACK_OPTIONS.dup
+
+        def inherited(subclass)
+          subclass.instance_variable_set(:@__hooks, Marshal.load(Marshal.dump(hooks)))
+          subclass.instance_variable_set(:@__callback_options, callback_options.dup)
         end
 
-        Hook = Data.define(:method_name, :callbacks) do
-          Callbacks = Data.define(:before, :after) do
-            def initialize(before: [], after: []) = super
-            def [](type) = public_send(type)
-          end
-          Callback = Data.define(:target, :options)
+        # Redefines method providing callbacks calls around it.
+        # Defines `before_[name]` and `after_[name]` methods for setting callbacks.
+        #
+        # @param method [Symbol] the name of the callbackable method.
+        # @param name [Symbol] alias for hooked method before_[name] & after_[name] methods.
+        def define_hooks_for(method, name: method)
+          raise(ArgumentError, "Hook for #{method} are already defined") if hooks.key?(method)
+          raise(ArgumentError, "Method #{method} is not defined") unless method_defined?(method)
 
-          def initialize(method_name:, callbacks: Callbacks.new) = super
-          def hashes(type) = Set.new callbacks[type].map(&:hash)
+          hooks[name] = Hook.new(name)
 
-          def add_callback(type:, target:, options: {})
-            new_callbacks = Callback[target, options]
-            callbacks[type] << new_callbacks unless hashes(type) === new_callbacks.hash
+          define_singleton_method(:"before_#{name}") do |target, options = {}|
+            set_callback(:before, name, target, options)
           end
-        end
-        # rubocop:enable Lint/ConstantDefinitionInBlock
-
-        def define_hooks_for(*method_names)
-          method_names.each do |method_name|
-            override_hookable_method(method_name)
 
-            hooks.add_hook(method_name)
+          define_singleton_method(:"after_#{name}") do |target, options = {}|
+            set_callback(:after, name, target, options)
+          end
 
-            define_callback_methods_for(method_name)
+          define_method(method) do |*args, &block|
+            self.class.hooks[name].run_callbacks(self) do
+              super(*args, &block)
+            end
           end
         end
 
+        # Sets a callback for an existing hook'ed method.
+        #
+        # @param type [Symbol] the type of callback, `:before` or `:after`
+        # @param method_name [Symbol] the name of the callbackable method.
+        # @param target [Symbol] the name of the callback method.
+        # @param options [Hash] the options for the callback.
+        # @options options [Symbol] :if the name of the method to check before executing the callback.
         def set_callback(type, method_name, target, options = {})
-          hooks[method_name].add_callback(type: type, target: target, options: options)
-        end
-
-        def hooks
-          @__hooks ||= Hooks.new
-        end
-
-        private
-
-        def inherited(subclass)
-          subclass.instance_variable_set(:@__hooks, @__hooks.deep_dup)
-        end
-
-        def override_hookable_method(method_name)
-          raise(MissingHookableMethod, method_name) unless method_defined?(method_name)
+          raise(ArgumentError, "Hook for :#{method_name} is not defined") unless hooks.key?(method_name)
+          raise(ArgumentError, "Hook Callback accepts only #{options.keys} options") if (options.keys - callback_options.keys).any?
 
-          define_method(method_name) do |*args|
-            with_callbacks(method_name) { super(*args) }
-          end
+          hooks[method_name].add_callback(type:, target:, options:)
         end
 
-        def define_callback_methods_for(method_name)
-          TYPES.each do |type|
-            define_singleton_method("#{type}_#{method_name}") do |target, options = {}|
-              set_callback(type, method_name, target, options)
-            end
-          end
+        # Sets a custom callback option.
+        #
+        # @param name [Symbol] the name of the option.
+        # @yield [*attrs, context:] the block to call.
+        # @yieldparam attrs [*] the attributes passed to the option.
+        # @yieldparam context [Object] the instance context (optional).
+        # @yieldreturn [Boolean].
+        def set_callback_options(option)
+          name, block            = option.first
+          callback_options[name] = block
         end
       end
     end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activefunction-core
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Nerbyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-27 00:00:00.000000000 Z
+date: 2024-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby-next-core
+  name: ruby-next
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 description: Provides core functionality, plugins and ruby-next integration for ActiveFunction
 email:
 - danil.maximov2000@gmail.com
@@ -34,7 +34,10 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/.rbnext/2.7/plugins/hooks.rb
 - lib/.rbnext/3.0/plugins/hooks.rb
+- lib/.rbnext/3.1/plugins/hooks.rb
+- lib/.rbnext/3.2/plugins/hooks.rb
 - lib/active_function_core.rb
 - lib/active_function_core/version.rb
 - lib/plugins/hooks.rb