dev_suite 0.2.7 → 0.2.9

data/lib/dev_suite/request_builder/tool/curl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      class Curl < Base
+        def build_command(http_method:, url:, headers:, body: nil)
+          validate_parameters(http_method, url, headers, body)
+
+          command = build_base_command(http_method, url)
+
+          add_headers(command, headers)
+          add_body(command, body)
+          add_insecure_option(command)
+          add_verbose_option(command)
+          add_follow_redirects_option(command)
+          add_cookie_option(command)
+          add_user_agent_option(command)
+          add_max_time_option(command)
+          add_connect_timeout_option(command)
+
+          command.join(" ").strip
+        end
+
+        private
+
+        def validate_parameters(http_method, url, headers, body)
+          validator = Validator::Curl.new
+          validator.validate!(
+            http_method: http_method,
+            url: url,
+            headers: headers,
+            body: body,
+          )
+        end
+
+        def build_base_command(http_method, url)
+          ["curl", "-X #{http_method}", "'#{url}'"]
+        end
+
+        def add_headers(command, headers)
+          headers.each do |key, value|
+            command << "-H '#{key}: #{value}'"
+          end
+        end
+
+        def add_body(command, body)
+          return unless body
+
+          command << (raw_data? ? "--data-raw '#{body}'" : "-d '#{body}'")
+        end
+
+        def add_insecure_option(command)
+          command << "--insecure" if fetch_setting("tool.curl.use_insecure", default: false)
+        end
+
+        def add_verbose_option(command)
+          command << "-v" if fetch_setting("tool.curl.verbose", default: false)
+        end
+
+        def add_follow_redirects_option(command)
+          command << "-L" if fetch_setting("tool.curl.follow_redirects", default: true)
+        end
+
+        def add_cookie_option(command)
+          cookie = fetch_setting("tool.curl.cookie")
+          command << "-b '#{cookie}'" if cookie
+        end
+
+        def add_user_agent_option(command)
+          user_agent = fetch_setting("tool.curl.user_agent")
+          command << "-A '#{user_agent}'" if user_agent
+        end
+
+        def add_max_time_option(command)
+          max_time = fetch_setting("tool.curl.max_time")
+          command << "--max-time #{max_time}" if max_time
+        end
+
+        def add_connect_timeout_option(command)
+          connect_timeout = fetch_setting("tool.curl.connect_timeout")
+          command << "--connect-timeout #{connect_timeout}" if connect_timeout
+        end
+
+        def raw_data?
+          fetch_setting("tool.curl.raw_data", default: false)
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool/tool.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      require_relative "validator"
+      require_relative "base"
+      require_relative "curl"
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool/validator/curl.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      module Validator
+        class Curl < Utils::Construct::Component::Validator::Base
+          VALID_HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"].freeze
+
+          def validate!(http_method:, url:, headers:, body: nil)
+            validate_http_method(http_method)
+            validate_url(url)
+            validate_headers(headers)
+            validate_body(body)
+          end
+
+          private
+
+          def validate_http_method(http_method)
+            validate_inclusion!(http_method, VALID_HTTP_METHODS, field_name: "HTTP Method")
+          end
+
+          def validate_url(url)
+            validate_url!(url, field_name: "URL")
+          end
+
+          def validate_headers(headers)
+            validate_hash!(headers, field_name: "Headers")
+          end
+
+          def validate_body(body)
+            validate_type!(body, [String, NilClass], field_name: "Body")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool/validator/validator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      module Validator
+        require_relative "curl"
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool/validator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      module Validator
+        require_relative "validator/validator"
+      end
+    end
+  end
+end

data/lib/dev_suite/request_builder/tool.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DevSuite
+  module RequestBuilder
+    module Tool
+      require_relative "tool/tool"
+    end
+  end
+end

data/lib/dev_suite/request_builder.rb

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

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

@@ -8,21 +8,23 @@ module DevSuite
       require_relative "base"
 
       class << self
-        def handle_missing_dependencies(missing_dependencies)
-          Config.configuration.delete_option_on_failure(:adapters, :faraday, *missing_dependencies)
+        def handle_missing_nethttp(missing_dependencies)
+          Config.configuration.remove_failed_dependency(:adapters, :net_http, *missing_dependencies)
+        end
+
+        def handle_missing_faraday(missing_dependencies)
+          Config.configuration.remove_failed_dependency(:adapters, :faraday, *missing_dependencies)
         end
       end
 
       # Load and register `net/http` adapter
-      require "net/http"
-      require_relative "net_http"
-      register_component(NetHttp)
+      load_dependency(["net/http"], on_failure: method(:handle_missing_nethttp)) do
+        require_relative "net_http"
+        register_component(NetHttp)
+      end
 
       # Load and register `faraday` adapter
-      Utils::DependencyLoader.safe_load_dependencies(
-        "faraday",
-        on_failure: method(:handle_missing_dependencies),
-      ) do
+      load_dependency(["faraday"], on_failure: method(:handle_missing_faraday)) do
         require_relative "faraday"
         register_component(Faraday)
       end

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

@@ -7,6 +7,8 @@ module DevSuite
 
       class Faraday < Base
         def enable
+          return unless faraday_defined?
+
           ::Faraday::Connection.class_eval do
             alias_method(:_original_run_request, :run_request)
 
@@ -20,17 +22,26 @@ module DevSuite
 
               Middleware::Faraday.new(lambda do |e|
                 _original_run_request(e.method, e.url, e.body, e.request_headers, &block)
-              end).call(env)
+              end).call(env, self)
             end
           end
         end
 
         def disable
+          return unless faraday_defined?
+
           ::Faraday::Connection.class_eval do
             alias_method(:run_request, :_original_run_request)
             remove_method(:_original_run_request)
           end
         end
+
+        private
+
+        # Check if Faraday is defined
+        def faraday_defined?
+          defined?(::Faraday::Connection) && defined?(::Faraday::Env)
+        end
       end
     end
   end

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

@@ -5,14 +5,14 @@ module DevSuite
     module Adapter
       module Middleware
         class Faraday < ::Faraday::Middleware
-          def call(env)
+          def call(env, instance = nil)
             # Log the request details
-            Logger.log_request(self, env)
+            Logger.log_request(instance, env)
 
             # Perform the actual request
             @app.call(env).on_complete do |response_env|
               # Log the response details
-              Logger.log_response(self, response_env)
+              Logger.log_response(instance, response_env)
             end
           end
         end

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

@@ -13,16 +13,25 @@ module DevSuite
 
             # 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
+              start_time = Time.now
+
               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)
+              response = nil
+              begin
+                # Call the original request method (now aliased as _original_request) to perform the actual HTTP request
+                response = _original_request(request, body, &block)
+              ensure
+                end_time = Time.now
+                response ||= Net::HTTPResponse.new("1.1", "500", "Internal Server Error")
+                response.instance_variable_set(:@start_time, start_time)
+                response.instance_variable_set(:@end_time, end_time)
+                response.define_singleton_method(:start_time) { @start_time }
+                response.define_singleton_method(:end_time) { @end_time }
 
-              # Optionally log the response details
-              Logger.log_response(self, response)
+                Logger.log_response(self, response)
+              end
 
-              # Return the response object so that the calling code receives the expected result
               response
             end
           end

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

@@ -8,6 +8,7 @@ module DevSuite
           log_headers: true,
           log_cookies: true,
           log_body: true,
+          log_response_time: true,
           log_level: :debug,
         )
 

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

@@ -4,11 +4,17 @@ module DevSuite
   module RequestLogger
     module Extractor
       class Base < Utils::Construct::Component::Base
-        def extract_request(native_request)
+        # Extracts the request details from an HTTP request object
+        # @param instance [Object] The instance of the HTTP client that is making the request
+        # @param request [Object] The request object that is being made
+        def extract_request(_instance, _request)
           raise NotImplementedError
         end
 
-        def extract_response(native_response)
+        # Extracts the response details from an HTTP response object
+        # @param instance [Object] The instance of the HTTP client that is making the request
+        # @param response [Object] The response object that is being returned
+        def extract_response(_instance, _response)
           raise NotImplementedError
         end
       end

data/lib/dev_suite/request_logger/extractor/extractor.rb

@@ -6,14 +6,13 @@ module DevSuite
       include Utils::Construct::Component::Manager
 
       require_relative "base"
-      require_relative "net_http"
 
-      register_component(NetHttp)
+      load_dependency(["net/http"], on_failure: ->(_) {}) do
+        require_relative "net_http"
+        register_component(NetHttp)
+      end
 
-      Utils::DependencyLoader.safe_load_dependencies(
-        "faraday",
-        on_failure: ->(_) {}, # Empty lambda to do nothing on failure
-      ) do
+      load_dependency(["faraday"], on_failure: ->(_) {}) do
         require_relative "faraday"
         register_component(Faraday)
       end

data/lib/dev_suite/request_logger/extractor/faraday.rb

@@ -4,31 +4,49 @@ module DevSuite
   module RequestLogger
     module Extractor
       class Faraday < Base
-        COMPONENT_KEY = ::Faraday::Middleware
+        COMPONENT_KEY = ::Faraday::Connection
 
-        def extract_request(native_request)
+        # Extracts the request details from a Faraday request object
+        # @param _instance [Faraday::Connection] The instance of the Faraday client that is making the request
+        # @param request [Faraday::Env] The request object that is being made
+        def extract_request(connection, request)
           Request.new(
-            method: native_request.method.to_s.upcase,
-            url: native_request.url.to_s,
-            headers: native_request.request_headers.to_h,
-            cookies: extract_cookies(native_request.request_headers),
-            body: native_request.body,
+            method: request.method.to_s.upcase,
+            url: build_url(connection),
+            headers: build_headers_from_request(request),
+            cookies: build_cookies(request),
+            body: request.body,
           )
         end
 
-        def extract_response(native_response)
+        # Extracts the response details from a Faraday response object
+        # @param _instance [Faraday::Connection] The instance of the Faraday client that received the response
+        # @param response [Faraday::Env] The response object received
+        def extract_response(_connection, response)
           Response.new(
-            status: native_response.status,
-            message: native_response.reason_phrase || "",
-            headers: native_response.response_headers.to_h,
-            body: native_response.body,
+            status: response.status,
+            message: response.reason_phrase || "",
+            headers: build_headers_from_response(response),
+            body: response.body,
           )
         end
 
         private
 
-        def extract_cookies(headers)
-          headers = headers.to_h
+        def build_url(connection)
+          connection.url_prefix.to_s
+        end
+
+        def build_headers_from_request(request)
+          request.request_headers.to_h
+        end
+
+        def build_headers_from_response(response)
+          response.response_headers.to_h
+        end
+
+        def build_cookies(request)
+          headers = build_headers_from_request(request)
           headers["Cookie"] ? [headers["Cookie"]] : []
         end
       end

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

@@ -6,30 +6,71 @@ module DevSuite
       class NetHttp < Base
         COMPONENT_KEY = ::Net::HTTP
 
-        def extract_request(native_request)
+        # Extracts the request details from a Net::HTTP request object
+        # @param http [Net::HTTP] The Net::HTTP object that is making the request
+        # @param request [Net::HTTP::Request] The request object that is being made
+        def extract_request(http, request)
           Request.new(
-            method: native_request.method,
-            url: native_request.uri.to_s,
-            headers: native_request.each_header.to_h,
-            cookies: extract_cookies(native_request),
-            body: native_request.body,
+            method: request.method,
+            url: build_url(http, request),
+            headers: request.each_header.to_h,
+            cookies: build_cookies(request),
+            body: request.body,
           )
         end
 
-        def extract_response(native_response)
+        # Extracts the response details from a Net::HTTP response object
+        # @param http [Net::HTTP] The Net::HTTP object that received the response
+        # @param response [Net::HTTPResponse] The response object received
+        # @return [Response] The extracted response details
+        def extract_response(_http, response)
           Response.new(
-            status: native_response.code.to_i,
-            message: native_response.message,
-            headers: native_response.each_header.to_h,
-            body: native_response.body,
+            status: response.code.to_i,
+            message: response.message,
+            headers: response.each_header.to_h,
+            body: response.body,
+            response_time: calculate_response_time(response),
           )
         end
 
         private
 
-        def extract_cookies(request)
+        # Builds the full URL for the request
+        # @param http [Net::HTTP] The Net::HTTP object
+        # @param request [Net::HTTP::Request] The request object
+        # @return [String] The fully constructed URL
+        def build_url(http, request)
+          scheme = determine_scheme(http)
+          host = http.address
+          port_part = determine_port(http, scheme)
+          path = request.path
+
+          "#{scheme}://#{host}#{port_part}#{path}"
+        end
+
+        # Extracts cookies from the request headers
+        # @param request [Net::HTTP::Request] The request object
+        # @return [Array<String>] Array of cookie strings
+        def build_cookies(request)
           request.to_hash["cookie"] || []
         end
+
+        # Calculates the response time (if available)
+        # This example assumes response time is tracked separately and stored in the `http` object
+        def calculate_response_time(response)
+          if response.respond_to?(:start_time) && response.respond_to?(:end_time)
+            response.end_time - response.start_time
+          end
+        end
+
+        def determine_scheme(http)
+          http.use_ssl? ? "https" : "http"
+        end
+
+        def determine_port(http, scheme)
+          default_port = (scheme == "https" ? 443 : 80)
+          http.port == default_port ? nil : ":#{http.port}"
+        end
       end
     end
   end

data/lib/dev_suite/request_logger/logger.rb

@@ -20,6 +20,7 @@ module DevSuite
           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)
+          log_response_time(response) if settings.get(:log_response_time)
         end
 
         private
@@ -34,12 +35,12 @@ module DevSuite
 
         def extract_request(instance, request)
           extractor = Extractor.build_component_from_instance(instance)
-          extractor.extract_request(request)
+          extractor.extract_request(instance, request)
         end
 
         def extract_response(instance, response)
           extractor = Extractor.build_component_from_instance(instance)
-          extractor.extract_response(response)
+          extractor.extract_response(instance, response)
         end
 
         def log_entry(message, emoji, level = settings.get(:log_level))
@@ -64,7 +65,7 @@ module DevSuite
 
         def log_headers(request)
           headers = request.headers
-          log_entry("Headers: #{headers}", :document) unless headers.empty?
+          log_entry("Headers: #{headers}", :document)
         end
 
         def log_cookies(request)
@@ -81,6 +82,11 @@ module DevSuite
 
           log_entry("#{type} Body: #{body}", :code)
         end
+
+        def log_response_time(response)
+          response_time = response.response_time
+          log_entry("Response Time: #{response_time} seconds", :stop) if response_time
+        end
       end
     end
   end

data/lib/dev_suite/request_logger/request.rb

@@ -5,6 +5,8 @@
 module DevSuite
   module RequestLogger
     class Request
+      include Utils::WarningHandler
+
       attr_reader :method, :url, :headers, :cookies, :body
 
       def initialize(method:, url:, headers:, cookies:, body:)
@@ -13,6 +15,16 @@ module DevSuite
         @headers = headers
         @cookies = cookies
         @body = body
+
+        validate_presence
+      end
+
+      private
+
+      def validate_presence
+        warn_if_missing("Request URL", @url)
+        warn_if_missing("Request Method", @method)
+        warn_if_missing("Request Headers", @headers)
       end
     end
   end

data/lib/dev_suite/request_logger/response.rb

@@ -1,28 +1,53 @@
 # frozen_string_literal: true
 
-# request_logger/response.rb
-
 module DevSuite
   module RequestLogger
     class Response
-      attr_reader :status, :message, :headers, :body
+      include Utils::WarningHandler
+
+      attr_reader :status, :message, :headers, :body, :content_type, :content_length, :response_time
 
-      def initialize(status:, message:, headers:, body:)
-        @status = status.to_i # Ensure status is always an integer
+      def initialize(
+        status:,
+        message:,
+        headers:,
+        body:,
+        response_time: nil
+      )
+        @status = status.to_i
         @message = message
-        @headers = headers || {} # Default to an empty hash if headers are nil
-        @body = body || "" # Default to an empty string if body is nil
+        @headers = headers
+        @body = body
+        @content_type = extract_content_type
+        @content_length = extract_content_length
+        @response_time = response_time
+
+        validate_presence
       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
+
+      private
+
+      def extract_content_type
+        header("Content-Type") || "unknown"
+      end
+
+      def extract_content_length
+        length = header("Content-Length")
+        length ? length.to_i : 0
+      end
+
+      def validate_presence
+        warn_if_missing("Response Status", @status)
+        warn_if_missing("Response Headers", @headers)
+      end
     end
   end
 end

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

@@ -23,6 +23,19 @@ module DevSuite
               snake_case_class_name.to_sym
             end
           end
+
+          private
+
+          # Fetches a setting based on the provided key.
+          # This method should be overridden by subclasses to provide specific behavior.
+          #
+          # @param key [String] The key for the setting.
+          # @param default [Object] The default value to return if the key is not found.
+          def fetch_setting(_key, _default = nil)
+            # Example implementation
+            # Config.configuration.settings.get(key, default)
+            raise NotImplementedError
+          end
         end
       end
     end

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

@@ -6,6 +6,7 @@ module DevSuite
       module Component
         require_relative "base"
         require_relative "manager"
+        require_relative "validator"
       end
     end
   end