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
|
use bstr::{BStr, BString, ByteSlice};
///
pub mod name {
use std::convert::Infallible;
/// The error used in [name()][super::name()] and [`name_partial()`][super::name_partial()]
#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum Error {
#[error("A reference must be a valid tag name as well")]
Tag(#[from] crate::tag::name::Error),
#[error("Standalone references must be all uppercased, like 'HEAD'")]
SomeLowercase,
}
impl From<Infallible> for Error {
fn from(_: Infallible) -> Self {
unreachable!("this impl is needed to allow passing a known valid partial path as parameter")
}
}
}
/// Validate a reference name running all the tests in the book. This disallows lower-case references like `lower`, but also allows
/// ones like `HEAD`, and `refs/lower`.
pub fn name(path: &BStr) -> Result<&BStr, name::Error> {
match validate(path, Mode::Complete)? {
None => Ok(path),
Some(_) => {
unreachable!("Without sanitization, there is no chance a sanitized version is returned.")
}
}
}
/// Validate a partial reference name. As it is assumed to be partial, names like `some-name` is allowed
/// even though these would be disallowed with when using [`name()`].
pub fn name_partial(path: &BStr) -> Result<&BStr, name::Error> {
match validate(path, Mode::Partial)? {
None => Ok(path),
Some(_) => {
unreachable!("Without sanitization, there is no chance a sanitized version is returned.")
}
}
}
/// The infallible version of [`name_partial()`] which instead of failing, alters `path` and returns it to be a valid
/// partial name, which would also pass [`name_partial()`].
///
/// Note that an empty `path` is replaced with a `-` in order to be valid.
pub fn name_partial_or_sanitize(path: &BStr) -> BString {
validate(path, Mode::PartialSanitize)
.expect("BUG: errors cannot happen as any issue is fixed instantly")
.expect("we always rebuild the path")
}
enum Mode {
Complete,
Partial,
/// like Partial, but instead of failing, a sanitized version is returned.
PartialSanitize,
}
fn validate(path: &BStr, mode: Mode) -> Result<Option<BString>, name::Error> {
let out = crate::tag::name_inner(
path,
match mode {
Mode::Complete | Mode::Partial => crate::tag::Mode::Validate,
Mode::PartialSanitize => crate::tag::Mode::Sanitize,
},
)?;
if let Mode::Complete = mode {
let input = out.as_ref().map_or(path, |b| b.as_bstr());
let saw_slash = input.find_byte(b'/').is_some();
if !saw_slash && !input.iter().all(|c| c.is_ascii_uppercase() || *c == b'_') {
return Err(name::Error::SomeLowercase);
}
}
Ok(out)
}
|
