use serde::{Deserialize, Serialize};
use std::path::PathBuf;
crate::string_newtypes! { Coordinate, Constraint, Version, RegistryId }
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Span {
pub start: usize,
pub end: usize,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Dependency {
pub coordinate: Coordinate,
pub constraint: Constraint,
pub section: String, pub source: Option<RegistryId>, pub span: Option<Span>, }
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VersionMeta {
pub version: Version,
pub yanked: bool,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Availability {
pub versions: Vec<VersionMeta>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Edit<'a> {
pub dep: &'a Dependency,
pub replacement: Constraint,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum Verdict {
Current {
latest: Version,
latest_pre: Option<Version>,
},
Outdated {
compatible: Option<Version>,
latest: Version,
latest_pre: Option<Version>,
},
Yanked,
Unsatisfiable {
constraint: Constraint,
#[serde(default)]
prerelease_available: bool,
},
Errored(String),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ManifestReport {
pub path: PathBuf,
pub ecosystem: String, pub verdicts: Vec<(Dependency, Verdict)>, }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Report {
pub manifests: Vec<ManifestReport>,
}
impl Default for Report {
fn default() -> Self {
Self::new()
}
}
impl Report {
pub fn new() -> Self {
Self {
manifests: Vec::new(),
}
}
pub fn push(&mut self, manifest_report: ManifestReport) {
self.manifests.push(manifest_report);
}
}
#[derive(Debug)]
pub enum UdError {
UnknownRegistry { id: RegistryId, ecosystem: String },
UnsupportedManifest(PathBuf),
NoManifestFound(PathBuf),
Io(std::io::Error),
Http(String),
Parse(String),
Message(String),
}
impl std::fmt::Display for UdError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::UnknownRegistry { id, ecosystem } => {
write!(f, "Unknown registry '{}' in ecosystem '{}'", id, ecosystem)
}
Self::UnsupportedManifest(path) => {
write!(f, "Unsupported manifest format: {}", path.display())
}
Self::NoManifestFound(path) => {
write!(
f,
"No supported manifest found in directory: {}",
path.display()
)
}
Self::Io(err) => write!(f, "IO error: {}", err),
Self::Http(msg) => write!(f, "HTTP/network error: {}", msg),
Self::Parse(msg) => write!(f, "Parse error: {}", msg),
Self::Message(msg) => write!(f, "{}", msg),
}
}
}
impl std::error::Error for UdError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(err) => Some(err),
_ => None,
}
}
}
impl From<std::io::Error> for UdError {
fn from(err: std::io::Error) -> Self {
Self::Io(err)
}
}