dev_suite 0.2.4 → 0.2.7

data/lib/dev_suite/request_logger/logger.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Logger
+      class << self
+        def log_request(instance, request)
+          request = extract_request(instance, request)
+          log_entry(format_request_line(instance, 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(instance, response)
+          response = extract_response(instance, response)
+          status_emoji = determine_status_emoji(response)
+          log_level = determine_log_level(response)
+
+          log_entry(format_response_line(instance, 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 extract_request(instance, request)
+          extractor = Extractor.build_component_from_instance(instance)
+          extractor.extract_request(request)
+        end
+
+        def extract_response(instance, response)
+          extractor = Extractor.build_component_from_instance(instance)
+          extractor.extract_response(response)
+        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? ? :success : :error
+        end
+
+        def determine_log_level(response)
+          response.success? ? settings.get(:log_level) : :error
+        end
+
+        def format_request_line(adapter, request)
+          "#{adapter.class} Request: #{request.method} #{request.url}"
+        end
+
+        def format_response_line(adapter, response)
+          "#{adapter.class} Response: #{response.status} #{response.message}"
+        end
+
+        def log_headers(request)
+          headers = request.headers
+          log_entry("Headers: #{headers}", :document) unless headers.empty?
+        end
+
+        def log_cookies(request)
+          cookies = request.cookies
+          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.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# request_logger/request.rb
+
+module DevSuite
+  module RequestLogger
+    class Request
+      attr_reader :method, :url, :headers, :cookies, :body
+
+      def initialize(method:, url:, headers:, cookies:, body:)
+        @method = method
+        @url = url
+        @headers = headers
+        @cookies = cookies
+        @body = body
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/request_logger.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    require_relative "request"
+    require_relative "response"
+    require_relative "config"
+    require_relative "adapter"
+    require_relative "logger"
+    require_relative "extractor"
+
+    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/response.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# request_logger/response.rb
+
+module DevSuite
+  module RequestLogger
+    class Response
+      attr_reader :status, :message, :headers, :body
+
+      def initialize(status:, message:, headers:, body:)
+        @status = status.to_i # Ensure status is always an integer
+        @message = message
+        @headers = headers || {} # Default to an empty hash if headers are nil
+        @body = body || "" # Default to an empty string if body is nil
+      end
+
+      # Check if the response is successful (2xx status codes)
+      def success?
+        status.between?(200, 299)
+      end
+
+      # Helper method to fetch specific headers in a case-insensitive way
+      def header(key)
+        headers[key.to_s.downcase] || headers[key.to_s]
+      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::Manager
+
+        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 < Utils::Construct::Config::Base
+          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.build_component(value)
+          end
+
+          def resolve_palette(value)
+            Palette.build_component(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/palette/base.rb

@@ -4,20 +4,7 @@ module DevSuite
   module Utils
     module Color
       module Palette
-        class Base
-          # Define COLORS constant in subclass
-          # Example:
-          # COLORS = {
-          #  red: 31,
-          #  green: 32,
-          #  yellow: 33,
-          #  blue: 34,
-          #  pink: 35,
-          #  light_blue: 36,
-          #  white: 37
-          #  }
-          #
-
+        class Base < Utils::Construct::Component::Base
           def colors
             unless self.class.const_defined?(:COLORS)
               raise NotImplementedError, "#{self.class} must define COLORS constant"

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Color
+      module Palette
+        include Construct::Component::Manager
+
+        require_relative "base"
+        require_relative "default"
+
+        register_component(Default)
+      end
+    end
+  end
+end

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

@@ -4,19 +4,7 @@ module DevSuite
   module Utils
     module Color
       module Palette
-        require_relative "palette/base"
-        require_relative "palette/default"
-
-        class << self
-          def create(type)
-            case type
-            when :default
-              Default.new
-            else
-              raise ArgumentError, "Unknown palette type: #{type}"
-            end
-          end
-        end
+        require_relative "palette/palette"
       end
     end
   end

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

@@ -4,7 +4,7 @@ module DevSuite
   module Utils
     module Color
       module Strategy
-        class Base
+        class Base < Utils::Construct::Component::Base
           def colorize(text, **kwargs)
             raise NotImplementedError
           end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Color
+      module Strategy
+        include Construct::Component::Manager
+
+        require_relative "base"
+        require_relative "basic"
+        require_relative "rgb"
+        require_relative "theme"
+
+        register_component(Basic)
+        register_component(Rgb)
+        register_component(Theme)
+      end
+    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

@@ -4,27 +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, palette: nil)
-            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)
-            else
-              raise ArgumentError, "Unknown strategy type: #{type}"
-            end
-          end
-        end
+        require_relative "strategy/strategy"
       end
     end
   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/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/component.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Utils
+    module Construct
+      module Component
+        require_relative "component/component"
+      end
+    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