chore: add vendor directory

1 files changed, 243 insertions, 0 deletions

diff --git a/vendor/matchit/tests/insert.rs b/vendor/matchit/tests/insert.rs
new file mode 100644
index 00000000..5513c1c6
--- /dev/null
+++ b/vendor/matchit/tests/insert.rs
@@ -0,0 +1,243 @@
+use matchit::{InsertError, Router};
+
+struct InsertTest(Vec<(&'static str, Result<(), InsertError>)>);
+
+impl InsertTest {
+    fn run(self) {
+        let mut router = Router::new();
+        for (route, expected) in self.0 {
+            let got = router.insert(route, route.to_owned());
+            assert_eq!(got, expected, "{route}");
+        }
+    }
+}
+
+fn conflict(with: &'static str) -> InsertError {
+    InsertError::Conflict { with: with.into() }
+}
+
+#[test]
+fn wildcard_conflict() {
+    InsertTest(vec![
+        ("/cmd/{tool}/{sub}", Ok(())),
+        ("/cmd/vet", Ok(())),
+        ("/foo/bar", Ok(())),
+        ("/foo/{name}", Ok(())),
+        ("/foo/{names}", Err(conflict("/foo/{name}"))),
+        ("/cmd/{*path}", Err(conflict("/cmd/{tool}/{sub}"))),
+        ("/cmd/{xxx}/names", Ok(())),
+        ("/cmd/{tool}/{xxx}/foo", Ok(())),
+        ("/src/{*filepath}", Ok(())),
+        ("/src/{file}", Err(conflict("/src/{*filepath}"))),
+        ("/src/static.json", Ok(())),
+        ("/src/$filepathx", Ok(())),
+        ("/src/", Ok(())),
+        ("/src/foo/bar", Ok(())),
+        ("/src1/", Ok(())),
+        ("/src1/{*filepath}", Ok(())),
+        ("/src2{*filepath}", Ok(())),
+        ("/src2/{*filepath}", Ok(())),
+        ("/src2/", Ok(())),
+        ("/src2", Ok(())),
+        ("/src3", Ok(())),
+        ("/src3/{*filepath}", Ok(())),
+        ("/search/{query}", Ok(())),
+        ("/search/valid", Ok(())),
+        ("/user_{name}", Ok(())),
+        ("/user_x", Ok(())),
+        ("/user_{bar}", Err(conflict("/user_{name}"))),
+        ("/id{id}", Ok(())),
+        ("/id/{id}", Ok(())),
+    ])
+    .run()
+}
+
+#[test]
+fn invalid_catchall() {
+    InsertTest(vec![
+        ("/non-leading-{*catchall}", Ok(())),
+        ("/foo/bar{*catchall}", Ok(())),
+        ("/src/{*filepath}/x", Err(InsertError::InvalidCatchAll)),
+        ("/src2/", Ok(())),
+        ("/src2/{*filepath}/x", Err(InsertError::InvalidCatchAll)),
+    ])
+    .run()
+}
+
+#[test]
+fn catchall_root_conflict() {
+    InsertTest(vec![("/", Ok(())), ("/{*filepath}", Ok(()))]).run()
+}
+
+#[test]
+fn child_conflict() {
+    InsertTest(vec![
+        ("/cmd/vet", Ok(())),
+        ("/cmd/{tool}", Ok(())),
+        ("/cmd/{tool}/{sub}", Ok(())),
+        ("/cmd/{tool}/misc", Ok(())),
+        ("/cmd/{tool}/{bad}", Err(conflict("/cmd/{tool}/{sub}"))),
+        ("/src/AUTHORS", Ok(())),
+        ("/src/{*filepath}", Ok(())),
+        ("/user_x", Ok(())),
+        ("/user_{name}", Ok(())),
+        ("/id/{id}", Ok(())),
+        ("/id{id}", Ok(())),
+        ("/{id}", Ok(())),
+        ("/{*filepath}", Err(conflict("/{id}"))),
+    ])
+    .run()
+}
+
+#[test]
+fn duplicates() {
+    InsertTest(vec![
+        ("/", Ok(())),
+        ("/", Err(conflict("/"))),
+        ("/doc/", Ok(())),
+        ("/doc/", Err(conflict("/doc/"))),
+        ("/src/{*filepath}", Ok(())),
+        ("/src/{*filepath}", Err(conflict("/src/{*filepath}"))),
+        ("/search/{query}", Ok(())),
+        ("/search/{query}", Err(conflict("/search/{query}"))),
+        ("/user_{name}", Ok(())),
+        ("/user_{name}", Err(conflict("/user_{name}"))),
+    ])
+    .run()
+}
+
+#[test]
+fn unnamed_param() {
+    InsertTest(vec![
+        ("/{}", Err(InsertError::InvalidParam)),
+        ("/user{}/", Err(InsertError::InvalidParam)),
+        ("/cmd/{}/", Err(InsertError::InvalidParam)),
+        ("/src/{*}", Err(InsertError::InvalidParam)),
+    ])
+    .run()
+}
+
+#[test]
+fn double_params() {
+    InsertTest(vec![
+        ("/{foo}{bar}", Err(InsertError::InvalidParamSegment)),
+        ("/{foo}{bar}/", Err(InsertError::InvalidParamSegment)),
+        ("/{foo}{{*bar}/", Err(InsertError::InvalidParamSegment)),
+    ])
+    .run()
+}
+
+#[test]
+fn normalized_conflict() {
+    InsertTest(vec![
+        ("/x/{foo}/bar", Ok(())),
+        ("/x/{bar}/bar", Err(conflict("/x/{foo}/bar"))),
+        ("/{y}/bar/baz", Ok(())),
+        ("/{y}/baz/baz", Ok(())),
+        ("/{z}/bar/bat", Ok(())),
+        ("/{z}/bar/baz", Err(conflict("/{y}/bar/baz"))),
+    ])
+    .run()
+}
+
+#[test]
+fn more_conflicts() {
+    InsertTest(vec![
+        ("/con{tact}", Ok(())),
+        ("/who/are/{*you}", Ok(())),
+        ("/who/foo/hello", Ok(())),
+        ("/whose/{users}/{name}", Ok(())),
+        ("/who/are/foo", Ok(())),
+        ("/who/are/foo/bar", Ok(())),
+        ("/con{nection}", Err(conflict("/con{tact}"))),
+        (
+            "/whose/{users}/{user}",
+            Err(conflict("/whose/{users}/{name}")),
+        ),
+    ])
+    .run()
+}
+
+#[test]
+fn catchall_static_overlap() {
+    InsertTest(vec![
+        ("/bar", Ok(())),
+        ("/bar/", Ok(())),
+        ("/bar/{*foo}", Ok(())),
+    ])
+    .run();
+
+    InsertTest(vec![
+        ("/foo", Ok(())),
+        ("/{*bar}", Ok(())),
+        ("/bar", Ok(())),
+        ("/baz", Ok(())),
+        ("/baz/{split}", Ok(())),
+        ("/", Ok(())),
+        ("/{*bar}", Err(conflict("/{*bar}"))),
+        ("/{*zzz}", Err(conflict("/{*bar}"))),
+        ("/{xxx}", Err(conflict("/{*bar}"))),
+    ])
+    .run();
+
+    InsertTest(vec![
+        ("/{*bar}", Ok(())),
+        ("/bar", Ok(())),
+        ("/bar/x", Ok(())),
+        ("/bar_{x}", Ok(())),
+        ("/bar_{x}", Err(conflict("/bar_{x}"))),
+        ("/bar_{x}/y", Ok(())),
+        ("/bar/{x}", Ok(())),
+    ])
+    .run();
+}
+
+#[test]
+fn duplicate_conflict() {
+    InsertTest(vec![
+        ("/hey", Ok(())),
+        ("/hey/users", Ok(())),
+        ("/hey/user", Ok(())),
+        ("/hey/user", Err(conflict("/hey/user"))),
+    ])
+    .run()
+}
+
+#[test]
+fn invalid_param() {
+    InsertTest(vec![
+        ("{", Err(InsertError::InvalidParam)),
+        ("}", Err(InsertError::InvalidParam)),
+        ("x{y", Err(InsertError::InvalidParam)),
+        ("x}", Err(InsertError::InvalidParam)),
+        ("/{foo}s", Err(InsertError::InvalidParamSegment)),
+    ])
+    .run();
+}
+
+#[test]
+fn escaped_param() {
+    InsertTest(vec![
+        ("{{", Ok(())),
+        ("}}", Ok(())),
+        ("xx}}", Ok(())),
+        ("}}yy", Ok(())),
+        ("}}yy{{}}", Ok(())),
+        ("}}yy{{}}{{}}y{{", Ok(())),
+        ("}}yy{{}}{{}}y{{", Err(conflict("}yy{}{}y{"))),
+        ("/{{yy", Ok(())),
+        ("/{yy}", Ok(())),
+        ("/foo", Ok(())),
+        ("/foo/{{", Ok(())),
+        ("/foo/{{/{x}", Ok(())),
+        ("/foo/{ba{{r}", Ok(())),
+        ("/bar/{ba}}r}", Ok(())),
+        ("/xxx/{x{{}}y}", Ok(())),
+    ])
+    .run()
+}
+
+#[test]
+fn bare_catchall() {
+    InsertTest(vec![("{*foo}", Ok(())), ("foo/{*bar}", Ok(()))]).run()
+}