Struct DefaultRouter 

pub struct DefaultRouter { /* private fields */ }

Available on native only.

Default router implementation Similar to Django REST Framework’s DefaultRouter and Django’s URLResolver

Implementations

impl DefaultRouter

pub fn new() -> DefaultRouter

Available on crate feature test only.

Create a new DefaultRouter

Examples

use reinhardt_urls::routers::DefaultRouter;

let router = DefaultRouter::new();
assert_eq!(router.get_routes().len(), 0);

pub fn reverser(&self) -> &UrlReverser

Available on crate feature test only.

Get a reference to the URL reverser This allows for URL name resolution (reverse routing)

Examples

use reinhardt_urls::routers::DefaultRouter;

let router = DefaultRouter::new();
let reverser = router.reverser();
assert_eq!(reverser.route_names().len(), 0);

pub fn reverse( &self, name: &str, params: &HashMap<String, String>, ) -> Result<String, Error>

Available on crate feature test only.

Reverse a URL name to a path Similar to Django’s reverse() function

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;
use std::collections::HashMap;

let handler = Arc::new(DummyHandler);
let mut router = DefaultRouter::new();
let mut route = path("/users/{id}/", handler)
    .with_namespace("users");
route.name = Some("detail".to_string());
router.add_route(route);

let mut params = HashMap::new();
params.insert("id".to_string(), "123".to_string());

let url = router.reverse("users:detail", &params).unwrap();
assert_eq!(url, "/users/123/");

pub fn reverse_with<S>( &self, name: &str, params: &[(S, S)], ) -> Result<String, Error>

where S: AsRef<str>,

Available on crate feature test only.

Reverse a URL name with positional parameters Convenience method for simple parameter passing

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let mut router = DefaultRouter::new();
let mut route = path("/users/{id}/", handler);
route.name = Some("detail".to_string());
router.add_route(route);

let url = router.reverse_with("detail", &[("id", "123")]).unwrap();
assert_eq!(url, "/users/123/");

pub fn register_viewset<V>(&mut self, prefix: &str, viewset: Arc<V>)

where V: ViewSet + 'static,

Available on crate features test and viewsets only.

Register a ViewSet with automatic URL pattern generation Similar to DRF’s router.register()

Examples

use reinhardt_urls::routers::DefaultRouter;
use reinhardt_views::viewsets::ViewSet;
use std::sync::Arc;

let viewset = Arc::new(DummyViewSet);
let mut router = DefaultRouter::new();
router.register_viewset("users", viewset);

assert_eq!(router.get_routes().len(), 2);

pub fn get_action_url_map<V>( &self, viewset: &V, base_url: &str, ) -> HashMap<String, String>

where V: ViewSet,

Available on crate features test and viewsets only.

Get URL map for a ViewSet’s extra actions Returns a map of action names to their full URLs

Examples

use reinhardt_urls::routers::DefaultRouter;
use reinhardt_views::viewsets::{ViewSet, register_action, ActionMetadata, FunctionActionHandler};
use std::sync::Arc;

let viewset = Arc::new(DummyViewSet);
let mut router = DefaultRouter::new();
router.register_viewset("test", viewset.clone());

let url_map = router.get_action_url_map(viewset.as_ref(), "http://testserver");
// The ViewSet has no extra actions, so the map will be empty
assert!(url_map.is_empty());

pub fn get_routes(&self) -> &[Route]

Available on crate feature test only.

Get all registered routes

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let mut router = DefaultRouter::new();
router.add_route(path("/users/", handler));

assert_eq!(router.get_routes().len(), 1);
assert_eq!(router.get_routes()[0].path, "/users/");

pub fn find_routes_by_namespace_pattern(&self, pattern: &str) -> Vec<&Route>

Available on crate feature test only.

Find routes that match a namespace pattern Used for namespace-based versioning

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let mut router = DefaultRouter::new();
router.add_route(path("/v1/users/", handler.clone()).with_namespace("v1"));
router.add_route(path("/v2/users/", handler).with_namespace("v2"));

let v1_routes = router.find_routes_by_namespace_pattern("/v{version}/");
assert_eq!(v1_routes.len(), 2);

pub fn extract_version_from_path<'a>( &self, path: &'a str, pattern: &str, ) -> Option<&'a str>

Available on crate feature test only.

Extract version from a path using namespace pattern Returns the version string if the path matches the pattern

Examples

use reinhardt_urls::routers::DefaultRouter;

let router = DefaultRouter::new();
assert_eq!(router.extract_version_from_path("/v1/users/", "/v{version}/"), Some("1"));
assert_eq!(router.extract_version_from_path("/v2/api/", "/v{version}/"), Some("2"));
assert_eq!(router.extract_version_from_path("/users/", "/v{version}/"), None);

pub fn get_available_versions(&self, pattern: &str) -> Vec<String>

Available on crate feature test only.

Get all unique versions found in registered routes for a given pattern Used for namespace-based versioning to discover available versions

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let mut router = DefaultRouter::new();
router.add_route(path("/v1/users/", handler.clone()).with_namespace("v1"));
router.add_route(path("/v2/users/", handler.clone()).with_namespace("v2"));
router.add_route(path("/v1/posts/", handler).with_namespace("v1"));

let versions = router.get_available_versions("/v{version}/");
assert!(versions.contains(&"1".to_string()));
assert!(versions.contains(&"2".to_string()));
assert_eq!(versions.len(), 2);

Trait Implementations

impl Default for DefaultRouter

fn default() -> DefaultRouter

Returns the “default value” for a type.

impl Handler for DefaultRouter

fn handle<'life0, 'async_trait>( &'life0 self, request: Request, ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, DefaultRouter: 'async_trait,

Handles an HTTP request and produces a response.

impl Router for DefaultRouter

fn mount(&mut self, prefix: &str, routes: Vec<Route>, namespace: Option<String>)

Mount routes at the given prefix

Examples

use reinhardt_urls::routers::{DefaultRouter, Router, path};
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let mut list_route = path("/", handler.clone());
list_route.name = Some("list".to_string());
let mut detail_route = path("/{id}/", handler);
detail_route.name = Some("detail".to_string());
let users_routes = vec![list_route, detail_route];

let mut router = DefaultRouter::new();
router.mount("/users", users_routes, Some("users".to_string()));

// Routes are prefixed: /users/ and /users/{id}/
assert_eq!(router.get_routes().len(), 2);

fn add_route(&mut self, route: Route)

Add a route to this router.

async fn route(&self, request: Request) -> Result<Response, Error>

Handle a request (similar to Handler::handle)

impl VersionedRouter for DefaultRouter

fn route_version_infos(&self) -> Vec<RouteVersionInfo>

Returns one RouteVersionInfo entry per registered route.