| use crate::{ |
| cfg::{PackageSpecOrExtended, Reason, ValidationContext}, |
| diag::{Diagnostic, FileId, Label}, |
| utf8path, LintLevel, PathBuf, Span, Spanned, |
| }; |
| use anyhow::Context as _; |
| use rustsec::advisory; |
| use time::Duration; |
| use toml_span::{de_helpers::*, value::ValueInner, Deserialize, Value}; |
| use url::Url; |
| |
| pub(crate) type AdvisoryId = Spanned<advisory::Id>; |
| |
| #[cfg_attr(test, derive(serde::Serialize))] |
| pub(crate) struct IgnoreId { |
| pub id: AdvisoryId, |
| pub reason: Option<Reason>, |
| } |
| |
| impl<'de> Deserialize<'de> for IgnoreId { |
| fn deserialize(value: &mut Value<'de>) -> Result<Self, toml_span::DeserError> { |
| let mut th = TableHelper::new(value)?; |
| let ids = th.required_s::<std::borrow::Cow<'de, str>>("id")?; |
| let id = match ids.value.parse() { |
| Ok(id) => Spanned::with_span(id, ids.span), |
| Err(err) => { |
| return Err(toml_span::Error { |
| kind: toml_span::ErrorKind::Custom( |
| format!("failed to parse advisory id: {err}").into(), |
| ), |
| span: ids.span, |
| line_info: None, |
| } |
| .into()); |
| } |
| }; |
| let reason = th.optional_s::<String>("reason"); |
| |
| th.finalize(None)?; |
| |
| Ok(Self { |
| id, |
| reason: reason.map(Reason::from), |
| }) |
| } |
| } |
| |
| impl Ord for IgnoreId { |
| fn cmp(&self, other: &Self) -> std::cmp::Ordering { |
| self.id.cmp(&other.id) |
| } |
| } |
| |
| impl PartialOrd for IgnoreId { |
| fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { |
| Some(self.cmp(other)) |
| } |
| } |
| |
| impl PartialEq for IgnoreId { |
| fn eq(&self, other: &Self) -> bool { |
| self.id.eq(&other.id) |
| } |
| } |
| |
| impl Eq for IgnoreId {} |
| |
| #[cfg_attr(test, derive(serde::Serialize))] |
| pub(crate) struct Deprecated { |
| /// How to handle crates that have a security vulnerability |
| pub vulnerability: LintLevel, |
| /// How to handle crates that have been marked as unmaintained in an advisory database |
| pub unmaintained: LintLevel, |
| /// How to handle crates that have been marked as unsound in an advisory database |
| pub unsound: LintLevel, |
| /// How to handle crates that have been marked with a notice in the advisory database |
| pub notice: LintLevel, |
| /// CVSS Qualitative Severity Rating Scale threshold to alert at. |
| /// |
| /// Vulnerabilities with explicit CVSS info which have a severity below |
| /// this threshold will be ignored. |
| pub severity_threshold: Option<advisory::Severity>, |
| } |
| |
| pub struct Config { |
| /// Path to the root directory where advisory databases are stored (default: $CARGO_HOME/advisory-dbs) |
| pub db_path: Option<Spanned<PathBuf>>, |
| /// List of urls to git repositories of different advisory databases. |
| pub db_urls: Vec<Spanned<Url>>, |
| /// How to handle crates that have been yanked from eg crates.io |
| pub yanked: Spanned<LintLevel>, |
| /// Ignore advisories for the given IDs |
| ignore: Vec<Spanned<IgnoreId>>, |
| /// Ignore yanked crates |
| pub ignore_yanked: Vec<Spanned<PackageSpecOrExtended<Reason>>>, |
| /// Use the git executable to fetch advisory database rather than gitoxide |
| pub git_fetch_with_cli: Option<bool>, |
| /// If set to true, the local crates indices are not checked for yanked crates |
| pub disable_yank_checking: bool, |
| /// The maximum duration, in RFC3339 format, that an advisory database is |
| /// allowed to not have been updated. This only applies when fetching advisory |
| /// databases has been disabled. Defaults to 90 days. |
| /// |
| /// Note that if fractional units are used in the format string they must |
| /// use the '.' separator instead of ',' which is used by some locales and |
| /// supported in the RFC3339 format, but not by this implementation |
| pub maximum_db_staleness: Spanned<Duration>, |
| deprecated: Option<Deprecated>, |
| deprecated_spans: Vec<Span>, |
| } |
| |
| impl Default for Config { |
| fn default() -> Self { |
| Self { |
| db_path: None, |
| db_urls: Vec::new(), |
| ignore: Vec::new(), |
| ignore_yanked: Vec::new(), |
| yanked: Spanned::new(LintLevel::Warn), |
| git_fetch_with_cli: None, |
| disable_yank_checking: false, |
| maximum_db_staleness: Spanned::new(Duration::seconds_f64(NINETY_DAYS)), |
| deprecated: None, |
| deprecated_spans: Vec::new(), |
| } |
| } |
| } |
| |
| const NINETY_DAYS: f64 = 90. * 24. * 60. * 60. * 60.; |
| |
| impl<'de> Deserialize<'de> for Config { |
| fn deserialize(value: &mut Value<'de>) -> Result<Self, toml_span::DeserError> { |
| let mut th = TableHelper::new(value)?; |
| |
| let version = th.optional("version").unwrap_or(1); |
| |
| let db_path = th.optional_s::<String>("db-path").map(|s| s.map()); |
| let db_urls = if let Some((_, mut urls)) = th.take("db-urls") { |
| let mut u = Vec::new(); |
| |
| match urls.take() { |
| ValueInner::Array(urla) => { |
| for mut v in urla { |
| match parse(&mut v) { |
| Ok(url) => u.push(Spanned::with_span(url, v.span)), |
| Err(err) => th.errors.push(err), |
| } |
| } |
| } |
| other => { |
| th.errors.push(expected("an array", other, urls.span)); |
| } |
| } |
| |
| u.sort(); |
| u |
| } else { |
| Vec::new() |
| }; |
| |
| use crate::cfg::deprecated; |
| |
| let mut fdeps = Vec::new(); |
| |
| let vulnerability = deprecated(&mut th, "vulnerability", &mut fdeps); |
| let unmaintained = deprecated(&mut th, "unmaintained", &mut fdeps); |
| let unsound = deprecated(&mut th, "unsound", &mut fdeps); |
| let notice = deprecated(&mut th, "notice", &mut fdeps); |
| |
| let yanked = th |
| .optional_s("yanked") |
| .unwrap_or(Spanned::new(LintLevel::Warn)); |
| let (ignore, ignore_yanked) = if let Some((_, mut ignore)) = th.take("ignore") { |
| let mut u = Vec::new(); |
| let mut y = Vec::new(); |
| |
| match ignore.take() { |
| ValueInner::Array(ida) => { |
| for mut v in ida { |
| match v.take() { |
| ValueInner::String(s) => { |
| // Attempt to parse an advisory id first, note we can't |
| // just immediately use parse as the from_str implementation |
| // for id will just blindly accept any string |
| if advisory::IdKind::detect(s.as_ref()) != advisory::IdKind::Other { |
| if let Ok(id) = s.parse::<advisory::Id>() { |
| u.push(Spanned::with_span( |
| IgnoreId { |
| id: Spanned::with_span(id, v.span), |
| reason: None, |
| }, |
| v.span, |
| )); |
| continue; |
| } |
| } |
| |
| v.set(ValueInner::String(s)); |
| } |
| ValueInner::Table(tab) => { |
| if tab.contains_key(&"id".into()) { |
| v.set(ValueInner::Table(tab)); |
| match IgnoreId::deserialize(&mut v) { |
| Ok(iid) => u.push(Spanned::with_span(iid, v.span)), |
| Err(mut err) => { |
| th.errors.append(&mut err.errors); |
| } |
| } |
| continue; |
| } |
| |
| v.set(ValueInner::Table(tab)); |
| } |
| other => { |
| th.errors.push(toml_span::Error { |
| kind: toml_span::ErrorKind::Wanted { |
| expected: "an advisory id or package spec", |
| found: other.type_str(), |
| }, |
| span: v.span, |
| line_info: None, |
| }); |
| continue; |
| } |
| } |
| |
| match PackageSpecOrExtended::deserialize(&mut v) { |
| Ok(pse) => y.push(Spanned::with_span(pse, v.span)), |
| Err(mut err) => { |
| th.errors.append(&mut err.errors); |
| } |
| } |
| } |
| } |
| other => { |
| th.errors.push(expected("an array", other, ignore.span)); |
| } |
| } |
| |
| u.sort(); |
| (u, y) |
| } else { |
| (Vec::new(), Vec::new()) |
| }; |
| let st = |th: &mut TableHelper<'_>, fdeps: &mut Vec<Span>| { |
| let (k, mut v) = th.take("severity-threshold")?; |
| |
| fdeps.push(k.span); |
| let s = match v.take_string(Some( |
| "https://docs.rs/rustsec/latest/rustsec/advisory/enum.Severity.html", |
| )) { |
| Ok(s) => s, |
| Err(err) => { |
| th.errors.push(err); |
| return None; |
| } |
| }; |
| |
| match s.parse() { |
| Ok(st) => Some(st), |
| Err(err) => { |
| th.errors.push( |
| ( |
| toml_span::ErrorKind::Custom( |
| format!("failed to parse rustsec::Severity: {err}").into(), |
| ), |
| v.span, |
| ) |
| .into(), |
| ); |
| None |
| } |
| } |
| }; |
| |
| let severity_threshold = st(&mut th, &mut fdeps); |
| let git_fetch_with_cli = th.optional("git-fetch-with-cli"); |
| let disable_yank_checking = th.optional("disable-yank-checking").unwrap_or_default(); |
| let maximum_db_staleness = if let Some((_, mut val)) = th.take("maximum-db-staleness") { |
| match val.take_string(Some("an RFC3339 time duration")) { |
| Ok(mds) => match parse_rfc3339_duration(&mds) { |
| Ok(mds) => Some(Spanned::with_span(mds, val.span)), |
| Err(err) => { |
| th.errors.push( |
| ( |
| toml_span::ErrorKind::Custom(err.to_string().into()), |
| val.span, |
| ) |
| .into(), |
| ); |
| None |
| } |
| }, |
| Err(err) => { |
| th.errors.push(err); |
| None |
| } |
| } |
| } else { |
| None |
| }; |
| |
| th.finalize(None)?; |
| |
| // Use the 90 days default as a fallback |
| let maximum_db_staleness = maximum_db_staleness |
| .unwrap_or_else(|| Spanned::new(Duration::seconds_f64(NINETY_DAYS))); |
| |
| let deprecated = if version <= 1 { |
| Some(Deprecated { |
| vulnerability: vulnerability.unwrap_or(LintLevel::Deny), |
| unmaintained: unmaintained.unwrap_or(LintLevel::Warn), |
| unsound: unsound.unwrap_or(LintLevel::Warn), |
| notice: notice.unwrap_or(LintLevel::Warn), |
| severity_threshold, |
| }) |
| } else { |
| None |
| }; |
| |
| Ok(Self { |
| db_path, |
| db_urls, |
| yanked, |
| ignore, |
| ignore_yanked, |
| git_fetch_with_cli, |
| disable_yank_checking, |
| maximum_db_staleness, |
| deprecated, |
| deprecated_spans: fdeps, |
| }) |
| } |
| } |
| |
| impl crate::cfg::UnvalidatedConfig for Config { |
| type ValidCfg = ValidConfig; |
| |
| fn validate(self, mut ctx: ValidationContext<'_>) -> Self::ValidCfg { |
| let mut ignore = self.ignore; |
| let mut ignore_yanked = self.ignore_yanked; |
| let mut db_urls = self.db_urls; |
| |
| ctx.dedup(&mut ignore); |
| ctx.dedup(&mut ignore_yanked); |
| ctx.dedup(&mut db_urls); |
| |
| // Require that each url has a valid domain name for when we splat it to a local path |
| for url in &db_urls { |
| if url.value.domain().is_none() { |
| ctx.push( |
| Diagnostic::error() |
| .with_message("advisory database url doesn't have a domain name") |
| .with_labels(vec![Label::secondary(ctx.cfg_id, url.span)]), |
| ); |
| } |
| } |
| |
| let db_path = if let Some(root) = self.db_path { |
| let exp_result; |
| |
| // When testing we use a specific default otherwise it gets redacted by insta |
| #[cfg(test)] |
| { |
| exp_result = shellexpand(root, ctx.cfg_id, |exp| match exp { |
| Expand::Home => Ok(Some("/home/you".into())), |
| Expand::Var(var) => { |
| unreachable!("unexpected expansion request for '{var}'") |
| } |
| }); |
| } |
| #[cfg(not(test))] |
| { |
| exp_result = shellexpand(root, ctx.cfg_id, normal_expand); |
| } |
| |
| match exp_result { |
| Ok(expanded) => Some(expanded), |
| Err(err) => { |
| ctx.diagnostics.push(err); |
| None |
| } |
| } |
| } else { |
| fn def_path() -> anyhow::Result<PathBuf> { |
| utf8path( |
| home::cargo_home() |
| .context("failed to resolve CARGO_HOME or HOME")? |
| .join("advisory-dbs"), |
| ) |
| } |
| |
| match def_path() { |
| Ok(pb) => Some(pb), |
| Err(err) => { |
| ctx.diagnostics.push(Diagnostic::error() |
| .with_message(format!("unable to obtain default advisory-dbs directory: {err:#}")) |
| .with_notes(vec!["the default directory is determined by $CARGO_HOME -> $HOME/.cargo".into()])); |
| None |
| } |
| } |
| }; |
| |
| use crate::diag::general::{Deprecated, DeprecationReason}; |
| |
| // Output any deprecations, we'll remove the fields at the same time we |
| // remove all the logic they drive |
| for dep in self.deprecated_spans { |
| ctx.push( |
| Deprecated { |
| reason: DeprecationReason::WillBeRemoved(Some( |
| "https://github.com/EmbarkStudios/cargo-deny/pull/611", |
| )), |
| key: dep, |
| file_id: ctx.cfg_id, |
| } |
| .into(), |
| ); |
| } |
| |
| ValidConfig { |
| file_id: ctx.cfg_id, |
| db_path: db_path.unwrap_or_default(), // If we failed to get a path the default won't be used since errors will have occurred |
| db_urls, |
| ignore: ignore.into_iter().map(|s| s.value).collect(), |
| ignore_yanked: ignore_yanked |
| .into_iter() |
| .map(|s| crate::bans::SpecAndReason { |
| spec: s.value.spec, |
| reason: s.value.inner, |
| use_instead: None, |
| file_id: ctx.cfg_id, |
| }) |
| .collect(), |
| deprecated: self.deprecated, |
| yanked: self.yanked, |
| git_fetch_with_cli: self.git_fetch_with_cli.unwrap_or_default(), |
| disable_yank_checking: self.disable_yank_checking, |
| maximum_db_staleness: self.maximum_db_staleness, |
| } |
| } |
| } |
| |
| #[cfg_attr(test, derive(serde::Serialize))] |
| pub struct ValidConfig { |
| pub file_id: FileId, |
| pub db_path: PathBuf, |
| pub db_urls: Vec<Spanned<Url>>, |
| pub(crate) ignore: Vec<IgnoreId>, |
| pub(crate) ignore_yanked: Vec<crate::bans::SpecAndReason>, |
| pub(crate) deprecated: Option<Deprecated>, |
| pub yanked: Spanned<LintLevel>, |
| pub git_fetch_with_cli: bool, |
| pub disable_yank_checking: bool, |
| pub maximum_db_staleness: Spanned<Duration>, |
| } |
| |
| /// We need to implement this ourselves since time doesn't support it |
| /// <https://github.com/time-rs/time/issues/571> |
| /// |
| /// ```text |
| /// dur-second = 1*DIGIT "S" |
| /// dur-minute = 1*DIGIT "M" [dur-second] |
| /// dur-hour = 1*DIGIT "H" [dur-minute] |
| /// dur-time = "T" (dur-hour / dur-minute / dur-second) |
| /// dur-day = 1*DIGIT "D" |
| /// dur-week = 1*DIGIT "W" |
| /// dur-month = 1*DIGIT "M" [dur-day] |
| /// dur-year = 1*DIGIT "Y" [dur-month] |
| /// dur-date = (dur-day / dur-month / dur-year) [dur-time] |
| /// |
| /// duration = "P" (dur-date / dur-time / dur-week) |
| /// ``` |
| fn parse_rfc3339_duration(value: &str) -> anyhow::Result<Duration> { |
| use anyhow::Context as _; |
| |
| let mut value = value |
| .strip_prefix('P') |
| .context("duration requires 'P' prefix")?; |
| |
| // The units that are allowed in the format, in the exact order they must be |
| // in, ie it is invalid to specify a unit that is lower in this order than |
| // one that has already been parsed |
| const UNITS: &[(char, f64)] = &[ |
| ('D', 24. * 60. * 60.), |
| // We calculate the length of the month by just getting the mean of all |
| // the months, and use 28.25 for February |
| ('M', 30.43 * 24. * 60. * 60.), |
| // Years we just use the standard 365 days and ignore leap years |
| ('Y', 365. * 24. * 60. * 60.), |
| ('W', 7. * 24. * 60. * 60.), |
| ('H', 60. * 60.), |
| ('M', 60.), |
| ('S', 1.), |
| ('W', 7. * 24. * 60. * 60.), |
| ]; |
| |
| // Validate the string only contains valid characters to simplify the rest |
| // of the function |
| for c in value.chars() { |
| if c == ',' { |
| anyhow::bail!("'{c}' is valid in the RFC-3339 duration format but not supported by this implementation, use '.' instead"); |
| } |
| |
| if c != '.' && c != 'T' && !c.is_ascii_digit() && !UNITS.iter().any(|(uc, _)| c == *uc) { |
| anyhow::bail!("'{c}' is not valid in the RFC-3339 duration format"); |
| } |
| } |
| |
| #[derive(Copy, Clone, PartialEq, PartialOrd)] |
| enum Unit { |
| Empty, |
| Year, |
| Month, |
| Day, |
| Time, |
| Hour, |
| Minute, |
| Second, |
| Week, |
| } |
| |
| impl Unit { |
| #[inline] |
| fn from(c: char, is_time: bool) -> Self { |
| match c { |
| 'D' => Self::Day, |
| 'T' => Self::Time, |
| 'H' => Self::Hour, |
| 'M' => { |
| if is_time { |
| Self::Minute |
| } else { |
| Self::Month |
| } |
| } |
| 'S' => Self::Second, |
| 'Y' => Self::Year, |
| 'W' => Self::Week, |
| other => unreachable!("'{other}' should be impossible"), |
| } |
| } |
| } |
| |
| let mut duration = Duration::new(0, 0); |
| |
| // The format requires that the units are in a specific order, but each |
| // unit is optional |
| let mut last_unit = Unit::Empty; |
| let mut last_unitc = '_'; |
| let mut supplied_units = 0; |
| // According to the spec, the T is required before any hour/minute/second units |
| // are allowed |
| let mut is_time = false; |
| |
| while !value.is_empty() { |
| let unit_index = value |
| .find(|c: char| c.is_ascii_uppercase()) |
| .context("unit not specified")?; |
| |
| let unitc = value.as_bytes()[unit_index] as char; |
| let unit = Unit::from(unitc, is_time); |
| |
| anyhow::ensure!( |
| unit > last_unit, |
| "unit '{unitc}' cannot follow '{last_unitc}'" |
| ); |
| |
| if unit == Unit::Time { |
| anyhow::ensure!( |
| unit_index == 0, |
| "unit not specified for value '{}'", |
| &value[..unit_index] |
| ); |
| is_time = true; |
| } else { |
| anyhow::ensure!(unit_index != 0, "value not specified for '{unitc}'"); |
| |
| let uvs = &value[..unit_index]; |
| let unit_value: f64 = uvs |
| .parse() |
| .with_context(|| "failed to parse value '{uvs}' for unit '{unit}'")?; |
| |
| supplied_units += 1; |
| |
| anyhow::ensure!( |
| !matches!(unit, Unit::Hour | Unit::Minute | Unit::Second) || is_time, |
| "'{unitc}' must be preceded with 'T'" |
| ); |
| |
| // This would be nicer if 'M' couldn't mean both months and minutes :p |
| let block = if is_time { &UNITS[4..] } else { &UNITS[..4] }; |
| let unit_to_seconds = block |
| .iter() |
| .find_map(|(c, uts)| (*c == unitc).then_some(*uts)) |
| .unwrap(); |
| |
| duration += time::Duration::checked_seconds_f64(unit_value * unit_to_seconds) |
| .with_context(|| format!("value '{unit_value}' for '{unitc}' is out of range"))?; |
| } |
| |
| last_unitc = unitc; |
| last_unit = unit; |
| value = &value[unit_index + 1..]; |
| } |
| |
| anyhow::ensure!(supplied_units > 0, "must supply at least one time unit"); |
| |
| Ok(duration) |
| } |
| |
| /// We could just hardcode these, but this makes testing easier |
| enum Expand<'v> { |
| Home, |
| Var(&'v str), |
| } |
| |
| #[cfg_attr(test, allow(dead_code))] |
| fn normal_expand(exp: Expand<'_>) -> anyhow::Result<Option<String>> { |
| match exp { |
| Expand::Home => { |
| let hd = |
| home::home_dir().context("HOME directory could not be obtained from the OS")?; |
| let uhd = utf8path(hd)?; |
| Ok(Some(uhd.into())) |
| } |
| // We treat this one variable specially |
| Expand::Var("CARGO_HOME") => Ok(Some( |
| utf8path(home::cargo_home().context("unable to determine CARGO_HOME")?)?.into(), |
| )), |
| Expand::Var(var_name) => match std::env::var(var_name) { |
| Ok(vv) => Ok(Some(vv)), |
| Err(std::env::VarError::NotPresent) => Ok(None), |
| Err(std::env::VarError::NotUnicode(original)) => { |
| anyhow::bail!("'{original:?}' is not utf-8") |
| } |
| }, |
| } |
| } |
| |
| /// This is a _basic_ shell expander, it's not meant to be fully featured, just |
| /// support the basic options a user would normally use, namely `~` expansion |
| /// and `$VAR_NAME` || `${VAR_NAME(?::-(default_value))?}` expansion |
| fn shellexpand( |
| to_expand: Spanned<PathBuf>, |
| cfg_id: FileId, |
| expand: impl Fn(Expand<'_>) -> anyhow::Result<Option<String>>, |
| ) -> Result<PathBuf, Diagnostic> { |
| let span = to_expand.span; |
| let original = to_expand.value; |
| let te = original.as_str(); |
| |
| if !te.contains('~') && !te.contains('$') { |
| return Ok(original); |
| } |
| |
| let mut exp = String::new(); |
| |
| let mut cursor = 0; |
| |
| if te.starts_with('~') { |
| exp.push_str( |
| &expand(Expand::Home) |
| .map_err(|err| { |
| Diagnostic::error() |
| .with_message(format!("unable to obtain $HOME: {err:#}")) |
| .with_labels(vec![Label::primary(cfg_id, span.start..span.start + 1)]) |
| })? |
| .expect("this either fails or returns a path"), |
| ); |
| cursor += 1; |
| } |
| |
| while let Some(ind) = te[cursor..].find('$') { |
| exp.push_str(&te[cursor..cursor + ind]); |
| let sspan = span.start + cursor + ind; |
| cursor += ind; |
| |
| let mut default = None; |
| let (var_name, next) = if te[cursor..].starts_with("${") { |
| let end = te[cursor..].find('}').ok_or_else(|| { |
| Diagnostic::error() |
| .with_message("opening `{` is unbalanced") |
| .with_labels(vec![Label::primary(cfg_id, sspan..span.end)]) |
| })?; |
| |
| // Check if a default value is available |
| let vname = if let Some((vname, def)) = te[cursor + 2..cursor + end].split_once(":-") { |
| default = Some(def); |
| vname |
| } else { |
| &te[cursor + 2..cursor + end] |
| }; |
| |
| // Ensure the variable name is valid so we can give a better error |
| // other than always failing to find a variable that can never exist |
| if vname |
| .find(|c: char| !(c.is_alphanumeric() || c == '_')) |
| .is_some() |
| { |
| return Err(Diagnostic::error() |
| .with_message("variable name is invalid") |
| .with_labels(vec![Label::primary( |
| cfg_id, |
| sspan..span.start + cursor + end + 1, |
| )])); |
| } |
| |
| (vname, cursor + end + 1) |
| } else { |
| cursor += 1; |
| if let Some(end) = te[cursor..].find(|c: char| !(c.is_alphanumeric() || c == '_')) { |
| (&te[cursor..cursor + end], cursor + end) |
| } else { |
| (&te[cursor..], te.len()) |
| } |
| }; |
| |
| if var_name.is_empty() { |
| return Err(Diagnostic::error() |
| .with_message("variable name cannot be empty") |
| .with_labels(vec![Label::primary(cfg_id, sspan..span.start + next)])); |
| } |
| |
| match expand(Expand::Var(var_name)) { |
| Ok(Some(vv)) => { |
| exp.push_str(&vv); |
| } |
| Err(err) => { |
| return Err(Diagnostic::error() |
| .with_message(format!("failed to expand variable: {err:#}")) |
| .with_labels(vec![Label::primary(cfg_id, sspan..span.start + next)])); |
| } |
| Ok(None) => { |
| if let Some(default) = default { |
| exp.push_str(default); |
| } else { |
| return Err(Diagnostic::error() |
| .with_message("failed to find variable") |
| .with_labels(vec![Label::primary(cfg_id, sspan..span.start + next)])); |
| } |
| } |
| } |
| |
| cursor = next; |
| } |
| |
| exp.push_str(&te[cursor..]); |
| |
| Ok(exp.into()) |
| } |
| |
| #[cfg(test)] |
| mod test { |
| |
| use super::{parse_rfc3339_duration as dur_parse, *}; |
| use crate::test_utils::{write_diagnostics, ConfigData}; |
| |
| struct Advisories { |
| advisories: Config, |
| } |
| |
| impl<'de> toml_span::Deserialize<'de> for Advisories { |
| fn deserialize( |
| value: &mut toml_span::value::Value<'de>, |
| ) -> Result<Self, toml_span::DeserError> { |
| let mut th = toml_span::de_helpers::TableHelper::new(value)?; |
| let advisories = th.required("advisories").unwrap(); |
| th.finalize(None)?; |
| Ok(Self { advisories }) |
| } |
| } |
| |
| #[test] |
| fn deserializes_advisories_cfg() { |
| let cd = ConfigData::<Advisories>::load("tests/cfg/advisories.toml"); |
| let validated = cd.validate_with_diags( |
| |a| a.advisories, |
| |files, diags| { |
| let diags = write_diagnostics(files, diags.into_iter()); |
| insta::assert_snapshot!(diags); |
| }, |
| ); |
| |
| insta::assert_json_snapshot!(validated); |
| } |
| |
| #[test] |
| fn warns_on_duplicates() { |
| let dupes = r#" |
| [advisories] |
| db-urls = [ |
| "https://github.com/rust-lang/crates.io-index", |
| "https://one.reg", |
| "https://one.reg", |
| ] |
| ignore = [ |
| "RUSTSEC-0000-0001", |
| { crate = "boop" }, |
| "RUSTSEC-0000-0001", |
| "boop", |
| ] |
| "#; |
| |
| let cd = ConfigData::<Advisories>::load_str("duplicates", dupes); |
| let _validated = cd.validate_with_diags( |
| |a| a.advisories, |
| |files, diags| { |
| let diags = write_diagnostics(files, diags.into_iter()); |
| insta::assert_snapshot!(diags); |
| }, |
| ); |
| } |
| |
| /// Validates we reject invalid formats, or at least ones we don't support |
| #[test] |
| fn rejects_invalid_durations() { |
| const FAILURES: &[&str] = &[ |
| "no-P", // Format requires 'P' at the beginning |
| "P", "PT", // Empty duration, must specify at least _one_ unit |
| "P1H3", "P2TH3", // Number without unit specified |
| "PT1HM", // Unit without number specified |
| "PT1M3H", "P1M3Y", "P2W1Y", "PT2W1H", // Units in an invalid order |
| "P5H", "P5S", // Time units must be preceded by T |
| // We don't accept ',' as a decimal separator even though it is allowed in the spec |
| "PT1,5S", |
| ]; |
| |
| let failures: String = FAILURES.iter().fold(String::new(), |mut acc, bad| { |
| use std::fmt::Write; |
| writeln!(&mut acc, "{:#?}", dur_parse(bad).unwrap_err()).unwrap(); |
| acc |
| }); |
| |
| insta::assert_snapshot!(failures); |
| } |
| |
| /// Validates we can parse many durations. |
| /// |
| /// Note the values were copied from <https://ijmacd.github.io/rfc3339-iso8601/> |
| /// but at least according to the grammar in the RFC...many were actually invalid :p |
| #[test] |
| fn parses_valid_durations() { |
| const DAY: f64 = 24. * 60. * 60.; |
| const MONTH: f64 = 30.43 * DAY; |
| const TABLE: &[(&str, f64)] = &[ |
| ("P1Y", 365. * DAY), |
| ("P1.5Y", 365. * 1.5 * DAY), |
| ("P1M", MONTH), |
| ("P2W", 7. * 2. * DAY), |
| ("P3D", 3. * DAY), |
| ("PT4H", 4. * 60. * 60.), |
| ("PT2M", 2. * 60.), |
| ("PT8S", 8.), |
| ("PT8.5S", 8.5), |
| ("P1Y3M", 365. * DAY + 3. * MONTH), |
| ("P1Y5D", 365. * DAY + 5. * DAY), |
| ("P1Y4M3D", 365. * DAY + 4. * MONTH + 3. * DAY), |
| ( |
| "P1Y3M2DT3H2M1S", |
| 365. * DAY + 3. * MONTH + 2. * DAY + 3. * 60. * 60. + 2. * 60. + 1., |
| ), |
| ("P2DT4H", 2. * DAY + 4. * 60. * 60.), |
| ("P2MT0.5M", 2. * MONTH + 0.5 * 60.), |
| ("P5DT1.6M", 5. * DAY + 60. * 1.6), |
| ("P1.5W", 7. * 1.5 * DAY), |
| ("P3D1.5W", 3. * DAY + 7. * 1.5 * DAY), |
| ("P2DT3.002S", 2. * DAY + 3.002), |
| ("P2DT3.02003S", 2. * DAY + 3.02003), |
| ("P2DT4H3M2.6S", 2. * DAY + 4. * 60. * 60. + 3. * 60. + 2.6), |
| ("PT3H2M1.1S", 3. * 60. * 60. + 2. * 60. + 1.1), |
| ]; |
| |
| for (dur, secs) in TABLE { |
| match dur_parse(dur) { |
| Ok(parsed) => { |
| assert_eq!( |
| parsed, |
| Duration::seconds_f64(*secs), |
| "unexpected duration for '{dur}'" |
| ); |
| } |
| Err(err) => { |
| panic!("failed to parse '{dur}': {err:#}"); |
| } |
| } |
| } |
| } |
| |
| #[cfg(unix)] |
| #[test] |
| fn expands_path() { |
| use super::Expand; |
| use std::{ffi::OsStr, os::unix::ffi::OsStrExt as _}; |
| |
| // Überraschung in ISO_8859_15 |
| const SURPRISE: &[u8] = &[220, 98, 101, 114, 114, 97, 115, 99, 104, 117, 110, 103]; |
| |
| macro_rules! expand { |
| ($expand:expr, $expected:literal, $value:expr) => { |
| if let Expand::Var(vn) = $expand { |
| assert_eq!(vn, $expected); |
| $value |
| } else { |
| unreachable!("expected a variable name"); |
| } |
| }; |
| } |
| |
| // These closurs need to be kept aligned with the toml array below |
| #[allow(clippy::type_complexity)] |
| let expanders: [Option<Box<dyn Fn(Expand<'_>) -> anyhow::Result<Option<String>>>>; |
| 16] = [ |
| Some(Box::new(|exp| { |
| if let Expand::Home = exp { |
| anyhow::bail!("HOME directory could not be obtained from the OS"); |
| } else { |
| panic!("unexpected request") |
| } |
| })), |
| Some(Box::new(|exp| { |
| if let Expand::Home = exp { |
| utf8path(std::ffi::OsStr::from_bytes(SURPRISE).into())?; |
| unreachable!(); |
| } else { |
| panic!("unexpected request") |
| } |
| })), |
| Some(Box::new(|exp| { |
| if let Expand::Home = exp { |
| Ok(Some("/this-home".into())) |
| } else { |
| panic!("unexpected request") |
| } |
| })), |
| Some(Box::new(|exp| { |
| expand!(exp, "CARGO_HOME", Ok(Some("/default/.works".into()))) |
| })), |
| Some(Box::new(|exp| { |
| expand!(exp, "CARGO_HOME2", Ok(Some("/this-also/.works".into()))) |
| })), |
| None, |
| Some(Box::new(|exp| expand!(exp, "NOPE", Ok(None)))), |
| Some(Box::new(|exp| { |
| expand!( |
| exp, |
| "NON_UTF8", |
| anyhow::bail!("'{:?}' is not utf-8", OsStr::from_bytes(SURPRISE)) |
| ) |
| })), |
| None, |
| None, |
| Some(Box::new(|exp| { |
| expand!(exp, "TRAILING", Ok(Some("trail".into()))) |
| })), |
| Some(Box::new(|exp| { |
| expand!(exp, "WINDOWS", Ok(Some("windows".into()))) |
| })), |
| None, |
| None, |
| Some(Box::new(|exp| { |
| expand!(exp, "IN_MID", Ok(Some("in-the-middle".into()))) |
| })), |
| Some(Box::new(|exp| { |
| if matches!(exp, Expand::Var("FIRST")) { |
| expand!(exp, "FIRST", Ok(Some("first".into()))) |
| } else { |
| expand!(exp, "SECOND", Ok(Some("second".into()))) |
| } |
| })), |
| ]; |
| |
| let toml = r#" |
| expansions = [ |
| "~/nope", # can't find $HOME |
| "~/not-utf8", # $HOME is not a utf-8 path |
| "~/works", # expands to /this-home/works |
| "$CARGO_HOME/advisory-dbs", # expands to /default/.works/advisory-dbs |
| "${CARGO_HOME2}/advisory-dbs", # expands to /this-also/.works/advisory-dbs |
| "${no-end", # fails due to unclosed { |
| "/missing/${NOPE:-but i have a default}/", # expands to /missing/but i have a default/ |
| "/non-utf8/$NON_UTF8", # fails due to NON_UTF8 |
| "$/empty", # fails due to empty variable |
| "/also-empty/${}", # ditto |
| "/has-trailing/$TRAILING", # expands to /has-trailing/trail |
| "C:/Users/me/$WINDOWS/works", # expands to C:/Users/me/windows/works |
| "$!", # fails due to empty variable name |
| "${!}", # fails due to invalid character in variable name |
| "/expands/stuff-${IN_MID}-like-this", # /expands/stuff-in-the-middle-like-this |
| "/expands/$FIRST-item/${SECOND}-item/multiple", # /expands/first-item/second-item/multiple |
| ] |
| "#; |
| let mut tv = toml_span::parse(toml).unwrap(); |
| let toml_span::value::ValueInner::Table(mut tab) = tv.take() else { |
| unreachable!() |
| }; |
| let mut expansions = tab.remove(&"expansions".into()).unwrap(); |
| let toml_span::value::ValueInner::Array(exp) = expansions.take() else { |
| unreachable!() |
| }; |
| |
| use toml_span::Deserialize as _; |
| |
| let mut files = crate::diag::Files::new(); |
| let cfg_id = files.add("expansions.toml", toml.into()); |
| |
| let mut output = String::new(); |
| |
| for (mut expansion, expander) in exp.into_iter().zip(expanders.into_iter()) { |
| let expansion = toml_span::Spanned::<String>::deserialize(&mut expansion) |
| .unwrap() |
| .map(); |
| |
| let expander = expander.unwrap_or_else(|| { |
| Box::new(|_exp| { |
| unreachable!("this should not be called"); |
| }) |
| }); |
| |
| match super::shellexpand(expansion, cfg_id, expander) { |
| Ok(pb) => output.push_str(pb.as_str()), |
| Err(err) => { |
| let ds = crate::test_utils::write_diagnostics(&files, std::iter::once(err)); |
| output.push_str(&ds); |
| } |
| } |
| |
| output.push('\n'); |
| } |
| |
| insta::assert_snapshot!(output); |
| } |
| } |
