musa-dsl 0.30.2 → 0.41.0

data/lib/musa-dsl/core-ext/arrayfy.rb

@@ -1,8 +1,87 @@
+require_relative 'extension'
 require_relative 'deep-copy'
 
 module Musa
   module Extension
+    # Refinement that converts any object to an array, with optional repetition and defaults.
+    #
+    # This refinement is essential for normalizing parameters in the DSL, allowing users
+    # to provide either single values or arrays and have them processed uniformly.
+    #
+    # ## Core Behavior
+    #
+    # - **Object**: Wraps in array; nil becomes []
+    # - **Array**: Returns clone or cycles to requested size
+    # - **size parameter**: Repeats/cycles to achieve target length
+    # - **default parameter**: Replaces nil values
+    #
+    # ## Use Cases
+    #
+    # - Normalizing velocity parameters (single value or per-note array)
+    # - Ensuring consistent array handling in DSL methods
+    # - Cycling patterns to fill required lengths
+    # - Providing default values for missing data
+    #
+    # @example Basic object wrapping
+    #   using Musa::Extension::Arrayfy
+    #
+    #   5.arrayfy           # => [5]
+    #   nil.arrayfy         # => []
+    #   [1, 2, 3].arrayfy   # => [1, 2, 3]
+    #
+    # @example Repetition with size
+    #   using Musa::Extension::Arrayfy
+    #
+    #   5.arrayfy(size: 3)        # => [5, 5, 5]
+    #   [1, 2].arrayfy(size: 5)   # => [1, 2, 1, 2, 1]
+    #   [1, 2, 3].arrayfy(size: 2) # => [1, 2]
+    #
+    # @example Default values for nil
+    #   using Musa::Extension::Arrayfy
+    #
+    #   nil.arrayfy(size: 3, default: 0)           # => [0, 0, 0]
+    #   [1, nil, 3].arrayfy(size: 5, default: -1)  # => [1, -1, 3, 1, -1]
+    #
+    # @example Musical application - velocity normalization
+    #   using Musa::Extension::Arrayfy
+    #
+    #   # User provides single velocity for chord
+    #   velocities = 90.arrayfy(size: 3)  # => [90, 90, 90]
+    #
+    #   # User provides array of velocities that cycles
+    #   velocities = [80, 100].arrayfy(size: 5)  # => [80, 100, 80, 100, 80]
+    #
+    # @see Musa::MIDIVoices::MIDIVoice#note Uses arrayfy for velocity normalization
+    # @note This refinement must be activated with `using Musa::Extension::Arrayfy`
+    # @note Arrays are cloned and singleton class modules are preserved
+    #
+    # ## Methods Added
+    #
+    # ### Object
+    # - {Object#arrayfy} - Converts any object into an array, optionally repeated to a target size
+    #
+    # ### Array
+    # - {Array#arrayfy} - Clones or cycles the array to achieve the target size, with nil replacement
     module Arrayfy
+      # @!method arrayfy(size: nil, default: nil)
+      #   Converts any object into an array, optionally repeated to a target size.
+      #
+      #   @note This method is added to Object via refinement. Requires `using Musa::Extension::Arrayfy`.
+      #
+      #   @param size [Integer, nil] target array length. If nil, returns single-element array.
+      #   @param default [Object, nil] value to use instead of nil.
+      #
+      #   @return [Array] single element repeated size times, or wrapped in array if size is nil.
+      #
+      #   @example With size
+      #     using Musa::Extension::Arrayfy
+      #     "hello".arrayfy(size: 3)  # => ["hello", "hello", "hello"]
+      #
+      #   @example Nil handling
+      #     using Musa::Extension::Arrayfy
+      #     nil.arrayfy(size: 2, default: :empty)  # => [:empty, :empty]
+      class ::Object; end
+
       refine Object do
         def arrayfy(size: nil, default: nil)
           if size
@@ -17,6 +96,37 @@ module Musa
 
       # TODO add a refinement for Hash? Should receive a list parameter with the ordered keys
 
+      # @!method arrayfy(size: nil, default: nil)
+      #   Clones or cycles the array to achieve the target size, with nil replacement.
+      #
+      #   The cycling behavior multiplies the array enough times to reach or exceed
+      #   the target size, then takes exactly the requested number of elements.
+      #   Singleton class modules (like P, V dataset extensions) are preserved.
+      #
+      #   @note This method is added to Array via refinement. Requires `using Musa::Extension::Arrayfy`.
+      #
+      #   @param size [Integer, nil] target length. If nil, returns clone of array.
+      #   @param default [Object, nil] value to replace nil elements with.
+      #
+      #   @return [Array] processed array of exactly the requested size.
+      #
+      #   @example Cycling shorter array
+      #     using Musa::Extension::Arrayfy
+      #     [1, 2].arrayfy(size: 5)  # => [1, 2, 1, 2, 1]
+      #
+      #   @example Truncating longer array
+      #     using Musa::Extension::Arrayfy
+      #     [1, 2, 3, 4, 5].arrayfy(size: 3)  # => [1, 2, 3]
+      #
+      #   @example Preserving dataset modules
+      #     using Musa::Extension::Arrayfy
+      #     p_sequence = [60, 1, 62].extend(Musa::Datasets::P)
+      #     p_sequence.arrayfy(size: 6)  # Result also extended with P
+      #
+      #   @note The cycling formula: array * (size / array.size + (size % array.size).zero? ? 0 : 1)
+      #     ensures enough repetitions to reach target size.
+      class ::Array; end
+
       refine Array do
         def arrayfy(size: nil, default: nil)
           if size

data/lib/musa-dsl/core-ext/attribute-builder.rb

@@ -1,10 +1,52 @@
+require_relative 'extension'
+
 module Musa
   module Extension
+    # Module providing metaprogramming methods for creating DSL builder patterns.
+    #
+    # AttributeBuilder defines class methods that generate instance methods for
+    # creating and managing collections of objects in a DSL-friendly way. It's
+    # heavily used throughout Musa DSL to create fluent, expressive APIs.
+    #
+    # ## Method Categories
+    #
+    # - **Adders to Hash**: Create methods that build hash-based collections
+    # - **Adders to Array**: Create methods that build array-based collections
+    # - **Builders**: Create single-object getter/setter DSL methods
+    #
+    # ## Naming Conventions
+    #
+    # - `add_item` / `item`: singular form adds one object
+    # - `items`: plural form adds multiple or retrieves collection
+    # - Automatic pluralization (item → items) unless specified
+    #
+    # @example Using in a class
+    #   class Score
+    #     extend Musa::Extension::AttributeBuilder
+    #
+    #     def initialize
+    #       @tracks = {}
+    #     end
+    #
+    #     attr_tuple_adder_to_hash :track, Track
+    #   end
+    #
+    #   score = Score.new
+    #   score.add_track :piano, params
+    #   score.tracks  # => { piano: Track(...) }
+    #
+    # @see Musa::Datasets Score classes use these extensively
     module AttributeBuilder
-      # add_thing id, parameter
-      # things id1: parameter1, id2: parameter2 -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
-      # things -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
+      # Creates methods for adding id/value tuples to a hash collection.
+      #
+      # Generates:
+      # - `add_#{name}(id, parameter)` → creates instance and adds to hash
+      # - `#{plural}(**parameters)` → batch add or retrieve hash
       #
+      # @param name [Symbol] singular name for the item.
+      # @param klass [Class] class to instantiate (receives id, parameter).
+      # @param plural [Symbol, nil] plural name (defaults to name + 's').
+      # @param variable [Symbol, nil] instance variable name (defaults to '@' + plural).
       def attr_tuple_adder_to_hash(name, klass, plural: nil, variable: nil)
 
         plural ||= name.to_s + 's'
@@ -26,10 +68,15 @@ module Musa
         end
       end
 
-      # add_thing id, parameter
-      # things id1: parameter1, id2: parameter2 -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
-      # things -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
-
+      # Creates methods for adding id/value tuples to an array collection.
+      #
+      # Similar to attr_tuple_adder_to_hash but stores items in an array instead of hash.
+      # Useful when order matters or duplicates are allowed.
+      #
+      # @param name [Symbol] singular name for the item.
+      # @param klass [Class] class to instantiate.
+      # @param plural [Symbol, nil] plural name.
+      # @param variable [Symbol, nil] instance variable name.
       def attr_tuple_adder_to_array(name, klass, plural: nil, variable: nil)
 
         plural ||= name.to_s + 's'
@@ -51,10 +98,14 @@ module Musa
         end
       end
 
-      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
-      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
-      # things -> (collection)
-
+      # Creates methods for adding complex objects (with multiple parameters) to an array.
+      #
+      # Supports both positional and keyword arguments when creating instances.
+      #
+      # @param name [Symbol] singular name.
+      # @param klass [Class] class to instantiate.
+      # @param plural [Symbol, nil] plural name.
+      # @param variable [Symbol, nil] instance variable name.
       def attr_complex_adder_to_array(name, klass, plural: nil, variable: nil)
 
         plural ||= name.to_s + 's'
@@ -86,10 +137,14 @@ module Musa
       end
 
 
-      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
-      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
-      # things -> (collection)
-
+      # Creates methods for adding complex objects with custom construction logic.
+      #
+      # The block receives parameters and should construct and add the object.
+      #
+      # @param name [Symbol] singular name.
+      # @param plural [Symbol, nil] plural name.
+      # @param variable [Symbol, nil] instance variable name.
+      # @yield Constructor block executed in instance context.
       def attr_complex_adder_to_custom(name, plural: nil, variable: nil, &constructor_and_adder)
 
         plural ||= name.to_s + 's'
@@ -121,9 +176,11 @@ module Musa
         end
       end
 
-      # thing value -> crea Thing(value)
-      # thing -> Thing(value)
-
+      # Creates a simple getter/setter DSL method for a single value.
+      #
+      # @param name [Symbol] attribute name.
+      # @param klass [Class, nil] class to instantiate (nil = use value as-is).
+      # @param variable [Symbol, nil] instance variable name.
       def attr_simple_builder(name, klass = nil, variable: nil)
         variable ||= ('@' + name.to_s).to_sym
 
@@ -140,34 +197,38 @@ module Musa
         attr_writer name
       end
 
-      # thing id: value -> crea Thing(id, value)
-      # thing -> Thing(id, value)
-
+      # Creates a getter/setter DSL method for a single id/value tuple.
+      #
+      # @param name [Symbol] attribute name.
+      # @param klass [Class] class to instantiate.
+      # @param variable [Symbol, nil] instance variable name.
       def attr_tuple_builder(name, klass, variable: nil)
         variable ||= ('@' + name.to_s).to_sym
 
         define_method name do |**parameters, &block|
-          raise ArgumentError, "Method #{name} can only create instances with one id: value arguments pattern" unless parameters.size == 1
-
           if parameters.empty?
             instance_variable_get variable
-          else
+          elsif parameters.size == 1
             parameter = parameters.first
             klass.new(*parameter, &block).tap do |object|
               instance_variable_set variable, object
             end
+          else
+            raise ArgumentError, "Method #{name} can only create instances with one id: value arguments pattern"
           end
         end
 
         attr_writer name
       end
 
-      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(value1, value2, key1: value3, key2: value3)
-      # thing -> Thing(value1, value2, key1: value3, key2: value4)
-      # y también...
-      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(first_parameter, value1, value2, key1: value3, key2: value3)
-      # thing -> Thing(first_parameter, value1, value2, key1: value3, key2: value4)
-
+      # Creates a getter/setter DSL method for complex objects with multiple parameters.
+      #
+      # Supports optional first_parameter that's automatically prepended when constructing.
+      #
+      # @param name [Symbol] attribute name.
+      # @param klass [Class] class to instantiate.
+      # @param variable [Symbol, nil] instance variable name.
+      # @param first_parameter [Object, nil] parameter automatically prepended to constructor.
       def attr_complex_builder(name, klass, variable: nil, first_parameter: nil)
         variable ||= ('@' + name.to_s).to_sym
 

data/lib/musa-dsl/core-ext/deep-copy.rb

@@ -1,12 +1,64 @@
-# Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
-# Modifications by Javier Sánchez Yeste
+require_relative 'extension'
 
 module Musa
   module Extension
+    # Module providing deep copy functionality for complex object graphs.
+    #
+    # DeepCopy implements recursive copying of objects, handling circular references,
+    # instance variables, singleton class modules, and various Ruby data structures.
+    #
+    # ## Features
+    #
+    # - Handles circular references via object registry
+    # - Preserves singleton class modules (dataset extensions)
+    # - Supports both :dup and :clone methods
+    # - Special handling for Arrays, Hashes, Ranges, Structs, Procs
+    # - Recursively copies instance variables
+    # - Optional freeze control for :clone method
+    #
+    # ## Use Cases
+    #
+    # - Deep copying musical event structures with complex nesting
+    # - Duplicating series configurations without shared state
+    # - Preserving dataset module extensions during copy operations
+    # - Safe duplication of mutable default values
+    #
+    # @example Basic deep copy
+    #   using Musa::Extension::DeepCopy
+    #
+    #   original = { items: [1, 2, 3] }
+    #   copy = original.dup(deep: true)
+    #   copy[:items] << 4
+    #   original[:items]  # => [1, 2, 3] (unchanged)
+    #
+    # @example Preserving modules
+    #   event = { pitch: 60 }.extend(Musa::Datasets::AbsI)
+    #   copy = event.dup(deep: true)
+    #   copy.is_a?(Musa::Datasets::AbsI)  # => true
+    #
+    # @see Arrayfy Uses deep_copy for preserving modules
+    # @see Hashify Uses deep_copy for preserving modules
+    #
+    # Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
+    #
+    # Modifications by Javier Sánchez Yeste
     module DeepCopy
+      # Main deep copy module providing class methods.
       module DeepCopy
         extend self
 
+        # Creates a deep copy of an object, recursively copying nested structures.
+        #
+        # Uses an object registry to handle circular references, ensuring each
+        # object is copied only once and all references point to the same copy.
+        #
+        # @param object [Object] object to copy.
+        # @param method [Symbol] :dup or :clone.
+        # @param freeze [Boolean, nil] for :clone, whether to freeze the copy.
+        #
+        # @return [Object] deep copy of the object.
+        #
+        # @raise [ArgumentError] if method is not :dup or :clone.
         def deep_copy(object, method: :dup, freeze: nil)
           raise ArgumentError, "deep_copy method can only be :dup or :clone" unless method == :dup || method == :clone
           register = {}
@@ -14,6 +66,22 @@ module Musa
           _deep_copy(register, object, method, freeze)
         end
 
+        # Copies singleton class modules from source to target.
+        #
+        # This is essential for preserving dataset extensions (P, V, AbsI, etc.)
+        # when copying musical data structures. Without this, copied objects
+        # would lose their dataset behaviors.
+        #
+        # @param source [Object] object whose singleton modules to copy.
+        # @param target [Object] object to receive the modules.
+        #
+        # @return [Object] target with modules applied.
+        #
+        # @example
+        #   source = [60, 100].extend(Musa::Datasets::V)
+        #   target = [60, 100]
+        #   DeepCopy.copy_singleton_class_modules(source, target)
+        #   target.is_a?(Musa::Datasets::V)  # => true
         def copy_singleton_class_modules(source, target)
           source.singleton_class.included_modules.each do |m|
             target.extend m unless target.is_a?(m)
@@ -24,6 +92,8 @@ module Musa
 
         protected
 
+        # Retrieves a previously registered copy from the registry.
+        # @api private
         def registered(object, register)
           register[object.__id__]
         end
@@ -173,6 +243,59 @@ module Musa
         end
       end
 
+      # Refinement adding deep copy support to Object#dup and Object#clone.
+      #
+      # Adds a `deep:` keyword parameter to both methods, enabling easy deep copying
+      # without explicit calls to DeepCopy.deep_copy.
+      #
+      # ## Methods Added
+      #
+      # ### Object
+      # - {Object#dup} - Enhanced dup with optional deep copy
+      # - {Object#clone} - Enhanced clone with optional deep copy
+      #
+      # @!method dup(deep: false)
+      #   Enhanced dup with optional deep copy.
+      #
+      #   @note This method is added to Object via refinement. Requires `using Musa::Extension::DeepCopy`.
+      #
+      #   @param deep [Boolean] if true, performs deep copy; if false, standard dup.
+      #
+      #   @return [Object] duplicated object (shallow or deep).
+      #
+      #   @example Shallow dup (default)
+      #     using Musa::Extension::DeepCopy
+      #     arr = [[1, 2]]
+      #     copy = arr.dup
+      #     copy[0] << 3
+      #     arr  # => [[1, 2, 3]] (inner array shared)
+      #
+      #   @example Deep dup
+      #     using Musa::Extension::DeepCopy
+      #     arr = [[1, 2]]
+      #     copy = arr.dup(deep: true)
+      #     copy[0] << 3
+      #     arr  # => [[1, 2]] (inner array independent)
+      class ::Object; end
+
+      # @!method clone(freeze: nil, deep: false)
+      #   Enhanced clone with optional deep copy.
+      #
+      #   @note This method is added to Object via refinement. Requires `using Musa::Extension::DeepCopy`.
+      #
+      #   @param freeze [Boolean, nil] whether to freeze the clone.
+      #   @param deep [Boolean] if true, performs deep copy; if false, standard clone.
+      #
+      #   @return [Object] cloned object (shallow or deep).
+      #
+      #   @example Deep clone with freeze control
+      #     using Musa::Extension::DeepCopy
+      #     hash = { nested: { value: 1 } }
+      #     copy = hash.clone(deep: true, freeze: true)
+      #     copy.frozen?  # => true
+      #     copy[:nested].frozen?  # => true (deep freeze)
+      class ::Object; end
+
       refine Object do
         def dup(deep: false)
           if deep

data/lib/musa-dsl/core-ext/dynamic-proxy.rb

@@ -1,7 +1,40 @@
+require_relative 'extension'
+
 module Musa
   module Extension
+    # Module providing dynamic proxy pattern implementation.
+    #
+    # DynamicProxy allows creating objects that forward all method calls to a
+    # receiver object, which can be set/changed dynamically. This is useful for
+    # lazy initialization, placeholder objects, and delegation patterns.
+    #
+    # ## Features
+    #
+    # - Transparent method forwarding via method_missing
+    # - Dynamic receiver assignment
+    # - Type checking delegation (is_a?, kind_of?, instance_of?)
+    # - Equality delegation (==, eql?)
+    # - Safe handling when receiver is nil
+    #
+    # @example Basic usage
+    #   proxy = Musa::Extension::DynamicProxy::DynamicProxy.new
+    #   proxy.receiver = "Hello"
+    #   proxy.upcase  # => "HELLO" (forwarded to String)
+    #
+    # @example Lazy initialization
+    #   proxy = DynamicProxy.new
+    #   # ... later ...
+    #   proxy.receiver = expensive_object
+    #   proxy.some_method  # Now forwards to expensive_object
     module DynamicProxy
+      # Mixin module providing dynamic proxy behavior.
+      #
+      # This module can be included in classes to add proxy capabilities.
+      # Requires an @receiver instance variable to be set.
       module DynamicProxyModule
+        # Forwards unknown methods to the receiver.
+        #
+        # @raise [NoMethodError] if @receiver is nil or doesn't respond to method.
         def method_missing(method_name, *args, **key_args, &block)
           raise NoMethodError, "Method '#{method_name}' is unknown because self is a DynamicProxy with undefined receiver" unless @receiver
 
@@ -12,52 +45,97 @@ module Musa
           end
         end
 
+        # Declares which methods the proxy responds to.
+        #
+        # @return [Boolean] true if receiver responds to method, false otherwise.
         def respond_to_missing?(method_name, include_private)
           @receiver&.respond_to?(method_name, include_private) || super
         end
 
+        # Checks if the proxy has a receiver assigned.
+        #
+        # @return [Boolean] true if @receiver is not nil.
         def has_receiver?
           !@receiver.nil?
         end
 
+        # Preserve original is_a? for internal use
         alias _is_a? is_a?
 
+        # Delegates is_a? check to receiver or uses original.
+        #
+        # @param klass [Class] class to check against.
+        # @return [Boolean] true if proxy or receiver is instance of klass.
         def is_a?(klass)
           _is_a?(klass) || @receiver&.is_a?(klass)
         end
 
+        # Preserve original kind_of? for internal use
         alias _kind_of? kind_of?
 
+        # Delegates kind_of? check to receiver or uses original.
+        #
+        # @param klass [Class] class to check against.
+        # @return [Boolean] true if proxy or receiver is kind of klass.
         def kind_of?(klass)
           _kind_of?(klass) || @receiver&.is_a?(klass)
         end
 
+        # Preserve original instance_of? for internal use
         alias _instance_of? instance_of?
 
+        # Delegates instance_of? check to receiver or uses original.
+        #
+        # @param klass [Class] class to check against.
+        # @return [Boolean] true if proxy or receiver is instance of klass.
         def instance_of?(klass)
           _instance_of?(klass) || @receiver&.instance_of?(klass)
         end
 
+        # Preserve original == for internal use
         alias _equalequal ==
 
+        # Delegates equality check to receiver or uses original.
+        #
+        # @param object [Object] object to compare with.
+        # @return [Boolean] true if proxy or receiver equals object.
         def ==(object)
           _equalequal(object) || @receiver&.==(object)
         end
 
+        # Preserve original eql? for internal use
         alias _eql? eql?
 
+        # Delegates eql? check to receiver or uses original.
+        #
+        # @param object [Object] object to compare with.
+        # @return [Boolean] true if proxy or receiver eql? object.
         def eql?(object)
           _eql?(object) || @receiver&.eql?(object)
         end
       end
 
+      # Concrete DynamicProxy class ready for instantiation.
+      #
+      # @example
+      #   proxy = DynamicProxy.new
+      #   proxy.receiver = [1, 2, 3]
+      #   proxy.size      # => 3
+      #   proxy.first     # => 1
+      #   proxy.is_a?(Array)  # => true
       class DynamicProxy
         include DynamicProxyModule
 
+        # Creates a new dynamic proxy.
+        #
+        # @param receiver [Object, nil] optional initial receiver object.
         def initialize(receiver = nil)
           @receiver = receiver
         end
 
+        # The object to which methods are delegated.
+        #
+        # @return [Object, nil] current receiver.
         attr_accessor :receiver
       end
     end

data/lib/musa-dsl/core-ext/extension.rb

@@ -0,0 +1,53 @@
+module Musa
+  # Namespace for core Ruby extensions and utilities used throughout Musa DSL.
+  #
+  # This module contains fundamental extensions and helper modules that enhance
+  # Ruby's capabilities for DSL construction and flexible block handling.
+  #
+  # ## Included Modules
+  #
+  # - {With} - Flexible DSL block execution with context switching
+  # - {SmartProcBinder::SmartProcBinder} - Intelligent parameter binding for Procs
+  # - {AttributeBuilder} - DSL-style attribute builder macros
+  # - {DynamicProxy::DynamicProxy} - Dynamic method proxying
+  #
+  # ## Purpose
+  #
+  # These extensions enable Musa DSL's characteristic features:
+  # - Builder pattern with flexible context switching
+  # - Method-style and block-style parameter passing
+  # - Dynamic method generation for DSL syntax
+  # - Intelligent parameter matching and binding
+  #
+  # ## Design Philosophy
+  #
+  # The extensions in this module prioritize:
+  # - **Flexibility**: Supporting multiple calling conventions
+  # - **Transparency**: Minimal interference with normal Ruby behavior
+  # - **Reusability**: General-purpose tools used across Musa DSL
+  #
+  # @example Using With for DSL blocks
+  #   class Builder
+  #     include Musa::Extension::With
+  #
+  #     def initialize(&block)
+  #       @items = []
+  #       with(&block) if block
+  #     end
+  #
+  #     def add(item)
+  #       @items << item
+  #     end
+  #   end
+  #
+  #   builder = Builder.new do
+  #     add :foo  # Executes in Builder's context
+  #   end
+  #
+  # @see With The core DSL block execution module
+  # @see SmartProcBinder Intelligent Proc parameter handling
+  # @see AttributeBuilder DSL attribute builder macros
+  # @see DynamicProxy Dynamic method proxying implementation
+  module Extension
+  end
+end