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