Struct trillium_router::RouterRef

pub struct RouterRef<'r>(_);

A &mut Router for use with Router::build

A wrapper around a &mut Router that supports imperative route registration. See Router::build for further documentation.

Implementations

impl<'r> RouterRef<'r>

pub fn get(&mut self, path: &'static str, handler: impl Handler)

Registers a handler for the get http method.

let router = Router::build(|mut router| {
    router.get("/some/route", |conn: Conn| async move {
        conn.ok("success")
    });
});

use trillium_testing::{methods::get, assert_ok, assert_not_handled};
assert_ok!(get("/some/route").on(&router), "success");
assert_not_handled!(get("/other/route").on(&router));

pub fn post(&mut self, path: &'static str, handler: impl Handler)

Registers a handler for the post http method.

let router = Router::build(|mut router| {
    router.post("/some/route", |conn: Conn| async move {
        conn.ok("success")
    });
});

use trillium_testing::{methods::post, assert_ok, assert_not_handled};
assert_ok!(post("/some/route").on(&router), "success");
assert_not_handled!(post("/other/route").on(&router));

pub fn put(&mut self, path: &'static str, handler: impl Handler)

Registers a handler for the put http method.

let router = Router::build(|mut router| {
    router.put("/some/route", |conn: Conn| async move {
        conn.ok("success")
    });
});

use trillium_testing::{methods::put, assert_ok, assert_not_handled};
assert_ok!(put("/some/route").on(&router), "success");
assert_not_handled!(put("/other/route").on(&router));

pub fn delete(&mut self, path: &'static str, handler: impl Handler)

Registers a handler for the delete http method.

let router = Router::build(|mut router| {
    router.delete("/some/route", |conn: Conn| async move {
        conn.ok("success")
    });
});

use trillium_testing::{methods::delete, assert_ok, assert_not_handled};
assert_ok!(delete("/some/route").on(&router), "success");
assert_not_handled!(delete("/other/route").on(&router));

pub fn patch(&mut self, path: &'static str, handler: impl Handler)

Registers a handler for the patch http method.

let router = Router::build(|mut router| {
    router.patch("/some/route", |conn: Conn| async move {
        conn.ok("success")
    });
});

use trillium_testing::{methods::patch, assert_ok, assert_not_handled};
assert_ok!(patch("/some/route").on(&router), "success");
assert_not_handled!(patch("/other/route").on(&router));

pub fn any(&mut self, path: &'static str, handler: impl Handler)

Appends the handler to all (get, post, put, delete, and patch) methods.

let router = Router::build(|mut router| {
    router.any("/any", |conn: Conn| async move {
        let response = format!("you made a {} request to /any", conn.method());
        conn.ok(response)
    });
});

use trillium_testing::prelude::*;
assert_ok!(get("/any").on(&router), "you made a GET request to /any");
assert_ok!(post("/any").on(&router), "you made a POST request to /any");
assert_ok!(delete("/any").on(&router), "you made a DELETE request to /any");
assert_ok!(patch("/any").on(&router), "you made a PATCH request to /any");
assert_ok!(put("/any").on(&router), "you made a PUT request to /any");

assert_not_handled!(get("/").on(&router));

Trait Implementations

impl<'r> Debug for RouterRef<'r>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.