dev_suite 0.2.3 → 0.2.5

data/lib/dev_suite/performance/{reportor → reporter}/helpers/stat_mappings.rb

@@ -2,7 +2,7 @@
 
 module DevSuite
   module Performance
-    module Reportor
+    module Reporter
       module Helpers
         module StatMappings
           PROFILER_STAT_TITLES = {

data/lib/dev_suite/performance/{reportor → reporter}/helpers/table_builder.rb

@@ -2,7 +2,7 @@
 
 module DevSuite
   module Performance
-    module Reportor
+    module Reporter
       module Helpers
         module TableBuilder
           class << self

data/lib/dev_suite/performance/{reportor → reporter}/helpers.rb

@@ -2,7 +2,7 @@
 
 module DevSuite
   module Performance
-    module Reportor
+    module Reporter
       module Helpers
         require_relative "helpers/stat_mappings"
         require_relative "helpers/table_builder"

data/lib/dev_suite/performance/{reportor → reporter}/simple.rb

@@ -2,7 +2,7 @@
 
 module DevSuite
   module Performance
-    module Reportor
+    module Reporter
       class Simple < Base
         #
         # Generates the performance report

data/lib/dev_suite/performance/reporter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module Performance
+    module Reporter
+      require_relative "reporter/base"
+      require_relative "reporter/simple"
+      require_relative "reporter/helpers"
+
+      class << self
+        def create(reporter)
+          case reporter
+          when :simple
+            Simple.new
+          else
+            raise ArgumentError, "Invalid reporter: #{reporter}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/performance.rb

@@ -8,7 +8,7 @@ module DevSuite
     require_relative "performance/data"
     require_relative "performance/profiler"
     require_relative "performance/profiler_manager"
-    require_relative "performance/reportor"
+    require_relative "performance/reporter"
     require_relative "performance/analyzer"
     require_relative "performance/config"
   end

data/lib/dev_suite/request_logger/adapter/adapter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Adapter
+      require "net/http"
+
+      require_relative "base"
+      require_relative "net_http"
+
+      class << self
+        def create(adapter)
+          case adapter
+          when :net_http
+            NetHttp.new
+          else
+            raise ArgumentError, "Adapter not found: #{adapter}"
+          end
+        end
+
+        def create_multiple(adapters)
+          adapters.map { |adapter| create(adapter) }
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/adapter/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Adapter
+      class Base
+        def enable
+          raise NotImplementedError
+        end
+
+        def disable
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/adapter/net_http.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Adapter
+      class NetHttp < Base
+        # Enables the logging of Net::HTTP requests by monkey patching the request method
+        def enable
+          ::Net::HTTP.class_eval do
+            # Alias the original request method with a unique name (_original_request)
+            # This preserves the original functionality so it can still be called after logging is added
+            alias_method(:_original_request, :request)
+
+            # Override the request method to add logging functionality
+            def request(request, body = nil, &block)
+              # Log the full URL of the HTTP request using the DevSuite::Utils::Logger
+              Logger.log_request(self, request)
+
+              # Call the original request method (now aliased as _original_request) to perform the actual HTTP request
+              response = _original_request(request, body, &block)
+
+              # Optionally log the response details
+              Logger.log_response(self, response)
+
+              # Return the response object so that the calling code receives the expected result
+              response
+            end
+          end
+        end
+
+        # Disables the logging by restoring the original Net::HTTP request method
+        def disable
+          ::Net::HTTP.class_eval do
+            # Restore the original request method by aliasing it back from _original_request
+            # This effectively removes the logging functionality and returns Net::HTTP to its original state
+            alias_method(:request, :_original_request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/adapter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Adapter
+      require_relative "adapter/adapter"
+    end
+  end
+end

data/lib/dev_suite/request_logger/config/config.rb

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

data/lib/dev_suite/request_logger/config/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Config
+      class Configuration < BaseConfiguration
+        set_default_settings(
+          log_headers: true,
+          log_cookies: true,
+          log_body: true,
+          log_level: :debug,
+        )
+
+        config_attr :adapters, default_value: [:net_http], type: :array, resolver: :resolve_adapters
+
+        private
+
+        def resolve_adapters(value)
+          Adapter.create_multiple(value)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_logger/config.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestLogger
+    module Config
+      require_relative "config/config"
+    end
+  end
+end

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