dev_suite 0.2.4 → 0.2.5

data/lib/dev_suite/request_logger/logger.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Logger
+      class << self
+        def log_request(adapter, request)
+          log_entry(format_request_line(adapter, request), :start)
+          log_headers(request) if settings.get(:log_headers)
+          log_cookies(request) if settings.get(:log_cookies)
+          log_body(request.body, "Request") if settings.get(:log_body)
+        end
+
+        def log_response(adapter, response)
+          status_emoji = determine_status_emoji(response)
+          log_level = determine_log_level(response)
+
+          log_entry(format_response_line(adapter, response), status_emoji, log_level)
+          log_headers(response) if settings.get(:log_headers)
+          log_body(response.body, "Response") if settings.get(:log_body)
+        end
+
+        private
+
+        def config
+          Config.configuration
+        end
+
+        def settings
+          config.settings
+        end
+
+        def log_entry(message, emoji, level = settings.get(:log_level))
+          Utils::Logger.log(message, level: level, emoji: emoji)
+        end
+
+        def determine_status_emoji(response)
+          response_success?(response) ? :success : :error
+        end
+
+        def determine_log_level(response)
+          response_success?(response) ? settings.get(:log_level) : :error
+        end
+
+        def response_success?(response)
+          response.code.to_i.between?(200, 299)
+        end
+
+        def extract_headers(request)
+          request.each_header.to_h
+        end
+
+        def extract_cookies(request)
+          if request.respond_to?(:to_hash) && request.to_hash["cookie"]
+            request.to_hash["cookie"]
+          elsif request.respond_to?(:headers) && request.headers["Cookie"]
+            [request.headers["Cookie"]]
+          else
+            []
+          end
+        end
+
+        def format_request_line(adapter, request)
+          "#{adapter.class} Request: #{request.method} #{request.uri}"
+        end
+
+        def format_response_line(adapter, response)
+          "#{adapter.class} Response: #{response.code} #{response.message}"
+        end
+
+        def log_headers(request)
+          headers = extract_headers(request)
+          log_entry("Headers: #{headers}", :document) unless headers.empty?
+        end
+
+        def log_cookies(request)
+          cookies = extract_cookies(request)
+          if cookies.any?
+            log_entry("Cookies: #{cookies.join("; ")}", :cookie)
+          else
+            log_entry("Cookies: None", :cookie)
+          end
+        end
+
+        def log_body(body, type)
+          return unless body && !body.empty?
+
+          log_entry("#{type} Body: #{body}", :code)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/request_logger.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    require_relative "config"
+    require_relative "adapter"
+    require_relative "logger"
+
+    class << self
+      def with_logging(&block)
+        enable_adapters
+        block.call
+      ensure
+        # Ensure that adapters are disabled even if an exception is raised
+        disable_adapters
+      end
+
+      private
+
+      def enable_adapters
+        Config.configuration.adapters.each(&:enable)
+      end
+
+      def disable_adapters
+        Config.configuration.adapters.each(&:disable)
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    require_relative "request_logger/request_logger"
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Color
+      require_relative "colorizer"
+      require_relative "palette"
+      require_relative "strategy"
+      require_relative "config"
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Color
+      module Config
+        include Construct::Config
+
+        require_relative "configuration"
+      end
+    end
+  end
+end

data/lib/dev_suite/utils/color/config/configuration.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Color
+      module Config
+        class Configuration < BaseConfiguration
+          config_attr :strategy,
+            default_value: :theme,
+            type: :symbol,
+            resolver: :resolve_strategy
+
+          config_attr :palette,
+            default_value: :default,
+            type: :symbol,
+            resolver: :resolve_palette
+
+          private
+
+          def resolve_strategy(value)
+            Strategy.create(value)
+          end
+
+          def resolve_palette(value)
+            Palette.create(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,37 +3,8 @@
 module DevSuite
   module Utils
     module Color
-      class Config
-        attr_accessor :strategy, :palette
-
-        def initialize(strategy: :theme, palette: :default)
-          @palette = Palette.create(palette)
-          @strategy = Strategy.create(strategy, palette: @palette)
-          freeze # Make the instance of this class immutable as well
-        end
-
-        class << self
-          #
-          # Provide global access to a single instance of Config
-          #
-          def configuration
-            @configuration ||= new
-          end
-
-          # Allow block-based configuration
-          def configure
-            yield(configuration)
-          rescue StandardError => e
-            handle_configuration_error(e)
-            raise
-          end
-
-          private
-
-          def handle_configuration_error(error)
-            puts "Configuration error: #{error.message}"
-          end
-        end
+      module Config
+        require_relative "config/config"
       end
     end
   end

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

@@ -5,17 +5,12 @@ module DevSuite
     module Color
       module Strategy
         class Theme < Base
-          def initialize(palette)
-            super()
-            @palette = palette
-          end
-
           def colorize(text, color: :default)
-            unless @palette.colors.key?(color)
+            unless palette.colors.key?(color)
               raise ArgumentError, "Invalid color key"
             end
 
-            color_code = @palette.colors[color]
+            color_code = palette.colors[color]
 
             unless valid_color_code?(color_code)
               raise ArgumentError, "Invalid color code"
@@ -26,6 +21,10 @@ module DevSuite
 
           private
 
+          def palette
+            Config.configuration.palette
+          end
+
           def valid_color_code?(color_code)
             color_code.is_a?(Integer) && color_code.between?(0, 255)
           end

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

@@ -10,16 +10,14 @@ module DevSuite
         require_relative "strategy/theme"
 
         class << self
-          def create(type, palette: nil)
+          def create(type)
             case type
             when :basic
               Basic.new
             when :rgb
               Rgb.new
             when :theme
-              raise ArgumentError, "Palette is required for theme strategy" unless palette
-
-              Theme.new(palette)
+              Theme.new
             else
               raise ArgumentError, "Unknown strategy type: #{type}"
             end

data/lib/dev_suite/utils/color.rb

@@ -3,10 +3,7 @@
 module DevSuite
   module Utils
     module Color
-      require_relative "color/colorizer"
-      require_relative "color/palette"
-      require_relative "color/strategy"
-      require_relative "color/config"
+      require_relative "color/color"
     end
   end
 end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          require_relative "validator"
+          require_relative "resolver"
+          require_relative "manager"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          module Manager
+            include Validator
+            include Resolver
+
+            class << self
+              def included(base)
+                base.extend(ClassMethods)
+              end
+            end
+
+            module ClassMethods
+              def config_attr(attr, default_value: nil, type: nil, resolver: nil)
+                config_attrs[attr] = { 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 define_config_attr_methods(attr)
+                define_method(attr) { instance_variable_get("@#{attr}") }
+                define_method("#{attr}=") do |value|
+                  validate_and_set_config_attr(attr: attr, value: value)
+                end
+              end
+            end
+
+            private
+
+            def initialize_config_attrs
+              self.class.config_attrs.each do |attr, details|
+                send("#{attr}=", details[:default_value]) unless instance_variable_defined?("@#{attr}")
+              end
+            end
+
+            def validate_and_set_config_attr(attr:, value:)
+              attr_details = self.class.config_attrs[attr]
+              type, resolver = attr_details.values_at(:type, :resolver)
+
+              validate_config_attr_type!(attr: attr, value: value, type: type) if type
+              resolved_value = resolver ? resolve_config_attr(value: value, resolver: resolver) : value
+              instance_variable_set("@#{attr}", resolved_value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Attribute
+          module Resolver
+            extend self
+
+            # Resolves the value of an attribute based on its resolver.
+            # If no resolver is provided, the value is returned as is.
+            #
+            # @param value [Object] The value to resolve.
+            # @param resolver [Proc] The resolver to use for the attribute.
+            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/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,20 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        class Base
+          include Attribute::Manager
+          include Hook::Manager
+
+          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,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        require_relative "attribute"
+        require_relative "hook"
+        require_relative "base"
+        require_relative "settings"
+        require_relative "configuration"
+        require_relative "manager"
+        require_relative "initializer"
+
+        class << self
+          def included(base)
+            base.extend(Manager)
+            Initializer.define_config_constants(base)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        class Configuration < Base
+          include Settings::Manager
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Hook
+          require_relative "manager"
+        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/initializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Config
+        module Initializer
+          class << self
+            def define_config_constants(base)
+              base.const_set(:BaseConfiguration, Configuration)
+
+              unless base.const_defined?(:Configuration)
+                base.const_set(:Configuration, Class.new(base::BaseConfiguration))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    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
+          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