Support reading relative paths from Cargo config (#91)

### Checklist

* [x] I have read the [Contributor Guide](../blob/main/CONTRIBUTING.md)
* [x] I have read and agree to the [Code of
Conduct](../blob/main/CODE_OF_CONDUCT.md)
* [x] I have added a description of my changes and why I'd like them
included in the section below

### Description of Changes

Improved handling of source replacement configuration to closer match
what Cargo does.

Author: kornelski

src/index/location.rs

@@ -57,9 +57,12 @@ impl<'iu> IndexUrl<'iu> {
     ) -> 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_source_replacement(config_root.clone(), cargo_home, "crates-io")?
-        {
+        if let Some(replacement) = get_source_replacement(
+            config_root.clone(),
+            cargo_home,
+            crate::CRATES_IO_INDEX,
+            "crates-io",
+        )? {
             return Ok(replacement);
         }
 
@@ -70,17 +73,16 @@ impl<'iu> IndexUrl<'iu> {
             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,
-                        }
-                    })?;
+                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
@@ -144,20 +146,22 @@ impl<'iu> IndexUrl<'iu> {
             }
         }
 
-        if let Some(replacement) =
-            get_source_replacement(config_root.clone(), cargo_home, registry_name)?
-        {
+        let registry_url = read_cargo_config(config_root.clone(), cargo_home, |_, config| {
+            let path = format!("/registries/{registry_name}/index");
+            config.pointer(&path)?.as_str().map(String::from)
+        })?
+        .ok_or_else(|| Error::UnknownRegistry(registry_name.into()))?;
+
+        if let Some(replacement) = get_source_replacement(
+            config_root.clone(),
+            cargo_home,
+            &registry_url,
+            registry_name,
+        )? {
             return Ok(replacement);
         }
 
-        read_cargo_config(config_root, cargo_home, |config| {
-            let path = format!("/registries/{registry_name}/index");
-            config
-                .pointer(&path)?
-                .as_str()
-                .map(|si| Self::NonCratesIo(si.to_owned().into()))
-        })?
-        .ok_or_else(|| Error::UnknownRegistry(registry_name.into()))
+        Ok(Self::NonCratesIo(registry_url.into()))
     }
 }
 
@@ -268,7 +272,7 @@ impl<'il> IndexLocation<'il> {
 pub(crate) fn read_cargo_config<T>(
     root: Option<PathBuf>,
     cargo_home: Option<&Path>,
-    callback: impl Fn(&toml_span::value::Value<'_>) -> Option<T>,
+    callback: impl Fn(&Path, &toml_span::value::Value<'_>) -> Option<T>,
 ) -> Result<Option<T>, Error> {
     if let Some(mut path) = root.or_else(|| {
         std::env::current_dir()
@@ -284,7 +288,7 @@ pub(crate) fn read_cargo_config<T>(
                 };
 
                 let toml = toml_span::parse(&contents).map_err(Box::new)?;
-                if let Some(value) = callback(&toml) {
+                if let Some(value) = callback(&path, &toml) {
                     return Ok(Some(value));
                 }
             }
@@ -306,7 +310,7 @@ pub(crate) fn read_cargo_config<T>(
         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) {
+            if let Some(value) = callback(&path, &toml) {
                 return Ok(Some(value));
             }
         }
@@ -322,20 +326,30 @@ pub(crate) fn read_cargo_config<T>(
 pub(crate) fn get_source_replacement<'iu>(
     root: Option<PathBuf>,
     cargo_home: Option<&Path>,
+    registry_url: &str,
     registry_name: &str,
 ) -> Result<Option<IndexUrl<'iu>>, Error> {
-    read_cargo_config(root, cargo_home, |config| {
-        let path = format!("/source/{registry_name}/replace-with");
-        let repw = config.pointer(&path)?.as_str()?;
+    read_cargo_config(root, cargo_home, |config_path, config| {
+        let sources = config.as_table()?.get("source")?.as_table()?;
+        let repw = sources.iter().find_map(|(source_name, source)| {
+            let source = source.as_table()?;
+
+            let matches = registry_name == source_name.name
+                || registry_url == source.get("registry")?.as_str()?;
+            matches.then_some(source.get("replace-with")?.as_str()?)
+        })?;
+
         let sources = config.pointer("/source")?.as_table()?;
         let replace_src = sources.get(repw)?.as_table()?;
 
         if let Some(rr) = replace_src.get("registry") {
             rr.as_str()
                 .map(|r| IndexUrl::NonCratesIo(r.to_owned().into()))
         } else if let Some(rlr) = replace_src.get("local-registry") {
-            rlr.as_str()
-                .map(|l| IndexUrl::Local(PathBuf::from(l).into()))
+            let rel_path = rlr.as_str()?;
+            Some(IndexUrl::Local(
+                config_path.parent()?.parent()?.join(rel_path).into(),
+            ))
         } else {
             None
         }

tests/local.rs

@@ -156,3 +156,52 @@ fn downloads_and_verifies() {
         .unwrap()
     );
 }
+
+#[test]
+fn finds_source_replacement() {
+    let td = tempfile::tempdir().unwrap();
+    let cfg_toml = td.path().join(".cargo/config.toml");
+    std::fs::create_dir_all(cfg_toml.parent().unwrap()).unwrap();
+    std::fs::write(
+        &cfg_toml,
+        r#"
+[registries.imaginary-registry]
+credential-provider = ["cargo:token"]
+index = "sparse+https://imaginary-registry.example.net/index/"
+
+[source._real_cargo_ignores_this_]
+registry = "sparse+https://imaginary-registry.example.net/index/"
+replace-with = "actual-registry-on-disk"
+
+[source.actual-registry-on-disk]
+local-registry = "test-local-registry"
+"#,
+    )
+    .unwrap();
+
+    let meta_path = td
+        .path()
+        .join("test-local-registry/index/ex/am/example-dependency");
+    std::fs::create_dir_all(meta_path.parent().unwrap()).unwrap();
+    std::fs::write(&meta_path, r#"{"name":"example-dependency","vers":"2.0.0","deps":[],"cksum":"a89f6827d6042043aa77282b091280d2ebb47365e3ff097d07f45b5a797dff63","features":{},"yanked":false}"#).unwrap();
+
+    let subdir = td.path().join("test-subdirectory");
+    std::fs::create_dir_all(&subdir).unwrap();
+
+    let url = tame_index::IndexUrl::for_registry_name(
+        Some(subdir.try_into().unwrap()),
+        None,
+        "imaginary-registry",
+    )
+    .unwrap();
+
+    assert!(matches!(url, tame_index::IndexUrl::Local(_)));
+    let index =
+        tame_index::index::ComboIndexCache::new(tame_index::IndexLocation::new(url)).unwrap();
+    let lock = tame_index::utils::flock::FileLock::unlocked();
+    let krate = index
+        .cached_krate("example-dependency".try_into().unwrap(), &lock)
+        .unwrap()
+        .unwrap();
+    assert_eq!("2.0.0", krate.versions[0].version);
+}