From ff8583cc0866e66c3704e5db27a51f66dad12fc3 Mon Sep 17 00:00:00 2001 From: r0wdiggity Date: Fri, 15 May 2026 13:36:36 -0500 Subject: [PATCH 1/2] fix: resolve registry auth tokens for cargo upgrade cargo-edit 0.13.10 uses tame_index with its own reqwest client that never reads auth tokens from Cargo's credential-provider, credentials.toml, or environment variables. This causes 401 Unauthorized errors when upgrading dependencies from private registries (e.g. AWS CodeArtifact). This commit: - Adds registry_token() to resolve tokens from env vars, credentials.toml, credential-provider commands, and config.toml (in priority order) - Injects resolved tokens into RemoteIndex Authorization headers - Treats dependencies with no explicit source as default registry deps, so source-replaced crates-io deps are also authenticated - Caches tokens per registry to avoid repeated credential-provider calls Fixes #931 --- Cargo.lock | 1 + Cargo.toml | 1 + src/bin/upgrade/upgrade.rs | 20 +- src/index.rs | 24 +- src/lib.rs | 1 + src/registry.rs | 558 +++++++++++++++++++++++++++++++++++++ 6 files changed, 595 insertions(+), 10 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 92b168036b..bab81727c3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -261,6 +261,7 @@ dependencies = [ "serde_derive", "snapbox 0.6.24", "tame-index", + "tempfile", "termcolor", "toml 1.1.2+spec-1.1.0", "toml_edit", diff --git a/Cargo.toml b/Cargo.toml index a94b765d57..4cdc938d45 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -89,6 +89,7 @@ version = "1.0.28" trycmd = "1.2.0" snapbox = { version = "0.6.24", features = ["cmd", "path"] } cargo-test-support = "0.10.0" +tempfile = "3" [profile.release] panic = "abort" diff --git a/src/bin/upgrade/upgrade.rs b/src/bin/upgrade/upgrade.rs index 1afdfcf9f7..8ff6be4695 100644 --- a/src/bin/upgrade/upgrade.rs +++ b/src/bin/upgrade/upgrade.rs @@ -6,8 +6,8 @@ use std::path::PathBuf; use anyhow::Context as _; use cargo_edit::{ CargoResult, CertsSource, CrateSpec, Dependency, IndexCache, LocalManifest, RustVersion, - Source, find_compatible_version, find_latest_version, registry_url, set_dep_version, - shell_note, shell_status, shell_warn, shell_write_stdout, + Source, find_compatible_version, find_latest_version, registry_token, registry_url, + set_dep_version, shell_note, shell_status, shell_warn, shell_write_stdout, }; use clap::Args; use indexmap::IndexMap; @@ -225,6 +225,7 @@ fn exec(args: UpgradeArgs) -> CargoResult<()> { let mut pinned_present = false; let mut incompatible_present = false; let mut uninteresting_crates = BTreeSet::new(); + let mut token_cache: std::collections::HashMap> = std::collections::HashMap::new(); for (pkg_name, manifest_path, rust_version) in manifests { let mut manifest = LocalManifest::try_new(&manifest_path)?; let mut crate_modified = false; @@ -296,15 +297,22 @@ fn exec(args: UpgradeArgs) -> CargoResult<()> { } }; - let (latest_compatible, latest_incompatible) = if dependency + let is_registry_dep = dependency .source .as_ref() - .and_then(|s| s.as_registry()) - .is_some() - { + .map(|s| s.as_registry().is_some()) + .unwrap_or(true); // None source means default registry (crates-io) + let (latest_compatible, latest_incompatible) = if is_registry_dep { // Update indices for any alternative registries, unless // we're offline. let registry_url = registry_url(&manifest_path, dependency.registry())?; + let cache_key = format!("{}:{:?}", manifest_path.display(), dependency.registry()); + let token = token_cache.entry(cache_key).or_insert_with(|| { + registry_token(&manifest_path, dependency.registry()) + }); + if let Some(token) = token { + index.set_token(®istry_url, token.clone()); + } let krate = index.krate(®istry_url, &dependency.name)?; let versions = krate .as_ref() diff --git a/src/index.rs b/src/index.rs index bab4955835..d47376ba73 100644 --- a/src/index.rs +++ b/src/index.rs @@ -17,6 +17,7 @@ pub enum CertsSource { pub struct IndexCache { certs_source: CertsSource, index: std::collections::HashMap, + tokens: std::collections::HashMap, } impl IndexCache { @@ -25,9 +26,15 @@ impl IndexCache { Self { certs_source, index: Default::default(), + tokens: Default::default(), } } + /// Set an auth token for a registry URL + pub fn set_token(&mut self, registry_url: &Url, token: String) { + self.tokens.insert(registry_url.to_string(), token); + } + /// Determines if the specified crate exists in the crates.io index #[inline] pub fn has_krate(&mut self, registry: &Url, name: &str) -> CargoResult { @@ -65,7 +72,8 @@ impl IndexCache { fn index<'s>(&'s mut self, registry: &Url) -> CargoResult<&'s mut AnyIndexCache> { if !self.index.contains_key(registry) { - let index = AnyIndex::open(registry, self.certs_source)?; + let token = self.tokens.get(®istry.to_string()).cloned(); + let index = AnyIndex::open(registry, self.certs_source, token)?; let index = AnyIndexCache::new(index); self.index.insert(registry.clone(), index); } @@ -122,13 +130,13 @@ enum AnyIndex { } impl AnyIndex { - fn open(url: &Url, certs_source: CertsSource) -> CargoResult { + fn open(url: &Url, certs_source: CertsSource, token: Option) -> CargoResult { if url.scheme() == "file" { LocalIndex::open(url) .map(Self::Local) .with_context(|| format!("invalid local registry {url:?}")) } else { - RemoteIndex::open(url, certs_source) + RemoteIndex::open(url, certs_source, token) .map(Self::Remote) .with_context(|| format!("invalid registry {url:?}")) } @@ -182,10 +190,11 @@ struct RemoteIndex { client: tame_index::external::reqwest::blocking::Client, lock: FileLock, etags: Vec<(String, String)>, + token: Option, } impl RemoteIndex { - fn open(url: &Url, certs_source: CertsSource) -> CargoResult { + fn open(url: &Url, certs_source: CertsSource, token: Option) -> CargoResult { log::trace!("opening index entry for {url}"); let url = url.to_string(); let url = tame_index::IndexUrl::NonCratesIo(std::borrow::Cow::Owned(url)); @@ -209,6 +218,7 @@ impl RemoteIndex { client, lock, etags: Vec::new(), + token, }) } @@ -237,6 +247,12 @@ impl RemoteIndex { let mut req = self.client.request(method, uri.to_string()); req = req.version(version); req = req.headers(headers); + if let Some(token) = &self.token { + req = req.header( + tame_index::external::reqwest::header::AUTHORIZATION, + token.as_str(), + ); + } let res = self.client.execute(req.build()?)?; // Grab the etag if it exists for future requests diff --git a/src/lib.rs b/src/lib.rs index 9de1793644..72ad099227 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -44,6 +44,7 @@ pub use fetch::{RustVersion, find_compatible_version, find_latest_version}; pub use index::*; pub use manifest::{LocalManifest, Manifest, find, get_dep_version, set_dep_version}; pub use metadata::manifest_from_pkgid; +pub use registry::registry_token; pub use registry::registry_url; pub use util::{ Color, ColorChoice, colorize_stderr, shell_note, shell_print, shell_status, shell_warn, diff --git a/src/registry.rs b/src/registry.rs index 4c59cb0ef3..7ec261bf8c 100644 --- a/src/registry.rs +++ b/src/registry.rs @@ -114,8 +114,213 @@ struct Source { } #[derive(Debug, Deserialize)] +#[allow(dead_code)] struct Registry { index: Option, + token: Option, + #[serde(rename = "credential-provider")] + credential_provider: Option, +} + +/// Resolve the auth token for a registry by checking (in order): +/// 1. Environment variable CARGO_REGISTRIES__TOKEN +/// 2. credentials.toml +/// 3. credential-provider command (cargo:token-from-stdout) +/// 4. token field in config.toml +pub fn registry_token(manifest_path: &Path, registry: Option<&str>) -> Option { + let registry_name = resolve_registry_name(manifest_path, registry); + let registry_name = registry_name.as_deref()?; + + // 1. Check environment variable + let env_key = format!( + "CARGO_REGISTRIES_{}_TOKEN", + registry_name.to_uppercase().replace('-', "_") + ); + if let Ok(token) = std::env::var(&env_key) + && !token.is_empty() + { + log::trace!("using token from environment variable {env_key}"); + return Some(token); + } + + // 2. Check credentials.toml + if let Some(token) = read_credentials_token(registry_name) { + log::trace!("using token from credentials.toml"); + return Some(token); + } + + // 3. Check config.toml for credential-provider or token + let (token, credential_provider) = read_config_auth(manifest_path, registry_name); + + if let Some(provider) = credential_provider + && let Some(cmd) = provider.strip_prefix("cargo:token-from-stdout ") + { + log::trace!("running credential-provider command: {cmd}"); + if let Some(token) = run_credential_command(cmd) { + return Some(token); + } + } + + // 4. Token from config.toml + if let Some(token) = token { + log::trace!("using token from config.toml"); + return Some(token); + } + + None +} + +/// Determine which registry name is ultimately used after source replacement +fn resolve_registry_name(manifest_path: &Path, registry: Option<&str>) -> Option { + let registries = read_all_configs(manifest_path); + + match registry { + Some(CRATES_IO_INDEX) | None => { + // Check if crates-io is replaced + if let Some(source) = registries.get(CRATES_IO_REGISTRY) + && let Some(replace_with) = &source.replace_with + { + return Some(replace_with.clone()); + } + None + } + Some(r) => Some(r.to_owned()), + } +} + +fn read_all_configs(manifest_path: &Path) -> HashMap { + let mut sources: HashMap = HashMap::new(); + for work_dir in manifest_path + .parent() + .expect("there must be a parent directory") + .ancestors() + { + let work_cargo_dir = work_dir.join(".cargo"); + let config_path = work_cargo_dir.join("config"); + if config_path.is_file() { + let _ = read_sources_from_config(&mut sources, &config_path); + } else { + let config_path = work_cargo_dir.join("config.toml"); + if config_path.is_file() { + let _ = read_sources_from_config(&mut sources, &config_path); + } + } + } + if let Ok(cargo_home) = home::cargo_home() { + let config_path = cargo_home.join("config"); + if config_path.is_file() { + let _ = read_sources_from_config(&mut sources, &config_path); + } else { + let config_path = cargo_home.join("config.toml"); + if config_path.is_file() { + let _ = read_sources_from_config(&mut sources, &config_path); + } + } + } + sources +} + +fn read_sources_from_config( + sources: &mut HashMap, + path: &Path, +) -> CargoResult<()> { + let content = std::fs::read_to_string(path)?; + let config = toml::from_str::(&content) + .with_context(|| anyhow::format_err!("invalid cargo config at {}", path.display()))?; + for (key, value) in config.source { + sources.entry(key).or_insert(value); + } + Ok(()) +} + +fn read_credentials_token(registry_name: &str) -> Option { + let cargo_home = home::cargo_home().ok()?; + for filename in &["credentials.toml", "credentials"] { + let path = cargo_home.join(filename); + if path.is_file() { + let content = std::fs::read_to_string(&path).ok()?; + let config: toml::Value = toml::from_str(&content).ok()?; + let token = config + .get("registries")? + .get(registry_name)? + .get("token")? + .as_str()?; + return Some(token.to_owned()); + } + } + None +} + +fn read_config_auth( + manifest_path: &Path, + registry_name: &str, +) -> (Option, Option) { + let mut token = None; + let mut credential_provider = None; + + let check_config = |path: &Path| -> Option<(Option, Option)> { + let content = std::fs::read_to_string(path).ok()?; + let config: CargoConfig = toml::from_str(&content).ok()?; + let reg = config.registries.get(registry_name)?; + Some((reg.token.clone(), reg.credential_provider.clone())) + }; + + for work_dir in manifest_path + .parent() + .expect("there must be a parent directory") + .ancestors() + { + let work_cargo_dir = work_dir.join(".cargo"); + for name in &["config", "config.toml"] { + let config_path = work_cargo_dir.join(name); + if config_path.is_file() + && let Some((t, cp)) = check_config(&config_path) + { + if token.is_none() { + token = t; + } + if credential_provider.is_none() { + credential_provider = cp; + } + } + } + } + + if let Ok(cargo_home) = home::cargo_home() { + for name in &["config", "config.toml"] { + let config_path = cargo_home.join(name); + if config_path.is_file() + && let Some((t, cp)) = check_config(&config_path) + { + if token.is_none() { + token = t; + } + if credential_provider.is_none() { + credential_provider = cp; + } + } + } + } + + (token, credential_provider) +} + +fn run_credential_command(cmd: &str) -> Option { + let parts: Vec<&str> = cmd.split_whitespace().collect(); + if parts.is_empty() { + return None; + } + let output = std::process::Command::new(parts[0]) + .args(&parts[1..]) + .output() + .ok()?; + if output.status.success() { + let token = String::from_utf8(output.stdout).ok()?.trim().to_owned(); + if !token.is_empty() { + return Some(token); + } + } + None } mod code_from_cargo { @@ -138,3 +343,356 @@ mod code_from_cargo { DefaultBranch, } } + +#[cfg(test)] +mod tests { + use super::*; + use std::fs; + use tempfile::TempDir; + + fn create_project_with_config(config_content: &str) -> TempDir { + let dir = TempDir::new().unwrap(); + let cargo_dir = dir.path().join(".cargo"); + fs::create_dir_all(&cargo_dir).unwrap(); + fs::write(cargo_dir.join("config.toml"), config_content).unwrap(); + // Create a fake CARGO_HOME inside the temp dir to avoid reading + // the real ~/.cargo/config.toml + let fake_cargo_home = dir.path().join("fake-cargo-home"); + fs::create_dir_all(&fake_cargo_home).unwrap(); + fs::write( + dir.path().join("Cargo.toml"), + r#"[package] +name = "test" +version = "0.1.0" +edition = "2021" + +[dependencies] +"#, + ) + .unwrap(); + dir + } + + #[test] + fn test_read_config_auth_reads_token_from_config() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer my-secret-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + let (token, credential_provider) = read_config_auth(&manifest_path, "my-registry"); + assert_eq!(token, Some("Bearer my-secret-token".to_owned())); + assert_eq!(credential_provider, None); + } + + #[test] + fn test_read_config_auth_reads_credential_provider() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +credential-provider = "cargo:token-from-stdout echo my-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + let (token, credential_provider) = read_config_auth(&manifest_path, "my-registry"); + assert_eq!(token, None); + assert_eq!( + credential_provider, + Some("cargo:token-from-stdout echo my-token".to_owned()) + ); + } + + #[test] + fn test_read_config_auth_reads_both_token_and_provider() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer fallback-token" +credential-provider = "cargo:token-from-stdout echo my-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + let (token, credential_provider) = read_config_auth(&manifest_path, "my-registry"); + assert_eq!(token, Some("Bearer fallback-token".to_owned())); + assert_eq!( + credential_provider, + Some("cargo:token-from-stdout echo my-token".to_owned()) + ); + } + + #[test] + fn test_read_config_auth_returns_none_for_unknown_registry() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer my-secret-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + let (token, credential_provider) = read_config_auth(&manifest_path, "other-registry"); + assert_eq!(token, None); + assert_eq!(credential_provider, None); + } + + #[test] + fn test_run_credential_command_success() { + let token = run_credential_command("echo hello-token"); + assert_eq!(token, Some("hello-token".to_owned())); + } + + #[test] + fn test_run_credential_command_failure() { + let token = run_credential_command("false"); + assert_eq!(token, None); + } + + #[test] + fn test_run_credential_command_not_found() { + let token = run_credential_command("nonexistent-command-12345"); + assert_eq!(token, None); + } + + #[test] + fn test_run_credential_command_empty_output() { + let token = run_credential_command("echo"); + assert_eq!(token, None); + } + + #[test] + fn test_resolve_registry_name_with_source_replacement() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" + +[source.crates-io] +replace-with = "my-registry" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + let name = resolve_registry_name(&manifest_path, None); + assert_eq!(name, Some("my-registry".to_owned())); + } + + #[test] + fn test_resolve_registry_name_explicit_registry() { + let dir = create_project_with_config(""); + let manifest_path = dir.path().join("Cargo.toml"); + let name = resolve_registry_name(&manifest_path, Some("custom-reg")); + assert_eq!(name, Some("custom-reg".to_owned())); + } + + #[test] + fn test_registry_token_from_env_var() { + let dir = create_project_with_config( + r#" +[registries.envtest-reg1] +index = "sparse+https://example.com/cargo/envtest-reg1/" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only, not run in parallel with other env var tests + unsafe { + std::env::set_var("CARGO_REGISTRIES_ENVTEST_REG1_TOKEN", "Bearer env-token"); + } + let token = registry_token(&manifest_path, Some("envtest-reg1")); + unsafe { + std::env::remove_var("CARGO_REGISTRIES_ENVTEST_REG1_TOKEN"); + } + + assert_eq!(token, Some("Bearer env-token".to_owned())); + } + + #[test] + fn test_registry_token_from_credential_provider() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +credential-provider = "cargo:token-from-stdout echo test-credential-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::remove_var("CARGO_REGISTRIES_MY_REGISTRY_TOKEN"); + } + let token = registry_token(&manifest_path, Some("my-registry")); + + assert_eq!(token, Some("test-credential-token".to_owned())); + } + + #[test] + fn test_registry_token_from_config_token_field() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer config-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::remove_var("CARGO_REGISTRIES_MY_REGISTRY_TOKEN"); + } + let token = registry_token(&manifest_path, Some("my-registry")); + + assert_eq!(token, Some("Bearer config-token".to_owned())); + } + + #[test] + fn test_registry_token_env_var_takes_precedence() { + let dir = create_project_with_config( + r#" +[registries.envtest-reg2] +index = "sparse+https://example.com/cargo/envtest-reg2/" +token = "Bearer config-token" +credential-provider = "cargo:token-from-stdout echo provider-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::set_var("CARGO_REGISTRIES_ENVTEST_REG2_TOKEN", "Bearer env-token"); + } + let token = registry_token(&manifest_path, Some("envtest-reg2")); + unsafe { + std::env::remove_var("CARGO_REGISTRIES_ENVTEST_REG2_TOKEN"); + } + + assert_eq!(token, Some("Bearer env-token".to_owned())); + } + + #[test] + fn test_registry_token_credential_provider_takes_precedence_over_config_token() { + let dir = create_project_with_config( + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer config-token" +credential-provider = "cargo:token-from-stdout echo provider-token" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::remove_var("CARGO_REGISTRIES_MY_REGISTRY_TOKEN"); + } + let token = registry_token(&manifest_path, Some("my-registry")); + + assert_eq!(token, Some("provider-token".to_owned())); + } + + #[test] + fn test_registry_token_with_source_replacement() { + let dir = create_project_with_config( + r#" +[registries.private-reg] +index = "sparse+https://example.com/cargo/private-reg/" +credential-provider = "cargo:token-from-stdout echo replaced-token" + +[source.crates-io] +replace-with = "private-reg" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::remove_var("CARGO_REGISTRIES_PRIVATE_REG_TOKEN"); + } + let token = registry_token(&manifest_path, None); + + assert_eq!(token, Some("replaced-token".to_owned())); + } + + #[test] + fn test_read_config_auth_local_takes_precedence_over_parent() { + let dir = TempDir::new().unwrap(); + + // Create a parent .cargo/config.toml with one token + let parent_cargo_dir = dir.path().join(".cargo"); + fs::create_dir_all(&parent_cargo_dir).unwrap(); + fs::write( + parent_cargo_dir.join("config.toml"), + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer parent-token" +credential-provider = "cargo:token-from-stdout echo parent-provider-token" +"#, + ) + .unwrap(); + + // Create a child project with its own .cargo/config.toml + let child_dir = dir.path().join("child"); + let child_cargo_dir = child_dir.join(".cargo"); + fs::create_dir_all(&child_cargo_dir).unwrap(); + fs::write( + child_cargo_dir.join("config.toml"), + r#" +[registries.my-registry] +index = "sparse+https://example.com/cargo/my-registry/" +token = "Bearer child-token" +credential-provider = "cargo:token-from-stdout echo child-provider-token" +"#, + ) + .unwrap(); + fs::write( + child_dir.join("Cargo.toml"), + r#"[package] +name = "test" +version = "0.1.0" +edition = "2021" + +[dependencies] +"#, + ) + .unwrap(); + + let manifest_path = child_dir.join("Cargo.toml"); + let (token, credential_provider) = read_config_auth(&manifest_path, "my-registry"); + assert_eq!(token, Some("Bearer child-token".to_owned())); + assert_eq!( + credential_provider, + Some("cargo:token-from-stdout echo child-provider-token".to_owned()) + ); + } + + #[test] + fn test_registry_token_hyphenated_name_env_var() { + let dir = create_project_with_config( + r#" +[registries.envtest-hyph-reg] +index = "sparse+https://example.com/cargo/envtest-hyph-reg/" +"#, + ); + let manifest_path = dir.path().join("Cargo.toml"); + + // SAFETY: test-only + unsafe { + std::env::set_var( + "CARGO_REGISTRIES_ENVTEST_HYPH_REG_TOKEN", + "Bearer hyphen-token", + ); + } + let token = registry_token(&manifest_path, Some("envtest-hyph-reg")); + unsafe { + std::env::remove_var("CARGO_REGISTRIES_ENVTEST_HYPH_REG_TOKEN"); + } + + assert_eq!(token, Some("Bearer hyphen-token".to_owned())); + } +} From aeb5df1f976f32cc6ca7b1f1ec233937bf267450 Mon Sep 17 00:00:00 2001 From: r0wdiggity Date: Fri, 15 May 2026 13:45:26 -0500 Subject: [PATCH 2/2] fix existing clippy errors --- Cargo.toml | 2 +- src/bin/upgrade/upgrade.rs | 12 +++++++----- src/registry.rs | 12 +++--------- 3 files changed, 11 insertions(+), 15 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 4cdc938d45..27a9d368b7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -129,7 +129,7 @@ create_dir = "warn" dbg_macro = "warn" debug_assert_with_mut_call = "warn" doc_markdown = "warn" -empty_enum = "warn" +empty_enums = "warn" enum_glob_use = "warn" expl_impl_clone_on_copy = "warn" explicit_deref_methods = "warn" diff --git a/src/bin/upgrade/upgrade.rs b/src/bin/upgrade/upgrade.rs index 8ff6be4695..fc478314b7 100644 --- a/src/bin/upgrade/upgrade.rs +++ b/src/bin/upgrade/upgrade.rs @@ -225,7 +225,8 @@ fn exec(args: UpgradeArgs) -> CargoResult<()> { let mut pinned_present = false; let mut incompatible_present = false; let mut uninteresting_crates = BTreeSet::new(); - let mut token_cache: std::collections::HashMap> = std::collections::HashMap::new(); + let mut token_cache: std::collections::HashMap> = + std::collections::HashMap::new(); for (pkg_name, manifest_path, rust_version) in manifests { let mut manifest = LocalManifest::try_new(&manifest_path)?; let mut crate_modified = false; @@ -306,10 +307,11 @@ fn exec(args: UpgradeArgs) -> CargoResult<()> { // Update indices for any alternative registries, unless // we're offline. let registry_url = registry_url(&manifest_path, dependency.registry())?; - let cache_key = format!("{}:{:?}", manifest_path.display(), dependency.registry()); - let token = token_cache.entry(cache_key).or_insert_with(|| { - registry_token(&manifest_path, dependency.registry()) - }); + let cache_key = + format!("{}:{:?}", manifest_path.display(), dependency.registry()); + let token = token_cache + .entry(cache_key) + .or_insert_with(|| registry_token(&manifest_path, dependency.registry())); if let Some(token) = token { index.set_token(®istry_url, token.clone()); } diff --git a/src/registry.rs b/src/registry.rs index 7ec261bf8c..c8b0b44022 100644 --- a/src/registry.rs +++ b/src/registry.rs @@ -123,7 +123,7 @@ struct Registry { } /// Resolve the auth token for a registry by checking (in order): -/// 1. Environment variable CARGO_REGISTRIES__TOKEN +/// 1. Environment variable `CARGO_REGISTRIES__TOKEN` /// 2. credentials.toml /// 3. credential-provider command (cargo:token-from-stdout) /// 4. token field in config.toml @@ -220,10 +220,7 @@ fn read_all_configs(manifest_path: &Path) -> HashMap { sources } -fn read_sources_from_config( - sources: &mut HashMap, - path: &Path, -) -> CargoResult<()> { +fn read_sources_from_config(sources: &mut HashMap, path: &Path) -> CargoResult<()> { let content = std::fs::read_to_string(path)?; let config = toml::from_str::(&content) .with_context(|| anyhow::format_err!("invalid cargo config at {}", path.display()))?; @@ -251,10 +248,7 @@ fn read_credentials_token(registry_name: &str) -> Option { None } -fn read_config_auth( - manifest_path: &Path, - registry_name: &str, -) -> (Option, Option) { +fn read_config_auth(manifest_path: &Path, registry_name: &str) -> (Option, Option) { let mut token = None; let mut credential_provider = None;