Adds url escape sequence decoding

- Add utility function to decode/unquote url encoded strings
- Updates URI object to decode/unquote url path and query values with
  "plus" character expansion into space for queries

Author: izo0x90

lightbug_http/uri.mojo

@@ -11,19 +11,91 @@ from lightbug_http.strings import (
     https,
 )
 
+
+fn find_all(s: String, sub_str: String) -> List[Int]:
+    match_idxs = List[Int]()
+    var current_idx: Int = s.find(sub_str)
+    while current_idx > -1:
+        match_idxs.append(current_idx)
+        current_idx = s.find(sub_str, start=current_idx + 1)
+    return match_idxs^
+
+
+fn unquote[expand_plus: Bool = False](input_str: String) -> String:
+    var encoded_str = input_str.replace(
+        QueryDelimiters.PLUS_ESCAPED_SPACE, " "
+    ) if expand_plus else input_str
+
+    var percent_idxs: List[Int] = find_all(
+        encoded_str, URIDelimiters.CHAR_ESCAPE
+    )
+
+    if len(percent_idxs) < 1:
+        return encoded_str
+
+    var sub_strings = List[String]()
+
+    var current_idx = 0
+    var slice_start = 0
+    var slice_end = 0
+
+    var str_bytes = List[UInt8]()
+    while current_idx < len(percent_idxs):
+        slice_end = percent_idxs[current_idx]
+        sub_strings.append(encoded_str[slice_start:slice_end])
+
+        var current_offset = slice_end
+        while current_idx < len(percent_idxs):
+            var char_byte = -1
+            if (current_offset + 3) <= len(encoded_str):
+                try:
+                    char_byte = atol(
+                        encoded_str[current_offset + 1 : current_offset + 3],
+                        base=16,
+                    )
+                except:
+                    pass
+
+            if char_byte < 0:
+                break
+
+            str_bytes.append(char_byte)
+
+            if percent_idxs[current_idx + 1] != (current_offset + 3):
+                current_offset += 3
+                break
+
+            current_idx += 1
+            current_offset = percent_idxs[current_idx]
+
+        if len(str_bytes) > 0:
+            str_bytes.append(0x00)
+            sub_strings.append(String(str_bytes))
+            str_bytes.clear()
+
+        slice_start = current_offset
+        current_idx += 1
+
+    sub_strings.append(encoded_str[slice_start:])
+
+    return str("").join(sub_strings)
+
+
 alias QueryMap = Dict[String, String]
 
 
 struct QueryDelimiters:
     alias STRING_START = "?"
     alias ITEM = "&"
     alias ITEM_ASSIGN = "="
+    alias PLUS_ESCAPED_SPACE = "+"
 
 
 struct URIDelimiters:
     alias SCHEMA = "://"
     alias PATH = strSlash
     alias ROOT_PATH = strSlash
+    alias CHAR_ESCAPE = "%"
 
 
 @value
@@ -80,10 +152,10 @@ struct URI(Writable, Stringable, Representable):
         var original_path: String
         var query_string: String
         if n >= 0:
-            original_path = request_uri[:n]
+            original_path = unquote(request_uri[:n])
             query_string = request_uri[n + 1 :]
         else:
-            original_path = request_uri
+            original_path = unquote(request_uri)
             query_string = ""
 
         var queries = QueryMap()
@@ -96,9 +168,9 @@ struct URI(Writable, Stringable, Representable):
                 if key_val[0]:
                     queries[key_val[0]] = ""
                     if len(key_val) == 2:
-                        # TODO: Query values are going to be URI encoded strings and should be decoded as part of the
-                        # query processing
-                        queries[key_val[0]] = key_val[1]
+                        queries[key_val[0]] = unquote[expand_plus=True](
+                            key_val[1]
+                        )
 
         return URI(
             _original_path=original_path,
@@ -115,7 +187,9 @@ struct URI(Writable, Stringable, Representable):
         )
 
     fn __str__(self) -> String:
-        var result = String.write(self.scheme, URIDelimiters.SCHEMA, self.host, self.path)
+        var result = String.write(
+            self.scheme, URIDelimiters.SCHEMA, self.host, self.path
+        )
         if len(self.query_string) > 0:
             result.write(QueryDelimiters.STRING_START, self.query_string)
         return result^

tests/lightbug_http/test_uri.mojo

@@ -107,8 +107,8 @@ def test_uri_parse_query_with_special_characters():
     testing.assert_equal(uri.host, "example.com")
     testing.assert_equal(uri.path, "/path")
     testing.assert_equal(uri.query_string, "name=John+Doe&email=john%40example.com")
-    # testing.assert_equal(uri.queries["name"], "John Doe") - fails, contains John+Doe
-    # testing.assert_equal(uri.queries["email"], "john@example.com") - fails, contains john%40example.com
+    testing.assert_equal(uri.queries["name"], "John Doe")
+    testing.assert_equal(uri.queries["email"], "john@example.com")
 
 def test_uri_parse_empty_query_values():
     var uri = URI.parse("http://example.com/api?key=&token=&empty")
@@ -132,8 +132,8 @@ def test_uri_parse_complex_query():
 def test_uri_parse_query_with_unicode():
     var uri = URI.parse("http://example.com/search?q=%E2%82%AC&lang=%F0%9F%87%A9%F0%9F%87%AA")
     testing.assert_equal(uri.query_string, "q=%E2%82%AC&lang=%F0%9F%87%A9%F0%9F%87%AA")
-    # testing.assert_equal(uri.queries["q"], "€") - fails, contains %E2%82%AC
-    # testing.assert_equal(uri.queries["lang"], "🇩🇪") - fails, contains %F0%9F%87%A9%F0%9F%87%AA
+    testing.assert_equal(uri.queries["q"], "€")
+    testing.assert_equal(uri.queries["lang"], "🇩🇪")
 
 # def test_uri_parse_query_with_fragments():
 #     var uri = URI.parse("http://example.com/page?id=123#section1")