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:

use uri_path_router::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:

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:

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.