negotiator 0.1.0

HTTP content negotiation for Accept, Accept-Charset, Accept-Encoding, and Accept-Language headers. A faithful port of the `negotiator` npm package. Zero dependencies, no_std.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! `Accept-Language` negotiation (port of `lib/language.js`).

use crate::common::{is_js_whitespace, js_trim, js_trim_start, negotiate, parse_float, Match};
use alloc::string::{String, ToString};
use alloc::vec::Vec;

struct LangSpec {
    prefix: String,
    full: String,
    q: f64,
    i: i64,
}

/// A language parsed for matching: its primary `prefix` and the `full` tag.
struct ParsedLang {
    prefix: String,
    full: String,
}

/// Matches `^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$`.
fn match_language(s: &str) -> Option<(&str, Option<&str>, Option<&str>)> {
    let s = js_trim_start(s);
    let prefix_end = s
        .find(|c| is_js_whitespace(c) || c == '-' || c == ';')
        .unwrap_or(s.len());
    if prefix_end == 0 {
        return None;
    }
    let prefix = &s[..prefix_end];
    let mut rest = &s[prefix_end..];
    let mut suffix = None;
    if let Some(after_dash) = rest.strip_prefix('-') {
        let suffix_end = after_dash
            .find(|c| is_js_whitespace(c) || c == ';')
            .unwrap_or(after_dash.len());
        if suffix_end == 0 {
            return None; // a `-` not followed by a suffix character fails the whole match
        }
        suffix = Some(&after_dash[..suffix_end]);
        rest = &after_dash[suffix_end..];
    }
    let rest = js_trim_start(rest);
    if rest.is_empty() {
        return Some((prefix, suffix, None));
    }
    rest.strip_prefix(';')
        .map(|params| (prefix, suffix, Some(params)))
}

fn parsed_lang(s: &str) -> Option<ParsedLang> {
    let (prefix, suffix, _) = match_language(s)?;
    let full = match suffix {
        Some(suf) => {
            let mut f = String::with_capacity(prefix.len() + 1 + suf.len());
            f.push_str(prefix);
            f.push('-');
            f.push_str(suf);
            f
        }
        None => prefix.to_string(),
    };
    Some(ParsedLang {
        prefix: prefix.to_string(),
        full,
    })
}

fn parse_accept_language(accept: &str) -> Vec<LangSpec> {
    accept
        .split(',')
        .enumerate()
        .filter_map(|(i, part)| parse_language(js_trim(part), i as i64))
        .collect()
}

fn parse_language(s: &str, i: i64) -> Option<LangSpec> {
    let (prefix, suffix, params) = match_language(s)?;
    let full = match suffix {
        Some(suf) => {
            let mut f = String::with_capacity(prefix.len() + 1 + suf.len());
            f.push_str(prefix);
            f.push('-');
            f.push_str(suf);
            f
        }
        None => prefix.to_string(),
    };
    let mut q = 1.0;
    if let Some(params) = params {
        // Note: language params are NOT trimmed, and the LAST `q` wins (no early break).
        for param in params.split(';') {
            let mut kv = param.split('=');
            if kv.next() == Some("q") {
                q = kv.next().map_or(f64::NAN, parse_float);
            }
        }
    }
    Some(LangSpec {
        prefix: prefix.to_string(),
        full,
        q,
        i,
    })
}

fn specify(language: &str, spec: &LangSpec) -> Option<Match> {
    let p = parsed_lang(language)?;
    let s = if spec.full.eq_ignore_ascii_case(&p.full) {
        4
    } else if spec.prefix.eq_ignore_ascii_case(&p.full) {
        2
    } else if spec.full.eq_ignore_ascii_case(&p.prefix) {
        1
    } else if spec.full != "*" {
        return None;
    } else {
        0
    };
    Some(Match {
        s,
        o: spec.i,
        q: spec.q,
    })
}

pub(crate) fn preferred_languages(accept: Option<&str>, provided: Option<&[&str]>) -> Vec<String> {
    // RFC 7231: a missing header means "*".
    let header = accept.unwrap_or("*");
    let accepts = parse_accept_language(header);
    negotiate(
        &accepts,
        provided,
        |s| s.q,
        |s| s.i,
        |s| s.full.clone(),
        specify,
    )
}