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
|
use crate::parse::Error;
use core::fmt::{self, Debug, Display};
pub(crate) enum ErrorKind {
UnexpectedEnd(Position),
UnexpectedChar(Position, char),
UnexpectedCharAfter(Position, char),
ExpectedCommaFound(Position, char),
LeadingZero(Position),
Overflow(Position),
EmptySegment(Position),
IllegalCharacter(Position),
WildcardNotTheOnlyComparator(char),
UnexpectedAfterWildcard,
ExcessiveComparators,
}
#[derive(Copy, Clone, Eq, PartialEq)]
pub(crate) enum Position {
Major,
Minor,
Patch,
Pre,
Build,
}
#[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
impl std::error::Error for Error {}
impl Display for Error {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
match &self.kind {
ErrorKind::UnexpectedEnd(pos) => {
write!(formatter, "unexpected end of input while parsing {}", pos)
}
ErrorKind::UnexpectedChar(pos, ch) => {
write!(
formatter,
"unexpected character {} while parsing {}",
QuotedChar(*ch),
pos,
)
}
ErrorKind::UnexpectedCharAfter(pos, ch) => {
write!(
formatter,
"unexpected character {} after {}",
QuotedChar(*ch),
pos,
)
}
ErrorKind::ExpectedCommaFound(pos, ch) => {
write!(
formatter,
"expected comma after {}, found {}",
pos,
QuotedChar(*ch),
)
}
ErrorKind::LeadingZero(pos) => {
write!(formatter, "invalid leading zero in {}", pos)
}
ErrorKind::Overflow(pos) => {
write!(formatter, "value of {} exceeds u64::MAX", pos)
}
ErrorKind::EmptySegment(pos) => {
write!(formatter, "empty identifier segment in {}", pos)
}
ErrorKind::IllegalCharacter(pos) => {
write!(formatter, "unexpected character in {}", pos)
}
ErrorKind::WildcardNotTheOnlyComparator(ch) => {
write!(
formatter,
"wildcard req ({}) must be the only comparator in the version req",
ch,
)
}
ErrorKind::UnexpectedAfterWildcard => {
formatter.write_str("unexpected character after wildcard in version req")
}
ErrorKind::ExcessiveComparators => {
formatter.write_str("excessive number of version comparators")
}
}
}
}
impl Display for Position {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str(match self {
Position::Major => "major version number",
Position::Minor => "minor version number",
Position::Patch => "patch version number",
Position::Pre => "pre-release identifier",
Position::Build => "build metadata",
})
}
}
impl Debug for Error {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Error(\"")?;
Display::fmt(self, formatter)?;
formatter.write_str("\")")?;
Ok(())
}
}
struct QuotedChar(char);
impl Display for QuotedChar {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
// Standard library versions prior to https://github.com/rust-lang/rust/pull/95345
// print character 0 as '\u{0}'. We prefer '\0' to keep error messages
// the same across all supported Rust versions.
if self.0 == '\0' {
formatter.write_str("'\\0'")
} else {
write!(formatter, "{:?}", self.0)
}
}
}
|
