Reconstructing Notify module

crates/notify/src/rules/pattern.rs

@@ -0,0 +1,99 @@
+use wildmatch::WildMatch;
+
+/// Create new pattern string based on prefix and suffix。
+///
+/// The rule is similar to event.NewPattern in the Go version:
+/// - If a prefix is provided and does not end with '*', '*' is appended.
+/// - If a suffix is provided and does not start with '*', then prefix '*'.
+/// - Replace "**" with "*".
+pub fn new_pattern(prefix: Option<&str>, suffix: Option<&str>) -> String {
+    let mut pattern = String::new();
+
+    // Process the prefix part
+    if let Some(p) = prefix {
+        if !p.is_empty() {
+            pattern.push_str(p);
+            if !p.ends_with('*') {
+                pattern.push('*');
+            }
+        }
+    }
+
+    // Process the suffix part
+    if let Some(s) = suffix {
+        if !s.is_empty() {
+            let mut s_to_append = s.to_string();
+            if !s.starts_with('*') {
+                s_to_append.insert(0, '*');
+            }
+
+            // If the pattern is empty (only suffixes are provided), then the pattern is the suffix
+            // Otherwise, append the suffix to the pattern
+            if pattern.is_empty() {
+                pattern = s_to_append;
+            } else {
+                pattern.push_str(&s_to_append);
+            }
+        }
+    }
+
+    // Replace "**" with "*"
+    pattern = pattern.replace("**", "*");
+
+    pattern
+}
+
+/// Simple matching object names and patterns。
+pub fn match_simple(pattern_str: &str, object_name: &str) -> bool {
+    if pattern_str == "*" {
+        // AWS S3 docs: A single asterisk (*) in the rule matches all objects.
+        return true;
+    }
+    // WildMatch considers an empty pattern to not match anything, which is usually desired.
+    // If pattern_str is empty, it means no specific filter, so it depends on interpretation.
+    // Go's wildcard.MatchSimple might treat empty pattern differently.
+    // For now, assume empty pattern means no match unless it's explicitly "*".
+    if pattern_str.is_empty() {
+        return false; // Or true if an empty pattern means "match all" in some contexts.
+        // Given Go's NewRulesMap defaults to "*", an empty pattern from Filter is unlikely to mean "match all".
+    }
+    WildMatch::new(pattern_str).matches(object_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_pattern() {
+        assert_eq!(new_pattern(Some("images/"), Some(".jpg")), "images/*.jpg");
+        assert_eq!(new_pattern(Some("images/"), None), "images/*");
+        assert_eq!(new_pattern(None, Some(".jpg")), "*.jpg");
+        assert_eq!(new_pattern(Some("foo"), Some("bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo*"), Some("bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo"), Some("*bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("foo*"), Some("*bar")), "foo*bar"); // foo* + *bar -> foo**bar -> foo*bar
+        assert_eq!(new_pattern(Some("*"), Some("*")), "*"); // * + * -> ** -> *
+        assert_eq!(new_pattern(Some("a"), Some("")), "a*");
+        assert_eq!(new_pattern(Some(""), Some("b")), "*b");
+        assert_eq!(new_pattern(None, None), "");
+        assert_eq!(new_pattern(Some("prefix"), Some("suffix")), "prefix*suffix");
+        assert_eq!(
+            new_pattern(Some("prefix/"), Some("/suffix")),
+            "prefix/*suffix"
+        ); // prefix/* + */suffix -> prefix/**/suffix -> prefix/*/suffix
+    }
+
+    #[test]
+    fn test_match_simple() {
+        assert!(match_simple("foo*", "foobar"));
+        assert!(!match_simple("foo*", "barfoo"));
+        assert!(match_simple("*.jpg", "photo.jpg"));
+        assert!(!match_simple("*.jpg", "photo.png"));
+        assert!(match_simple("*", "anything.anything"));
+        assert!(match_simple("foo*bar", "foobazbar"));
+        assert!(!match_simple("foo*bar", "foobar_baz"));
+        assert!(match_simple("a*b*c", "axbyc"));
+        assert!(!match_simple("a*b*c", "axbc"));
+    }
+}