feat(path): add option to normalize forward slash of object name

Signed-off-by: w0od <dingboning02@163.com>

Author: Littlew0od

crates/s3s/Cargo.toml

@@ -20,6 +20,8 @@ rustdoc-args = ["--cfg", "docsrs"]
 [features]
 openssl = ["dep:openssl"]
 minio = []
+# Normalize forward slash for object name
+normalize_forward_slash = []
 
 [target.'cfg(not(windows))'.dependencies]
 openssl = { workspace = true, optional = true }

crates/s3s/src/path.rs

@@ -6,6 +6,8 @@
 //! + [Bucket naming rules](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html)
 
 use crate::validation::{AwsNameValidation, NameValidation};
+#[cfg(feature = "normalize_forward_slash")]
+use std::borrow::Cow;
 use std::net::IpAddr;
 
 /// A path in the S3 storage
@@ -156,6 +158,40 @@ pub const fn check_key(key: &str) -> bool {
     key.len() <= 1024
 }
 
+/// Normalizes a path:
+ /// - If the path does not start with `/`, no normalization is performed.
+ /// - If the path starts with `/`, normalization:
+ ///   - removes all leading slashes (unless the entire path is one or more `/`)
+ ///   - replaces consecutive internal slashes with a single slash
+ ///   - reduces one or more trailing slashes to a single trailing slash
+/// - Examples:
+///   - "/"                 -> "/"
+///   - "/keyname"          -> "keyname"
+///   - "//keyname"         -> "keyname"
+///   - "//keyname/"        -> "keyname/"
+///   - "//dir////keyname"  -> "dir/keyname"
+///   - "dir///sub//file"   -> "dir///sub//file"
+///   - "/dir///sub//file"  -> "dir/sub/file"
+#[cfg(feature = "normalize_forward_slash")]
+fn normalize_path(path: &str) -> Cow<'_, str> {
+    if !path.starts_with('/') {
+        return Cow::Borrowed(path);
+    }
+    let end_with_slash = path.ends_with('/');
+    let parts: Vec<&str> = path.split('/').filter(|s| !s.is_empty()).collect();
+
+    if parts.is_empty() {
+        Cow::Borrowed("/")
+    } else {
+        let joined = parts.join("/");
+        if end_with_slash {
+            Cow::Owned(format!("{joined}/"))
+        } else {
+            Cow::Owned(joined)
+        }
+    }
+}
+
 /// Parses a path-style request
 /// # Errors
 /// Returns an `Err` if the s3 path is invalid
@@ -185,6 +221,11 @@ pub fn parse_path_style_with_validation(uri_path: &str, validation: &dyn NameVal
 
     let Some(key) = key else { return Ok(S3Path::bucket(bucket)) };
 
+    #[cfg(feature = "normalize_forward_slash")]
+    let normalized_key = normalize_path(key);
+    #[cfg(feature = "normalize_forward_slash")]
+    let key = normalized_key.as_ref();
+
     if !check_key(key) {
         return Err(ParseS3PathError::KeyTooLong);
     }
@@ -219,6 +260,11 @@ pub fn parse_virtual_hosted_style_with_validation(
         return Ok(S3Path::Bucket { bucket: bucket.into() });
     }
 
+    #[cfg(feature = "normalize_forward_slash")]
+    let normalized_key = normalize_path(key);
+    #[cfg(feature = "normalize_forward_slash")]
+    let key = normalized_key.as_ref();
+
     if !check_key(key) {
         return Err(ParseS3PathError::KeyTooLong);
     }
@@ -393,6 +439,46 @@ mod tests {
         assert_eq!(result1.is_err(), result2.is_err());
     }
 
+    #[test]
+    #[cfg(feature = "normalize_forward_slash")]
+    fn test_path_style_normalize_forward_slash() {
+        let cases = [
+            ("/bucket-name//", Ok(S3Path::object("bucket-name", "/"))),
+            ("/bucket-name/object-name", Ok(S3Path::object("bucket-name", "object-name"))),
+            ("/bucket-name//object-name", Ok(S3Path::object("bucket-name", "object-name"))),
+            ("/bucket-name///object-name/", Ok(S3Path::object("bucket-name", "object-name/"))),
+            ("/bucket-name/dir/object-name", Ok(S3Path::object("bucket-name", "dir/object-name"))),
+            ("/bucket-name/dir//object-name", Ok(S3Path::object("bucket-name", "dir//object-name"))),
+            ("/bucket-name//dir/object-name/", Ok(S3Path::object("bucket-name", "dir/object-name/"))),
+        ];
+
+        for (uri_path, expected) in cases {
+            assert_eq!(parse_path_style_with_validation(uri_path, &AwsNameValidation::new()), expected);
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "normalize_forward_slash")]
+    fn test_virtual_hosted_style_normalize_forward_slash() {
+        let cases = [
+            ("/", Ok(S3Path::bucket("bucket-name"))),
+            ("//", Ok(S3Path::object("bucket-name", "/"))),
+            ("///", Ok(S3Path::object("bucket-name", "/"))),
+            ("/object-name", Ok(S3Path::object("bucket-name", "object-name"))),
+            ("//object-name", Ok(S3Path::object("bucket-name", "object-name"))),
+            ("///object-name/", Ok(S3Path::object("bucket-name", "object-name/"))),
+            ("/dir//object-name/", Ok(S3Path::object("bucket-name", "dir//object-name/"))),
+            ("//dir//object-name/", Ok(S3Path::object("bucket-name", "dir/object-name/"))),
+        ];
+
+        for (uri_path, expected) in cases {
+            assert_eq!(
+                parse_virtual_hosted_style_with_validation(Some("bucket-name"), uri_path, &AwsNameValidation::new()),
+                expected
+            );
+        }
+    }
+
     // --- S3Path accessor coverage ---
 
     #[test]
@@ -481,4 +567,26 @@ mod tests {
         let err = ParseS3PathError::KeyTooLong;
         assert!(!format!("{err}").is_empty());
     }
+
+    #[test]
+    #[cfg(feature = "normalize_forward_slash")]
+    fn key_name_normalize_forward_slash() {
+        let cases = [
+            ("/", "/"),
+            ("/////", "/"),
+            ("object-name", "object-name"),
+            ("object-name/", "object-name/"),
+            ("object-name///", "object-name///"),
+            ("/object-name", "object-name"),
+            ("///object-name", "object-name"),
+            ("///object-name/", "object-name/"),
+            ("/dir/object-name", "dir/object-name"),
+            ("///dir/object-name", "dir/object-name"),
+            ("/dir////object-name", "dir/object-name"),
+            ("///dir1////dir2/object-name////////", "dir1/dir2/object-name/"),
+        ];
+        for (input, expected) in &cases {
+            assert_eq!(normalize_path(input).as_ref(), *expected);
+        }
+    }
 }