makit 0.0.140 → 0.0.142

data/lib/makit/services/error_handler.rb

@@ -1,226 +1,226 @@
-# frozen_string_literal: true
-
-module Makit
-  module Services
-    # Service class responsible for handling and formatting errors
-    # Provides user-friendly error messages and recovery suggestions
-    class ErrorHandler
-      # Error message templates with suggestions
-      ERROR_MESSAGES = {
-        invalid_url: {
-          message: "The repository URL '%<url>s' is not valid.",
-          suggestions: [
-            "Use HTTPS format: https://github.com/user/repo.git",
-            "Use SSH format: git@github.com:user/repo.git",
-            "Use simple format: user/repo",
-            "Ensure the URL points to a git repository",
-          ],
-        },
-        invalid_directory: {
-          message: "The directory path '%<directory>s' is not valid.",
-          suggestions: [
-            "Use absolute paths like /path/to/directory",
-            "Use relative paths like ./relative/path",
-            "Ensure the path doesn't contain null characters",
-            "Keep directory paths under 255 characters",
-          ],
-        },
-        invalid_commit: {
-          message: "The commit '%<commit>s' is not valid.",
-          suggestions: [
-            "Use 'latest' for the most recent commit",
-            "Use a full 40-character commit hash",
-            "Use a short 7+ character commit hash",
-            "Verify the commit exists in the repository",
-          ],
-        },
-        directory_not_found: {
-          message: "The directory '%<directory>s' does not exist or is not accessible.",
-          suggestions: [
-            "Check that the directory path is correct",
-            "Verify you have read permissions for the directory",
-            "Create the directory first if it doesn't exist",
-            "Use 'makit init' to create a new project directory",
-          ],
-        },
-        git_command_failed: {
-          message: "Git command failed: %<command>s",
-          suggestions: [
-            "Check that git is installed and available in PATH",
-            "Verify you have network connectivity for remote operations",
-            "Ensure you have proper permissions for the repository",
-            "Check that the remote repository URL is accessible",
-          ],
-        },
-        clone_failed: {
-          message: "Failed to clone repository '%<url>s'.",
-          suggestions: [
-            "Check that the repository URL is correct and accessible",
-            "Verify your network connectivity",
-            "Ensure you have proper authentication (SSH keys, tokens)",
-            "Check that you have write permissions to the destination directory",
-          ],
-        },
-        pull_failed: {
-          message: "Failed to pull changes from repository.",
-          suggestions: [
-            "Check that you have network connectivity",
-            "Verify the remote repository is accessible",
-            "Ensure your local repository is in a clean state",
-            "Try 'git status' to check for conflicts",
-          ],
-        },
-        build_failed: {
-          message: "Build process failed for repository '%<url>s' at commit '%<commit>s'.",
-          suggestions: [
-            "Check the build logs for specific error messages",
-            "Verify all dependencies are installed",
-            "Ensure the commit hash is valid and exists",
-            "Try building manually to isolate the issue",
-          ],
-        },
-      }.freeze
-
-      class << self
-        # Format an error with user-friendly message and suggestions
-        #
-        # @param error_type [Symbol] the type of error from ERROR_MESSAGES
-        # @param details [Hash] details to interpolate into the message
-        # @param original_error [Exception] the original exception (optional)
-        # @return [String] formatted error message with suggestions
-        def format_error(error_type, details = {}, original_error = nil)
-          error_config = ERROR_MESSAGES[error_type]
-          return "Unknown error type: #{error_type}" unless error_config
-
-          message = error_config[:message] % details
-          suggestions = error_config[:suggestions]
-
-          formatted_message = ["❌ Error: #{message}"]
-
-          if suggestions && !suggestions.empty?
-            formatted_message << ""
-            formatted_message << "💡 Suggestions:"
-            suggestions.each_with_index do |suggestion, index|
-              formatted_message << "  #{index + 1}. #{suggestion}"
-            end
-          end
-
-          if original_error && !original_error.message.empty?
-            formatted_message << ""
-            formatted_message << "🔍 Technical details:"
-            formatted_message << "  #{original_error.class}: #{original_error.message}"
-          end
-
-          formatted_message.join("\n")
-        end
-
-        # Handle ArgumentError exceptions with user-friendly formatting
-        #
-        # @param error [ArgumentError] the argument error to format
-        # @param context [Hash] additional context about where the error occurred
-        # @return [String] formatted error message
-        def handle_argument_error(error, context = {})
-          case error.message
-          when /URL parameter cannot be nil|URL parameter cannot be empty|Invalid URL format/
-            format_error(:invalid_url, { url: context[:url] || "unknown" }, error)
-          when /directory parameter cannot be nil|directory parameter cannot be empty|directory path/
-            format_error(:invalid_directory, { directory: context[:directory] || "unknown" }, error)
-          when /commit parameter cannot be nil|commit parameter cannot be empty|Invalid commit format/
-            format_error(:invalid_commit, { commit: context[:commit] || "unknown" }, error)
-          else
-            "❌ Error: #{error.message}\n💡 Please check your input parameters and try again."
-          end
-        end
-
-        # Handle Makit-specific exceptions with user-friendly formatting
-        #
-        # @param error [Makit::Error] the Makit error to format
-        # @param context [Hash] additional context about where the error occurred
-        # @return [String] formatted error message
-        def handle_makit_error(error, context = {})
-          case error
-          when Makit::DirectoryError
-            format_error(:directory_not_found, { directory: context[:directory] || "unknown" }, error)
-          when Makit::CloneError
-            format_error(:clone_failed, { url: context[:url] || "unknown" }, error)
-          when Makit::PullError
-            format_error(:pull_failed, {}, error)
-          when Makit::BuildError
-            format_error(:build_failed, { url: context[:url] || "unknown", commit: context[:commit] || "unknown" },
-                         error)
-          when Makit::GitError
-            format_error(:git_command_failed, { command: context[:command] || "unknown" }, error)
-          else
-            "❌ Error: #{error.message}\n💡 Please refer to the documentation or run with --verbose for more details."
-          end
-        end
-
-        # Log error with context for debugging
-        #
-        # @param error [Exception] the error to log
-        # @param context [Hash] additional context information
-        def log_error(error, context = {})
-          return unless defined?(Makit::LOGGER) && Makit::LOGGER
-
-          Makit::LOGGER.error "Error occurred: #{error.class} - #{error.message}"
-          Makit::LOGGER.error "Context: #{context.inspect}" unless context.empty?
-          Makit::LOGGER.debug "Backtrace: #{error.backtrace&.join("\n")}" if error.backtrace
-        end
-
-        # Wrap a block with comprehensive error handling
-        #
-        # @param context [Hash] context information for error messages
-        # @yield block to execute with error handling
-        # @return [Object] the result of the block
-        def with_error_handling(context = {})
-          yield
-        rescue ArgumentError => e
-          log_error(e, context)
-          formatted_message = handle_argument_error(e, context)
-          raise Makit::ValidationError, formatted_message
-        rescue Makit::Error => e
-          log_error(e, context)
-          formatted_message = handle_makit_error(e, context)
-          raise e.class, formatted_message
-        rescue StandardError => e
-          log_error(e, context)
-          formatted_message = "❌ An unexpected error occurred: #{e.message}\n💡 Please check the logs or run with --verbose for more details."
-          raise Makit::Error, formatted_message
-        end
-
-        # Validate input and provide helpful error messages
-        #
-        # @param validations [Array<Hash>] array of validation rules
-        # @example
-        #   validate_inputs([
-        #     { value: url, validator: :url, name: 'repository URL' },
-        #     { value: commit, validator: :commit, name: 'commit hash' }
-        #   ])
-        def validate_inputs(validations)
-          validations.each do |validation|
-            value = validation[:value]
-            validator = validation[:validator]
-            name = validation[:name] || "parameter"
-
-            case validator
-            when :url
-              Validator.validate_url_parameter(value)
-            when :directory
-              Validator.validate_directory_parameter(value)
-            when :commit
-              Validator.validate_commit_parameter(value)
-            when :required_string
-              Validator.validate_required_string(value, name)
-            when :boolean
-              Validator.validate_boolean_parameter(value, name)
-            end
-          rescue ArgumentError => e
-            context = { validator => value }
-            formatted_message = handle_argument_error(e, context)
-            raise Makit::ValidationError, formatted_message
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Makit
+  module Services
+    # Service class responsible for handling and formatting errors
+    # Provides user-friendly error messages and recovery suggestions
+    class ErrorHandler
+      # Error message templates with suggestions
+      ERROR_MESSAGES = {
+        invalid_url: {
+          message: "The repository URL '%<url>s' is not valid.",
+          suggestions: [
+            "Use HTTPS format: https://github.com/user/repo.git",
+            "Use SSH format: git@github.com:user/repo.git",
+            "Use simple format: user/repo",
+            "Ensure the URL points to a git repository",
+          ],
+        },
+        invalid_directory: {
+          message: "The directory path '%<directory>s' is not valid.",
+          suggestions: [
+            "Use absolute paths like /path/to/directory",
+            "Use relative paths like ./relative/path",
+            "Ensure the path doesn't contain null characters",
+            "Keep directory paths under 255 characters",
+          ],
+        },
+        invalid_commit: {
+          message: "The commit '%<commit>s' is not valid.",
+          suggestions: [
+            "Use 'latest' for the most recent commit",
+            "Use a full 40-character commit hash",
+            "Use a short 7+ character commit hash",
+            "Verify the commit exists in the repository",
+          ],
+        },
+        directory_not_found: {
+          message: "The directory '%<directory>s' does not exist or is not accessible.",
+          suggestions: [
+            "Check that the directory path is correct",
+            "Verify you have read permissions for the directory",
+            "Create the directory first if it doesn't exist",
+            "Use 'makit init' to create a new project directory",
+          ],
+        },
+        git_command_failed: {
+          message: "Git command failed: %<command>s",
+          suggestions: [
+            "Check that git is installed and available in PATH",
+            "Verify you have network connectivity for remote operations",
+            "Ensure you have proper permissions for the repository",
+            "Check that the remote repository URL is accessible",
+          ],
+        },
+        clone_failed: {
+          message: "Failed to clone repository '%<url>s'.",
+          suggestions: [
+            "Check that the repository URL is correct and accessible",
+            "Verify your network connectivity",
+            "Ensure you have proper authentication (SSH keys, tokens)",
+            "Check that you have write permissions to the destination directory",
+          ],
+        },
+        pull_failed: {
+          message: "Failed to pull changes from repository.",
+          suggestions: [
+            "Check that you have network connectivity",
+            "Verify the remote repository is accessible",
+            "Ensure your local repository is in a clean state",
+            "Try 'git status' to check for conflicts",
+          ],
+        },
+        build_failed: {
+          message: "Build process failed for repository '%<url>s' at commit '%<commit>s'.",
+          suggestions: [
+            "Check the build logs for specific error messages",
+            "Verify all dependencies are installed",
+            "Ensure the commit hash is valid and exists",
+            "Try building manually to isolate the issue",
+          ],
+        },
+      }.freeze
+
+      class << self
+        # Format an error with user-friendly message and suggestions
+        #
+        # @param error_type [Symbol] the type of error from ERROR_MESSAGES
+        # @param details [Hash] details to interpolate into the message
+        # @param original_error [Exception] the original exception (optional)
+        # @return [String] formatted error message with suggestions
+        def format_error(error_type, details = {}, original_error = nil)
+          error_config = ERROR_MESSAGES[error_type]
+          return "Unknown error type: #{error_type}" unless error_config
+
+          message = error_config[:message] % details
+          suggestions = error_config[:suggestions]
+
+          formatted_message = ["❌ Error: #{message}"]
+
+          if suggestions && !suggestions.empty?
+            formatted_message << ""
+            formatted_message << "💡 Suggestions:"
+            suggestions.each_with_index do |suggestion, index|
+              formatted_message << "  #{index + 1}. #{suggestion}"
+            end
+          end
+
+          if original_error && !original_error.message.empty?
+            formatted_message << ""
+            formatted_message << "🔍 Technical details:"
+            formatted_message << "  #{original_error.class}: #{original_error.message}"
+          end
+
+          formatted_message.join("\n")
+        end
+
+        # Handle ArgumentError exceptions with user-friendly formatting
+        #
+        # @param error [ArgumentError] the argument error to format
+        # @param context [Hash] additional context about where the error occurred
+        # @return [String] formatted error message
+        def handle_argument_error(error, context = {})
+          case error.message
+          when /URL parameter cannot be nil|URL parameter cannot be empty|Invalid URL format/
+            format_error(:invalid_url, { url: context[:url] || "unknown" }, error)
+          when /directory parameter cannot be nil|directory parameter cannot be empty|directory path/
+            format_error(:invalid_directory, { directory: context[:directory] || "unknown" }, error)
+          when /commit parameter cannot be nil|commit parameter cannot be empty|Invalid commit format/
+            format_error(:invalid_commit, { commit: context[:commit] || "unknown" }, error)
+          else
+            "❌ Error: #{error.message}\n💡 Please check your input parameters and try again."
+          end
+        end
+
+        # Handle Makit-specific exceptions with user-friendly formatting
+        #
+        # @param error [Makit::Error] the Makit error to format
+        # @param context [Hash] additional context about where the error occurred
+        # @return [String] formatted error message
+        def handle_makit_error(error, context = {})
+          case error
+          when Makit::DirectoryError
+            format_error(:directory_not_found, { directory: context[:directory] || "unknown" }, error)
+          when Makit::CloneError
+            format_error(:clone_failed, { url: context[:url] || "unknown" }, error)
+          when Makit::PullError
+            format_error(:pull_failed, {}, error)
+          when Makit::BuildError
+            format_error(:build_failed, { url: context[:url] || "unknown", commit: context[:commit] || "unknown" },
+                         error)
+          when Makit::GitError
+            format_error(:git_command_failed, { command: context[:command] || "unknown" }, error)
+          else
+            "❌ Error: #{error.message}\n💡 Please refer to the documentation or run with --verbose for more details."
+          end
+        end
+
+        # Log error with context for debugging
+        #
+        # @param error [Exception] the error to log
+        # @param context [Hash] additional context information
+        def log_error(error, context = {})
+          return unless defined?(Makit::LOGGER) && Makit::LOGGER
+
+          Makit::LOGGER.error "Error occurred: #{error.class} - #{error.message}"
+          Makit::LOGGER.error "Context: #{context.inspect}" unless context.empty?
+          Makit::LOGGER.debug "Backtrace: #{error.backtrace&.join("\n")}" if error.backtrace
+        end
+
+        # Wrap a block with comprehensive error handling
+        #
+        # @param context [Hash] context information for error messages
+        # @yield block to execute with error handling
+        # @return [Object] the result of the block
+        def with_error_handling(context = {})
+          yield
+        rescue ArgumentError => e
+          log_error(e, context)
+          formatted_message = handle_argument_error(e, context)
+          raise Makit::ValidationError, formatted_message
+        rescue Makit::Error => e
+          log_error(e, context)
+          formatted_message = handle_makit_error(e, context)
+          raise e.class, formatted_message
+        rescue StandardError => e
+          log_error(e, context)
+          formatted_message = "❌ An unexpected error occurred: #{e.message}\n💡 Please check the logs or run with --verbose for more details."
+          raise Makit::Error, formatted_message
+        end
+
+        # Validate input and provide helpful error messages
+        #
+        # @param validations [Array<Hash>] array of validation rules
+        # @example
+        #   validate_inputs([
+        #     { value: url, validator: :url, name: 'repository URL' },
+        #     { value: commit, validator: :commit, name: 'commit hash' }
+        #   ])
+        def validate_inputs(validations)
+          validations.each do |validation|
+            value = validation[:value]
+            validator = validation[:validator]
+            name = validation[:name] || "parameter"
+
+            case validator
+            when :url
+              Validator.validate_url_parameter(value)
+            when :directory
+              Validator.validate_directory_parameter(value)
+            when :commit
+              Validator.validate_commit_parameter(value)
+            when :required_string
+              Validator.validate_required_string(value, name)
+            when :boolean
+              Validator.validate_boolean_parameter(value, name)
+            end
+          rescue ArgumentError => e
+            context = { validator => value }
+            formatted_message = handle_argument_error(e, context)
+            raise Makit::ValidationError, formatted_message
+          end
+        end
+      end
+    end
+  end
+end