dev_suite 0.2.7 → 0.2.10

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

@@ -17,26 +17,28 @@ module DevSuite
               @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
+            # Check if a component is registered
+            def component_registered?(component_key)
+              unless registered_components.key?(component_key)
+                Utils::Logger.log("Component not found for key: #{component_key}", level: :warn, emoji: :warning)
+                return false
+              end
+              true
             end
 
             # Build a single component
-            def build_component(component_key)
+            def build_component(component_key, **options, &block)
               component_class = registered_components[component_key]
 
               raise ArgumentError, "Component not found for key: #{component_key}" unless component_class
 
-              component_class.new
+              component_class.new(**options, &block)
             end
 
-            # Build multiple components
+            # Build multiple components by filtering registered ones
             def build_components(component_keys)
-              component_keys.map { |key| build_component(key) }
+              component_keys.select { |key| component_registered?(key) }
+                .map { |key| build_component(key) }
             end
 
             def build_component_from_instance(instance)
@@ -49,6 +51,21 @@ module DevSuite
 
               component_class.last.new
             end
+
+            private
+
+            # 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
+
+            # Load a dependency and execute a block if successful
+            def load_dependency(dependencies = [], on_failure: -> {}, &block)
+              DependencyLoader.safe_load_dependencies(dependencies, on_failure: on_failure, &block)
+            end
           end
         end
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Validator
+          class Base
+            include ValidationRule
+
+            def validate!(**args)
+              raise NotImplementedError
+            end
+
+            protected
+
+            def raise_validation_error(field, message)
+              raise ValidationError.new(field, message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Validator
+          class ValidationError < StandardError
+            attr_reader :field, :message
+
+            def initialize(field, message)
+              @field = field
+              @message = message
+              super("[#{field}] #{message}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Validator
+          module ValidationRule
+            def validate_inclusion!(value, allowed_values, field_name: "Value")
+              unless allowed_values.include?(value)
+                raise_validation_error(
+                  field_name,
+                  "#{value} is not valid. Allowed values: #{allowed_values.join(", ")}",
+                )
+              end
+            end
+
+            def validate_non_empty_string!(value, field_name: "Value")
+              unless value.is_a?(String) && !value.strip.empty?
+                raise_validation_error(field_name, "must be a non-empty string.")
+              end
+            end
+
+            def validate_url!(url, field_name: "URL")
+              unless url =~ /\A#{URI::DEFAULT_PARSER.make_regexp(["http", "https"])}\z/
+                raise_validation_error(field_name, "#{url} is not a valid URL.")
+              end
+            end
+
+            def validate_hash!(value, field_name: "Value")
+              unless value.is_a?(Hash)
+                raise_validation_error(field_name, "must be a Hash. Provided value is #{value.class.name}.")
+              end
+            end
+
+            def validate_array_of_type!(array, klass, field_name: "Array")
+              unless array.is_a?(Array) && array.all? { |item| item.is_a?(klass) }
+                raise_validation_error(field_name, "must be an Array of #{klass.name} instances.")
+              end
+            end
+
+            def validate_range!(value, range, field_name: "Value")
+              unless range.include?(value)
+                raise_validation_error(field_name, "#{value} is not within the allowed range: #{range}.")
+              end
+            end
+
+            def validate_presence!(value, field_name: "Value")
+              if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+                raise_validation_error(field_name, "is required and cannot be empty.")
+              end
+            end
+
+            def validate_type!(value, allowed_types, field_name: "Value")
+              return if allowed_types.any? { |type| value.is_a?(type) }
+
+              allowed_names = allowed_types.map(&:name).join(", ")
+              raise_validation_error(
+                field_name,
+                "must be one of the following types: #{allowed_names}. Got #{value.class.name} instead.",
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Validator
+          require_relative "validation_error"
+          require_relative "validation_rule"
+          require_relative "base"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        module Validator
+          require_relative "validator/validator"
+        end
+      end
+    end
+  end
+end

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

@@ -5,50 +5,41 @@ module DevSuite
     module Construct
       module Config
         module DependencyHandler
-          class << self
-            def included(base)
-              base.class_eval do
-                attr_accessor(:missing_dependencies)
-              end
-              base.include(InstanceMethods)
-            end
+          # Use a lazy initializer in the getter method
+          def missing_dependencies
+            @missing_dependencies ||= []
           end
 
-          module InstanceMethods
-            def initialize(*args)
-              super
-              @missing_dependencies ||= []
-            end
+          def remove_failed_dependency(attr_name, option_key, *missing_dependencies)
+            track_missing_dependency(missing_dependencies)
 
-            def delete_option_on_failure(attr_name, option_key, *missing_dependencies)
+            attribute = send(attr_name)
+            original_attribute = send("original_#{attr_name}")
+
+            if original_attribute.is_a?(Array) && original_attribute.include?(option_key)
+              attribute.delete(option_key)
               log_missing_dependency(attr_name, option_key, missing_dependencies)
-              send(attr_name).delete(option_key)
-              track_missing_dependency(missing_dependencies)
             end
+          end
 
-            private
+          private
 
-            def track_missing_dependency(missing_dependencies)
-              @missing_dependencies = missing_dependencies
-            end
+          def track_missing_dependency(missing_dependencies)
+            @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
+          def log_missing_dependency(attr_name, option_key, missing_dependencies)
+            missing_dependencies.each do |dependency|
+              log_warning("Missing dependency: #{dependency}. " \
+                "Please add `gem '#{dependency}'` to your Gemfile and run `bundle install`.")
+              log_warning("Deleted option #{option_key} from `config.#{attr_name}`")
             end
           end
+
+          def log_warning(message)
+            Utils::Logger.log(message, level: :warn, emoji: :warning)
+          end
         end
       end
     end

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

@@ -8,49 +8,66 @@ module DevSuite
           class Base
             def initialize(settings = {})
               @default_settings = settings
-              @settings = merge_settings(@default_settings, settings)
+              @settings = Utils::Data.deep_merge(@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
+              key_path = extract_path_from_keys(keys)
+              Utils::Data.set_value_by_path(@settings, key_path, 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
+            def get(*keys, default: nil)
+              key_path = extract_path_from_keys(keys)
+              value = Utils::Data.get_value_by_path(@settings, key_path)
+              value.nil? ? default : value
             end
 
             def reset!
-              @settings = @default_settings
+              @settings = Utils::Data.deep_merge(@default_settings, {})
+            end
+
+            def to_h
+              @settings
+            end
+
+            def merge(options)
+              Utils::Data.deep_merge(@settings, options)
             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)
+            # Extract path from mixed input (strings or arrays) and handle array-like syntax
+            def extract_path_from_keys(keys)
+              keys = keys.flatten
+
+              # Handle case where keys is a single dot-separated string with array-like notation
+              if keys.size == 1 && keys.first.is_a?(String)
+                return parse_string_key(keys.first)
               end
+
+              # Otherwise, symbolize all keys and convert string-based array indices
+              keys.map { |key| parse_key_component(key) }
+            end
+
+            # Parse dot-separated strings and handle array-like notation (e.g., "users[1].avt")
+            def parse_string_key(key)
+              key.split(".").flat_map { |segment| parse_key_component(segment) }
             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
+            # Parse individual components of the key (convert "users[1]" to [:users, 1])
+            def parse_key_component(component)
+              if component.match?(/\[\d+\]/)
+                # Handle array-like notation in strings like "users[1]"
+                component.scan(/[^\[\]]+/).map { |part| integer_or_symbol(part) }
+              else
+                integer_or_symbol(component)
               end
             end
+
+            # Convert to integer if it's a number, otherwise symbolize
+            def integer_or_symbol(part)
+              part.match?(/^\d+$/) ? part.to_i : part.to_sym
+            end
           end
         end
       end

data/lib/dev_suite/utils/data/base_operations.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module BaseOperations
+        # Recursively delete a key from any level in the data structure
+        def deep_delete_key(data, key_to_delete)
+          case data
+          when Hash, Array
+            delete_key_from_structure(data, key_to_delete)
+          else
+            data
+          end
+        end
+
+        # Destructive deep merge (modifies hash1)
+        def deep_merge!(hash1, hash2)
+          return hash1 if hash2.nil?
+
+          hash2.each do |key, new_val|
+            hash1[key] = merge_value(hash1[key], new_val)
+          end
+          hash1
+        end
+
+        # Non-destructive deep merge
+        def deep_merge(hash1, hash2)
+          deep_merge!(hash1.dup, hash2)
+        end
+
+        private
+
+        # Helper to merge individual values based on their types
+        def merge_value(old_val, new_val)
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge!(old_val, new_val)
+          else
+            new_val
+          end
+        end
+
+        # Helper method to delete key from both Hash and Array recursively
+        def delete_key_from_structure(data, key_to_delete)
+          case data
+          when Hash
+            data.each_with_object({}) do |(key, value), result|
+              unless key == key_to_delete
+                result[key] = deep_delete_key(value, key_to_delete)
+              end
+            end
+          when Array
+            data.map { |item| deep_delete_key(item, key_to_delete) }
+          else
+            data
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      require_relative "base_operations"
+      require_relative "transformations"
+      require_relative "search_filter"
+      require_relative "path_access"
+      require_relative "serialization"
+
+      extend BaseOperations
+      extend Transformations
+      extend SearchFilter
+      extend PathAccess
+      extend Serialization
+    end
+  end
+end

data/lib/dev_suite/utils/data/path_access.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Data
+      module PathAccess
+        # Fetch value from a nested structure using a path
+        def get_value_by_path(data, path)
+          keys = parse_path(path)
+          traverse_path_for_get(data, keys)
+        end
+
+        # Set value in a nested structure using a path
+        def set_value_by_path(data, path, value)
+          keys = parse_path(path)
+          last_key = keys.pop
+          target = traverse_path_for_set(data, keys)
+
+          set_final_value(target, last_key, value)
+        end
+
+        # Delete a key from a nested structure using a path
+        def delete_key_by_path(data, path)
+          keys = parse_path(path)
+          last_key = keys.pop
+          target = traverse_path_for_delete(data, keys)
+
+          delete_final_key(target, last_key)
+        end
+
+        private
+
+        # Parse the path into an array of keys/symbols/integers
+        def parse_path(path)
+          return path if path.is_a?(Array)
+          return [path] if single_symbol_path?(path)
+
+          parse_symbol_or_string_path(path)
+        end
+
+        # Check if the path is a symbol without dots
+        def single_symbol_path?(path)
+          path.is_a?(Symbol) && !path.to_s.include?(".")
+        end
+
+        # Parse a symbol or string path into an array of keys
+        def parse_symbol_or_string_path(path)
+          if path.is_a?(Symbol)
+            parse_symbol_path(path)
+          else
+            parse_string_path(path)
+          end
+        end
+
+        # Parse a symbol path that contains dots (e.g., :"test.1")
+        def parse_symbol_path(path)
+          path.to_s.split(".").map { |part| parse_part(part) }
+        end
+
+        # Parse a string path into keys (e.g., 'users.1.name')
+        def parse_string_path(path)
+          path.to_s.split(/\.|\[|\]/).reject(&:empty?).map { |part| parse_part(part) }
+        end
+
+        # Parse each part into either a symbol or integer
+        def parse_part(part)
+          part.match?(/^\d+$/) ? part.to_i : part.to_sym
+        end
+
+        # Helper to traverse the path for getting values
+        def traverse_path_for_get(data, keys)
+          keys.reduce(data) do |current_data, key|
+            check_invalid_path(current_data, key)
+
+            case current_data
+            when Hash
+              fetch_from_hash(current_data, key)
+            when Array
+              fetch_from_array(current_data, key)
+            else
+              raise KeyError, "Invalid data type at '#{key}'"
+            end
+          end
+        end
+
+        # Helper to traverse the path for setting values
+        def traverse_path_for_set(data, keys)
+          keys.reduce(data) do |current_data, key|
+            check_invalid_path(current_data, key)
+
+            case current_data
+            when Hash
+              current_data[find_existing_key(current_data, key)] ||= {}
+            when Array
+              current_data[key.to_i] ||= {}
+            else
+              break nil
+            end
+          end
+        end
+
+        # Helper to check for invalid paths
+        def check_invalid_path(data, key)
+          raise KeyError, "Invalid path at '#{key}'" if data.nil?
+        end
+
+        # Fetch value from a hash, trying both symbol and string keys
+        def fetch_from_hash(hash, key)
+          hash[key.to_sym] || hash[key.to_s]
+        end
+
+        # Fetch value from an array if the key is an integer
+        def fetch_from_array(array, key)
+          key.is_a?(Integer) ? array[key] : nil
+        end
+
+        # Set the final value in a hash or array
+        def set_final_value(target, last_key, value)
+          case target
+          when Hash
+            target[find_existing_key(target, last_key)] = value
+          when Array
+            if last_key.is_a?(Integer)
+              target[last_key] = value
+            else
+              raise KeyError, "Invalid path or type at '#{last_key}'"
+            end
+          else
+            raise KeyError, "Invalid target type for path at '#{last_key}'"
+          end
+        end
+
+        # Check if the key already exists and return the key in its original type (symbol or string)
+        def find_existing_key(hash, key)
+          return key if hash.key?(key) # Key already exists in original form
+          return key.to_s if hash.key?(key.to_s) # Exists as a string
+          return key.to_sym if hash.key?(key.to_sym) # Exists as a symbol
+
+          key # Otherwise, return the key as-is (use the incoming type)
+        end
+
+        # Helper to traverse the path for deletion
+        def traverse_path_for_delete(data, keys)
+          keys.reduce(data) do |current_data, key|
+            check_invalid_path(current_data, key)
+
+            case current_data
+            when Hash
+              current_data[find_existing_key(current_data, key)]
+            when Array
+              current_data[key.to_i]
+            else
+              raise KeyError, "Invalid data type at '#{key}'"
+            end
+          end
+        end
+
+        # Helper to delete the final key in a hash or array
+        def delete_final_key(target, last_key)
+          case target
+          when Hash
+            target.delete(find_existing_key(target, last_key))
+          when Array
+            target.delete_at(last_key.to_i) if last_key.is_a?(Integer)
+          else
+            raise KeyError, "Cannot delete key from unsupported data type"
+          end
+        end
+      end
+    end
+  end
+end