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::error::{Error, ErrorKind};
use crate::{advisory, package::Package};
use serde::{Deserialize, Serialize};
use std::{fmt, str::FromStr};
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Warning {
pub kind: Kind,
pub package: Package,
pub advisory: Option<advisory::Metadata>,
pub versions: Option<advisory::Versions>,
}
impl Warning {
pub fn new(
kind: Kind,
package: &Package,
advisory: Option<advisory::Metadata>,
versions: Option<advisory::Versions>,
) -> Self {
Self {
kind,
package: package.clone(),
advisory,
versions,
}
}
pub fn is_notice(&self) -> bool {
match self.kind {
Kind::Notice => true,
_ => false,
}
}
pub fn is_unmaintained(&self) -> bool {
match self.kind {
Kind::Unmaintained => true,
_ => false,
}
}
pub fn is_unsound(&self) -> bool {
match self.kind {
Kind::Unmaintained => true,
_ => false,
}
}
pub fn is_yanked(&self) -> bool {
match self.kind {
Kind::Unmaintained => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Serialize, Ord)]
#[non_exhaustive]
pub enum Kind {
#[serde(rename = "notice")]
Notice,
#[serde(rename = "unmaintained")]
Unmaintained,
#[serde(rename = "unsound")]
Unsound,
#[serde(rename = "yanked")]
Yanked,
}
impl Kind {
pub fn as_str(&self) -> &str {
match self {
Self::Notice => "notice",
Self::Unmaintained => "unmaintained",
Self::Unsound => "unsound",
Self::Yanked => "yanked",
}
}
}
impl FromStr for Kind {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Error> {
Ok(match s {
"notice" => Kind::Notice,
"unmaintained" => Kind::Unmaintained,
"unsound" => Kind::Unsound,
"yanked" => Kind::Yanked,
other => fail!(ErrorKind::Parse, "invalid warning type: {}", other),
})
}
}
impl fmt::Display for Kind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.as_str())
}
}