Robust Path Handling in Rust

This challenge focuses on building a module for handling file paths in Rust, providing functionalities for normalization, joining, and checking path validity. Robust path handling is crucial for any application interacting with the file system, ensuring consistency and preventing errors due to platform-specific path formats. Your goal is to create a reusable module that simplifies common path manipulation tasks.

Problem Description

You are tasked with creating a Rust module named path_utils that provides several functions for working with file paths. The module should include the following functionalities:

1. normalize_path(path: &str) -> String: This function should take a string representing a file path as input and return a normalized version of the path. Normalization should involve:

   • Removing redundant separators (e.g., // or /./).
   • Resolving . (current directory) and .. (parent directory) components. Note: .. should only resolve up to the root directory; it should not go above it.
   • Ensuring the path uses forward slashes (/) as separators, regardless of the operating system.

2. join_paths(base: &str, relative: &str) -> String: This function should take a base path and a relative path as input and return a new path that is the result of joining the two. The function should normalize the resulting path.

3. is_valid_path(path: &str) -> bool: This function should take a path as input and return true if the path is valid (i.e., not empty and contains at least one separator /). Return false otherwise.

Key Requirements:

• The module should be named path_utils.
• All functions should be public.
• Error handling is not required for this challenge; invalid paths should be handled gracefully (e.g., by returning an empty string or a normalized version of the input).
• The normalization process should be consistent across different operating systems.
• The join_paths function should handle cases where either the base or relative path is empty.

Expected Behavior:

• normalize_path should correctly handle various path formats, including absolute paths, relative paths, and paths with redundant separators.
• join_paths should correctly combine the base and relative paths, normalizing the result.
• is_valid_path should accurately determine whether a path is valid based on the defined criteria.

Edge Cases to Consider:

• Empty paths.
• Paths containing only separators.
• Paths with multiple consecutive separators.
• Paths with . and .. components.
• Paths starting or ending with separators.
• Base path being empty in join_paths.
• Relative path being empty in join_paths.

Examples

Example 1:

Input: normalize_path("/home//user/./documents/../")
Output: /home/user/documents
Explanation: Redundant separators and `.` and `..` components are removed, and the path is normalized to use forward slashes.

Example 2:

Input: join_paths("/home/user", "documents/report.txt")
Output: /home/user/documents/report.txt
Explanation: The base and relative paths are joined, and the resulting path is normalized.

Example 3:

Input: is_valid_path("")
Output: false
Explanation: An empty path is considered invalid.

Example 4:

Input: is_valid_path("/")
Output: true
Explanation: A path containing a single separator is considered valid.

Example 5:

Input: join_paths("", "relative/path")
Output: /relative/path
Explanation: When the base path is empty, the relative path is normalized.

Constraints

• All paths are represented as strings.
• The maximum length of a path string is 1024 characters.
• The functions should be reasonably efficient for typical path lengths (less than 256 characters). Optimization for extremely long paths is not required.
• The code should be well-documented and easy to understand.

Notes

• Consider using string manipulation techniques like split, trim, and replace to normalize the paths.
• You can use a stack to keep track of the directory levels when resolving . and .. components.
• Remember to handle edge cases carefully to ensure the robustness of your module.
• The goal is to create a reusable and reliable path handling module. Focus on correctness and clarity over extreme performance optimization.
• You are not required to handle file system existence checks (e.g., checking if a file or directory actually exists). This challenge focuses solely on path manipulation.