activefunction 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 291381221a57e279bfad4dddf88cbeb3695a83e2b4882960b1255304e01a78db
-  data.tar.gz: 8a2a8d432700fff63717b76198bc032986bc2c6656e7eb9dbf034f78552bcb29
+  metadata.gz: 4f2bbae1e08a02af0dbabf4b235ece3823d17aec26e76b24ad7f4b514ea8526c
+  data.tar.gz: 6097f177bb4b5dff0583c21c40d45c67aeb4bd81eb6551b52e59c440b3e5e027
 SHA512:
-  metadata.gz: 70f3d994a4703b373f91a4df21e0b02a424f0a049a391caf04558ffbcebd80546a3f6683fce5c5a66111336d0827aaa2049ce4b5fbafa64fa7720e13278cf2b7
-  data.tar.gz: fc0bd5b0c69e64147e7d1729c179c5ef44a931733b9b71b3adec4aa623a7f01f50d70553c7bd58ade6080c2f4e8dab52d2716ebea0b042556296a17d61276e0c
+  metadata.gz: 51cfd314a65879813c1e8c8c23ea80b32621a1479a5c4ea09c789557ddcc80b05b29af2d84181fec90984c4137f8cc4735bd24e76a6eb2e38d81cfa543605ea7
+  data.tar.gz: 2ea0d89e66aa2a3c89f3b011a84bed5628a9e2e1de78c506f24d93393ab389922581ba1429509c3f8e30883a6788216069078aec3d38cd692c6eda1314b6a69f

data/CHANGELOG.md

@@ -46,4 +46,11 @@
 
 - Start gem restructuring for modularizaition
 - Introduce `activefunction-core` gem with RubyNext integration
- 
+
+# [0.4.0] - 2024-01-11
+
+- Replace `ActiveFunction::Functions::Callbacks` with `ActiveFunctionCore::Plugins::Hooks`
+- Introduce Plugin system
+- Global refactoring
+
+

data/README.md

@@ -1,144 +1,213 @@
 # ActiveFunction
 
-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. 
+Playground gem for Ruby 3.2+ features and more.
 
-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).
+Collection of gems designed to be used with FaaS (Function as a Service) computing instances. Inspired by aws-sdk v3 gem structure & rails/activesupport.
 
+## Features
 
+- **Ruby Version Compatibility:** Implemented with most of ruby 3.2+ features, BUT supports Ruby versions >= 2.6 through the use of the [RubyNext](https://github.com/ruby-next/ruby-next) transpiler. (CI'ed)
+- **Type Safety:** Achieves type safety through the use of RBS and [Steep](https://github.com/soutaro/steep). (CI'ed)
+  - Note: disabled due to the presence of Ruby::UnsupportedSyntax errors.
+- **Plugins System:** Provides a simple Plugin system (inspired by [Polishing Ruby Programming by Jeremy Evans](https://github.com/PacktPublishing/Polished-Ruby-Programming)) to load gem plugins as well as self-defined plugins.
+- **Gem Collection** Provides a collection of gems designed to be used within ActiveFunction or standalone.
 
-## A Short Example
+# Gems
+
+- [activefunction](/) - Main gem, provides rails/action-controller like API with callbacks, strong parameters and rendering under plugins.
+- [activefunction-core](/gems/activefunction-core/README.md) - Provides RubyNext integration and External Standalone Plugins
+- activefunction-orm - WIP (ORM around AWS PartiQL)
+
+## Quick Start
 
 Here's a simple example of a function that uses ActiveFunction:
 
 ```ruby
-require 'active_function'
+require "active_function"
 
 class AppFunction < ActiveFunction::Base
-  def index 
-    render json: SomeTable.all
-  end 
+  def index
+    response_with_error if @request[:data].nil?
+
+    return if performed?
+
+    @response.status  = 200
+    @response.headers = {"Content-Type" => "application/json"}
+    @response.body    = @request[:data]
+  end
+
+  private def response_with_error
+    @response.status = 400
+    @response.commit!
+  end
 end
+
+AppFunction.process(:index, {data: {id: 1}}) # => { :statusCode=>200, :headers=> {"Content-Type"=>"application/json"}, :body=>{id: 1}"}
 ```
 
-Use `#process` method to proceed the request:
+## Plugins
 
-```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`. 
+ActiveFunction supports plugins which can be loaded by `ActiveFunction.config` method. Currently, there are 3 plugins available:
+  - [:callbacks](#callbacks) - provides `:before_action` and `:after_action` callbacks with `:if`, `:unless` & `:only` options.
+  - [:strong_parameters](#strong-parameters) - provides strong parameters support via `#params` instance method.
+  - [:rendering](#rendering) - provides rendering support via `#render` instance method.
+
+## Configuration
+
+To configure ActiveFunction with plugins, use the `ActiveFunction.config` method.
 
 ```ruby
-class AppFunction < ActiveFunction::Base
-  before_action :set_user 
-  after_action :log_response
-  
-  # some action ...
+# config/initializers/active_function.rb
+require "active_function"
 
-  private 
+ActiveFunction.config do
+  plugin :callbacks
+  plugin :strong_parameters
+  plugin :rendering
+end
+```
 
-  def set_user 
-    @user = User.first
-  end 
+```ruby
+# app/functions/app_function.rb
+class AppFunction < ActiveFunction::Base
+  before_action :parse_user_data
 
-  def log_response 
-    Logger.info @response 
+  def index
+    render json: @user_data
   end
+
+  private def parse_user_data = @user_data = params.require(:data).permit(:id, :name).to_h
 end
 ```
 
-Callbacks also can be user  with `only: Array[Symbol]` and `if: Symbol` options.
+Use `#process` method to proceed the request:
 
 ```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
+# handler.rb
+AppFunction.process(:index, {data: { id: 1, name: 2}}) # => { :statusCode=>200, :headers=> {"Content-Type"=>"application/json"}, :body=>"{\"id\":1,\"name\":2}"}
 ```
 
-Callbacks are inheritable so all callbacks calls will be inherited from base class
+
+## Callbacks
+
+Simple callbacks engined by [ActiveFunctionCore::Plugins::Hooks](https://github.com/DanilMaximov/activefunction/tree/master/gems/activefunction-core#hooks) external plugin and provides `:before_action` and `:after_action` which runs around provided action in `#process`.
+
 ```ruby
-class BaseFunction < ActiveFunction::Base
-  before_action :set_current_user
+require "active_function"
 
-  def set_current_user
-    @current_user = User.first
-  end 
+ActiveFunction.config do
+  plugin :callbacks
 end
 
-class PostsFunction < BaseFunction
+class AppFunction < ActiveFunction::Base
+  before_action :set_user
+  after_action :log_response
+
   def index
-    render json: @current_user
+    # some actions ...
   end
+
+  private
+
+  def set_user     = @_user ||= User.find(@request[:id])
+  def log_response = Logger.info(@response)
 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.
+
+### Callbacks options
+
+Supports default [ActiveFunctionCore::Plugins::Hooks::Hook::Callback options](https://github.com/DanilMaximov/activefunction/tree/master/gems/activefunction-core#options) `:if => Symbol` & `:unless => Symbol` options.
+
+Support custom defined in ActiveFunction::Function::Callbacks `only: Array[Symbol]` option.
 
 ```ruby
-PostFunction.process(:index, data: { id: 1, name: "Pupa" })
+class AppFunction < ActiveFunction::Base
+  before_action :set_user, only: %i[show update destroy], if: :request_valid?
+
+  # some actions ...
+
+  private def request_valid? = true
+end
 ```
+More details in [ActiveFunctionCore::Plugins::Hooks readme](https://github.com/DanilMaximov/activefunction/tree/master/gems/activefunction-core#hooks)
+
+## Strong Parameters
+
+ActiveFunction supports strong parameters which can be accessed by `#params` instance method.
+
+The `#params` method represents a Ruby 3.2 Data class that allows the manipulation of request parameters. It supports the following methods:
+
+- `[]`: Access parameters by key.
+- `permit`: Specify the allowed parameters.
+- `require`: Ensure the presence of a specific parameter.
+- `to_h`: Convert the parameters to a hash.
+
+Usage Example:
 
-Simple usage:
 ```ruby
+require "active_function"
+
+ActiveFunction.config do
+  plugin :strong_parameters
+end
+
 class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: permitted_params
-  end 
+  def index
+    @response.body = permitted_params
+  end
 
   def permitted_params = params
     .require(:data)
     .permit(:id, :name)
     .to_h
-end 
+end
+
+PostFunction.process(:index, data: {id: 1, name: "Pupa"})
 ```
+
 Strong params supports nested attributes
-```ruby 
+```ruby
 params.permit(:id, :name, :address => [:city, :street])
 ```
 
 ## 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
+
+ActiveFunction supports rendering of JSON. The #render method is used for rendering responses. It accepts the following options:
+
+- `head`: Set response headers. Defaults to `{ "Content-Type" => "application/json" }`.
+- `json`: Set the response body with a JSON-like object. Defaults to `{}`.
+- `status`: Set the HTTP status code. Defaults to `200`.
+
+Additionally, the method automatically commits the response and JSONifies the body.
+
+Usage Example:
 ```ruby
-class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: { id: 1, name: "Pupa" }, status: 201
-  end 
+require "active_function"
+
+ActiveFunction.config do
+  plugin :rendering
 end
-```
-Headers can be passed by `:headers` option. Default headers are `{"Content-Type" => "application/json"}`.
-```ruby
+
 class PostsFunction < ActiveFunction::Base
-  def index 
-    render json: { id: 1, name: "Pupa" }, headers: { "X-Request-Id" => "123" }
-  end 
+  def index
+    render json: {id: 1, name: "Pupa"}, status: 200, head: {"Some-Header" => "Some-Value"}
+  end
 end
-```
 
+PostFunction.process(:index) # => { :statusCode=>200, :headers=> {"Content-Type"=>"application/json", "Some-Header" => "Some-Value"}, :body=>"{\"id\":1,\"name\":\"Pupa\"}"}
+```
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'activefunction', git: "https://github.com/DanilMaximov/activefunction.git"
+gem "activefunction"
 ```
 
 ## 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` 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/active_function/functions/strong_parameters.rb

@@ -3,52 +3,45 @@
 require "forwardable"
 
 module ActiveFunction
-  class ParameterMissingError < Error
-    MESSAGE_TEMPLATE = "Missing parameter: %s"
+  module Functions
+    module StrongParameters
+      ActiveFunction.register_plugin :strong_parameters, self
 
-    attr_reader :message
+      Error = Class.new(StandardError)
 
-    def initialize(param)
-      MESSAGE_TEMPLATE % param
-    end
-  end
+      class Parameters < Data.define(:params, :permitted)
+        class ParameterMissingError < Error
+          MESSAGE_TEMPLATE = "Missing parameter: %s"
 
-  class UnpermittedParameterError < Error
-    MESSAGE_TEMPLATE = "Unpermitted parameter: %s"
+          attr_reader :message
 
-    attr_reader :message
-
-    def initialize(param)
-      MESSAGE_TEMPLATE % param
-    end
-  end
+          def initialize(param)
+            MESSAGE_TEMPLATE % param
+          end
+        end
 
-  module Functions
-    module StrongParameters
-      def params
-        @_params ||= Parameters.new(@request)
-      end
+        class UnpermittedParameterError < Error
+          MESSAGE_TEMPLATE = "Unpermitted parameter: %s"
 
-      class Parameters
-        extend Forwardable
-        def_delegators :@parameters, :each, :map
-        include Enumerable
+          attr_reader :message
 
-        def initialize(parameters, permitted: false)
-          @parameters = parameters
-          @permitted  = permitted
+          def initialize(param)
+            MESSAGE_TEMPLATE % param
+          end
         end
 
+        protected :params
+
         def [](attribute)
-          nested_attribute(parameters[attribute])
+          nested_attribute(params[attribute])
         end
 
         def require(attribute)
-          value = self[attribute]
-
-          raise ParameterMissingError, attribute if value.nil?
-
-          value
+          if (value = self[attribute])
+            value
+          else
+            raise ParameterMissingError, attribute
+          end
         end
 
         def permit(*attributes)
@@ -60,28 +53,37 @@ module ActiveFunction
                 pparams[k] = process_nested(self[k], :permit, v)
               end
             else
-              next unless parameters.key?(attribute)
+              next unless params.key?(attribute)
 
               pparams[attribute] = self[attribute]
             end
           end
 
-          Parameters.new(pparams, permitted: true)
+          with(params: pparams, permitted: true)
         end
 
+        # Redefines RubyNext::Core::Data instance methods
         def to_h
-          raise UnpermittedParameterError, parameters.keys unless @permitted
+          raise UnpermittedParameterError, params.keys unless permitted
 
-          parameters.transform_values { |_1| process_nested(_1, :to_h) }
+          params.transform_values { |_1| process_nested(_1, :to_h) }
+        end
+
+        def hash
+          @attributes.to_h.hash
+        end
+
+        def with(params:, permitted: false)
+          self.class.new(params, permitted)
         end
 
         private
 
         def nested_attribute(attribute)
           if attribute.is_a? Hash
-            Parameters.new(attribute)
+            with(params: attribute)
           elsif attribute.is_a?(Array) && attribute[0].is_a?(Hash)
-            attribute.map { |_1| Parameters.new(_1) }
+            attribute.map { |it| with(params: it) }
           else
             attribute
           end
@@ -96,8 +98,10 @@ module ActiveFunction
             attribute
           end
         end
+      end
 
-        attr_reader :parameters
+      def params
+        @_params ||= Parameters.new(@request, false)
       end
     end
   end

data/lib/.rbnext/3.0/active_function/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveFunction
+  class SuperBase
+    attr_reader :action_name, :request, :response
+
+    def initialize(action_name, request, response)
+      @action_name = action_name
+      @request     = request
+      @response    = response
+    end
+
+    def dispatch
+      process(action_name)
+
+      @response.commit! unless performed?
+
+      @response.to_h
+    end
+
+    def process(action) ;  public_send(action); end
+
+    private def performed? ;  @response.committed?; end
+  end
+
+  class Base < SuperBase
+    Error = Class.new(StandardError)
+
+    # @param [String, Symbol] action_name - name of method to call
+    # @param [Hash] request - request params, accessible through `#params` method
+    # @param [Response] response - response object
+    def self.process(action_name, request = {}, response = Response.new)
+      raise ArgumentError, "Action method #{action_name} is not defined" unless method_defined?(action_name)
+
+      new(action_name, request, response).dispatch
+    end
+  end
+end

data/lib/.rbnext/3.0/active_function/functions/response.rb

@@ -2,29 +2,26 @@
 
 module ActiveFunction
   module Functions
-    class Response
-      attr_accessor :status, :headers, :body
+    module Response
+      ActiveFunction.register_plugin :response, self
 
-      def initialize(status: 200, headers: {}, body: nil)
-        @status     = status
-        @headers    = headers
-        @body       = body
-        @committed  = false
-      end
+      class Response < Struct.new(:status, :headers, :body, :committed)
+        def initialize(status: 200, headers: {}, body: nil, committed: false) ;  super(status, headers, body, committed); end
 
-      def to_h
-        {
-          statusCode: status,
-          headers:    headers,
-          body:       body
-        }
-      end
+        def to_h
+          {
+            statusCode: status,
+            headers: headers,
+            body: body
+          }
+        end
 
-      def commit!
-        @committed = true
-      end
+        def commit!
+          self.committed = true
+        end
 
-      def committed? ;  @committed; end
+        alias_method :committed?, :committed
+      end
     end
   end
 end

data/lib/.rbnext/3.0/active_function.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_function_core"
+require "active_function/version"
+require "active_function/base"
+
+RubyNext::Language.setup_gem_load_path(transpile: true)
+
+module ActiveFunction
+  class << self
+    # Configure ActiveFunction.
+    #
+    # @param block [Proc]
+    # @return [void]
+    def config(&block)
+      class_eval(&block)
+      @_plugins.freeze
+      self::Base.freeze
+    end
+
+    def plugins ;  @_plugins ||= {}; end
+
+    # Register plugin.
+    #
+    # @param symbol [Symbol]
+    # @param mod [Module]
+    def register_plugin(symbol, mod)
+      plugins[symbol] = mod
+    end
+
+    # Monkey patch ActiveFunction::Base with provided plugin.
+    #
+    # @param mod [Symbol, Module]
+    # @return [void]
+    def plugin(mod)
+      if mod.is_a? Symbol
+        begin
+          require "active_function/functions/#{mod}"
+          mod = plugins.fetch(mod)
+        rescue LoadError
+          raise ArgumentError, "Unknown plugin #{mod}"
+        end
+      end
+
+      self::Base.include(mod)
+    end
+  end
+
+  plugin :response
+end

data/lib/.rbnext/3.1/active_function/functions/response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveFunction
+  module Functions
+    module Response
+      ActiveFunction.register_plugin :response, self
+
+      class Response < Struct.new(:status, :headers, :body, :committed)
+        def initialize(status: 200, headers: {}, body: nil, committed: false) = super(status, headers, body, committed)
+
+        def to_h
+          {
+            statusCode: status,
+            headers: headers,
+            body: body
+          }
+        end
+
+        def commit!
+          self.committed = true
+        end
+
+        alias_method :committed?, :committed
+      end
+    end
+  end
+end

data/lib/active_function/base.rb

@@ -1,20 +1,38 @@
 # frozen_string_literal: true
 
 module ActiveFunction
-  class Base
-    require "active_function/functions/core"
-    require "active_function/functions/callbacks"
-    require "active_function/functions/strong_parameters"
-    require "active_function/functions/rendering"
-    require "active_function/functions/response"
-
-    include Functions::Core
-    include Functions::Callbacks
-    include Functions::Rendering
-    include Functions::StrongParameters
-
-    def self.process(action_name, request = {}, response = Functions::Response.new)
-      new.dispatch(action_name, request, response)
+  class SuperBase
+    attr_reader :action_name, :request, :response
+
+    def initialize(action_name, request, response)
+      @action_name = action_name
+      @request     = request
+      @response    = response
+    end
+
+    def dispatch
+      process(action_name)
+
+      @response.commit! unless performed?
+
+      @response.to_h
+    end
+
+    def process(action) = public_send(action)
+
+    private def performed? = @response.committed?
+  end
+
+  class Base < SuperBase
+    Error = Class.new(StandardError)
+
+    # @param [String, Symbol] action_name - name of method to call
+    # @param [Hash] request - request params, accessible through `#params` method
+    # @param [Response] response - response object
+    def self.process(action_name, request = {}, response = Response.new)
+      raise ArgumentError, "Action method #{action_name} is not defined" unless method_defined?(action_name)
+
+      new(action_name, request, response).dispatch
     end
   end
 end

data/lib/active_function/functions/callbacks.rb

@@ -1,68 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveFunction
-  class MissingCallbackContext < Error
-    MESSAGE_TEMPLATE = "Missing callback context: %s"
-
-    attr_reader :message
-
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
-
   module Functions
     module Callbacks
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      private
-
-      def process(*)
-        _run_callbacks :before
-
-        super
-
-        _run_callbacks :after
-      end
+      ActiveFunction.register_plugin :callbacks, self
 
-      def _run_callbacks(type)
-        self.class.callbacks[type].each do |callback_method, options|
-          raise MissingCallbackContext, callback_method unless respond_to?(callback_method, true)
-
-          send(callback_method) if _executable?(options)
-        end
-      end
-
-      def _executable?(options)
-        return false if options[:only] && !options[:only].include?(@action_name)
-        return false if options[:if] && !send(options[:if])
-        true
-      end
-
-      module ClassMethods
-        def inherited(subclass)
-          subclass.instance_variable_set(:@__callbacks, @__callbacks)
-        end
-
-        def before_action(method, options = {})
-          set_callback :before, method, options
-        end
-
-        def after_action(method, options = {})
-          set_callback :after, method, options
-        end
-
-        def set_callback(type, method, options = {})
-          callbacks[type][method] = options
-        end
-
-        def callbacks
-          @__callbacks ||= {before: {}, after: {}}
-
-          @__callbacks
-        end
+      def self.included(base)
+        base.include ActiveFunctionCore::Plugins::Hooks
+        base.define_hooks_for :process, name: :action
+        base.set_callback_options only: ->(args, context:) { args.to_set === context.action_name }
       end
     end
   end

data/lib/active_function/functions/rendering.rb

@@ -3,18 +3,22 @@
 require "json"
 
 module ActiveFunction
-  class DoubleRenderError < Error
-    MESSAGE_TEMPLATE = "#render was called multiple times in action: %s"
+  module Functions
+    module Rendering
+      ActiveFunction.register_plugin :rendering, self
 
-    attr_reader :message
+      Error = Class.new(StandardError)
 
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
+      class DoubleRenderError < Error
+        MESSAGE_TEMPLATE = "#render was called multiple times in action: %s"
+
+        attr_reader :message
+
+        def initialize(context)
+          @message = MESSAGE_TEMPLATE % context
+        end
+      end
 
-  module Functions
-    module Rendering
       DEFAULT_HEADER = {"Content-Type" => "application/json"}.freeze
 
       def render(status: 200, json: {}, head: {})

data/lib/active_function/functions/response.rb

@@ -2,29 +2,26 @@
 
 module ActiveFunction
   module Functions
-    class Response
-      attr_accessor :status, :headers, :body
+    module Response
+      ActiveFunction.register_plugin :response, self
 
-      def initialize(status: 200, headers: {}, body: nil)
-        @status     = status
-        @headers    = headers
-        @body       = body
-        @committed  = false
-      end
+      class Response < Struct.new(:status, :headers, :body, :committed)
+        def initialize(status: 200, headers: {}, body: nil, committed: false) = super(status, headers, body, committed)
 
-      def to_h
-        {
-          statusCode: status,
-          headers:    headers,
-          body:       body
-        }
-      end
+        def to_h
+          {
+            statusCode: status,
+            headers:,
+            body:
+          }
+        end
 
-      def commit!
-        @committed = true
-      end
+        def commit!
+          self.committed = true
+        end
 
-      def committed? = @committed
+        alias_method :committed?, :committed
+      end
     end
   end
 end

data/lib/active_function/functions/strong_parameters.rb

@@ -3,52 +3,45 @@
 require "forwardable"
 
 module ActiveFunction
-  class ParameterMissingError < Error
-    MESSAGE_TEMPLATE = "Missing parameter: %s"
+  module Functions
+    module StrongParameters
+      ActiveFunction.register_plugin :strong_parameters, self
 
-    attr_reader :message
+      Error = Class.new(StandardError)
 
-    def initialize(param)
-      MESSAGE_TEMPLATE % param
-    end
-  end
+      class Parameters < Data.define(:params, :permitted)
+        class ParameterMissingError < Error
+          MESSAGE_TEMPLATE = "Missing parameter: %s"
 
-  class UnpermittedParameterError < Error
-    MESSAGE_TEMPLATE = "Unpermitted parameter: %s"
+          attr_reader :message
 
-    attr_reader :message
-
-    def initialize(param)
-      MESSAGE_TEMPLATE % param
-    end
-  end
+          def initialize(param)
+            MESSAGE_TEMPLATE % param
+          end
+        end
 
-  module Functions
-    module StrongParameters
-      def params
-        @_params ||= Parameters.new(@request)
-      end
+        class UnpermittedParameterError < Error
+          MESSAGE_TEMPLATE = "Unpermitted parameter: %s"
 
-      class Parameters
-        extend Forwardable
-        def_delegators :@parameters, :each, :map
-        include Enumerable
+          attr_reader :message
 
-        def initialize(parameters, permitted: false)
-          @parameters = parameters
-          @permitted  = permitted
+          def initialize(param)
+            MESSAGE_TEMPLATE % param
+          end
         end
 
+        protected :params
+
         def [](attribute)
-          nested_attribute(parameters[attribute])
+          nested_attribute(params[attribute])
         end
 
         def require(attribute)
-          value = self[attribute]
-
-          raise ParameterMissingError, attribute if value.nil?
-
-          value
+          if (value = self[attribute])
+            value
+          else
+            raise ParameterMissingError, attribute
+          end
         end
 
         def permit(*attributes)
@@ -60,28 +53,37 @@ module ActiveFunction
                 pparams[k] = process_nested(self[k], :permit, v)
               end
             else
-              next unless parameters.key?(attribute)
+              next unless params.key?(attribute)
 
               pparams[attribute] = self[attribute]
             end
           end
 
-          Parameters.new(pparams, permitted: true)
+          with(params: pparams, permitted: true)
         end
 
+        # Redefines RubyNext::Core::Data instance methods
         def to_h
-          raise UnpermittedParameterError, parameters.keys unless @permitted
+          raise UnpermittedParameterError, params.keys unless permitted
 
-          parameters.transform_values { process_nested(_1, :to_h) }
+          params.transform_values { process_nested(_1, :to_h) }
+        end
+
+        def hash
+          @attributes.to_h.hash
+        end
+
+        def with(params:, permitted: false)
+          self.class.new(params, permitted)
         end
 
         private
 
         def nested_attribute(attribute)
           if attribute.is_a? Hash
-            Parameters.new(attribute)
+            with(params: attribute)
           elsif attribute.is_a?(Array) && attribute[0].is_a?(Hash)
-            attribute.map { Parameters.new(_1) }
+            attribute.map { |it| with(params: it) }
           else
             attribute
           end
@@ -96,8 +98,10 @@ module ActiveFunction
             attribute
           end
         end
+      end
 
-        attr_reader :parameters
+      def params
+        @_params ||= Parameters.new(@request, false)
       end
     end
   end

data/lib/active_function/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveFunction
-  VERSION = "0.3.5"
+  VERSION = "0.4.0"
 end

data/lib/active_function.rb

@@ -1,12 +1,50 @@
 # frozen_string_literal: true
 
 require "active_function_core"
+require "active_function/version"
+require "active_function/base"
 
 RubyNext::Language.setup_gem_load_path(transpile: true)
 
 module ActiveFunction
-  class Error < StandardError; end
+  class << self
+    # Configure ActiveFunction.
+    #
+    # @param block [Proc]
+    # @return [void]
+    def config(&block)
+      class_eval(&block)
+      @_plugins.freeze
+      self::Base.freeze
+    end
 
-  require "active_function/version"
-  require "active_function/base"
+    def plugins = @_plugins ||= {}
+
+    # Register plugin.
+    #
+    # @param symbol [Symbol]
+    # @param mod [Module]
+    def register_plugin(symbol, mod)
+      plugins[symbol] = mod
+    end
+
+    # Monkey patch ActiveFunction::Base with provided plugin.
+    #
+    # @param mod [Symbol, Module]
+    # @return [void]
+    def plugin(mod)
+      if mod.is_a? Symbol
+        begin
+          require "active_function/functions/#{mod}"
+          mod = plugins.fetch(mod)
+        rescue LoadError
+          raise ArgumentError, "Unknown plugin #{mod}"
+        end
+      end
+
+      self::Base.include(mod)
+    end
+  end
+
+  plugin :response
 end

metadata

@@ -1,76 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: activefunction
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Nerbyk
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-20 00:00:00.000000000 Z
+date: 2024-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activefunction-core
   requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.0.1
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 5.15.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.15.0
-- !ruby/object:Gem::Dependency
-  name: minitest-reporters
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.3
-  type: :development
+        version: 0.2.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.3
-description: "\n    rails/action_controller like gem which provides lightweight callbacks,\n
-  \   strong parameters & rendering features. It's designed to be used with\n    AWS
-  Lambda functions, but can be also used with any Ruby application.\n\n    Implemented
-  with some of ruby 3.x features, but also supports\n    ruby 2.6.x thanks to RubyNext
-  transpiler. Type safety achieved\n    by RBS and Steep.\n  "
+        version: 0.2.2
+description: "\n    ActiveFunction is a collection of gems designed to be used with
+  Function as a Service (FaaS) computing instances. Inspired by aws-sdk v3 gem structure
+  and rails/activesupport.\n\n    Features:\n    - Ruby Version Compatibility: Implemented
+  with most of Ruby 3.2+ features, with support for Ruby versions >= 2.6 through the
+  RubyNext transpiler (CI'ed).\n    - Type Safety: Achieves type safety through the
+  use of RBS and Steep (CI'ed) [Note: disabled due to the presence of Ruby::UnsupportedSyntax
+  errors].\n    - Plugins System: Provides a simple Plugin system inspired by Polishing
+  Ruby Programming by Jeremy Evans to load gem plugins and self-defined plugins.\n
+  \   - Gem Collection: Offers a collection of gems designed for use within ActiveFunction
+  or as standalone components.\n  "
 email:
 - danil.maximov2000@gmail.com
 executables: []
@@ -86,12 +49,13 @@ files:
 - bin/ruby-next
 - bin/setup
 - lib/.rbnext/2.7/active_function/functions/strong_parameters.rb
-- lib/.rbnext/3.0/active_function/functions/core.rb
+- lib/.rbnext/3.0/active_function.rb
+- lib/.rbnext/3.0/active_function/base.rb
 - lib/.rbnext/3.0/active_function/functions/response.rb
+- lib/.rbnext/3.1/active_function/functions/response.rb
 - lib/active_function.rb
 - lib/active_function/base.rb
 - lib/active_function/functions/callbacks.rb
-- lib/active_function/functions/core.rb
 - lib/active_function/functions/rendering.rb
 - lib/active_function/functions/response.rb
 - lib/active_function/functions/strong_parameters.rb
@@ -105,7 +69,7 @@ metadata:
   homepage_uri: https://github.com/DanilMaximov/activefunction
   source_code_uri: https://github.com/DanilMaximov/activefunction
   changelog_uri: https://github.com/DanilMaximov/activefunction/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -120,9 +84,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.5.4
+signing_key: 
 specification_version: 4
-summary: rails/action_controller like gem which provides callbacks, strong parameters
-  & rendering features.
+summary: Playground gem for Ruby 3.2+ features and more, designed for FaaS computing
+  instances, but mostly used for experiments.
 test_files: []

data/lib/.rbnext/3.0/active_function/functions/core.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveFunction
-  class MissingRouteMethod < Error
-    MESSAGE_TEMPLATE = "Missing function route: %s"
-
-    attr_reader :message
-
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
-
-  class NotRenderedError < Error
-    MESSAGE_TEMPLATE = "render was not called: %s"
-
-    attr_reader :message
-
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
-
-  module Functions
-    module Core
-      attr_reader :action_name, :request, :response
-
-      def dispatch(action_name, request, response)
-        @action_name = action_name
-        @request     = request
-        @response    = response
-
-        raise MissingRouteMethod, @action_name unless respond_to?(action_name)
-
-        process(@action_name)
-
-        raise NotRenderedError, @action_name unless performed?
-
-        @response.to_h
-      end
-
-      private
-
-      def process(action) ;  public_send(action); end
-
-      def performed? ;  @response.committed?; end
-    end
-  end
-end

data/lib/active_function/functions/core.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveFunction
-  class MissingRouteMethod < Error
-    MESSAGE_TEMPLATE = "Missing function route: %s"
-
-    attr_reader :message
-
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
-
-  class NotRenderedError < Error
-    MESSAGE_TEMPLATE = "render was not called: %s"
-
-    attr_reader :message
-
-    def initialize(context)
-      @message = MESSAGE_TEMPLATE % context
-    end
-  end
-
-  module Functions
-    module Core
-      attr_reader :action_name, :request, :response
-
-      def dispatch(action_name, request, response)
-        @action_name = action_name
-        @request     = request
-        @response    = response
-
-        raise MissingRouteMethod, @action_name unless respond_to?(action_name)
-
-        process(@action_name)
-
-        raise NotRenderedError, @action_name unless performed?
-
-        @response.to_h
-      end
-
-      private
-
-      def process(action) = public_send(action)
-
-      def performed? = @response.committed?
-    end
-  end
-end