girt 0.18.0

An incremental, idiomatic Rust implementation of Git
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

use std::sync::atomic::AtomicBool;

use super::{Error, check, encoding};

#[derive(Clone, Default)]
pub(super) struct Headers(Vec<(Vec<u8>, Vec<u8>)>);
pub(super) struct HeaderBudget {
    pub(super) bytes: usize,
    pub(super) fields: usize,
}
impl Headers {
    pub(super) fn get(&self, name: &[u8]) -> Option<&[u8]> {
        self.0
            .iter()
            .rev()
            .find(|(key, _)| key.eq_ignore_ascii_case(name))
            .map(|(_, value)| value.as_slice())
    }
    pub(super) fn decode(
        &self,
        name: &[u8],
        budget: &mut usize,
        cancel: &AtomicBool,
    ) -> Result<Option<String>, Error> {
        self.get(name)
            .map(|value| {
                let text = encoding::header(value, cancel)?;
                if text.len() > *budget {
                    return Err(Error::Limit("decoded bytes"));
                }
                *budget -= text.len();
                Ok(text)
            })
            .transpose()
    }
    pub(super) fn overridden(mut self, inner: Self) -> Self {
        for name in [b"from".as_slice(), b"subject", b"date"] {
            if let Some(value) = inner.get(name) {
                self.0.retain(|(key, _)| !key.eq_ignore_ascii_case(name));
                self.0.push((name.to_vec(), value.to_vec()));
            }
        }
        self
    }
}
pub(super) fn read<'a>(
    input: &'a [u8],
    budget: &mut HeaderBudget,
    in_body: bool,
    cancel: &AtomicBool,
) -> Result<(Headers, &'a [u8]), Error> {
    read_lines(
        input,
        input.split_inclusive(|&byte| byte == b'\n'),
        budget,
        in_body,
        cancel,
    )
}

pub(super) fn read_lines<'a>(
    input: &'a [u8],
    lines: impl Iterator<Item = &'a [u8]>,
    budget: &mut HeaderBudget,
    in_body: bool,
    cancel: &AtomicBool,
) -> Result<(Headers, &'a [u8]), Error> {
    let mut result = Headers::default();
    let mut offset = 0;
    for line in lines {
        check(cancel)?;
        let value = line.strip_suffix(b"\n").unwrap_or(line);
        if value.is_empty() {
            offset += line.len();
            break;
        }
        let continuation = value.starts_with(b" ") || value.starts_with(b"\t");
        let field = crate::bytes::split_once(value, b':');
        if !continuation && field.is_none() {
            break;
        }
        if in_body
            && !continuation
            && !field.is_some_and(|(key, _)| {
                [b"from".as_slice(), b"subject", b"date"]
                    .iter()
                    .any(|name| key.eq_ignore_ascii_case(name))
            })
        {
            break;
        }
        if line.len() > budget.bytes {
            return Err(Error::Limit("header bytes"));
        }
        budget.bytes -= line.len();
        if value.contains(&0) {
            return Err(Error::Malformed("header NUL"));
        }
        if continuation {
            let (_, previous) = result
                .0
                .last_mut()
                .ok_or(Error::Malformed("header continuation"))?;
            previous.push(b' ');
            previous.extend_from_slice(value.trim_ascii());
        } else if let Some((name, value)) = field {
            if budget.fields == 0 {
                return Err(Error::Limit("headers"));
            }
            budget.fields -= 1;
            let mut value = value.trim_ascii().to_vec();
            if in_body && !name.eq_ignore_ascii_case(b"subject") {
                value.push(b' ');
            }
            result.0.push((name.to_ascii_lowercase(), value));
        }
        offset += line.len();
    }
    Ok((result, &input[offset..]))
}