matchit 与路径语法

    fn set_node(&mut self, path: &str, id: RouteId) -> Result<(), String> {
        let node = Arc::make_mut(&mut self.node);

        node.insert(path, id)
            .map_err(|err| format!("Invalid route {path:?}: {err}"))
    }

fn validate_v07_paths(path: &str) -> Result<(), &'static str> {
    path.split('/')
        .find_map(|segment| {
            if segment.starts_with(':') {
                Some(Err(
                    "Path segments must not start with `:`. For capture groups, use \
                `{capture}`. If you meant to literally match a segment starting with \
                a colon, call `without_v07_checks` on the router.",
                ))
            } else if segment.starts_with('*') {
                // ...

axum = "=0.8.9"
tower = { version = "=0.5.3", features = ["util"] }

use std::panic::{self, AssertUnwindSafe};

use axum::{Router, routing::get};

fn try_build(label: &str, f: impl FnOnce() -> Router) {
  match panic::catch_unwind(AssertUnwindSafe(f)) {
    Ok(_) => println!("{label}\n  ok"),
    Err(e) => {
      let msg = e
        .downcast_ref::<String>()
        .cloned()
        .or_else(|| e.downcast_ref::<&str>().map(|s| s.to_string()))
        .unwrap_or_default();
      println!("{label}\n  panic: {msg}");
    }
  }
}

fn main() {
  panic::set_hook(Box::new(|_| {}));
  let h = || get(|| async {});

  try_build("route(\"/users/:id\")", || Router::new().route("/users/:id", h()));
  try_build("route(\"/files/*path\")", || Router::new().route("/files/*path", h()));
  try_build("route(\"users\")", || Router::new().route("users", h()));
  try_build("route(\"\")", || Router::new().route("", h()));
  try_build("route(\"/users/{id}\") + route(\"/users/{name}\")", || {
    Router::new().route("/users/{id}", h()).route("/users/{name}", h())
  });
  try_build("route(\"/{a}/foo\") + route(\"/{b}/bar\")", || {
    Router::new().route("/{a}/foo", h()).route("/{b}/bar", h())
  });
  try_build("route(\"/assets/{file}\") + route(\"/assets/{*path}\")", || {
    Router::new().route("/assets/{file}", h()).route("/assets/{*path}", h())
  });
  try_build("route(\"/{*a}\") + route(\"/{*b}\")", || {
    Router::new().route("/{*a}", h()).route("/{*b}", h())
  });
  try_build("route_service(\"/a\") twice", || {
    Router::new()
      .route_service("/a", tower::service_fn(|_| async { Ok::<_, std::convert::Infallible>("") }))
      .route_service("/a", tower::service_fn(|_| async { Ok::<_, std::convert::Infallible>("") }))
  });
  try_build("route(\"/files/{*path}/edit\")", || Router::new().route("/files/{*path}/edit", h()));
  try_build("route(\"/users/{}\")", || Router::new().route("/users/{}", h()));
  try_build("route(\"/{id}.json\")", || Router::new().route("/{id}.json", h()));
  try_build("route(\"/v{version}/x\")", || Router::new().route("/v{version}/x", h()));
  try_build("route(\"/{a}{b}\")", || Router::new().route("/{a}{b}", h()));
  try_build("route(\"/{{literal}}\")", || Router::new().route("/{{literal}}", h()));
  try_build("without_v07_checks().route(\"/:id\")", || {
    Router::new().without_v07_checks().route("/:id", h())
  });
}

route("/users/:id")
  panic: Path segments must not start with `:`. For capture groups, use `{capture}`. If you meant to literally match a segment starting with a colon, call `without_v07_checks` on the router.
route("/files/*path")
  panic: Path segments must not start with `*`. For wildcard capture, use `{*wildcard}`. If you meant to literally match a segment starting with an asterisk, call `without_v07_checks` on the router.
route("users")
  panic: Paths must start with a `/`
route("")
  panic: Paths must start with a `/`. Use "/" for root routes
route("/users/{id}") + route("/users/{name}")
  panic: Invalid route "/users/{name}": Insertion failed due to conflict with previously registered route: /users/{id}
route("/{a}/foo") + route("/{b}/bar")
  ok
route("/assets/{file}") + route("/assets/{*path}")
  panic: Invalid route "/assets/{*path}": Insertion failed due to conflict with previously registered route: /assets/{file}
route("/{*a}") + route("/{*b}")
  panic: Invalid route "/{*b}": Insertion failed due to conflict with previously registered route: /{*a}
route_service("/a") twice
  panic: Invalid route "/a": Insertion failed due to conflict with previously registered route: /a
route("/files/{*path}/edit")
  panic: Invalid route "/files/{*path}/edit": Catch-all parameters are only allowed at the end of a route
route("/users/{}")
  panic: Invalid route "/users/{}": Parameters must be registered with a valid name
route("/{id}.json")
  panic: Invalid route "/{id}.json": Only one parameter is allowed per path segment
route("/v{version}/x")
  ok
route("/{a}{b}")
  panic: Invalid route "/{a}{b}": Only one parameter is allowed per path segment
route("/{{literal}}")
  ok
without_v07_checks().route("/:id")
  ok

axum = "=0.8.9"
tokio = { version = "=1.54.1", features = ["full"] }
tower = { version = "=0.5.3", features = ["util"] }
http-body-util = "0.1"

use axum::{
  Router,
  body::Body,
  extract::{MatchedPath, RawPathParams},
  http::Request,
  routing::get,
};
use http_body_util::BodyExt;
use tower::ServiceExt;

async fn show(m: MatchedPath, params: RawPathParams) -> String {
  let params: Vec<String> = params.iter().map(|(k, v)| format!("{k}={v:?}")).collect();
  format!("{} {}", m.as_str(), params.join(" "))
}

#[tokio::main]
async fn main() {
  let mut app = Router::new();
  for path in [
    "/",
    "/users",
    "/users/new",
    "/users/new/edit",
    "/users/{id}",
    "/users/{id}/posts",
    "/assets/logo.png",
    "/assets/{*path}",
    "/v{version}/status",
    "/foo",
    "/foo/",
    "/bar",
    "/{{literal}}",
  ] {
    app = app.route(path, get(show));
  }

  for uri in [
    "/",
    "/users",
    "/users/",
    "/users/new",
    "/users/42",
    "/users/new/edit",
    "/users/new/posts",
    "/users/42/edit",
    "/users/42/",
    "/users//posts",
    "/assets/logo.png",
    "/assets/img/a.png",
    "/assets/",
    "/assets",
    "/v2/status",
    "/foo",
    "/foo/",
    "/bar",
    "/bar/",
    "/{literal}",
  ] {
    let req = Request::get(uri).body(Body::empty()).unwrap();
    let res = app.clone().oneshot(req).await.unwrap();
    let status = res.status().as_u16();
    let body = res.into_body().collect().await.unwrap().to_bytes();
    println!("{uri:<18} {status} {}", String::from_utf8_lossy(&body));
  }
}

/                  200 / 
/users             200 /users 
/users/            404 
/users/new         200 /users/new 
/users/42          200 /users/{id} id="42"
/users/new/edit    200 /users/new/edit 
/users/new/posts   200 /users/{id}/posts id="new"
/users/42/edit     404 
/users/42/         404 
/users//posts      200 /users/{id}/posts id=""
/assets/logo.png   200 /assets/logo.png 
/assets/img/a.png  200 /assets/{*path} path="img/a.png"
/assets/           404 
/assets            404 
/v2/status         200 /v{version}/status version="2"
/foo               200 /foo 
/foo/              200 /foo/ 
/bar               200 /bar 
/bar/              404 
/{literal}         200 /{{literal}}