highnoon 0.0.9

minimal web server framework inspired by tide, but built on hyper
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::endpoint::Endpoint;
use crate::state::State;
use crate::{Request, Responder};
use hyper::{Method, StatusCode};
use route_recognizer::Params;
use std::collections::HashMap;

type DynEndpoint<S> = dyn Endpoint<S> + Send + Sync + 'static;

type Recogniser<S> = route_recognizer::Router<Box<DynEndpoint<S>>>;

pub(crate) struct Router<S> {
    methods: HashMap<Method, Recogniser<S>>,
    all: Recogniser<S>,
}

pub(crate) struct RouteTarget<'a, S>
where
    S: Send + Sync + 'static,
{
    pub(crate) ep: &'a DynEndpoint<S>,
    pub(crate) params: Params,
}

impl<S: State> Router<S> {
    pub(crate) fn new() -> Self {
        Self {
            methods: HashMap::new(),
            all: Recogniser::new(),
        }
    }

    pub(crate) fn add(
        &mut self,
        method: Method,
        path: &str,
        ep: impl Endpoint<S> + Sync + Send + 'static,
    ) {
        self.methods
            .entry(method)
            .or_insert_with(route_recognizer::Router::new)
            .add(path, Box::new(ep))
    }

    pub(crate) fn add_all(&mut self, path: &str, ep: impl Endpoint<S> + Sync + Send + 'static) {
        self.all.add(path, Box::new(ep))
    }

    pub(crate) fn lookup(&self, method: &Method, path: &str) -> RouteTarget<S> {
        if let Some(match_) = self
            .methods
            .get(method)
            .and_then(|recog| recog.recognize(path).ok())
        {
            RouteTarget {
                ep: &***match_.handler(),
                params: match_.params().clone(), // TODO - avoid this clone?
            }
        } else if let Ok(match_) = self.all.recognize(path) {
            RouteTarget {
                ep: &***match_.handler(),
                params: match_.params().clone(), // TODO - avoid this clone?
            }
        } else if self
            .methods
            .iter()
            .filter(|(k, _)| k != method)
            .any(|(_, recog)| recog.recognize(path).is_ok())
        {
            RouteTarget {
                ep: &method_not_allowed,
                params: Params::new(),
            }
        } else {
            RouteTarget {
                ep: &not_found,
                params: Params::new(),
            }
        }
    }
}

async fn method_not_allowed<S: State>(_: Request<S>) -> impl Responder {
    StatusCode::METHOD_NOT_ALLOWED
}

async fn not_found<S: State>(_: Request<S>) -> impl Responder {
    StatusCode::NOT_FOUND
}