Rust Path Manipulation Utility

This challenge focuses on building a robust path manipulation utility in Rust. You'll learn to work with file system paths, perform common operations like joining, normalizing, and extracting components, and handle various path formats and potential errors gracefully. This is crucial for any application that interacts with the file system, ensuring your program can reliably navigate and manage data locations.

Problem Description

Your task is to create a Rust module that provides several common path manipulation functionalities. This module should be able to handle different path separators (e.g., / for Unix-like systems and \ for Windows) and operate on various path representations.

Key Requirements:

1. join_paths Function:

   • Takes a slice of strings representing path segments.
   • Returns a single String representing the joined path.
   • Should correctly handle leading/trailing slashes in segments and insert appropriate separators.
   • Must be cross-platform compatible, using the system's native path separator.

2. normalize_path Function:

   • Takes a single String representing a path.
   • Returns a String representing the normalized path.
   • Normalization should:
     • Resolve . (current directory) and .. (parent directory) components.
     • Remove redundant separators (e.g., // should become /).
     • Handle absolute paths correctly (e.g., /a/../b should become /b).

3. get_path_components Function:

   • Takes a single String representing a path.
   • Returns a Vec<String> containing the individual components of the path.
   • The root directory (e.g., / on Unix) should be handled as a separate component if it's the only component.
   • Empty components resulting from consecutive separators should be ignored.

4. Error Handling:

   • All functions should return a Result to indicate success or failure.
   • Define custom error types to represent different path manipulation errors (e.g., invalid path format, normalization issues).

Expected Behavior:

• Paths should be treated as strings, but the operations should mimic file system path logic.
• The utility should be flexible enough to work with both relative and absolute paths.

Edge Cases:

• Empty input paths.
• Paths with only separators (e.g., ///).
• Paths with complex . and .. sequences at the beginning, middle, and end.
• Paths containing only a root directory.

Examples

Example 1: join_paths

Input: ["usr", "local", "bin"]
Output: Ok("/usr/local/bin")  // Assuming Unix-like system

Input: ["C:\\Users", "Documents", "Report.txt"]
Output: Ok("C:\\Users\\Documents\\Report.txt") // Assuming Windows system

Input: ["/home/user/", "documents/", "/report.txt"]
Output: Ok("/home/user/documents/report.txt")

Input: []
Output: Ok("")

Explanation: The function joins the provided segments using the appropriate path separator, ensuring that redundant separators are not introduced between segments.

Example 2: normalize_path

Input: "/a/./b/../../c/"
Output: Ok("/c")

Input: "C:\\Users\\..\\Documents\\file.txt"
Output: Ok("C:\\Documents\\file.txt") // Assuming Windows system

Input: "///a//b/"
Output: Ok("/a/b") // Assuming Unix-like system

Input: "."
Output: Ok(".")

Input: ".."
Output: Ok("..")

Input: ""
Output: Ok("")

Explanation: Redundant separators are removed, and . and .. components are resolved to create the shortest equivalent path.

Example 3: get_path_components

Input: "/usr/local/bin"
Output: Ok(vec!["/", "usr", "local", "bin"])

Input: "documents/report.txt"
Output: Ok(vec!["documents", "report.txt"])

Input: "/"
Output: Ok(vec!["/"])

Input: ""
Output: Ok(vec![])

Input: "///a//b/"
Output: Ok(vec!["/", "a", "b"])

Explanation: The path is broken down into its constituent parts, with the root handled as a special case and empty components omitted.

Constraints

• The functions should operate on String and &str types for flexibility.
• The output for join_paths and normalize_path should be a String.
• The output for get_path_components should be a Vec<String>.
• Performance is not a primary concern, but excessively inefficient algorithms should be avoided.
• Your solution should be written entirely in Rust, utilizing standard library features where appropriate.

Notes

• Consider using Rust's std::path module for inspiration or even leveraging its components if allowed (though the goal is to implement the logic yourself for learning).
• Think about how to detect the operating system's path separator.
• Define an enum for your custom error types.
• For normalize_path, be careful with absolute paths. Normalizing /a/../b should result in /b, not just b.
• The root component for Unix-like systems is /. For Windows, a drive letter like C: followed by a separator could be considered part of the root. You can simplify this by assuming a consistent representation for the root in your normalization logic.