This library provides a procedural macro that uses a small domain specific
language to create a naive parser that can translate the path of a URI into a
variant of a flattened enum for routing purposes.
The generated logic is basically a big nested match that greedily accepts an
input &str, splits it into segments separated by / characters, and outputs
a variant of the enum, optionally capturing segments of the path if they are
specified as variables.
You write this:
```rust use uripathrouter::route;
route! { Router, "foo" => VariantA, "bar" => VariantBar { "x" => BarX, var => BarWithVariable(var) }, "nested" / "syntax" / "demonstration" => Nested, } ```
The macro will produce a flattened enum like this:
rust
pub enum Router<'a> {
VariantA,
VariantBar,
BarX,
BarWithVariable { var: &'a str },
Nested,
}
Note that the enum only captures the variable when a variant specifies it,
and always does so as a borrow and as such without any allocations.
To convert a &str into a variant, use TryFrom:
rust
assert_eq!(Router::try_from("/foo"), Ok(Router::VariantA));
assert_eq!(Router::try_from("/bar"), Ok(Router::VariantBar));
assert_eq!(Router::try_from("/bar/x"), Ok(Router::BarX));
assert_eq!(
Router::try_from("/bar/not-x"),
Ok(Router::BarWithVariable { var: "not-x" })
);
assert_eq!(Router::try_from("/whatever"), Err(()));
assert_eq!(
Router::try_from("/nested/syntax/demonstration"),
Ok(Router::Nested)
);
A nifty feature of this crate is that documentation is auto-generated for
every variant of the enum describing what pattern matches it.
You can check this out by hovering over the variant in your IDE (assuming you
have rust-analyzer or something similar configured to display tooltips), or
by running cargo doc on your crate and searching for the generated enum.
This library is provided under the MIT license. See LICENSE.