stroma 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27a735955a54fe9ea248a066afbdf10edaa55bc903b83574e84d405fb01fa020
-  data.tar.gz: e63528c3ac53e3a32a757493745dac02ee46958a486b184cda3d3d4fc4463c6f
+  metadata.gz: 73bb516679b54a0f43b33efffc0719d76211dda900024976ef6398e0b0911564
+  data.tar.gz: 34301bc64ab57e7f5f3b0fbf9bd9d71d3a23887d83dd652706b5184d4d6237a4
 SHA512:
-  metadata.gz: 19f5d6847f269dfe65070f267426b68ec7a61b72cdfde478ec3542ed9d75a232465c32412eab4bb8d432e4fb648962b309a5d7dc450ec2b14ce329506a86e55c
-  data.tar.gz: fc4c1300028fa543f2d097d70dcba472644837579a73d58235e51215ac7792d1ce0a1e423f3daac97dac1bcbcad0ab48642f3b63ae663dade353e505bd59466d
+  metadata.gz: 2ee5cfa5a9f5f54aa8cb2b713a29cf1802abb6b98cd70f2e89eb3697652ce631e4f77017c0c8207309877e7e2289275caeabcda123d48cebd1527a0e397185d8
+  data.tar.gz: d8f0362ad411eea72508423e3a931e360924c996d88c011924a6ca0d483d45ddbdbd83bd590fc90cc5b466785bcac232c853a9dcc40fc8eefbfb154b90444180

data/README.md

@@ -39,32 +39,27 @@ Building modular DSLs shouldn't require reinventing the wheel. Stroma provides a
 Stroma is a foundation for library authors building DSL-driven frameworks (service objects, form objects, decorators, etc.).
 
 **Core lifecycle:**
-1. **Register** - Define DSL modules at boot time via `Stroma::Registry`
-2. **Compose** - Classes include `Stroma::DSL` to gain all registered modules automatically
-3. **Extend** (optional) - Users can add cross-cutting logic via `before`/`after` hooks
+1. **Define** - Create a Matrix with DSL modules at boot time
+2. **Include** - Classes include the matrix's DSL to gain all modules
+3. **Extend** (optional) - Add cross-cutting logic via `before`/`after` hooks
 
 ## 🚀 Quick Start
 
 ### Installation
 
 ```ruby
-spec.add_dependency "stroma", ">= 0.3"
+spec.add_dependency "stroma", ">= 0.4"
 ```
 
 ### Define your library's DSL
 
 ```ruby
 module MyLib
-  module DSL
-    # Register DSL modules at load time
-    Stroma::Registry.register(:inputs, MyLib::Inputs::DSL)
-    Stroma::Registry.register(:actions, MyLib::Actions::DSL)
-    Stroma::Registry.finalize!
-
-    def self.included(base)
-      base.include(Stroma::DSL)
-    end
+  STROMA = Stroma::Matrix.define(:my_lib) do
+    register :inputs, MyLib::Inputs::DSL
+    register :actions, MyLib::Actions::DSL
   end
+  private_constant :STROMA
 end
 ```
 
@@ -73,7 +68,7 @@ end
 ```ruby
 module MyLib
   class Base
-    include MyLib::DSL
+    include STROMA.dsl
   end
 end
 ```

data/lib/stroma/dsl/generator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Stroma
+  module DSL
+    # Generates a DSL module scoped to a specific Matrix.
+    #
+    # ## Purpose
+    #
+    # Creates a module that:
+    # - Stores matrix reference on the module itself
+    # - Defines ClassMethods for service classes
+    # - Handles inheritance with state duplication
+    #
+    # Memory model:
+    # - Matrix owns @dsl_module (generated once, cached)
+    # - ServiceClass gets @stroma_matrix (same reference)
+    # - ServiceClass gets @stroma (unique State per class)
+    #
+    # ## Usage
+    #
+    # ```ruby
+    # # Called internally by Matrix#dsl
+    # dsl_module = Stroma::DSL::Generator.call(matrix)
+    #
+    # # The generated module is included in base classes
+    # class MyLib::Base
+    #   include dsl_module
+    # end
+    # ```
+    #
+    # ## Integration
+    #
+    # Called by Matrix#dsl to generate the DSL module.
+    # Generated module includes all registered extensions.
+    class Generator
+      class << self
+        # Generates a DSL module for the given matrix.
+        #
+        # @param matrix [Matrix] The matrix to generate DSL for
+        # @return [Module] The generated DSL module
+        def call(matrix)
+          new(matrix).generate
+        end
+      end
+
+      # Creates a new generator for the given matrix.
+      #
+      # @param matrix [Matrix] The matrix to generate DSL for
+      def initialize(matrix)
+        @matrix = matrix
+      end
+
+      # Generates the DSL module.
+      #
+      # Creates a module with ClassMethods that provides:
+      # - stroma_matrix accessor for matrix reference
+      # - stroma accessor for per-class state
+      # - inherited hook for state duplication
+      # - extensions DSL for registering hooks
+      #
+      # @return [Module] The generated DSL module
+      def generate # rubocop:disable Metrics/MethodLength
+        matrix = @matrix
+        class_methods = build_class_methods
+
+        Module.new do
+          @stroma_matrix = matrix
+
+          class << self
+            attr_reader :stroma_matrix
+
+            def included(base)
+              mtx = stroma_matrix
+              base.extend(self::ClassMethods)
+              base.instance_variable_set(:@stroma_matrix, mtx)
+              base.instance_variable_set(:@stroma, State.new)
+
+              mtx.entries.each { |entry| base.include(entry.extension) }
+            end
+          end
+
+          const_set(:ClassMethods, class_methods)
+        end
+      end
+
+      private
+
+      # Builds the ClassMethods module.
+      #
+      # @return [Module] The ClassMethods module
+      def build_class_methods # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        Module.new do
+          attr_reader :stroma_matrix
+
+          def stroma
+            @stroma ||= State.new
+          end
+
+          def inherited(child)
+            super
+            child.instance_variable_set(:@stroma_matrix, stroma_matrix)
+            child.instance_variable_set(:@stroma, stroma.dup)
+            Hooks::Applier.apply!(child, child.stroma.hooks, stroma_matrix)
+          end
+
+          private
+
+          def extensions(&block)
+            @stroma_hooks_factory ||= Hooks::Factory.new(stroma.hooks, stroma_matrix)
+            @stroma_hooks_factory.instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stroma/hooks/applier.rb

@@ -6,31 +6,46 @@ module Stroma
     #
     # ## Purpose
     #
-    # Iterates through all registered DSL modules and includes corresponding
-    # before/after hooks in the target class. For each registry entry,
-    # before hooks are included first, then after hooks.
+    # Includes hook extension modules into target class.
+    # Maintains order based on matrix registry entries.
+    # For each entry: before hooks first, then after hooks.
     #
     # ## Usage
     #
     # ```ruby
-    # applier = Stroma::Hooks::Applier.new(ChildService, hooks)
+    # # Called internally during class inheritance
+    # applier = Stroma::Hooks::Applier.new(ChildService, hooks, matrix)
     # applier.apply!
-    # # ChildService now includes all hook modules
     # ```
     #
     # ## Integration
     #
-    # Called by Stroma::DSL.inherited after duplicating
-    # parent's configuration. Uses Registry.entries to determine
-    # hook application order.
+    # Called by DSL::Generator's inherited hook.
+    # Creates a temporary instance that is garbage collected after apply!.
     class Applier
+      class << self
+        # Applies all registered hooks to the target class.
+        #
+        # Convenience class method that creates an applier and applies hooks.
+        #
+        # @param target_class [Class] The class to apply hooks to
+        # @param hooks [Collection] The hooks collection to apply
+        # @param matrix [Matrix] The matrix providing registry entries
+        # @return [void]
+        def apply!(target_class, hooks, matrix)
+          new(target_class, hooks, matrix).apply!
+        end
+      end
+
       # Creates a new applier for applying hooks to a class.
       #
       # @param target_class [Class] The class to apply hooks to
       # @param hooks [Collection] The hooks collection to apply
-      def initialize(target_class, hooks)
+      # @param matrix [Matrix] The matrix providing registry entries
+      def initialize(target_class, hooks, matrix)
         @target_class = target_class
         @hooks = hooks
+        @matrix = matrix
       end
 
       # Applies all registered hooks to the target class.
@@ -39,21 +54,12 @@ module Stroma
       # then after hooks. Does nothing if hooks collection is empty.
       #
       # @return [void]
-      #
-      # @example
-      #   applier.apply!
-      #   # Target class now includes all extension modules
       def apply!
         return if @hooks.empty?
 
-        Registry.entries.each do |entry|
-          @hooks.before(entry.key).each do |hook|
-            @target_class.include(hook.extension)
-          end
-
-          @hooks.after(entry.key).each do |hook|
-            @target_class.include(hook.extension)
-          end
+        @matrix.entries.each do |entry|
+          @hooks.before(entry.key).each { |hook| @target_class.include(hook.extension) }
+          @hooks.after(entry.key).each { |hook| @target_class.include(hook.extension) }
         end
       end
     end

data/lib/stroma/hooks/factory.rb

@@ -6,21 +6,16 @@ module Stroma
     #
     # ## Purpose
     #
-    # Provides the `before` and `after` methods used within the extensions
-    # block to register hooks. Validates that target keys exist in Registry
-    # before adding hooks.
+    # Provides before/after DSL methods for hook registration.
+    # Validates target keys against the matrix's registry.
+    # Delegates to Hooks::Collection for storage.
     #
     # ## Usage
     #
-    # Used within `extensions` block in classes that include Stroma::DSL:
-    #
     # ```ruby
-    # # Library Base class (includes Stroma::DSL via library's DSL module)
-    # class MyLib::Base
-    #   include MyLib::DSL  # MyLib::DSL includes Stroma::DSL
-    #
+    # class MyService < MyLib::Base
     #   extensions do
-    #     before :actions, ValidationModule
+    #     before :actions, ValidationModule, AuthModule
     #     after :outputs, LoggingModule
     #   end
     # end
@@ -28,15 +23,16 @@ module Stroma
     #
     # ## Integration
     #
-    # Created by DSL.extensions method and receives instance_eval of the block.
-    # Validates keys against Registry.keys and raises UnknownHookTarget
-    # for invalid keys.
+    # Created by DSL::Generator's extensions method.
+    # Cached as @stroma_hooks_factory on each service class.
     class Factory
       # Creates a new factory for registering hooks.
       #
       # @param hooks [Collection] The hooks collection to add to
-      def initialize(hooks)
+      # @param matrix [Matrix] The matrix providing valid keys
+      def initialize(hooks, matrix)
         @hooks = hooks
+        @matrix = matrix
       end
 
       # Registers one or more before hooks for a target key.
@@ -44,6 +40,7 @@ module Stroma
       # @param key [Symbol] The registry key to hook before
       # @param extensions [Array<Module>] Extension modules to include
       # @raise [Exceptions::UnknownHookTarget] If key is not registered
+      # @return [void]
       #
       # @example
       #   before :actions, ValidationModule, AuthorizationModule
@@ -57,6 +54,7 @@ module Stroma
       # @param key [Symbol] The registry key to hook after
       # @param extensions [Array<Module>] Extension modules to include
       # @raise [Exceptions::UnknownHookTarget] If key is not registered
+      # @return [void]
       #
       # @example
       #   after :outputs, LoggingModule, AuditModule
@@ -67,16 +65,17 @@ module Stroma
 
       private
 
-      # Validates that the key exists in the Registry.
+      # Validates that the key exists in the matrix's registry.
       #
       # @param key [Symbol] The key to validate
       # @raise [Exceptions::UnknownHookTarget] If key is not registered
+      # @return [void]
       def validate_key!(key)
-        return if Registry.key?(key)
+        return if @matrix.key?(key)
 
         raise Exceptions::UnknownHookTarget,
-              "Unknown hook target: #{key.inspect}. " \
-              "Valid keys: #{Registry.keys.map(&:inspect).join(', ')}"
+              "Unknown hook target #{key.inspect} for #{@matrix.name.inspect}. " \
+              "Valid: #{@matrix.keys.map(&:inspect).join(', ')}"
       end
     end
   end

data/lib/stroma/matrix.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Stroma
+  # Main entry point for libraries using Stroma.
+  #
+  # ## Purpose
+  #
+  # Creates an isolated registry and generates a scoped DSL module.
+  # Each matrix has its own registry - no conflicts with other libraries.
+  #
+  # Lifecycle:
+  # - Boot time: Matrix.define creates Registry, registers extensions
+  # - Boot time: finalize! freezes registry, dsl generates Module
+  # - Boot time: freeze makes Matrix immutable
+  # - Runtime: All structures frozen, no allocations
+  #
+  # ## Usage
+  #
+  # ```ruby
+  # module MyLib
+  #   STROMA = Stroma::Matrix.define(:my_lib) do
+  #     register :inputs, Inputs::DSL
+  #     register :outputs, Outputs::DSL
+  #   end
+  #   private_constant :STROMA
+  # end
+  #
+  # class MyLib::Base
+  #   include MyLib::STROMA.dsl
+  # end
+  # ```
+  #
+  # ## Integration
+  #
+  # Stored as a constant in the library's namespace.
+  # Owns the Registry and generates DSL module via DSL::Generator.
+  class Matrix
+    class << self
+      # Defines a new Matrix with given name.
+      #
+      # Preferred way to create a Matrix. Semantically indicates
+      # that we are defining an immutable DSL scope.
+      #
+      # @param name [Symbol, String] The matrix identifier
+      # @yield Block for registering DSL modules
+      # @return [Matrix] The frozen matrix instance
+      #
+      # @example
+      #   STROMA = Stroma::Matrix.define(:my_lib) do
+      #     register :inputs, Inputs::DSL
+      #     register :outputs, Outputs::DSL
+      #   end
+      def define(name, &block)
+        new(name, &block)
+      end
+    end
+
+    # @!attribute [r] name
+    #   @return [Symbol] The matrix identifier
+    # @!attribute [r] registry
+    #   @return [Registry] The registry of DSL modules
+    # @!attribute [r] dsl
+    #   @return [Module] The DSL module to include in base classes
+    attr_reader :name, :registry, :dsl
+
+    # Creates a new Matrix with given name.
+    #
+    # Evaluates the block to register DSL modules, then finalizes
+    # the registry and freezes the matrix.
+    #
+    # @param name [Symbol, String] The matrix identifier
+    # @yield Block for registering DSL modules
+    def initialize(name, &block)
+      @name = name.to_sym
+      @registry = Registry.new(@name)
+
+      instance_eval(&block) if block_given?
+      @registry.finalize!
+      @dsl = DSL::Generator.call(self)
+      freeze
+    end
+
+    # Registers a DSL module with the given key.
+    #
+    # @param key [Symbol] The registry key
+    # @param extension [Module] The DSL module to register
+    # @return [void]
+    def register(key, extension)
+      @registry.register(key, extension)
+    end
+
+    # Returns all registered entries.
+    #
+    # @return [Array<Entry>] The registry entries
+    def entries
+      registry.entries
+    end
+
+    # Returns all registered keys.
+    #
+    # @return [Array<Symbol>] The registry keys
+    def keys
+      registry.keys
+    end
+
+    # Checks if a key is registered.
+    #
+    # @param key [Symbol] The key to check
+    # @return [Boolean] true if the key is registered
+    def key?(key)
+      registry.key?(key)
+    end
+  end
+end

data/lib/stroma/registry.rb

@@ -1,63 +1,71 @@
 # frozen_string_literal: true
 
 module Stroma
-  # Manages global registration of DSL modules for Stroma.
+  # Manages registration of DSL modules for a specific matrix.
   #
   # ## Purpose
   #
-  # Singleton registry that stores all DSL modules that will be included
-  # in service classes. Implements two-phase lifecycle: registration
-  # followed by finalization.
+  # Stores DSL module entries with their keys.
+  # Implements two-phase lifecycle: registration → finalization.
+  # Each Matrix has its own Registry - no global state.
   #
   # ## Usage
   #
   # ```ruby
-  # # During gem initialization:
-  # Stroma::Registry.register(:inputs, Inputs::DSL)
-  # Stroma::Registry.register(:outputs, Outputs::DSL)
-  # Stroma::Registry.finalize!
+  # registry = Stroma::Registry.new(:my_lib)
+  # registry.register(:inputs, Inputs::DSL)
+  # registry.register(:outputs, Outputs::DSL)
+  # registry.finalize!
   #
-  # # After finalization:
-  # Stroma::Registry.keys       # => [:inputs, :outputs]
-  # Stroma::Registry.key?(:inputs)  # => true
+  # registry.keys      # => [:inputs, :outputs]
+  # registry.key?(:inputs)  # => true
   # ```
   #
   # ## Integration
   #
-  # Used by Stroma::DSL to include all registered modules in service classes.
-  # Used by Stroma::Hooks::Factory to validate hook target keys.
-  #
-  # ## Thread Safety
-  #
-  # Registration must occur during single-threaded boot phase.
-  # After finalization, all read operations are thread-safe.
+  # Created and owned by Matrix.
+  # Entries are accessed via Matrix#entries and Matrix#keys.
   class Registry
-    include Singleton
+    # @!attribute [r] matrix_name
+    #   @return [Symbol] The name of the owning matrix
+    attr_reader :matrix_name
 
-    class << self
-      delegate :register,
-               :finalize!,
-               :entries,
-               :keys,
-               :key?,
-               to: :instance
-    end
-
-    def initialize
+    # Creates a new registry for the given matrix.
+    #
+    # @param matrix_name [Symbol, String] The matrix identifier
+    def initialize(matrix_name)
+      @matrix_name = matrix_name.to_sym
       @entries = []
       @finalized = false
     end
 
+    # Registers a DSL module with the given key.
+    #
+    # @param key [Symbol, String] The registry key
+    # @param extension [Module] The DSL module to register
+    # @raise [Exceptions::RegistryFrozen] If registry is finalized
+    # @raise [Exceptions::KeyAlreadyRegistered] If key already exists
+    # @return [void]
     def register(key, extension)
-      raise Exceptions::RegistryFrozen, "Registry is finalized" if @finalized
+      if @finalized
+        raise Exceptions::RegistryFrozen,
+              "Registry for #{@matrix_name.inspect} is finalized"
+      end
 
+      key = key.to_sym
       if @entries.any? { |e| e.key == key }
-        raise Exceptions::KeyAlreadyRegistered, "Key #{key.inspect} already registered"
+        raise Exceptions::KeyAlreadyRegistered,
+              "Key #{key.inspect} already registered in #{@matrix_name.inspect}"
       end
 
       @entries << Entry.new(key:, extension:)
     end
 
+    # Finalizes the registry, preventing further registrations.
+    #
+    # Idempotent - can be called multiple times safely.
+    #
+    # @return [void]
     def finalize!
       return if @finalized
 
@@ -65,28 +73,45 @@ module Stroma
       @finalized = true
     end
 
+    # Returns all registered entries.
+    #
+    # @raise [Exceptions::RegistryNotFinalized] If not finalized
+    # @return [Array<Entry>] The registry entries
     def entries
       ensure_finalized!
       @entries
     end
 
+    # Returns all registered keys.
+    #
+    # @raise [Exceptions::RegistryNotFinalized] If not finalized
+    # @return [Array<Symbol>] The registry keys
     def keys
       ensure_finalized!
       @entries.map(&:key)
     end
 
+    # Checks if a key is registered.
+    #
+    # @param key [Symbol, String] The key to check
+    # @raise [Exceptions::RegistryNotFinalized] If not finalized
+    # @return [Boolean] true if the key is registered
     def key?(key)
       ensure_finalized!
-      @entries.any? { |e| e.key == key }
+      @entries.any? { |e| e.key == key.to_sym }
     end
 
     private
 
+    # Ensures the registry is finalized.
+    #
+    # @raise [Exceptions::RegistryNotFinalized] If not finalized
+    # @return [void]
     def ensure_finalized!
       return if @finalized
 
       raise Exceptions::RegistryNotFinalized,
-            "Registry not finalized. Call Stroma::Registry.finalize! after registration."
+            "Registry for #{@matrix_name.inspect} not finalized"
     end
   end
 end

data/lib/stroma/version.rb

@@ -3,7 +3,7 @@
 module Stroma
   module VERSION
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
     PRE = nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stroma
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Anton Sokolov
@@ -132,7 +132,7 @@ files:
 - README.md
 - Rakefile
 - lib/stroma.rb
-- lib/stroma/dsl.rb
+- lib/stroma/dsl/generator.rb
 - lib/stroma/engine.rb
 - lib/stroma/entry.rb
 - lib/stroma/exceptions/base.rb
@@ -145,6 +145,7 @@ files:
 - lib/stroma/hooks/collection.rb
 - lib/stroma/hooks/factory.rb
 - lib/stroma/hooks/hook.rb
+- lib/stroma/matrix.rb
 - lib/stroma/registry.rb
 - lib/stroma/settings/collection.rb
 - lib/stroma/settings/registry_settings.rb
@@ -173,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Foundation for building modular, extensible DSLs
 test_files: []

data/lib/stroma/dsl.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Stroma
-  # Main integration point between Stroma and service classes.
-  #
-  # ## Purpose
-  #
-  # Module that provides the core Stroma functionality to service classes:
-  # - Includes all registered DSL modules
-  # - Provides extensions block for hook registration
-  # - Handles inheritance with proper state copying
-  #
-  # ## Usage
-  #
-  # Library authors create a DSL module that includes Stroma::DSL:
-  #
-  # ```ruby
-  # module MyLib::DSL
-  #   def self.included(base)
-  #     base.include(Stroma::DSL)
-  #   end
-  # end
-  #
-  # class MyLib::Base
-  #   include MyLib::DSL
-  #
-  #   extensions do
-  #     before :actions, MyExtension
-  #   end
-  # end
-  # ```
-  #
-  # ## Extension Settings Access
-  #
-  # Extensions access their settings through the stroma.settings hierarchy:
-  #
-  # ```ruby
-  # # In ClassMethods:
-  # stroma.settings[:actions][:authorization][:method_name] = :authorize
-  #
-  # # In InstanceMethods:
-  # self.class.stroma.settings[:actions][:authorization][:method_name]
-  # ```
-  #
-  # ## Integration
-  #
-  # Included by service classes that want Stroma hook functionality.
-  # Provides ClassMethods with: stroma, inherited, extensions.
-  module DSL
-    def self.included(base)
-      base.extend(ClassMethods)
-
-      Registry.entries.each do |entry|
-        base.include(entry.extension)
-      end
-    end
-
-    # Class-level methods for Stroma integration.
-    #
-    # ## Purpose
-    #
-    # Provides access to Stroma state and hooks DSL at the class level.
-    # Handles proper duplication during inheritance.
-    #
-    # ## Key Methods
-    #
-    # - `stroma` - Access the State container
-    # - `inherited` - Copy state to child classes
-    # - `extensions` - DSL block for hook registration
-    module ClassMethods
-      def self.extended(base)
-        base.instance_variable_set(:@stroma, State.new)
-      end
-
-      # Handles inheritance by duplicating Stroma state.
-      #
-      # Creates an independent copy of hooks and settings for the child class,
-      # then applies all registered hooks to the child.
-      #
-      # @param child [Class] The child class being created
-      # @return [void]
-      def inherited(child)
-        super
-
-        child.instance_variable_set(:@stroma, stroma.dup)
-
-        Hooks::Applier.new(child, child.stroma.hooks).apply!
-      end
-
-      # Returns the Stroma state for this service class.
-      #
-      # @return [State] The Stroma state container
-      #
-      # @example Accessing hooks
-      #   stroma.hooks.before(:actions)
-      #
-      # @example Accessing settings
-      #   stroma.settings[:actions][:authorization][:method_name]
-      def stroma
-        @stroma ||= State.new
-      end
-
-      private
-
-      # DSL block for registering hooks.
-      #
-      # Evaluates the block in the context of a Hooks::Factory,
-      # allowing before/after hook registration.
-      #
-      # @yield Block with before/after DSL calls
-      # @return [void]
-      #
-      # @example
-      #   extensions do
-      #     before :actions, AuthorizationExtension
-      #     after :outputs, LoggingExtension
-      #   end
-      def extensions(&block)
-        @stroma_hooks_factory ||= Hooks::Factory.new(stroma.hooks)
-        @stroma_hooks_factory.instance_eval(&block)
-      end
-    end
-  end
-end