activefunction-core 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a64c7260d306142ff9c0b5e48d0cd34c9258e65af3e19bbd7aa6b1121a8a3eff
-  data.tar.gz: 14514dbbad34d5f8b64fadd0b146c5a1f90a955578cbf5e51fe161af4d5939ad
+  metadata.gz: 0b2cfe13205db0147f98083ea9d83b4f6ee0a1a1baaec08f848bf7a650a6e844
+  data.tar.gz: 136a5559b4c123ba50c384cfaf4beb05a5a9dca14ae398866e9a98a32d72338c
 SHA512:
-  metadata.gz: 13038598288b048965d93d6299bc7fe1feda28f28bcee220c87d5361f59060e43c07d44089279840da2c3877dd8a100aacad5b32216a692b9497f431ebab0cdc
-  data.tar.gz: 3522dd0d9db78ac518093fc9b7f4bf9be48da2593ef63fe0766e7a51b04ab729b63ef521fdc5a0f115fabac0f7207268d02cb586f3aabd50561408adabd47464
+  metadata.gz: 5b2a5470029dc54aab1677f6d08af01d1eaca7673d38003745630a82355e44d810085a66c4f4dbafe50409fb4f2e730e3cacc17384883093943e97169ed4ddfe
+  data.tar.gz: 8865302a689494285e6ffc23ba6197aca98b2ae6ee3049364c8c0084bfeb3a5507df4e5d3d674277037e5b0621b1a42afacad08d94d2604b13c30a7f496af26c

data/CHANGELOG.md

@@ -1,3 +1,13 @@
 ## [0.1.0]
 
 - Introduce ruby-next integration
+
+## [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

@@ -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 ||= {}; 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.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.0.1"
+  VERSION = "0.2.0"
 end

data/lib/active_function_core.rb

@@ -5,7 +5,9 @@ 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"
 
   require "active_function_core/version"
 end

data/lib/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, **)
+          super(callbacks: callbacks.to_h { [_1, []] }, **)
+        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

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activefunction-core
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Nerbyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-20 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: '0.15'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.15.3
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.15'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.15.3
+        version: '1.0'
 description: Provides core functionality, plugins and ruby-next integration for ActiveFunction
 email:
 - danil.maximov2000@gmail.com
@@ -40,8 +34,13 @@ 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
 - sig/active_function_core.rbs
 - sig/manifest.yml
 homepage: https://github.com/DanilMaximov/activefunction