Fix optional base_input on can_parse.

Add URLSearchParams wrappers.
Update typing stubs.

Author: TkTech

can_ada.pyi

@@ -1,18 +1,19 @@
-from __future__ import annotations
-import can_ada
-import typing
+from typing import Iterator, overload
 
-__all__ = [
-    "URL",
-    "can_parse",
-    "parse",
-    "idna_encode",
-    "idna_decode"
-]
+__version__: str
 
-
-class URL():
-    def __str__(self) -> str: ...
+class URL:
+    hash: str
+    host: str
+    hostname: str
+    href: str
+    password: str
+    pathname: str
+    port: str
+    protocol: str
+    search: str
+    username: str
+    def __init__(self, *args, **kwargs) -> None: ...
     def has_credentials(self) -> bool: ...
     def has_empty_hostname(self) -> bool: ...
     def has_hash(self) -> bool: ...
@@ -25,104 +26,45 @@ class URL():
     def has_valid_domain(self) -> bool: ...
     def to_diagram(self) -> str: ...
     def validate(self) -> bool: ...
-    def __add__(self, other) -> "URL": ...
-    @property
-    def hash(self) -> str:
-        """
-        :type: str
-        """
-    @hash.setter
-    def hash(self, arg1: str) -> None:
-        pass
-    @property
-    def host(self) -> str:
-        """
-        :type: str
-        """
-    @host.setter
-    def host(self, arg1: str) -> None:
-        pass
-    @property
-    def hostname(self) -> str:
-        """
-        :type: str
-        """
-    @hostname.setter
-    def hostname(self, arg1: str) -> None:
-        pass
-    @property
-    def href(self) -> str:
-        """
-        :type: str
-        """
-    @href.setter
-    def href(self, arg1: str) -> None:
-        pass
-    @property
-    def origin(self) -> str:
-        """
-        :type: str
-        """
-    @property
-    def password(self) -> str:
-        """
-        :type: str
-        """
-    @password.setter
-    def password(self, arg1: str) -> None:
-        pass
-    @property
-    def pathname(self) -> str:
-        """
-        :type: str
-        """
-    @pathname.setter
-    def pathname(self, arg1: str) -> None:
-        pass
+    def __add__(self, arg0: str) -> URL: ...
     @property
-    def pathname_length(self) -> int:
-        """
-        :type: int
-        """
+    def origin(self) -> str: ...
     @property
-    def port(self) -> str:
-        """
-        :type: str
-        """
-    @port.setter
-    def port(self, arg1: str) -> None:
-        pass
-    @property
-    def protocol(self) -> str:
-        """
-        :type: str
-        """
-    @protocol.setter
-    def protocol(self, arg1: str) -> None:
-        pass
-    @property
-    def search(self) -> str:
-        """
-        :type: str
-        """
-    @search.setter
-    def search(self, arg1: str) -> None:
-        pass
-    @property
-    def username(self) -> str:
-        """
-        :type: str
-        """
-    @username.setter
-    def username(self, arg1: str) -> None:
-        pass
-    pass
-def can_parse(input: str, base_input: str = None) -> bool:
-    pass
-def parse(arg0: str) -> URL:
-    pass
-def idna_encode(arg0: str) -> bytes:
-    pass
-def idna_decode(arg0: bytes) -> str:
-    pass
-__version__ = '1.0.0'
+    def pathname_length(self) -> int: ...
+
+class URLSearchParams:
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, arg0: str) -> None: ...
+    def append(self, arg0: str, arg1: str) -> None: ...
+    def copy(self) -> URLSearchParams: ...
+    def get(self, arg0: str) -> str | None: ...
+    def get_all(self, arg0: str) -> list[str]: ...
+    def has(self, key: str, value: str | None = ...) -> bool: ...
+    def keys(self) -> URLSearchParamsKeysIter: ...
+    def remove(self, key: str, value: str | None = ...) -> None: ...
+    def size(self) -> int: ...
+    def sort(self) -> None: ...
+    def values(self) -> URLSearchParamsValuesIter: ...
+    def __contains__(self, arg0: str) -> bool: ...
+    def __delitem__(self, arg0: str) -> None: ...
+    def __getitem__(self, arg0: str) -> str: ...
+    def __iter__(self) -> Iterator[tuple[str, str]]: ...
+    def __len__(self) -> int: ...
+    def __setitem__(self, arg0: str, arg1: str) -> None: ...
+
+class URLSearchParamsKeysIter:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def __iter__(self) -> URLSearchParamsKeysIter: ...
+    def __next__(self) -> str | None: ...
+
+class URLSearchParamsValuesIter:
+    def __init__(self, *args, **kwargs) -> None: ...
+    def __iter__(self) -> URLSearchParamsValuesIter: ...
+    def __next__(self) -> str | None: ...
+
+def can_parse(input: str, base_input: str | None = ...) -> bool: ...
+def idna_decode(arg0: str) -> str: ...
+def idna_encode(arg0: str) -> bytes: ...
+def parse(arg0: str) -> URL: ...

src/binding.cpp

@@ -1,4 +1,5 @@
 #include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
 #include "ada.h"
 
 namespace py = pybind11;
@@ -10,10 +11,9 @@ PYBIND11_MODULE(can_ada, m) {
     m.attr("__version__") = "dev";
 #endif
 
-    m.def("can_parse",
-          &ada::can_parse,
-          py::arg("input"),
-          py::arg("base_input") = static_cast<const std::string_view*>(nullptr));
+    m.def("can_parse", [](std::string_view input, std::optional<std::string_view*> base_input) {
+        return ada::can_parse(input, base_input.value_or(nullptr));
+    }, py::arg("input"), py::arg("base_input") = py::none());
 
     py::class_<ada::url_aggregator>(m, "URL")
         .def_property("hash", &ada::url_aggregator::get_hash, &ada::url_aggregator::set_hash)
@@ -52,6 +52,80 @@ PYBIND11_MODULE(can_ada, m) {
           return url.value();
         });
 
+    py::class_<ada::url_search_params_keys_iter>(m, "URLSearchParamsKeysIter")
+        .def("__iter__", [](ada::url_search_params_keys_iter &self) {
+            return &self;
+        })
+        .def("__next__", [](ada::url_search_params_keys_iter &self) {
+            if (self.has_next()) {
+                return self.next();
+            } else {
+                throw pybind11::stop_iteration();
+            }
+        });
+
+    py::class_<ada::url_search_params_values_iter>(m, "URLSearchParamsValuesIter")
+        .def("__iter__", [](ada::url_search_params_values_iter &self) {
+            return &self;
+        })
+        .def("__next__", [](ada::url_search_params_values_iter &self) {
+            if (self.has_next()) {
+                return self.next();
+            } else {
+                throw pybind11::stop_iteration();
+            }
+        });
+
+    py::class_<ada::url_search_params>(m, "URLSearchParams")
+        .def(py::init<>())
+        .def(py::init<const std::string_view>())
+        .def("get", &ada::url_search_params::get)
+        .def("get_all", &ada::url_search_params::get_all)
+        .def("has", [](ada::url_search_params &self, std::string_view key, std::optional<std::string_view> value) {
+            if (value) {
+                return self.has(key, value.value());
+            }
+            return self.has(key);
+        }, py::arg("key"), py::arg("value") = py::none())
+        .def("append", &ada::url_search_params::append)
+        .def("remove", [](ada::url_search_params &self, std::string_view key, std::optional<std::string_view> value) {
+            if (value) {
+                self.remove(key, value.value());
+                return;
+            }
+            self.remove(key);
+        }, py::arg("key"), py::arg("value") = py::none())
+        .def("copy", [](ada::url_search_params &self) {
+            return ada::url_search_params(self);
+        })
+        .def("sort", &ada::url_search_params::sort)
+        .def("size", &ada::url_search_params::size)
+        .def("keys", [](ada::url_search_params &self) {
+            return self.get_keys();
+        }, py::keep_alive<0, 1>())
+        .def("values", [](ada::url_search_params &self) {
+            return self.get_values();
+        }, py::keep_alive<0, 1>())
+        .def("__str__", &ada::url_search_params::to_string)
+        .def("__getitem__", [](ada::url_search_params &self, std::string_view key) {
+            auto v = self.get(key);
+            if (v) {
+                return v.value();
+            }
+            throw pybind11::key_error("Key not found.");
+        })
+        .def("__setitem__", &ada::url_search_params::set)
+        .def("__delitem__", [](ada::url_search_params &self, std::string_view key) {
+            self.remove(key);
+        })
+        .def("__len__", &ada::url_search_params::size)
+        .def("__contains__", [](ada::url_search_params &self, std::string_view key) {
+            return self.has(key);
+        })
+        .def("__iter__", [](ada::url_search_params &self) {
+            return py::make_iterator(self.begin(), self.end());
+        }, py::keep_alive<0, 1>());
+
     m.def("idna_decode", &ada::idna::to_unicode);
     m.def("idna_encode", [](std::string input) -> py::bytes {
       return py::bytes(ada::idna::to_ascii(input));

tests/test_parsing.py

@@ -5,6 +5,9 @@ def test_can_parse():
     assert can_ada.can_parse("/", "https://tkte.ch") is True
     assert can_ada.can_parse("/", "/tkte.ch") is False
 
+    assert can_ada.can_parse("https://tkte.ch") is True
+    assert can_ada.can_parse("//tkte.ch") is False
+
 
 def test_parse():
     """

tests/test_search.py

@@ -0,0 +1,100 @@
+import pytest
+
+import can_ada
+
+
+def test_get_and_set():
+    """
+    Ensure we can get & ste the various parts of the URLSearchParams.
+    """
+    params = can_ada.URLSearchParams("?a=1&b=2&c=3")
+    assert params["a"] == "1"
+    assert params["b"] == "2"
+    assert params["c"] == "3"
+
+    with pytest.raises(KeyError):
+        params["d"]
+
+    assert params.get("a") == "1"
+    assert params.get("d") is None
+
+    assert "a" in params
+    assert "d" not in params
+
+    assert params.has("a") is True
+    assert params.has("d") is False
+
+    params.remove("a")
+    assert params.has("a") is False
+    assert params.get("a") is None
+
+
+def test_get_all_and_set():
+    """
+    Ensure we can get & set multiple values for a single key.
+    """
+    params = can_ada.URLSearchParams("?a=1&b=2&c=3&c=4")
+    assert params.get_all("a") == ["1"]
+    assert params.get_all("b") == ["2"]
+    assert params.get_all("c") == ["3", "4"]
+
+    params["a"] = "2"
+    assert params.get_all("a") == ["2"]
+
+    params["c"] = "5"
+    assert params.get_all("c") == ["5"]
+    params.append("c", "6")
+    assert params.get_all("c") == ["5", "6"]
+
+    params.remove("c", "6")
+    assert params.get_all("c") == ["5"]
+
+    params.remove("c", "5")
+    assert params.get_all("c") == []
+
+    params.append("c", "5")
+    params.append("c", "6")
+    assert params.has("c", "5") is True
+    assert params.has("c", "6") is True
+    assert params.has("c", "7") is False
+
+
+def test_size():
+    """
+    Ensure we can get the size of the URLSearchParams.
+    """
+    params = can_ada.URLSearchParams("?a=1&b=2&c=3")
+    assert len(params) == 3
+
+
+def test_copy():
+    """
+    Ensure we can copy a URLSearchParams object.
+    """
+    params_1 = can_ada.URLSearchParams("?a=1&b=2&c=3")
+    params_2 = params_1.copy()
+
+    # Ensure the copy isn't sharing memory
+    assert params_2["a"] == "1"
+    params_1["a"] = "2"
+    assert params_2["a"] == "1"
+
+
+def test_sort():
+    """
+    Ensure we can sort the URLSearchParams.
+    """
+    params = can_ada.URLSearchParams("?c=3&b=2&a=1")
+    assert list(params.keys()) == ["c", "b", "a"]
+    params.sort()
+    assert list(params.keys()) == ["a", "b", "c"]
+
+
+def test_iterators():
+    """
+    Ensure we can iterate over the URLSearchParams.
+    """
+    params = can_ada.URLSearchParams("?a=1&b=2&c=3")
+    assert list(params) == [("a", "1"), ("b", "2"), ("c", "3")]
+    assert list(params.keys()) == ["a", "b", "c"]
+    assert list(params.values()) == ["1", "2", "3"]