use core::fmt;
use std::io;
use std::path::PathBuf;
use crate::plan::WorkspaceError;
#[derive(Debug)]
pub enum DiscoverError {
CargoMetadata {
status: Option<i32>,
message: String,
},
CargoNotRunnable {
source: io::Error,
},
PnpmList {
status: Option<i32>,
message: String,
},
PnpmRoot {
status: Option<i32>,
message: String,
},
PnpmNotRunnable {
source: io::Error,
},
InvalidMetadata {
message: String,
},
PnpmVersion {
message: String,
},
WorkspaceRootOutsideRepository {
workspace_root: PathBuf,
repository_root: PathBuf,
},
Io {
path: PathBuf,
source: io::Error,
},
Json(serde_json::Error),
Toml {
path: PathBuf,
message: String,
},
Version {
package: String,
message: String,
},
Range {
package: String,
dependency: String,
message: String,
},
UnresolvedCatalog {
package: String,
dependency: String,
catalog_name: Option<String>,
path: Option<PathBuf>,
},
UnknownDependencyKind {
package: String,
dependency: String,
kind: String,
},
Workspace(WorkspaceError),
}
impl fmt::Display for DiscoverError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::CargoMetadata { status, message } => match status {
Some(code) => write!(f, "cargo metadata exited {code}: {message}"),
None => write!(f, "cargo metadata failed: {message}"),
},
Self::CargoNotRunnable { source } => write!(f, "could not run cargo: {source}"),
Self::PnpmList { status, message } => match status {
Some(code) => write!(f, "pnpm list exited {code}: {message}"),
None => write!(f, "pnpm list failed: {message}"),
},
Self::PnpmRoot { status, message } => match status {
Some(code) => write!(f, "pnpm root -w exited {code}: {message}"),
None => write!(f, "pnpm root -w failed: {message}"),
},
Self::PnpmNotRunnable { source } => write!(f, "could not run pnpm: {source}"),
Self::InvalidMetadata { message } => write!(f, "discovery metadata: {message}"),
Self::PnpmVersion { message } => write!(f, "`pnpm --version` {message}"),
Self::WorkspaceRootOutsideRepository {
workspace_root,
repository_root,
} => write!(
f,
"workspace root {} is outside repository {}",
workspace_root.display(),
repository_root.display()
),
Self::Io { path, source } => write!(f, "read {}: {source}", path.display()),
Self::Json(err) => write!(f, "discovery JSON: {err}"),
Self::Toml { path, message } => {
write!(f, "parse {}: {message}", path.display())
}
Self::Version { package, message } => {
write!(f, "package {package}: {message}")
}
Self::Range {
package,
dependency,
message,
} => write!(f, "{package} dependency on {dependency}: {message}"),
Self::UnresolvedCatalog {
package,
dependency,
catalog_name,
path,
} => {
let protocol = match catalog_name {
None => String::from("catalog:"),
Some(catalog) => format!("catalog:{catalog}"),
};
match path {
Some(path) => write!(
f,
"{package} dependency on {dependency}: unresolved catalog protocol {protocol} in {}",
path.display()
),
None => write!(
f,
"{package} dependency on {dependency}: unresolved catalog protocol {protocol} (no pnpm-workspace.yaml found)"
),
}
}
Self::UnknownDependencyKind {
package,
dependency,
kind,
} => write!(
f,
"{package} dependency on {dependency}: unknown kind {kind:?}"
),
Self::Workspace(err) => write!(f, "{err}"),
}
}
}
impl std::error::Error for DiscoverError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::CargoNotRunnable { source }
| Self::PnpmNotRunnable { source }
| Self::Io { source, .. } => Some(source),
Self::Json(err) => Some(err),
Self::Workspace(err) => Some(err),
_ => None,
}
}
}
impl From<WorkspaceError> for DiscoverError {
fn from(value: WorkspaceError) -> Self {
Self::Workspace(value)
}
}
impl From<serde_json::Error> for DiscoverError {
fn from(value: serde_json::Error) -> Self {
Self::Json(value)
}
}