dev_suite 0.2.4 → 0.2.7

data/lib/dev_suite/utils/construct/config/attribute/attr_resolving.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          require_relative "validator"
+
+          module AttrResolving
+            private
+
+            # Sets a configuration attribute value with validation and resolution
+            def set_config_attr(attr:, value:)
+              attr_details = fetch_attr_details(attr)
+
+              store_original_value(attr, value)
+              validated_value = validate_config_attr(attr, value, attr_details)
+              resolved_value = resolve_config_attr_value(validated_value, attr_details)
+
+              store_resolved_value(attr, resolved_value)
+            end
+
+            # Fetches the details of a configuration attribute
+            def fetch_attr_details(attr_name)
+              self.class.config_attrs[attr_name]
+            end
+
+            # Stores the original value of an attribute before processing
+            def store_original_value(attr_name, value)
+              instance_variable_set("@original_#{attr_name}", value)
+            end
+
+            # Stores the resolved value of an attribute after processing
+            def store_resolved_value(attr_name, value)
+              instance_variable_set("@#{attr_name}", value)
+            end
+
+            # Validates the value of a configuration attribute
+            def validate_config_attr(attr_name, value, attr_details)
+              if attr_details[:type]
+                Validator.validate_config_attr_type!(
+                  attr: attr_name,
+                  value: value,
+                  type: attr_details[:type],
+                )
+              end
+              value
+            end
+
+            # Resolves the value of a configuration attribute
+            def resolve_config_attr_value(value, attr_details)
+              if attr_details[:resolver]
+                resolve_config_attr(
+                  value: value,
+                  resolver: attr_details[:resolver],
+                )
+              else
+                value
+              end
+            end
+
+            # Resolves the value of an attribute based on its resolver.
+            # If no resolver is provided, the value is returned as is.
+            def resolve_config_attr(value:, resolver:)
+              case resolver
+              when Proc
+                resolver.call(value)
+              when Symbol
+                send(resolver, value)
+              else
+                value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/attribute/attribute.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          require_relative "attr_definition"
+          require_relative "attr_initialization"
+          require_relative "attr_resolving"
+
+          class << self
+            def included(base)
+              base.extend(AttrDefinition)
+            end
+          end
+
+          include AttrInitialization
+          include AttrResolving
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/attribute/validator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          module Validator
+            extend self
+
+            # Validates an attribute's value based on its type.
+            #
+            # @param attr [Symbol] The name of the attribute.
+            # @param value [Object] The value to validate.
+            # @param type [Symbol] The expected type of the attribute.
+            def validate_config_attr_type!(attr:, value:, type:)
+              case type
+              when :symbol
+                validate_symbol!(value)
+              when :hash
+                validate_hash!(value)
+              when :array
+                validate_array!(value)
+              when :class
+                validate_instance_of!(value, Object)
+              else
+                raise ArgumentError, "Unknown type #{type} for attribute #{attr}"
+              end
+            end
+
+            # Utility method to validate a Symbol.
+            def validate_symbol!(value)
+              raise ArgumentError, "Expected a Symbol, got #{value.class}" unless value.is_a?(Symbol)
+            end
+
+            # Utility method to validate a Hash.
+            def validate_hash!(value)
+              raise ArgumentError, "Expected a Hash, got #{value.class}" unless value.is_a?(Hash)
+            end
+
+            # Utility method to validate an Array.
+            def validate_array!(value)
+              raise ArgumentError, "Expected an Array, got #{value.class}" unless value.is_a?(Array)
+            end
+
+            # Utility method to validate a class instance.
+            def validate_instance_of!(value, klass)
+              raise ArgumentError, "Expected an instance of #{klass}, got #{value.class}" unless value.is_a?(klass)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/attribute.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          require_relative "attribute/attribute"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        class Base
+          # Foundation for all configurations
+          include Attribute
+          include Hook
+
+          # Include the settings manager and dependency handler
+          include Settings::Manager
+          include DependencyHandler
+
+          def initialize
+            run_hooks(:before_initialize)
+            initialize_config_attrs
+            run_hooks(:after_initialize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/config.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        require_relative "attribute"
+        require_relative "hook"
+        require_relative "settings"
+        require_relative "dependency_handler"
+        require_relative "base"
+        require_relative "manager"
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/dependency_handler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module DependencyHandler
+          class << self
+            def included(base)
+              base.class_eval do
+                attr_accessor(:missing_dependencies)
+              end
+              base.include(InstanceMethods)
+            end
+          end
+
+          module InstanceMethods
+            def initialize(*args)
+              super
+              @missing_dependencies ||= []
+            end
+
+            def delete_option_on_failure(attr_name, option_key, *missing_dependencies)
+              log_missing_dependency(attr_name, option_key, missing_dependencies)
+              send(attr_name).delete(option_key)
+              track_missing_dependency(missing_dependencies)
+            end
+
+            private
+
+            def track_missing_dependency(missing_dependencies)
+              @missing_dependencies = missing_dependencies
+            end
+
+            def log_missing_dependency(attr_name, option_key, missing_dependencies)
+              missing_dependencies.each do |dependency|
+                Utils::Logger.log(
+                  "Missing dependency: #{dependency}. " \
+                    "Please add `gem '#{dependency}'` to your Gemfile and run `bundle install`.",
+                  level: :warn,
+                  emoji: :warning,
+                )
+
+                Utils::Logger.log(
+                  "Deleting option #{option_key} from `config.#{attr_name}`",
+                  level: :warn,
+                  emoji: :warning,
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/hook/hook.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          require_relative "hook_registry"
+          require_relative "hook_runner"
+
+          class << self
+            def included(base)
+              base.extend(HookRegistry)
+            end
+          end
+
+          include HookRunner
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/hook/hook_registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          module HookRegistry
+            # Registers a hook for a specific stage
+            def register_hook(stage, &block)
+              hooks[stage] ||= []
+              hooks[stage] << block
+            end
+
+            # Retrieves the hooks registered for this class
+            def hooks
+              @hooks ||= {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/hook/hook_runner.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          module HookRunner
+            private
+
+            # Runs all hooks registered for a given stage
+            def run_hooks(stage)
+              self.class.hooks[stage]&.each { |hook| instance_eval(&hook) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/hook/manager.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          module Manager
+            class << self
+              def included(base)
+                base.extend(ClassMethods)
+              end
+            end
+
+            module ClassMethods
+              def register_hook(stage, &block)
+                hooks[stage] ||= []
+                hooks[stage] << block
+              end
+
+              def hooks
+                @hooks ||= {}
+              end
+            end
+
+            private
+
+            def run_hooks(stage)
+              self.class.hooks[stage]&.each { |hook| instance_eval(&hook) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/hook.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          require_relative "hook/hook"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/manager.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Manager
+          class << self
+            def included(base)
+              base.extend(ClassMethods)
+            end
+          end
+
+          module ClassMethods
+            # Provides access to a single instance of the configuration class
+            # It dynamically uses the Configuration class in the including module's namespace
+            def configuration
+              @configuration ||= self::Configuration.new
+            end
+
+            # Allows block-based configuration
+            # Example usage:
+            #   ConfigClass.configure do |config|
+            #     config.attr_name = value
+            #   end
+            def configure
+              yield(configuration)
+            rescue StandardError => e
+              ErrorHandler.handle_error(e)
+            end
+
+            # Resets the configuration by reinitializing it with default values
+            def reset!
+              @configuration = self::Configuration.new # Reinitialize the configuration instance
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/settings/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Settings
+          class Base
+            def initialize(settings = {})
+              @default_settings = settings
+              @settings = merge_settings(@default_settings, settings)
+            end
+
+            def set(*keys, value)
+              key_path = normalize_keys(keys)
+              last_key = key_path.pop
+              target = key_path.each_with_object(@settings) do |key, nested|
+                nested[key] ||= {}
+              end
+              target[last_key] = value
+            end
+
+            def get(*keys)
+              key_path = normalize_keys(keys)
+              key_path.reduce(@settings) do |nested, key|
+                nested.is_a?(Hash) ? nested[key] : nil
+              end
+            end
+
+            def reset!
+              @settings = @default_settings
+            end
+
+            private
+
+            def normalize_keys(keys)
+              key_path = keys.flatten
+              if key_path.size == 1 && key_path.first.is_a?(String)
+                key_path.first.to_s.split(".").map(&:to_sym)
+              else
+                key_path.map(&:to_sym)
+              end
+            end
+
+            def merge_settings(defaults, overrides)
+              defaults.merge(overrides) do |_key, oldval, newval|
+                if oldval.is_a?(Hash) && newval.is_a?(Hash)
+                  merge_settings(oldval, newval)
+                else
+                  newval
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/settings/manager.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Settings
+          module Manager
+            class << self
+              def included(base)
+                base.extend(ClassMethods)
+              end
+            end
+
+            module ClassMethods
+              # Ensure that default configuration attributes are applied to subclasses.
+              def inherited(subclass)
+                subclass.set_default_settings
+                super
+              end
+
+              # Define default settings for the class.
+              def set_default_settings(settings = {})
+                config_attr(:settings, default_value: settings, type: :hash, resolver: :resolve_settings)
+              end
+            end
+
+            private
+
+            def resolve_settings(value)
+              Base.new(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/settings/settings.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Settings
+          require_relative "base"
+          require_relative "manager"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config/settings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Settings
+          require_relative "settings/settings"
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/config.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        require_relative "config/config"
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/construct.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      require_relative "config"
+      require_relative "component"
+    end
+  end
+end

data/lib/dev_suite/utils/construct.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      # The Construct module serves as a namespace for reusable constructs that
+      # provide foundational utilities, such as configuration management, which
+      # can be included in other modules throughout the DevSuite framework.
+      #
+      # This module centralizes shared functionality to promote code reuse,
+      # maintainability, and consistency across different modules.
+
+      require_relative "construct/construct"
+    end
+  end
+end

data/lib/dev_suite/utils/dependency_loader.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module DependencyLoader
+      class << self
+        # Public method to safely load multiple dependencies.
+        # Executes the given block if all dependencies are successfully loaded.
+        # Calls the on_failure handler with the list of missing dependencies if any are not found.
+        #
+        # @param dependencies [Array<String>] List of gem names to load.
+        # @param on_failure [Proc] Handler to call with missing dependencies if any are not found.
+        # @yield Executes the block if all dependencies are loaded.
+        def safe_load_dependencies(*dependencies, on_failure: method(:default_failure_handler))
+          missing_dependencies = find_missing_dependencies(dependencies)
+
+          if missing_dependencies.empty?
+            yield if block_given?
+          else
+            on_failure.call(missing_dependencies)
+          end
+        end
+
+        # Check if a gem is installed by attempting to require it.
+        #
+        # @param gem_name [String] The name of the gem to check.
+        # @return [Boolean] true if the gem is installed, false otherwise.
+        def gem_installed?(gem_name)
+          require gem_name
+          true
+        rescue LoadError
+          false
+        end
+
+        private
+
+        # Finds and returns a list of missing dependencies from the provided list.
+        #
+        # @param dependencies [Array<String>] List of gem names to check.
+        # @return [Array<String>] List of missing dependencies.
+        def find_missing_dependencies(dependencies)
+          dependencies.reject { |gem_name| gem_installed?(gem_name) }
+        end
+
+        # Default failure handler that logs missing dependencies.
+        #
+        # @param missing_dependencies [Array<String>] List of missing dependencies.
+        def default_failure_handler(missing_dependencies)
+          missing_dependencies.each do |gem_name|
+            log_missing_dependency(gem_name)
+          end
+        end
+
+        # Logs a warning about a missing dependency.
+        #
+        # @param gem_name [String] The name of the missing gem.
+        def log_missing_dependency(gem_name)
+          gem_simple_name = gem_name.split("/").last.capitalize
+          message = "#{gem_simple_name} gem not installed. Please add `gem '#{gem_simple_name.downcase}'` " \
+            "to your Gemfile and run `bundle install`."
+
+          Utils::Logger.log(
+            message,
+            level: :warn,
+            emoji: :warning,
+          )
+        end
+      end
+    end
+  end
+end