spikard 0.3.6 → 0.5.0

data/vendor/crates/spikard-http/src/query_parser.rs

@@ -128,11 +128,11 @@ pub fn parse_query_string(qs: &[u8], separator: char) -> Vec<(String, String)> {
 /// - Numbers (if parse_numbers is true)
 /// - Strings (fallback)
 #[inline]
-fn decode_value(json_str: String, parse_numbers: bool) -> Value {
-    if PARENTHESES_RE.is_match(json_str.as_str()) {
-        let result: Value = match from_str(json_str.as_str()) {
+fn decode_value(raw: &str, parse_numbers: bool) -> Value {
+    if PARENTHESES_RE.is_match(raw) {
+        let result: Value = match from_str(raw) {
             Ok(value) => value,
-            Err(_) => match from_str(json_str.replace('\'', "\"").as_str()) {
+            Err(_) => match from_str(raw.replace('\'', "\"").as_str()) {
                 Ok(normalized) => normalized,
                 Err(_) => Value::Null,
             },
@@ -140,27 +140,31 @@ fn decode_value(json_str: String, parse_numbers: bool) -> Value {
         return result;
     }
 
-    let normalized = json_str.replace('"', "");
+    let normalized = if raw.as_bytes().contains(&b'"') {
+        Cow::Owned(raw.replace('"', ""))
+    } else {
+        Cow::Borrowed(raw)
+    };
 
     let json_boolean = parse_boolean(&normalized);
-    let json_null = Ok::<_, Infallible>(normalized == "null");
+    let json_null = Ok::<_, Infallible>(normalized.as_ref() == "null");
 
     if parse_numbers {
-        let json_integer = normalized.parse::<i64>();
-        let json_float = normalized.parse::<f64>();
+        let json_integer = normalized.as_ref().parse::<i64>();
+        let json_float = normalized.as_ref().parse::<f64>();
         return match (json_integer, json_float, json_boolean, json_null) {
             (Ok(json_integer), _, _, _) => Value::from(json_integer),
             (_, Ok(json_float), _, _) => Value::from(json_float),
             (_, _, Ok(json_boolean), _) => Value::from(json_boolean),
             (_, _, _, Ok(true)) => Value::Null,
-            _ => Value::from(normalized),
+            _ => Value::from(normalized.as_ref()),
         };
     }
 
     match (json_boolean, json_null) {
         (Ok(json_boolean), _) => Value::from(json_boolean),
         (_, Ok(true)) => Value::Null,
-        _ => Value::from(normalized),
+        _ => Value::from(normalized.as_ref()),
     }
 }
 
@@ -174,43 +178,33 @@ fn decode_value(json_str: String, parse_numbers: bool) -> Value {
 /// - "" (empty string) → Err (don't coerce, preserve as empty string)
 #[inline]
 fn parse_boolean(s: &str) -> Result<bool, ()> {
-    let lower = s.to_lowercase();
-    if lower == "true" || s == "1" {
+    if s.eq_ignore_ascii_case("true") || s == "1" {
         Ok(true)
-    } else if lower == "false" || s == "0" {
+    } else if s.eq_ignore_ascii_case("false") || s == "0" {
         Ok(false)
     } else {
         Err(())
     }
 }
 
-/// Parse a query string into a JSON Value.
+/// Convert already-decoded query pairs into a JSON Value.
 ///
-/// This function:
-/// - Handles multiple values for the same key (creates arrays)
-/// - Auto-converts types (numbers, booleans, null, objects, arrays)
-/// - Collapses single-item arrays into single values
+/// This is useful when callers need both:
+/// - the raw decoded pairs (for error messages / multi-value handling), and
+/// - a JSON object with type coercion (for downstream consumers),
 ///
-/// # Arguments
-/// * `qs` - The query string bytes
-/// * `parse_numbers` - Whether to parse numeric strings into numbers
-///
-/// # Example
-/// ```ignore
-/// let result = parse_query_string_to_json(b"foo=1&foo=2&bar=test&active=true", true);
-/// // {"foo": [1, 2], "bar": "test", "active": true}
-/// ```
+/// while avoiding a second URL-decoding pass.
 #[inline]
-pub fn parse_query_string_to_json(qs: &[u8], parse_numbers: bool) -> Value {
+pub fn parse_query_pairs_to_json(pairs: &[(String, String)], parse_numbers: bool) -> Value {
     let mut array_map: FxHashMap<String, Vec<Value>> = FxHashMap::default();
 
-    for (key, value) in parse_query_string(qs, '&') {
-        match array_map.get_mut(&key) {
+    for (key, value) in pairs {
+        match array_map.get_mut(key) {
             Some(entry) => {
                 entry.push(decode_value(value, parse_numbers));
             }
             None => {
-                array_map.insert(key, vec![decode_value(value, parse_numbers)]);
+                array_map.insert(key.clone(), vec![decode_value(value, parse_numbers)]);
             }
         }
     }
@@ -227,6 +221,28 @@ pub fn parse_query_string_to_json(qs: &[u8], parse_numbers: bool) -> Value {
         .collect::<Value>()
 }
 
+/// Parse a query string into a JSON Value.
+///
+/// This function:
+/// - Handles multiple values for the same key (creates arrays)
+/// - Auto-converts types (numbers, booleans, null, objects, arrays)
+/// - Collapses single-item arrays into single values
+///
+/// # Arguments
+/// * `qs` - The query string bytes
+/// * `parse_numbers` - Whether to parse numeric strings into numbers
+///
+/// # Example
+/// ```ignore
+/// let result = parse_query_string_to_json(b"foo=1&foo=2&bar=test&active=true", true);
+/// // {"foo": [1, 2], "bar": "test", "active": true}
+/// ```
+#[inline]
+pub fn parse_query_string_to_json(qs: &[u8], parse_numbers: bool) -> Value {
+    let pairs = parse_query_string(qs, '&');
+    parse_query_pairs_to_json(&pairs, parse_numbers)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -366,4 +382,412 @@ mod tests {
         let result = parse_query_string_to_json(b"name=test%26value%3D123", false);
         assert_eq!(result, json!({ "name": "test&value=123" }));
     }
+
+    #[test]
+    fn test_malformed_percent_single_char() {
+        let result = parse_query_string(b"key=%", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("%"))]);
+    }
+
+    #[test]
+    fn test_malformed_percent_single_hex_only() {
+        let result = parse_query_string(b"key=%2", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("%2"))]);
+    }
+
+    #[test]
+    fn test_malformed_percent_invalid_hex_chars() {
+        let result = parse_query_string(b"key=%GG&other=value", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("key"), String::from("%GG")),
+                (String::from("other"), String::from("value")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_malformed_percent_mixed_invalid_hex() {
+        let result = parse_query_string(b"key=%2G&other=value", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("key"), String::from("%2G")),
+                (String::from("other"), String::from("value")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_percent_encoding_lowercase_hex() {
+        let result = parse_query_string(b"key=%2f&other=test", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("key"), String::from("/")),
+                (String::from("other"), String::from("test")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_percent_encoding_uppercase_hex() {
+        let result = parse_query_string(b"key=%2F&other=test", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("key"), String::from("/")),
+                (String::from("other"), String::from("test")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_percent_encoding_mixed_case_hex() {
+        let result = parse_query_string(b"key=%2f%3D%4A", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("/=J"))]);
+    }
+
+    #[test]
+    fn test_plus_as_space_in_value() {
+        let result = parse_query_string(b"message=hello+world", '&');
+        assert_eq!(result, vec![(String::from("message"), String::from("hello world"))]);
+    }
+
+    #[test]
+    fn test_plus_as_space_multiple_plus() {
+        let result = parse_query_string(b"message=a+b+c+d", '&');
+        assert_eq!(result, vec![(String::from("message"), String::from("a b c d"))]);
+    }
+
+    #[test]
+    fn test_percent_encoded_space_vs_plus() {
+        let result = parse_query_string(b"a=%20space&b=+plus", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("a"), String::from(" space")),
+                (String::from("b"), String::from(" plus")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_mixed_plus_and_percent_encoded_space() {
+        let result = parse_query_string(b"text=hello+%20world", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("hello  world"))]);
+    }
+
+    #[test]
+    fn test_ampersand_in_value_encoded() {
+        let result = parse_query_string(b"text=foo%26bar", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("foo&bar"))]);
+    }
+
+    #[test]
+    fn test_equals_in_value_encoded() {
+        let result = parse_query_string(b"text=a%3Db", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("a=b"))]);
+    }
+
+    #[test]
+    fn test_question_mark_in_value_encoded() {
+        let result = parse_query_string(b"text=what%3F", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("what?"))]);
+    }
+
+    #[test]
+    fn test_hash_in_value_encoded() {
+        let result = parse_query_string(b"text=anchor%23top", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("anchor#top"))]);
+    }
+
+    #[test]
+    fn test_multiple_encoded_special_chars() {
+        let result = parse_query_string(b"text=%26%3D%3F%23", '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("&=?#"))]);
+    }
+
+    #[test]
+    fn test_empty_query_string() {
+        let result = parse_query_string(b"", '&');
+        assert_eq!(result, vec![]);
+    }
+
+    #[test]
+    fn test_multiple_consecutive_separators() {
+        let result = parse_query_string(b"a=1&&&b=2", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("a"), String::from("1")),
+                (String::from("b"), String::from("2")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_key_without_value() {
+        let result = parse_query_string(b"key=", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from(""))]);
+    }
+
+    #[test]
+    fn test_key_without_equals() {
+        let result = parse_query_string(b"key", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from(""))]);
+    }
+
+    #[test]
+    fn test_value_without_key() {
+        let result = parse_query_string(b"=value", '&');
+        assert_eq!(result, vec![(String::from(""), String::from("value"))]);
+    }
+
+    #[test]
+    fn test_multiple_equals_in_pair() {
+        let result = parse_query_string(b"key=val=more", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("val=more"))]);
+    }
+
+    #[test]
+    fn test_separator_at_start() {
+        let result = parse_query_string(b"&key=value", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("value"))]);
+    }
+
+    #[test]
+    fn test_separator_at_end() {
+        let result = parse_query_string(b"key=value&", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("value"))]);
+    }
+
+    #[test]
+    fn test_separator_at_both_ends() {
+        let result = parse_query_string(b"&key=value&", '&');
+        assert_eq!(result, vec![(String::from("key"), String::from("value"))]);
+    }
+
+    #[test]
+    fn test_multiple_values_same_key() {
+        let result = parse_query_string(b"tag=foo&tag=bar&tag=baz", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("tag"), String::from("foo")),
+                (String::from("tag"), String::from("bar")),
+                (String::from("tag"), String::from("baz")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_multiple_values_mixed_keys() {
+        let result = parse_query_string(b"tag=foo&id=1&tag=bar&id=2", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("tag"), String::from("foo")),
+                (String::from("id"), String::from("1")),
+                (String::from("tag"), String::from("bar")),
+                (String::from("id"), String::from("2")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_json_conversion_empty_key() {
+        let result = parse_query_string_to_json(b"=value", false);
+        assert_eq!(result, json!({ "": "value" }));
+    }
+
+    #[test]
+    fn test_json_conversion_all_empty_values() {
+        let result = parse_query_string_to_json(b"a=&b=&c=", false);
+        assert_eq!(result, json!({ "a": "", "b": "", "c": "" }));
+    }
+
+    #[test]
+    fn test_json_conversion_malformed_json_object() {
+        let result = parse_query_string_to_json(b"data={invalid", false);
+        assert_eq!(result, json!({ "data": "{invalid" }));
+    }
+
+    #[test]
+    fn test_json_conversion_malformed_json_array() {
+        let result = parse_query_string_to_json(b"items=[1,2,", false);
+        assert_eq!(result, json!({ "items": "[1,2," }));
+    }
+
+    #[test]
+    fn test_json_conversion_with_quotes_in_value() {
+        let result = parse_query_string_to_json(b"text=\"hello\"", false);
+        assert_eq!(result, json!({ "text": "hello" }));
+    }
+
+    #[test]
+    fn test_json_conversion_single_quotes_in_object() {
+        let result = parse_query_string_to_json(b"obj={'key':'value'}", false);
+        let value = result.get("obj");
+        assert!(value.is_some());
+    }
+
+    #[test]
+    fn test_boolean_case_insensitive_variations() {
+        assert_eq!(parse_query_string_to_json(b"a=tRuE", false), json!({"a": true}));
+        assert_eq!(parse_query_string_to_json(b"a=FaLsE", false), json!({"a": false}));
+        assert_eq!(
+            parse_query_string_to_json(b"a=tRuE&b=FaLsE", false),
+            json!({"a": true, "b": false})
+        );
+    }
+
+    #[test]
+    fn test_boolean_with_numbers_no_parse() {
+        assert_eq!(parse_query_string_to_json(b"a=1", false), json!({"a": true}));
+        assert_eq!(parse_query_string_to_json(b"a=0", false), json!({"a": false}));
+    }
+
+    #[test]
+    fn test_number_parsing_negative() {
+        assert_eq!(parse_query_string_to_json(b"a=-123", true), json!({"a": -123}));
+        assert_eq!(parse_query_string_to_json(b"a=-1.5", true), json!({"a": -1.5}));
+    }
+
+    #[test]
+    fn test_number_parsing_zero() {
+        assert_eq!(parse_query_string_to_json(b"a=0", true), json!({"a": 0}));
+        assert_eq!(parse_query_string_to_json(b"a=0.0", true), json!({"a": 0.0}));
+    }
+
+    #[test]
+    fn test_number_parsing_scientific_notation() {
+        assert_eq!(parse_query_string_to_json(b"a=1e10", true), json!({"a": 1e10}));
+        assert_eq!(parse_query_string_to_json(b"a=1.5e-3", true), json!({"a": 1.5e-3}));
+    }
+
+    #[test]
+    fn test_array_mixed_types_with_number_parsing() {
+        assert_eq!(
+            parse_query_string_to_json(b"vals=1&vals=2.5&vals=true&vals=test", true),
+            json!({"vals": [1, 2.5, true, "test"]})
+        );
+    }
+
+    #[test]
+    fn test_array_mixed_types_without_number_parsing() {
+        assert_eq!(
+            parse_query_string_to_json(b"vals=1&vals=2.5&vals=true&vals=test", false),
+            json!({"vals": [true, "2.5", true, "test"]})
+        );
+    }
+
+    #[test]
+    fn test_utf8_chinese_characters() {
+        let result = parse_query_string("name=中文".as_bytes(), '&');
+        assert_eq!(result, vec![(String::from("name"), String::from("中文"))]);
+    }
+
+    #[test]
+    fn test_utf8_emoji() {
+        let result = parse_query_string("emoji=🚀".as_bytes(), '&');
+        assert_eq!(result, vec![(String::from("emoji"), String::from("🚀"))]);
+    }
+
+    #[test]
+    fn test_utf8_mixed_with_encoding() {
+        let result = parse_query_string("text=hello%20中文".as_bytes(), '&');
+        assert_eq!(result, vec![(String::from("text"), String::from("hello 中文"))]);
+    }
+
+    #[test]
+    fn test_custom_separator_semicolon() {
+        let result = parse_query_string(b"a=1;b=2;c=3", ';');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("a"), String::from("1")),
+                (String::from("b"), String::from("2")),
+                (String::from("c"), String::from("3")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_custom_separator_comma() {
+        let result = parse_query_string(b"a=1,b=2,c=3", ',');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("a"), String::from("1")),
+                (String::from("b"), String::from("2")),
+                (String::from("c"), String::from("3")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_percent_encoding_all_byte_values() {
+        let result = parse_query_string(b"space=%20&at=%40&hash=%23&dollar=%24", '&');
+        assert_eq!(
+            result,
+            vec![
+                (String::from("space"), String::from(" ")),
+                (String::from("at"), String::from("@")),
+                (String::from("hash"), String::from("#")),
+                (String::from("dollar"), String::from("$")),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_high_byte_values_in_percent_encoding() {
+        let result = parse_query_string(b"high=%ff%fe%fd", '&');
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].0, "high");
+    }
+
+    #[test]
+    fn test_very_long_query_string() {
+        let mut long_query = String::from("key=");
+        long_query.push_str(&"a".repeat(10000));
+        let result = parse_query_string(long_query.as_bytes(), '&');
+        assert_eq!(result.len(), 1);
+        assert_eq!(result[0].0, "key");
+        assert_eq!(result[0].1.len(), 10000);
+    }
+
+    #[test]
+    fn test_very_large_number_of_parameters() {
+        let mut query = String::new();
+        for i in 0..100 {
+            if i > 0 {
+                query.push('&');
+            }
+            query.push_str(&format!("param{}=value{}", i, i));
+        }
+        let result = parse_query_string(query.as_bytes(), '&');
+        assert_eq!(result.len(), 100);
+        assert_eq!(result[0].0, "param0");
+        assert_eq!(result[99].0, "param99");
+    }
+
+    #[test]
+    fn test_literal_space_in_value() {
+        let result = parse_query_string(b"name=hello world", '&');
+        assert_eq!(result, vec![(String::from("name"), String::from("hello world"))]);
+    }
+
+    #[test]
+    fn test_tab_in_value() {
+        let result = parse_query_string(b"name=hello\tworld", '&');
+        assert_eq!(result, vec![(String::from("name"), String::from("hello\tworld"))]);
+    }
+
+    #[test]
+    fn test_newline_in_value() {
+        let result = parse_query_string(b"name=hello\nworld", '&');
+        assert_eq!(result, vec![(String::from("name"), String::from("hello\nworld"))]);
+    }
 }