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::{error::Error, fmt};
#[derive(Debug, PartialEq)]
pub struct ParseError<'a> {
pub original: &'a str,
pub span: std::ops::Range<usize>,
pub reason: Reason,
}
#[derive(Debug, PartialEq)]
pub enum Reason {
UnknownLicense,
UnknownException,
InvalidCharacters,
UnclosedParens,
UnopenedParens,
Empty,
Unexpected(&'static [&'static str]),
SeparatedPlus,
UnknownTerm,
GnuNoPlus,
}
impl<'a> fmt::Display for ParseError<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.original)?;
f.write_str("\n")?;
for _ in 0..self.span.start {
f.write_str(" ")?;
}
match &self.reason {
Reason::UnclosedParens => f.write_fmt(format_args!("- {}", Reason::UnclosedParens)),
Reason::UnopenedParens => f.write_fmt(format_args!("^ {}", Reason::UnopenedParens)),
other => {
for _ in self.span.start..self.span.end {
f.write_str("^")?;
}
f.write_fmt(format_args!(" {}", other))
}
}
}
}
impl fmt::Display for Reason {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::UnknownLicense => f.write_str("unknown license id"),
Self::UnknownException => f.write_str("unknown exception id"),
Self::InvalidCharacters => f.write_str("invalid character(s)"),
Self::UnclosedParens => f.write_str("unclosed parens"),
Self::UnopenedParens => f.write_str("unopened parens"),
Self::Empty => f.write_str("empty expression"),
Self::Unexpected(expected) => {
if expected.len() > 1 {
f.write_str("expected one of ")?;
for (i, exp) in expected.iter().enumerate() {
f.write_fmt(format_args!("{}`{}`", if i > 0 { ", " } else { "" }, exp))?;
}
f.write_str(" here")
} else if !expected.is_empty() {
f.write_fmt(format_args!("expected a `{}` here", expected[0]))
} else {
f.write_str("the term was not expected here")
}
}
Self::SeparatedPlus => f.write_str("`+` must not follow whitespace"),
Self::UnknownTerm => f.write_str("unknown term"),
Self::GnuNoPlus => f.write_str("a GNU license was followed by a `+`"),
}
}
}
impl<'a> Error for ParseError<'a> {
fn description(&self) -> &str {
match self.reason {
Reason::UnknownLicense => "unknown license id",
Reason::UnknownException => "unknown exception id",
Reason::InvalidCharacters => "invalid character(s)",
Reason::UnclosedParens => "unclosed parens",
Reason::UnopenedParens => "unopened parens",
Reason::Empty => "empty expression",
Reason::Unexpected(_) => "unexpected term",
Reason::SeparatedPlus => "`+` must not follow whitespace",
Reason::UnknownTerm => "unknown term",
Reason::GnuNoPlus => "a GNU license was followed by a `+`",
}
}
}