| //! Helpers for initializing the remote and local disk location of an index |
| |
| use crate::{Error, Path, PathBuf}; |
| use std::borrow::Cow; |
| |
| /// A remote index url |
| #[derive(Default, Debug)] |
| pub enum IndexUrl<'iu> { |
| /// The canonical crates.io HTTP sparse index. |
| /// |
| /// See [`crate::CRATES_IO_HTTP_INDEX`] |
| #[default] |
| CratesIoSparse, |
| /// The canonical crates.io git index. |
| /// |
| /// See [`crate::CRATES_IO_INDEX`] |
| CratesIoGit, |
| /// A non-crates.io index. |
| /// |
| /// This variant uses the url to determine the index kind (sparse or git) by |
| /// inspecting the url's scheme. This is because sparse indices are required |
| /// to have the `sparse+` scheme modifier |
| NonCratesIo(Cow<'iu, str>), |
| /// A [local registry](crate::index::LocalRegistry) |
| Local(Cow<'iu, Path>), |
| } |
| |
| impl<'iu> IndexUrl<'iu> { |
| /// Gets the url as a string |
| pub fn as_str(&'iu self) -> &'iu str { |
| match self { |
| Self::CratesIoSparse => crate::CRATES_IO_HTTP_INDEX, |
| Self::CratesIoGit => crate::CRATES_IO_INDEX, |
| Self::NonCratesIo(url) => url, |
| Self::Local(pb) => pb.as_str(), |
| } |
| } |
| |
| /// Returns true if the url points to a sparse registry |
| pub fn is_sparse(&self) -> bool { |
| match self { |
| Self::CratesIoSparse => true, |
| Self::CratesIoGit | Self::Local(..) => false, |
| Self::NonCratesIo(url) => url.starts_with("sparse+http"), |
| } |
| } |
| |
| /// Gets the [`IndexUrl`] for crates.io, depending on the local environment. |
| /// |
| /// 1. Determines if the crates.io registry has been [replaced](https://doc.rust-lang.org/cargo/reference/source-replacement.html) |
| /// 2. Determines if the protocol was explicitly [configured](https://doc.rust-lang.org/cargo/reference/config.html#registriescrates-ioprotocol) by the user |
| /// 3. Otherwise, detects the version of cargo (see [`crate::utils::cargo_version`]), and uses that to determine the appropriate default |
| pub fn crates_io( |
| config_root: Option<PathBuf>, |
| cargo_home: Option<&Path>, |
| cargo_version: Option<&str>, |
| ) -> Result<Self, Error> { |
| // If the crates.io registry has been replaced it doesn't matter what |
| // the protocol for it has been changed to |
| if let Some(replacement) = get_crates_io_replacement(config_root.clone(), cargo_home)? { |
| return Ok(replacement); |
| } |
| |
| let sparse_index = match std::env::var("CARGO_REGISTRIES_CRATES_IO_PROTOCOL") |
| .ok() |
| .as_deref() |
| { |
| Some("sparse") => true, |
| Some("git") => false, |
| _ => { |
| let sparse_index = |
| read_cargo_config(config_root, cargo_home, |config| { |
| match config |
| .pointer("/registries/crates-io/protocol") |
| .and_then(|p| p.as_str())? |
| { |
| "sparse" => Some(true), |
| "git" => Some(false), |
| _ => None, |
| } |
| })?; |
| |
| if let Some(si) = sparse_index { |
| si |
| } else { |
| let vers = match cargo_version { |
| Some(v) => v.trim().parse()?, |
| None => crate::utils::cargo_version(None)?, |
| }; |
| |
| vers >= semver::Version::new(1, 70, 0) |
| } |
| } |
| }; |
| |
| Ok(if sparse_index { |
| Self::CratesIoSparse |
| } else { |
| Self::CratesIoGit |
| }) |
| } |
| } |
| |
| impl<'iu> From<&'iu str> for IndexUrl<'iu> { |
| #[inline] |
| fn from(s: &'iu str) -> Self { |
| Self::NonCratesIo(s.into()) |
| } |
| } |
| |
| /// The local disk location to place an index |
| #[derive(Default)] |
| pub enum IndexPath { |
| /// The default cargo home root path |
| #[default] |
| CargoHome, |
| /// User-specified root path |
| UserSpecified(PathBuf), |
| /// An exact path on disk where an index is located. |
| /// |
| /// Unlike the other two variants, this variant won't take the index's url |
| /// into account to calculate the unique url hash as part of the full path |
| Exact(PathBuf), |
| } |
| |
| impl From<Option<PathBuf>> for IndexPath { |
| /// Converts an optional path to a rooted path. |
| /// |
| /// This never constructs a [`Self::Exact`], that can only be done explicitly |
| fn from(pb: Option<PathBuf>) -> Self { |
| if let Some(pb) = pb { |
| Self::UserSpecified(pb) |
| } else { |
| Self::CargoHome |
| } |
| } |
| } |
| |
| /// Helper for constructing an index location, consisting of the remote url for |
| /// the index and the local location on disk |
| #[derive(Default)] |
| pub struct IndexLocation<'il> { |
| /// The remote url of the registry index |
| pub url: IndexUrl<'il>, |
| /// The local disk path of the index |
| pub root: IndexPath, |
| } |
| |
| impl<'il> IndexLocation<'il> { |
| /// Constructs an index with the specified url located in the default cargo |
| /// home |
| pub fn new(url: IndexUrl<'il>) -> Self { |
| Self { |
| url, |
| root: IndexPath::CargoHome, |
| } |
| } |
| |
| /// Changes the root location of the index on the local disk. |
| /// |
| /// If not called, or set to [`None`], the default cargo home disk location |
| /// is used as the root |
| pub fn with_root(mut self, root: Option<PathBuf>) -> Self { |
| self.root = root.into(); |
| self |
| } |
| |
| /// Obtains the full local disk path and URL of this index location |
| pub fn into_parts(self) -> Result<(PathBuf, String), Error> { |
| let url = self.url.as_str(); |
| |
| let root = match self.root { |
| IndexPath::CargoHome => crate::utils::cargo_home()?, |
| IndexPath::UserSpecified(root) => root, |
| IndexPath::Exact(path) => return Ok((path, url.to_owned())), |
| }; |
| |
| let (path, mut url) = crate::utils::get_index_details(url, Some(root))?; |
| |
| if !url.ends_with('/') { |
| url.push('/'); |
| } |
| |
| Ok((path, url)) |
| } |
| } |
| |
| /// Calls the specified function for each cargo config located according to |
| /// cargo's standard hierarchical structure |
| /// |
| /// Note that this only supports the use of `.cargo/config.toml`, which is not |
| /// supported below cargo 1.39.0 |
| /// |
| /// See <https://doc.rust-lang.org/cargo/reference/config.html#hierarchical-structure> |
| pub(crate) fn read_cargo_config<T>( |
| root: Option<PathBuf>, |
| cargo_home: Option<&Path>, |
| callback: impl Fn(&toml_span::value::Value<'_>) -> Option<T>, |
| ) -> Result<Option<T>, Error> { |
| if let Some(mut path) = root.or_else(|| { |
| std::env::current_dir() |
| .ok() |
| .and_then(|pb| PathBuf::from_path_buf(pb).ok()) |
| }) { |
| loop { |
| path.push(".cargo/config.toml"); |
| if path.exists() { |
| let contents = match std::fs::read_to_string(&path) { |
| Ok(c) => c, |
| Err(err) => return Err(Error::IoPath(err, path)), |
| }; |
| |
| let toml = toml_span::parse(&contents).map_err(Box::new)?; |
| if let Some(value) = callback(&toml) { |
| return Ok(Some(value)); |
| } |
| } |
| path.pop(); |
| path.pop(); |
| |
| // Walk up to the next potential config root |
| if !path.pop() { |
| break; |
| } |
| } |
| } |
| |
| if let Some(home) = cargo_home |
| .map(Cow::Borrowed) |
| .or_else(|| crate::utils::cargo_home().ok().map(Cow::Owned)) |
| { |
| let path = home.join("config.toml"); |
| if path.exists() { |
| let fc = std::fs::read_to_string(&path)?; |
| let toml = toml_span::parse(&fc).map_err(Box::new)?; |
| if let Some(value) = callback(&toml) { |
| return Ok(Some(value)); |
| } |
| } |
| } |
| |
| Ok(None) |
| } |
| |
| /// Gets the url of a replacement registry for crates.io if one has been configured |
| /// |
| /// See <https://doc.rust-lang.org/cargo/reference/source-replacement.html> |
| #[inline] |
| pub(crate) fn get_crates_io_replacement<'iu>( |
| root: Option<PathBuf>, |
| cargo_home: Option<&Path>, |
| ) -> Result<Option<IndexUrl<'iu>>, Error> { |
| read_cargo_config(root, cargo_home, |config| { |
| let repw = config.pointer("/source/crates-io/replace-with")?.as_str()?; |
| let sources = config.pointer("/source")?.as_table()?; |
| let replace_src = sources.get(&repw.into())?.as_table()?; |
| |
| if let Some(rr) = replace_src.get(&"registry".into()) { |
| rr.as_str() |
| .map(|r| IndexUrl::NonCratesIo(r.to_owned().into())) |
| } else if let Some(rlr) = replace_src.get(&"local-registry".into()) { |
| rlr.as_str() |
| .map(|l| IndexUrl::Local(PathBuf::from(l).into())) |
| } else { |
| None |
| } |
| }) |
| } |
| |
| #[cfg(test)] |
| mod test { |
| // Current stable is 1.70.0 |
| #[test] |
| fn opens_sparse() { |
| assert!(std::env::var_os("CARGO_REGISTRIES_CRATES_IO_PROTOCOL").is_none()); |
| assert!(matches!( |
| crate::index::ComboIndexCache::new(super::IndexLocation::new( |
| super::IndexUrl::crates_io(None, None, None).unwrap() |
| )) |
| .unwrap(), |
| crate::index::ComboIndexCache::Sparse(_) |
| )); |
| } |
| |
| /// Verifies we can parse .cargo/config.toml files to either use the crates-io |
| /// protocol set, or source replacements |
| #[test] |
| fn parses_from_file() { |
| assert!(std::env::var_os("CARGO_REGISTRIES_CRATES_IO_PROTOCOL").is_none()); |
| |
| let td = tempfile::tempdir().unwrap(); |
| let root = crate::PathBuf::from_path_buf(td.path().to_owned()).unwrap(); |
| let cfg_toml = td.path().join(".cargo/config.toml"); |
| |
| std::fs::create_dir_all(cfg_toml.parent().unwrap()).unwrap(); |
| |
| const GIT: &str = r#"[registries.crates-io] |
| protocol = "git" |
| "#; |
| |
| // First just set the protocol from the sparse default to git |
| std::fs::write(&cfg_toml, GIT).unwrap(); |
| |
| let iurl = super::IndexUrl::crates_io(Some(root.clone()), None, None).unwrap(); |
| assert_eq!(iurl.as_str(), crate::CRATES_IO_INDEX); |
| assert!(!iurl.is_sparse()); |
| |
| // Next set replacement registries |
| for (i, (kind, url)) in [ |
| ( |
| "registry", |
| "sparse+https://sparse-registry-parses-from-file.com", |
| ), |
| ("registry", "https://sparse-registry-parses-from-file.git"), |
| ("local-registry", root.as_str()), |
| ] |
| .iter() |
| .enumerate() |
| { |
| std::fs::write(&cfg_toml, format!("{GIT}\n[source.crates-io]\nreplace-with = 'replacement'\n[source.replacement]\n{kind} = '{url}'")).unwrap(); |
| |
| let iurl = super::IndexUrl::crates_io(Some(root.clone()), None, None).unwrap(); |
| assert_eq!(i == 0, iurl.is_sparse()); |
| assert_eq!(iurl.as_str(), *url); |
| } |
| } |
| } |
