dev_suite 0.2.5 → 0.2.7

data/lib/dev_suite/utils/color/strategy.rb

@@ -4,25 +4,7 @@ module DevSuite
   module Utils
     module Color
       module Strategy
-        require_relative "strategy/base"
-        require_relative "strategy/basic"
-        require_relative "strategy/rgb"
-        require_relative "strategy/theme"
-
-        class << self
-          def create(type)
-            case type
-            when :basic
-              Basic.new
-            when :rgb
-              Rgb.new
-            when :theme
-              Theme.new
-            else
-              raise ArgumentError, "Unknown strategy type: #{type}"
-            end
-          end
-        end
+        require_relative "strategy/strategy"
       end
     end
   end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        class Base
+          class << self
+            # Returns the key for the class. If the COMPONENT_KEY constant is defined, it returns its value.
+            # Otherwise, it generates a key based on the class name.
+            def component_key
+              return const_get(:COMPONENT_KEY) if const_defined?(:COMPONENT_KEY)
+
+              generate_key_from_class_name
+            end
+
+            private
+
+            # Generates a key from the class name by converting it to snake_case and symbolizing it.
+            def generate_key_from_class_name
+              class_name = name.split("::").last
+              snake_case_class_name = class_name.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+              snake_case_class_name.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        require_relative "base"
+        require_relative "manager"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Initializer
+          extend self
+
+          def define_constants(base)
+            structure_module = ensure_structure_module(base)
+            define_structure_component(structure_module)
+          end
+
+          private
+
+          def ensure_structure_module(base)
+            base.const_defined?(:Structure) ? base.const_get(:Structure) : base.const_set(:Structure, Module.new)
+          end
+
+          def define_structure_component(structure_module)
+            structure_module.const_set(:Component, Base) unless structure_module.const_defined?(:Component)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Manager
+          class << self
+            def included(base)
+              base.extend(ClassMethods)
+            end
+          end
+
+          module ClassMethods
+            # Stores a mapping of component symbols to their respective classes
+            def registered_components
+              @registered_components ||= {}
+            end
+
+            # Register a new component
+            def register_component(component_class)
+              raise ArgumentError,
+                "#{component_class} must define a component_key" unless component_class.respond_to?(:component_key)
+
+              registered_components[component_class.component_key] = component_class
+            end
+
+            # Build a single component
+            def build_component(component_key)
+              component_class = registered_components[component_key]
+
+              raise ArgumentError, "Component not found for key: #{component_key}" unless component_class
+
+              component_class.new
+            end
+
+            # Build multiple components
+            def build_components(component_keys)
+              component_keys.map { |key| build_component(key) }
+            end
+
+            def build_component_from_instance(instance)
+              component_class = registered_components.find do |klass, _|
+                instance.is_a?(klass)
+              end
+
+              raise ArgumentError,
+                "Component not found for instance: #{instance.class}" unless component_class
+
+              component_class.last.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/construct/{config/configuration.rb → component.rb}

@@ -3,10 +3,8 @@
 module DevSuite
   module Utils
     module Construct
-      module Config
-        class Configuration < Base
-          include Settings::Manager
-        end
+      module Component
+        require_relative "component/component"
       end
     end
   end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          module AttrDefinition
+            def config_attr(attr, default_value: nil, type: nil, resolver: nil)
+              config_attrs[attr] = build_attr_details(
+                default_value: default_value,
+                type: type,
+                resolver: resolver,
+              )
+              define_config_attr_methods(attr)
+            end
+
+            def config_attrs
+              @config_attrs ||= {}
+            end
+
+            def config_attr_present?(attr)
+              config_attrs.key?(attr)
+            end
+
+            private
+
+            def build_attr_details(default_value:, type:, resolver:)
+              {
+                default_value: default_value,
+                type: type,
+                resolver: resolver,
+              }
+            end
+
+            def define_config_attr_methods(attr)
+              define_getter_methods(attr)
+              define_setter_methods(attr)
+              define_delete_method(attr)
+            end
+
+            def define_getter_methods(attr)
+              define_method(attr) do
+                instance_variable_get("@#{attr}")
+              end
+
+              define_method("original_#{attr}") do
+                instance_variable_get("@original_#{attr}")
+              end
+            end
+
+            def define_setter_methods(attr)
+              define_method("#{attr}=") do |value|
+                set_config_attr(attr: attr, value: value)
+              end
+            end
+
+            def define_delete_method(attr)
+              define_method("#{attr}.delete") do |*keys|
+                current_value = instance_variable_get("@#{attr}")
+                original_value = instance_variable_get("@original_#{attr}")
+
+                if original_value.is_a?(Array) && current_value.is_a?(Array)
+                  keys.each do |key|
+                    original_value.delete(key)
+                    set_config_attr(attr: attr, value: original_value)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          module AttrInitialization
+            private
+
+            # Initializes all configuration attributes with their default values
+            def initialize_config_attrs
+              self.class.config_attrs.each do |attr, details|
+                send("#{attr}=", details[:default_value]) unless instance_variable_defined?("@#{attr}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,9 +5,18 @@ module DevSuite
     module Construct
       module Config
         module Attribute
-          require_relative "validator"
-          require_relative "resolver"
-          require_relative "manager"
+          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

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

@@ -5,8 +5,13 @@ module DevSuite
     module Construct
       module Config
         class Base
-          include Attribute::Manager
-          include Hook::Manager
+          # 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)

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

@@ -6,18 +6,10 @@ module DevSuite
       module Config
         require_relative "attribute"
         require_relative "hook"
-        require_relative "base"
         require_relative "settings"
-        require_relative "configuration"
+        require_relative "dependency_handler"
+        require_relative "base"
         require_relative "manager"
-        require_relative "initializer"
-
-        class << self
-          def included(base)
-            base.extend(Manager)
-            Initializer.define_config_constants(base)
-          end
-        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

@@ -5,7 +5,16 @@ module DevSuite
     module Construct
       module Config
         module Hook
-          require_relative "manager"
+          require_relative "hook_registry"
+          require_relative "hook_runner"
+
+          class << self
+            def included(base)
+              base.extend(HookRegistry)
+            end
+          end
+
+          include HookRunner
         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/manager.rb

@@ -5,26 +5,34 @@ module DevSuite
     module Construct
       module Config
         module Manager
-          # 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
+          class << self
+            def included(base)
+              base.extend(ClassMethods)
+            end
           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
+          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
+            # Resets the configuration by reinitializing it with default values
+            def reset!
+              @configuration = self::Configuration.new # Reinitialize the configuration instance
+            end
           end
         end
       end

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

@@ -4,6 +4,7 @@ module DevSuite
   module Utils
     module Construct
       require_relative "config"
+      require_relative "component"
     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

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

@@ -4,7 +4,7 @@ module DevSuite
   module Utils
     module FileLoader
       module Config
-        include Construct::Config
+        include Construct::Config::Manager
 
         require_relative "configuration"
       end