pub(crate) mod function {
use crate::{IdentityRef, SignatureRef};
use bstr::ByteSlice;
use gix_date::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
use gix_utils::btoi::to_signed;
use winnow::error::{ErrMode, ErrorKind};
use winnow::stream::Stream;
use winnow::{
combinator::{alt, opt, separated_pair, terminated},
error::{AddContext, ParserError, StrContext},
prelude::*,
stream::AsChar,
token::{take, take_until, take_while},
};
const SPACE: &[u8] = b" ";
pub fn decode<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
i: &mut &'a [u8],
) -> PResult<SignatureRef<'a>, E> {
separated_pair(
identity,
opt(b" "),
opt((
terminated(take_until(0.., SPACE), take(1usize))
.verify_map(|v| to_signed::<SecondsSinceUnixEpoch>(v).ok())
.context(StrContext::Expected("<timestamp>".into())),
alt((
take_while(1.., b'-').map(|_| Sign::Minus),
take_while(1.., b'+').map(|_| Sign::Plus),
))
.context(StrContext::Expected("+|-".into())),
take_while(2, AsChar::is_dec_digit)
.verify_map(|v| to_signed::<OffsetInSeconds>(v).ok())
.context(StrContext::Expected("HH".into())),
take_while(1..=2, AsChar::is_dec_digit)
.verify_map(|v| to_signed::<OffsetInSeconds>(v).ok())
.context(StrContext::Expected("MM".into())),
take_while(0.., AsChar::is_dec_digit).map(|v: &[u8]| v),
))
.map(|maybe_timestamp| {
if let Some((time, sign, hours, minutes, trailing_digits)) = maybe_timestamp {
let offset = if trailing_digits.is_empty() {
(hours * 3600 + minutes * 60) * if sign == Sign::Minus { -1 } else { 1 }
} else {
0
};
Time {
seconds: time,
offset,
sign,
}
} else {
Time::new(0, 0)
}
}),
)
.context(StrContext::Expected("<name> <<email>> <timestamp> <+|-><HHMM>".into()))
.map(|(identity, time)| SignatureRef {
name: identity.name,
email: identity.email,
time,
})
.parse_next(i)
}
pub fn identity<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
i: &mut &'a [u8],
) -> PResult<IdentityRef<'a>, E> {
let start = i.checkpoint();
let eol_idx = i.find_byte(b'\n').unwrap_or(i.len());
let right_delim_idx =
i[..eol_idx]
.rfind_byte(b'>')
.ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
i,
&start,
StrContext::Label("Closing '>' not found"),
)))?;
let i_name_and_email = &i[..right_delim_idx];
let skip_from_right = i_name_and_email
.iter()
.rev()
.take_while(|b| b.is_ascii_whitespace() || **b == b'>')
.count();
let left_delim_idx =
i_name_and_email
.find_byte(b'<')
.ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
&i_name_and_email,
&start,
StrContext::Label("Opening '<' not found"),
)))?;
let skip_from_left = i[left_delim_idx..]
.iter()
.take_while(|b| b.is_ascii_whitespace() || **b == b'<')
.count();
let mut name = i[..left_delim_idx].as_bstr();
name = name.strip_suffix(b" ").unwrap_or(name).as_bstr();
let email = i
.get(left_delim_idx + skip_from_left..right_delim_idx - skip_from_right)
.ok_or(ErrMode::Cut(E::from_error_kind(i, ErrorKind::Eof).add_context(
&i_name_and_email,
&start,
StrContext::Label("Skipped parts run into each other"),
)))?
.as_bstr();
*i = i.get(right_delim_idx + 1..).unwrap_or(&[]);
Ok(IdentityRef { name, email })
}
}
pub use function::identity;
#[cfg(test)]
mod tests {
mod parse_signature {
use bstr::ByteSlice;
use gix_date::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch};
use gix_testtools::to_bstr_err;
use winnow::prelude::*;
use crate::{signature, SignatureRef, Time};
fn decode<'i>(
i: &mut &'i [u8],
) -> PResult<SignatureRef<'i>, winnow::error::TreeError<&'i [u8], winnow::error::StrContext>> {
signature::decode.parse_next(i)
}
fn signature(
name: &'static str,
email: &'static str,
seconds: SecondsSinceUnixEpoch,
sign: Sign,
offset: OffsetInSeconds,
) -> SignatureRef<'static> {
SignatureRef {
name: name.as_bytes().as_bstr(),
email: email.as_bytes().as_bstr(),
time: Time { seconds, offset, sign },
}
}
#[test]
fn tz_minus() {
assert_eq!(
decode
.parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 -0230")
.expect("parse to work")
.1,
signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Minus, -9000)
);
}
#[test]
fn tz_plus() {
assert_eq!(
decode
.parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 +0230")
.expect("parse to work")
.1,
signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Plus, 9000)
);
}
#[test]
fn negative_offset_0000() {
assert_eq!(
decode
.parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 -0000")
.expect("parse to work")
.1,
signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Minus, 0)
);
}
#[test]
fn negative_offset_double_dash() {
assert_eq!(
decode
.parse_peek(b"name <name@example.com> 1288373970 --700")
.expect("parse to work")
.1,
signature("name", "name@example.com", 1288373970, Sign::Minus, -252000)
);
}
#[test]
fn empty_name_and_email() {
assert_eq!(
decode.parse_peek(b" <> 12345 -1215").expect("parse to work").1,
signature("", "", 12345, Sign::Minus, -44100)
);
}
#[test]
fn invalid_signature() {
assert_eq!(
decode.parse_peek(b"hello < 12345 -1215")
.map_err(to_bstr_err)
.expect_err("parse fails as > is missing")
.to_string(),
"in end of file at 'hello < 12345 -1215'\n 0: invalid Closing '>' not found at 'hello < 12345 -1215'\n 1: expected `<name> <<email>> <timestamp> <+|-><HHMM>` at 'hello < 12345 -1215'\n"
);
}
#[test]
fn invalid_time() {
assert_eq!(
decode.parse_peek(b"hello <> abc -1215").expect("parse to work").1,
signature("hello", "", 0, Sign::Plus, 0)
);
}
}
}