joist 1.0.0

A backend framework for Rust: routing, middleware, JSON, config and plugins, with no third-party dependencies.
Documentation
/// HTTP header fields.
///
/// Lookup is case-insensitive, because the wire format is, but insertion order
/// is preserved so a response goes out looking the way it was written. Repeated
/// fields are kept rather than collapsed, since `Set-Cookie` genuinely repeats.
#[derive(Debug, Clone, Default)]
pub struct Headers {
    entries: Vec<(String, String)>,
}

impl Headers {
    pub fn new() -> Headers {
        Headers {
            entries: Vec::new(),
        }
    }

    pub fn len(&self) -> usize {
        self.entries.len()
    }

    pub fn is_empty(&self) -> bool {
        self.entries.is_empty()
    }

    /// The first value for `name`, if any.
    pub fn get(&self, name: &str) -> Option<&str> {
        self.entries
            .iter()
            .find(|(k, _)| k.eq_ignore_ascii_case(name))
            .map(|(_, v)| v.as_str())
    }

    /// Every value for `name`, in order.
    pub fn get_all(&self, name: &str) -> Vec<&str> {
        self.entries
            .iter()
            .filter(|(k, _)| k.eq_ignore_ascii_case(name))
            .map(|(_, v)| v.as_str())
            .collect()
    }

    pub fn contains(&self, name: &str) -> bool {
        self.get(name).is_some()
    }

    /// Replace every existing value for `name` with this one.
    pub fn set(&mut self, name: &str, value: &str) {
        self.remove(name);
        self.entries.push((name.to_string(), value.to_string()));
    }

    /// Add a value without disturbing existing ones.
    pub fn append(&mut self, name: &str, value: &str) {
        self.entries.push((name.to_string(), value.to_string()));
    }

    pub fn remove(&mut self, name: &str) {
        self.entries.retain(|(k, _)| !k.eq_ignore_ascii_case(name));
    }

    pub fn iter(&self) -> impl Iterator<Item = (&str, &str)> {
        self.entries.iter().map(|(k, v)| (k.as_str(), v.as_str()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn lookup_ignores_case() {
        let mut h = Headers::new();
        h.set("Content-Type", "text/plain");
        assert_eq!(h.get("content-type"), Some("text/plain"));
        assert_eq!(h.get("CONTENT-TYPE"), Some("text/plain"));
    }

    #[test]
    fn set_replaces_append_does_not() {
        let mut h = Headers::new();
        h.append("Set-Cookie", "a=1");
        h.append("set-cookie", "b=2");
        assert_eq!(h.get_all("Set-Cookie"), vec!["a=1", "b=2"]);

        h.set("Set-Cookie", "c=3");
        assert_eq!(h.get_all("Set-Cookie"), vec!["c=3"]);
    }

    #[test]
    fn preserves_insertion_order() {
        let mut h = Headers::new();
        h.set("B", "2");
        h.set("A", "1");
        let names: Vec<&str> = h.iter().map(|(k, _)| k).collect();
        assert_eq!(names, vec!["B", "A"]);
    }

    #[test]
    fn remove_is_case_insensitive() {
        let mut h = Headers::new();
        h.set("X-Trace", "1");
        h.remove("x-trace");
        assert!(!h.contains("X-Trace"));
    }
}