happy 0.1.1

A simple web framework with a focus on serving static files and hosting APIs
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

use regex::{Regex, RegexSet, Captures};
use hyper::Method;

#[derive(Clone)]
pub struct RouteBuilder<T> {
    set: RegexSet,
    regex_and_verbs: Vec<(Option<Method>, Regex)>,
    values: Vec<T>,
}

impl <T> RouteBuilder<T> {
    pub fn new<I: Iterator<Item=(Option<Method>, String, T)>>(routes: I) -> RouteBuilder<T> {
        let mut all_regex_strings = vec![];
        let mut regex_and_verbs = vec![];
        let mut values = vec![];

        for (method, regex, value) in routes {
            all_regex_strings.push(regex.clone());
            regex_and_verbs.push((method, Regex::new(&regex).unwrap()));
            values.push(value);
        }

        let regex_set = RegexSet::new(all_regex_strings).unwrap();

        RouteBuilder {
            set: regex_set,
            regex_and_verbs: regex_and_verbs,
            values: values,
        }
    }

    pub fn match_path<'a, 'b>(&'a self, in_verb: Method, target: &'b str) -> Option<(&'a T, Captures<'b>)> {
        let mut best_capture = None;
        let mut best_index = None;
        for index in self.set.matches(target) {
            let &(ref verb, ref regex) = &self.regex_and_verbs[index];
            if !(verb.is_none() || verb.as_ref() == Some(&in_verb)) {
                continue;
            }

            let capture = regex.captures(target);

            let (nc, ni) = match (best_capture, capture) {
                (None, new) => (new, Some(index)),
                (old, None) => (old, best_index),
                (Some(old), Some(new)) => {
                    if new.len() > old.len() {
                        (Some(new), Some(index))
                    } else {
                        (Some(old), best_index)
                    }
                }
            };
            best_capture = nc;
            best_index = ni;
        }

        match (best_capture, best_index) {
            (Some(bc), Some(bi)) => Some((&self.values[bi], bc)),
            (None, None) => None,
            _ => unreachable!()
        }
    }
}