class_composer 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd01814260b83eaa363cdbdff3d1f078ee85b7d6850841a847e7d89edcef6e29
-  data.tar.gz: 43d27db959b1dfdbd364cc1be9af76d0debe4786031822d290d7dac6292afefd
+  metadata.gz: ce164acfb44d923b971f227a236fef5388cbeef8295f8419a46f815ac8bdaa0f
+  data.tar.gz: a0adb222a5704fd56916621669c9cce3112e07a27e338ca2c5e8b51e4a91d42f
 SHA512:
-  metadata.gz: 2802e0cae4ad7be7d5f866436250e24e89e5ef032d1196d0951b517e18de28b7db6473f757277f239519c167de6de3f15f10a19853fdef9818ae2e400e13e3af
-  data.tar.gz: 175613d8ea5f331652eabad44e6090fb16f50703dbcb099dfb72bf96a5a2cd564eb8b3c491ed411124e908adada075ec6603b6b85a41f64e9661195b665e9b00
+  metadata.gz: fee77c510173e27b695924ff5f5ddb050e00bfb3d26e4b8f5a124576fa72554f462ca06e0ecd31abbb150b6aca339cb22fef11d46724829e0bb0f11f937d4ac8
+  data.tar.gz: 5ce561d2dcc6b3e0e87efc4e55eec8ab243aff03ae758c069ce816674378a39c6f3e8e0c36e925c013e3d255b56d714647dd6ca4a831f3cd82dc0c3306ad6abd

data/CHANGELOG.md

@@ -10,6 +10,11 @@
 
 # Release Notes
 
+## v2.1.0 (Dec 2024)
+- Default Dynamic Configuration -- Allow config options to be defaulted to other config variables. Ability to provide a Symbol of an existing `composer` or a Proc to custom define from anything in the application
+- Update how default_shown works when generating the config
+- Extract `class_methods` and `instance_methods` to their own files
+
 ## v2.0.0 (Nov 2024)
 - Minimum Ruby Version bumped to v3.1
 - Initializer File Generator

data/docs/basic_composer.md

@@ -39,6 +39,21 @@ add_composer :status, allowed: Symbol, default: :different_default
 add_composer :status, allowed: Symbol, default: "This type does not match Symbol. This default value will raise error"
 ```
 
+### Dynamic Default
+- Required: False
+- Description: This option allows you to set a dynamic default composed of other `add_composer` values. The `dynamic_default` is lazy loaded.
+- Type: Expected value to be a Symbol mapping to another `add_composer` method or a Proc that takes an instance as an argument.
+- Note: When using `dynamic_default`, validations will lazily get run on retrieval. This means that you could have a runtime error if the dynamic value is not of the correct `allowed` type.
+
+Examples
+```ruby
+add_composer :app_name, allowed: Symbol, default: "My Cool App Name"
+
+add_composer :app_name_comms, allowed: String, dynamic_default: :app_name
+
+add_composer :app_name_website, allowed: String, dynamic_default: ->(instance) { "#{instance.app_name} + #{instance.app_name_comms}" }
+```
+
 ### Description
 - Required: False (Recommend)
 - Description: This option provides a human readable description of what the current configuration option does. This value is useful when [Generating an Initializer](generating_initializer.md)

data/docs/generating_initializer.md

@@ -28,7 +28,7 @@ end
 class AppConfiguration
   include ClassComposer::Generator
 
-  add_composer_blocking :login, composer_class: LoginStrategy, desc: "Login Strategy for my Application"
+  add_composer :login, allowed: LoginStrategy, default: LoginStrategy.new, desc: "Login Strategy for my Application"
 
   add_composer_blocking :lockable, composer_class: LockableStrategy, enable_attr: :enable, desc: "Lock Strategy for my Application. By default this is disabled"
 end

data/lib/class_composer/generate_config.rb

@@ -57,7 +57,6 @@ module ClassComposer
           children.each do |child|
             children_config += generate(mapping: child, space_count:, demeters_deep: config_prepend)
           end
-          # binding.pry
 
           children_config.flatten(1)
         else
@@ -100,10 +99,18 @@ module ClassComposer
     def spec(key:, metadata:, space_count:, demeters_deep:)
       config = concat_demeter_with_key(key, demeters_deep)
 
-      if metadata[:allowed].include?(String)
+      if metadata[:default_shown]
+         default = metadata[:default_shown]
+      elsif metadata[:dynamic_default]
+        if Symbol === metadata[:dynamic_default]
+          default = concat_demeter_with_key(metadata[:dynamic_default], demeters_deep)
+        else
+          default = " # Proc provided for :dynamic_default parameter. :default_shown parameter not provided"
+        end
+      elsif metadata[:allowed].include?(String)
         default = "\"#{metadata[:default]}\""
       else
-        default = metadata[:default]
+        default = custom_case(metadata[:default])
       end
       arr = []
 
@@ -114,6 +121,17 @@ module ClassComposer
       arr
     end
 
+    def custom_case(default)
+      case default
+      when Symbol
+        default.inspect
+      when (ActiveSupport::Duration rescue NilClass)
+        default.inspect.gsub(" ", ".")
+      else
+        default
+      end
+    end
+
     def prepending(space_count)
       "#{" " * space_count}#"
     end

data/lib/class_composer/generator/class_methods.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module ClassComposer
+  module Generator
+    module ClassMethods
+      COMPOSER_VALIDATE_METHOD_NAME = ->(name) { :"__composer_#{name}_is_valid__?" }
+      COMPOSER_ASSIGNED_ATTR_NAME = ->(name) { :"@__composer_#{name}_value_assigned__" }
+      COMPOSER_ASSIGNED_ARRAY_METHODS = ->(name) { :"@__composer_#{name}_array_methods_set__" }
+      COMPOSER_ALLOWED_FROZEN_TYPE_ARGS = [:raise, :log]
+
+      def add_composer_blocking(name, composer_class:, desc: nil, block_prepend: "with", enable_attr: nil)
+        unless composer_class.include?(ClassComposer::Generator)
+          raise ClassComposer::Error, ".add_composer_blocking passed `composer_class:` that does not include ClassComposer::Generator. Passed argument must include ClassComposer::Generator"
+        end
+
+        blocking_name = "#{block_prepend}_#{name}"
+        blocking_attributes = { block_name: blocking_name, enable_attr: enable_attr }
+        add_composer(name, allowed: composer_class, default: composer_class.new, desc: desc, blocking_attributes: blocking_attributes)
+
+        define_method(blocking_name) do |&blk|
+          instance = public_send(:"#{name}")
+          instance.public_send(:"#{enable_attr}=", true) if enable_attr
+
+          blk.(instance) if blk
+
+          method(:"#{name}=").call(instance)
+        end
+
+        if enable_attr
+          define_method("#{name}?") do
+            public_send(:"#{name}").public_send(enable_attr)
+          end
+        end
+      end
+
+      def add_composer(name, allowed:, desc: nil, validator: ->(_) { true }, validation_error_klass: ::ClassComposer::ValidatorError, error_klass: ::ClassComposer::Error, blocking_attributes: nil, default_shown: nil, **params, &blk)
+        default =
+          if params.has_key?(:default)
+            params[:default]
+          else
+            ClassComposer::DefaultObject
+          end
+
+        if params[:default] && params[:dynamic_default]
+          raise Error, "Composer :#{name} had both the `:default` and `:dynamic_default` assigned. Only one allowed"
+        end
+
+        if dynamic_default = params[:dynamic_default]
+          if ![Proc, Symbol].include?(dynamic_default.class)
+            raise Error, "Composer :#{name} defined `:dynamic_default: #{dynamic_default}`. Expected value to be a Symbol mapped to a composer element or a Proc"
+          end
+
+          if Symbol === dynamic_default && composer_mapping[dynamic_default].nil?
+            raise Error, "Composer :#{name} defined `dynamic_default: #{dynamic_default}`. #{dynamic_default} is not defined. Please ensure that all dynamic_default's are defined before setting them"
+          end
+        end
+
+        if allowed.is_a?(Array)
+          allowed << ClassComposer::DefaultObject
+        else
+          allowed = [allowed, ClassComposer::DefaultObject]
+        end
+
+        if allowed.select { _1.include?(ClassComposer::Generator) }.count > 1
+          raise Error, "Allowed arguments has multiple classes that include ClassComposer::Generator. Max 1 is allowed"
+        end
+
+        validate_proc = __composer_validator_proc__(validator: validator, allowed: allowed, name: name, error_klass: error_klass)
+        __composer_validate_options__!(name: name, validate_proc: validate_proc, default: default, validation_error_klass: validation_error_klass, error_klass: error_klass)
+
+        array_proc = __composer_array_proc__(name: name, validator: validator, allowed: allowed, params: params)
+        __composer_assignment__(name: name, allowed: allowed, params: params, validator: validate_proc, array_proc: array_proc, validation_error_klass: validation_error_klass, error_klass: error_klass, &blk)
+        __composer_retrieval__(name: name, allowed: allowed, default: default, array_proc: array_proc, params: params, validator: validate_proc, validation_error_klass: validation_error_klass)
+
+        # Add to mapping
+        __add_to_composer_mapping__(name: name, default: default, allowed: allowed, desc: desc, blocking_attributes: blocking_attributes, default_shown: default_shown, dynamic_default: params[:dynamic_default])
+      end
+
+      def composer_mapping
+        @composer_mapping ||= {}
+      end
+
+      def composer_generate_config(wrapping:, require_file: nil, space_count: 2)
+        @composer_generate_config ||= GenerateConfig.new(instance: self)
+
+        @composer_generate_config.execute(wrapping:, require_file:, space_count:)
+      end
+
+      def __add_to_composer_mapping__(name:, default:, allowed:, desc:, blocking_attributes:, default_shown: nil, dynamic_default: nil)
+        children = Array(allowed).select { _1.include?(ClassComposer::Generator) }.map do |allowed_class|
+          allowed_class.composer_mapping
+        end
+
+        composer_mapping[name] = {
+          desc: desc,
+          children: children.empty? ? nil : children,
+          dynamic_default: dynamic_default,
+          default_shown: default_shown,
+          default: (default.to_s.start_with?("#<") ? default.class : default),
+          blocking_attributes: blocking_attributes,
+          allowed: allowed,
+        }.compact
+      end
+
+      def __composer_validate_options__!(name:, validate_proc:, default:, params: {}, validation_error_klass:, error_klass:)
+        unless validate_proc.(default)
+          raise validation_error_klass, "Default value [#{default}] for #{self.class}.#{name} is not valid"
+        end
+
+        if instance_methods.include?(name.to_sym)
+          raise error_klass, "[#{name}] is already defined. Ensure composer names are all uniq and do not class with class instance methods"
+        end
+      end
+
+      def __composer_array_proc__(name:, validator:, allowed:, params:)
+        Proc.new do |value, _itself|
+          _itself.send(:"#{name}=", value)
+        end
+      end
+
+      # create assignment method for the incoming name
+      def __composer_assignment__(name:, params:, allowed:, validator:, array_proc:, validation_error_klass:, error_klass:, &blk)
+        define_method(:"#{name}=") do |value|
+          case class_composer_frozen!(name)
+          when false
+            # false is returned when the instance is frozen AND we do not allow the operation to proceed
+            return
+          when true
+            # true is returned when the instance is frozen AND we allow the operation to proceed
+          when nil
+            # nil is returned when the instance is not frozen
+          end
+
+          is_valid = self.class.__run_validation_item(name: name, validator: validator, allowed: allowed, value: value, params: params)
+
+          if is_valid[:valid]
+            instance_variable_set(COMPOSER_ASSIGNED_ATTR_NAME.(name), true)
+            instance_variable_set(:"@#{name}", value)
+          else
+            raise validation_error_klass, is_valid[:message].compact.join(" ")
+          end
+
+          if value.is_a?(Array) && !value.instance_variable_get(COMPOSER_ASSIGNED_ARRAY_METHODS.(name))
+            _itself = itself
+            value.define_singleton_method(:<<) do |val|
+              array_proc.(super(val), _itself)
+            end
+            value.instance_variable_set(COMPOSER_ASSIGNED_ARRAY_METHODS.(name), true)
+          end
+
+          if blk
+            yield(name, value)
+          end
+
+          value
+        end
+      end
+
+      def __run_validation_item(validator:, name:, value:, allowed:, params:)
+        if validator.(value)
+          return { valid: true }
+        end
+
+        message = ["#{self.class}.#{name} failed validation. #{name} is expected to be #{allowed}. Received [#{value}](#{value.class})"]
+        message << (params[:invalid_message].is_a?(Proc) ? params[:invalid_message].(value) : params[:invalid_message].to_s)
+
+        { valid: false, message: message }
+      end
+
+      # retrieve the value for the name -- Or return the default value
+      def __composer_retrieval__(name:, default:, array_proc:, allowed:, params:, validator:, validation_error_klass:)
+        define_method(:"#{name}") do
+          value = instance_variable_get(:"@#{name}")
+          return value if instance_variable_get(COMPOSER_ASSIGNED_ATTR_NAME.(name))
+
+          if dynamic_default = params[:dynamic_default]
+            if Proc === dynamic_default
+              value = dynamic_default.(self)
+            else
+              # We know the method exists because we already checked validity from within
+              # `compose_mapping` on add_composer creation
+              value = method(:"#{dynamic_default}").()
+            end
+            is_valid = self.class.__run_validation_item(name: name, validator: validator, allowed: allowed, value: value, params: params)
+
+            if is_valid[:valid]
+              instance_variable_set(COMPOSER_ASSIGNED_ATTR_NAME.(name), true)
+              instance_variable_set(:"@#{name}", value)
+            else
+              raise validation_error_klass, is_valid[:message].compact.join(" ")
+            end
+
+            return value
+          end
+
+          if default.is_a?(Array) && !default.instance_variable_get(COMPOSER_ASSIGNED_ARRAY_METHODS.(name))
+            _itself = itself
+            default.define_singleton_method(:<<) do |value|
+              array_proc.(super(value), _itself)
+            end
+            default.instance_variable_set(COMPOSER_ASSIGNED_ARRAY_METHODS.(name), true)
+          end
+
+          default == ClassComposer::DefaultObject ? ClassComposer::DefaultObject.value : default
+        end
+      end
+
+      # create validator method for incoming name
+      def __composer_validator_proc__(validator:, allowed:, name:, error_klass:)
+        if validator && !validator.is_a?(Proc)
+          raise error_klass, "Expected validator to be a Proc. Received [#{validator.class}]"
+        end
+
+        # Proc will validate the entire attribute -- Full assignment must occur before validate is called
+        Proc.new do |value|
+          begin
+            allow =
+              if allowed.is_a?(Array)
+                allowed.include?(value.class)
+              else
+                allowed == value.class
+              end
+            # order is important -- Do not run validator if it is the default object
+            # Default object will likely raise an error if there is a custom validator
+            (allowed.include?(ClassComposer::DefaultObject) && value == ClassComposer::DefaultObject) || (allow && validator.(value))
+          rescue StandardError => e
+            raise error_klass, "#{e} occurred during validation for value [#{value}]. Check custom validator for #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/class_composer/generator/instance_methods.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ClassComposer
+  module Generator
+    module InstanceMethods
+      def class_composer_frozen!(key)
+        # when nil, we allow changes to the instance methods
+        return if @class_composer_frozen.nil?
+
+        # When frozen is a proc, we let the user decide how to handle
+        # The return value decides if the value can be changed or not
+        if Proc === @class_composer_frozen
+          return @class_composer_frozen.(self, key)
+        end
+
+        msg = "#{self.class} instance methods are frozen. Attempted to change variable [#{key}]."
+        case @class_composer_frozen
+        when FROZEN_LOG_AND_ALLOW
+          msg += " This operation will proceed."
+          Kernel.warn(msg)
+          return true
+        when FROZEN_LOG_AND_SKIP
+          msg += " This operation will NOT proceed."
+          Kernel.warn(msg)
+          return false
+        when FROZEN_RAISE
+          raise Error, msg
+        end
+      end
+
+      def class_composer_assign_defaults!(children: false)
+        self.class.composer_mapping.each do |key, metadata|
+          assigned_value = method(:"#{key}").call
+          method(:"#{key}=").call(assigned_value)
+
+          if children && metadata[:children]
+            method(:"#{key}").call().class_composer_assign_defaults!(children: children)
+          end
+        end
+
+        nil
+      end
+
+      def class_composer_freeze_objects!(behavior: nil, children: false, &block)
+        if behavior && block
+          raise ArgumentError, "`behavior` and `block` can not both be present. Choose one"
+        end
+
+        if behavior.nil? && block.nil?
+          raise ArgumentError, "`behavior` or `block` must be present."
+        end
+
+        if block
+          @class_composer_frozen = block
+        else
+          if !FROZEN_TYPES.include?(behavior)
+            raise Error, "Unknown behavior [#{behavior}]. Expected one of #{FROZEN_TYPES}."
+          end
+          @class_composer_frozen = behavior
+        end
+
+        # If children is set, iterate the children, otherwise exit early
+        return if children == false
+
+        self.class.composer_mapping.each do |key, metadata|
+          next unless metadata[:children]
+
+          method(:"#{key}").call().class_composer_freeze_objects!(behavior:, children:, &block)
+        end
+      end
+    end
+  end
+end

data/lib/class_composer/generator.rb

@@ -2,6 +2,8 @@
 
 require "class_composer/default_object"
 require "class_composer/generate_config"
+require "class_composer/generator/instance_methods"
+require "class_composer/generator/class_methods"
 
 module ClassComposer
   FROZEN_TYPES = [
@@ -14,257 +16,5 @@ module ClassComposer
       base.extend(ClassMethods)
       base.include(InstanceMethods)
     end
-
-    module InstanceMethods
-      def class_composer_frozen!(key)
-        # when nil, we allow changes to the instance methods
-        return if @class_composer_frozen.nil?
-
-        # When frozen is a proc, we let the user decide how to handle
-        # The return value decides if the value can be changed or not
-        if Proc === @class_composer_frozen
-          return @class_composer_frozen.(self, key)
-        end
-
-        msg = "#{self.class} instance methods are frozen. Attempted to change variable [#{key}]."
-        case @class_composer_frozen
-        when FROZEN_LOG_AND_ALLOW
-          msg += " This operation will proceed."
-          Kernel.warn(msg)
-          return true
-        when FROZEN_LOG_AND_SKIP
-          msg += " This operation will NOT proceed."
-          Kernel.warn(msg)
-          return false
-        when FROZEN_RAISE
-          raise Error, msg
-        end
-      end
-
-      def class_composer_assign_defaults!(children: false)
-        self.class.composer_mapping.each do |key, metadata|
-          assigned_value = method(:"#{key}").call
-          method(:"#{key}=").call(assigned_value)
-
-          if children && metadata[:children]
-            method(:"#{key}").call().class_composer_assign_defaults!(children: children)
-          end
-        end
-
-        nil
-      end
-
-      def class_composer_freeze_objects!(behavior: nil, children: false, &block)
-        if behavior && block
-          raise ArgumentError, "`behavior` and `block` can not both be present. Choose one"
-        end
-
-        if behavior.nil? && block.nil?
-          raise ArgumentError, "`behavior` or `block` must be present."
-        end
-
-        if block
-          @class_composer_frozen = block
-        else
-          if !FROZEN_TYPES.include?(behavior)
-            raise Error, "Unknown behavior [#{behavior}]. Expected one of #{FROZEN_TYPES}."
-          end
-          @class_composer_frozen = behavior
-        end
-
-        # If children is set, iterate the children, otherwise exit early
-        return if children == false
-
-        self.class.composer_mapping.each do |key, metadata|
-          next unless metadata[:children]
-
-          method(:"#{key}").call().class_composer_freeze_objects!(behavior:, children:, &block)
-        end
-      end
-    end
-
-    module ClassMethods
-      COMPOSER_VALIDATE_METHOD_NAME = ->(name) { :"__composer_#{name}_is_valid__?" }
-      COMPOSER_ASSIGNED_ATTR_NAME = ->(name) { :"@__composer_#{name}_value_assigned__" }
-      COMPOSER_ASSIGNED_ARRAY_METHODS = ->(name) { :"@__composer_#{name}_array_methods_set__" }
-      COMPOSER_ALLOWED_FROZEN_TYPE_ARGS = [:raise, :log]
-
-      def add_composer_blocking(name, composer_class:, desc: nil, block_prepend: "with", enable_attr: nil)
-        unless composer_class.include?(ClassComposer::Generator)
-          raise ClassComposer::Error, ".add_composer_blocking passed `composer_class:` that does not include ClassComposer::Generator. Passed argument must include ClassComposer::Generator"
-        end
-
-        blocking_name = "#{block_prepend}_#{name}"
-        blocking_attributes = { block_name: blocking_name, enable_attr: enable_attr }
-        add_composer(name, allowed: composer_class, default: composer_class.new, desc: desc, blocking_attributes: blocking_attributes)
-
-        define_method(blocking_name) do |&blk|
-          instance = public_send(:"#{name}")
-          instance.public_send(:"#{enable_attr}=", true) if enable_attr
-
-          blk.(instance) if blk
-
-          method(:"#{name}=").call(instance)
-        end
-
-        if enable_attr
-          define_method("#{name}?") do
-            public_send(:"#{name}").public_send(enable_attr)
-          end
-        end
-      end
-
-      def add_composer(name, allowed:, desc: nil, validator: ->(_) { true }, validation_error_klass: ::ClassComposer::ValidatorError, error_klass: ::ClassComposer::Error, blocking_attributes: nil, default_shown: nil, **params, &blk)
-        default =
-          if params.has_key?(:default)
-            params[:default]
-          else
-            ClassComposer::DefaultObject
-          end
-
-        if allowed.is_a?(Array)
-          allowed << ClassComposer::DefaultObject
-        else
-          allowed = [allowed, ClassComposer::DefaultObject]
-        end
-
-        if allowed.select { _1.include?(ClassComposer::Generator) }.count > 1
-          raise Error, "Allowed arguments has multiple classes that include ClassComposer::Generator. Max 1 is allowed"
-        end
-
-        validate_proc = __composer_validator_proc__(validator: validator, allowed: allowed, name: name, error_klass: error_klass)
-        __composer_validate_options__!(name: name, validate_proc: validate_proc, default: default, validation_error_klass: validation_error_klass, error_klass: error_klass)
-
-        array_proc = __composer_array_proc__(name: name, validator: validator, allowed: allowed, params: params)
-        __composer_assignment__(name: name, allowed: allowed, params: params, validator: validate_proc, array_proc: array_proc, validation_error_klass: validation_error_klass, error_klass: error_klass, &blk)
-        __composer_retrieval__(name: name, default: default, array_proc: array_proc)
-
-        # Add to mapping
-        __add_to_composer_mapping__(name: name, default: default, allowed: allowed, desc: desc, blocking_attributes: blocking_attributes, default_shown: default_shown)
-      end
-
-      def composer_mapping
-        @composer_mapping ||= {}
-      end
-
-      def composer_generate_config(wrapping:, require_file: nil, space_count: 2)
-        @composer_generate_config ||= GenerateConfig.new(instance: self)
-
-        @composer_generate_config.execute(wrapping:, require_file:, space_count:)
-      end
-
-      def __add_to_composer_mapping__(name:, default:, allowed:, desc:, blocking_attributes:, default_shown: nil)
-        children = Array(allowed).select { _1.include?(ClassComposer::Generator) }.map do |allowed_class|
-          allowed_class.composer_mapping
-        end
-
-        composer_mapping[name] = {
-          desc: desc,
-          children: children.empty? ? nil : children,
-          default: default_shown || (default.to_s.start_with?("#<") ? default.class : default),
-          blocking_attributes: blocking_attributes,
-          allowed: allowed,
-        }.compact
-      end
-
-      def __composer_validate_options__!(name:, validate_proc:, default:, params: {}, validation_error_klass:, error_klass:)
-        unless validate_proc.(default)
-          raise validation_error_klass, "Default value [#{default}] for #{self.class}.#{name} is not valid"
-        end
-
-        if instance_methods.include?(name.to_sym)
-          raise error_klass, "[#{name}] is already defined. Ensure composer names are all uniq and do not class with class instance methods"
-        end
-      end
-
-      def __composer_array_proc__(name:, validator:, allowed:, params:)
-        Proc.new do |value, _itself|
-          _itself.send(:"#{name}=", value)
-        end
-      end
-
-      # create assignment method for the incoming name
-      def __composer_assignment__(name:, params:, allowed:, validator:, array_proc:, validation_error_klass:, error_klass:, &blk)
-        define_method(:"#{name}=") do |value|
-          case class_composer_frozen!(name)
-          when false
-            # false is returned when the instance is frozen AND we do not allow the operation to proceed
-            return
-          when true
-            # true is returned when the instance is frozen AND we allow the operation to proceed
-          when nil
-            # nil is returned when the instance is not frozen
-          end
-
-          is_valid = validator.(value)
-
-          if is_valid
-            instance_variable_set(COMPOSER_ASSIGNED_ATTR_NAME.(name), true)
-            instance_variable_set(:"@#{name}", value)
-          else
-            message = ["#{self.class}.#{name} failed validation. #{name} is expected to be #{allowed}. Received [#{value}](#{value.class})"]
-
-            message << (params[:invalid_message].is_a?(Proc) ? params[:invalid_message].(value) : params[:invalid_message].to_s)
-            raise validation_error_klass, message.compact.join(" ")
-          end
-
-          if value.is_a?(Array) && !value.instance_variable_get(COMPOSER_ASSIGNED_ARRAY_METHODS.(name))
-            _itself = itself
-            value.define_singleton_method(:<<) do |val|
-              array_proc.(super(val), _itself)
-            end
-            value.instance_variable_set(COMPOSER_ASSIGNED_ARRAY_METHODS.(name), true)
-          end
-
-          if blk
-            yield(name, value)
-          end
-
-          value
-        end
-      end
-
-      # retrieve the value for the name -- Or return the default value
-      def __composer_retrieval__(name:, default:, array_proc:)
-        define_method(:"#{name}") do
-          value = instance_variable_get(:"@#{name}")
-          return value if instance_variable_get(COMPOSER_ASSIGNED_ATTR_NAME.(name))
-
-          if default.is_a?(Array) && !default.instance_variable_get(COMPOSER_ASSIGNED_ARRAY_METHODS.(name))
-            _itself = itself
-            default.define_singleton_method(:<<) do |value|
-              array_proc.(super(value), _itself)
-            end
-            default.instance_variable_set(COMPOSER_ASSIGNED_ARRAY_METHODS.(name), true)
-          end
-
-          default == ClassComposer::DefaultObject ? ClassComposer::DefaultObject.value : default
-        end
-      end
-
-      # create validator method for incoming name
-      def __composer_validator_proc__(validator:, allowed:, name:, error_klass:)
-        if validator && !validator.is_a?(Proc)
-          raise error_klass, "Expected validator to be a Proc. Received [#{validator.class}]"
-        end
-
-        # Proc will validate the entire attribute -- Full assignment must occur before validate is called
-        Proc.new do |value|
-          begin
-            allow =
-              if allowed.is_a?(Array)
-                allowed.include?(value.class)
-              else
-                allowed == value.class
-              end
-            # order is important -- Do not run validator if it is the default object
-            # Default object will likely raise an error if there is a custom validator
-            (allowed.include?(ClassComposer::DefaultObject) && value == ClassComposer::DefaultObject) || (allow && validator.(value))
-          rescue StandardError => e
-            raise error_klass, "#{e} occurred during validation for value [#{value}]. Check custom validator for #{name}"
-          end
-        end
-      end
-    end
   end
 end

data/lib/class_composer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClassComposer
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

data/lib/class_composer.rb

@@ -6,5 +6,4 @@ require "class_composer/generator"
 module ClassComposer
   class Error < StandardError; end
   class ValidatorError < Error; end
-  # Your code goes here...
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: class_composer
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-01 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies: []
 description: Compose configurations for any class.
 email:
@@ -43,6 +43,8 @@ files:
 - lib/class_composer/default_object.rb
 - lib/class_composer/generate_config.rb
 - lib/class_composer/generator.rb
+- lib/class_composer/generator/class_methods.rb
+- lib/class_composer/generator/instance_methods.rb
 - lib/class_composer/version.rb
 homepage: https://github.com/matt-taylor/class_composer
 licenses: