Clone but do not checkout repositories

Author: smoelius

Cargo.lock

@@ -27,7 +27,6 @@ sha1_smol = { version = "1.0", features = ["std"] }
 tempfile = "3.14"
 termcolor = "1.4"
 toml = "0.8"
-walkdir = "2.5"
 
 [target.'cfg(unix)'.dependencies]
 libc = { version = "0.2", optional = true }

Cargo.toml

@@ -14,18 +14,17 @@ use std::{
     collections::{HashMap, HashSet},
     env::args,
     ffi::OsStr,
-    fs::{read_to_string, File},
-    io::IsTerminal,
+    fs::File,
+    io::{BufRead, IsTerminal},
     path::{Path, PathBuf},
-    process::{exit, Command},
+    process::{exit, Command, Stdio},
     str::FromStr,
     sync::atomic::{AtomicBool, Ordering},
     time::{Duration, SystemTime},
 };
 use tempfile::TempDir;
 use termcolor::{ColorChoice, ColorSpec, StandardStream, WriteColor};
 use toml::{Table, Value};
-use walkdir::WalkDir;
 
 mod curl;
 mod flush;
@@ -809,14 +808,30 @@ fn clone_repository(pkg: &Package, purpose: Purpose) -> Result<RepoStatus<PathBu
     }
 }
 
+const LINE_PREFIX: &str = "D  ";
+
 fn membership_in_clone(pkg: &Package, repo_dir: &Path) -> Result<bool> {
-    for entry in WalkDir::new(repo_dir) {
-        let entry = entry?;
-        let path = entry.path();
+    let mut command = Command::new("git");
+    command.args(["status", "--porcelain"]);
+    command.current_dir(repo_dir);
+    command.stdout(Stdio::piped());
+    let mut child = command
+        .spawn()
+        .with_context(|| format!("command failed: {command:?}"))?;
+    #[allow(clippy::unwrap_used)]
+    let stdout = child.stdout.take().unwrap();
+    let reader = std::io::BufReader::new(stdout);
+    for result in reader.lines() {
+        let line = result.with_context(|| format!("failed to read `{}`", repo_dir.display()))?;
+        #[allow(clippy::panic)]
+        let path = line.strip_prefix(LINE_PREFIX).map_or_else(
+            || panic!("cache is corrupt at `{}`", repo_dir.display()),
+            Path::new,
+        );
         if path.file_name() != Some(OsStr::new("Cargo.toml")) {
             continue;
         }
-        let contents = read_to_string(path).with_context(|| format!("failed to read {path:?}"))?;
+        let contents = show(repo_dir, path)?;
         let Ok(table) = contents.parse::<Table>()
         /* smoelius: This "failed to parse" warning is a little too noisy.
         .map_err(|error| {
@@ -843,6 +858,26 @@ fn membership_in_clone(pkg: &Package, repo_dir: &Path) -> Result<bool> {
     Ok(false)
 }
 
+fn show(repo_dir: &Path, path: &Path) -> Result<String> {
+    let mut command = Command::new("git");
+    command.args(["show", &format!("HEAD:{}", path.display())]);
+    command.current_dir(repo_dir);
+    command.stdout(Stdio::piped());
+    let output = command
+        .output()
+        .with_context(|| format!("failed to run command: {command:?}"))?;
+    if !output.status.success() {
+        let error = String::from_utf8(output.stderr)?;
+        bail!(
+            "failed to read `{}` in `{}`: {}",
+            path.display(),
+            repo_dir.display(),
+            error
+        );
+    }
+    String::from_utf8(output.stdout).map_err(Into::into)
+}
+
 fn display_unmaintained_pkgs(unmaintained_pkgs: &[UnmaintainedPkg]) -> Result<()> {
     let mut pkgs_needing_warning = Vec::new();
     let mut at_least_one_newer_version_is_available = false;

src/main.rs

@@ -23,10 +23,10 @@
 //!
 //! A similar statement applies to versions.
 //!
-//! The on-disk cache resides at `$HOME/.cache/cargo-unmaintained/v1`.
+//! The on-disk cache resides at `$HOME/.cache/cargo-unmaintained/v2`.
 
 use super::{urls, SECS_PER_DAY};
-use anyhow::{anyhow, ensure, Context, Result};
+use anyhow::{anyhow, bail, ensure, Context, Result};
 use cargo_metadata::Package;
 use crates_io_api::{SyncClient, Version};
 use once_cell::{sync::Lazy, unsync::OnceCell};
@@ -72,7 +72,7 @@ thread_local! {
 static CACHE_DIRECTORY: Lazy<PathBuf> = Lazy::new(|| {
     let base_directories = xdg::BaseDirectories::new().unwrap();
     base_directories
-        .create_cache_directory("cargo-unmaintained/v1")
+        .create_cache_directory("cargo-unmaintained/v2")
         .unwrap()
 });
 
@@ -170,15 +170,23 @@ impl Cache {
             let repo_dir = self.repositories_dir().join(url_digest(url.as_str()));
             let exists = repository_existence(&repo_dir)?;
             let mut command = if exists {
+                let branch_name = branch_name(&repo_dir)?;
                 let mut command = Command::new("git");
-                command.args(["pull", "--ff-only"]);
+                command.args([
+                    "fetch",
+                    "--update-head-ok",
+                    "origin",
+                    &format!("{branch_name}:{branch_name}"),
+                ]);
                 command.current_dir(&repo_dir);
                 command
             } else {
                 let mut command = Command::new("git");
+                // smoelius: The full repository is no longer checked out.
                 command.args([
                     "clone",
                     "--depth=1",
+                    "--no-checkout",
                     "--quiet",
                     url.as_str(),
                     &repo_dir.to_string_lossy(),
@@ -379,3 +387,22 @@ fn repository_existence(repo_dir: &Path) -> Result<bool> {
         )
     })
 }
+
+fn branch_name(repo_dir: &Path) -> Result<String> {
+    let mut command = Command::new("git");
+    command.args(["rev-parse", "--abbrev-ref", "HEAD"]);
+    command.current_dir(repo_dir);
+    let output = command
+        .output()
+        .with_context(|| format!("failed to run command: {command:?}"))?;
+    if !output.status.success() {
+        let error = String::from_utf8(output.stderr)?;
+        bail!(
+            "failed to get `{}` branch name: {}",
+            repo_dir.display(),
+            error
+        );
+    }
+    let stdout = std::str::from_utf8(&output.stdout)?;
+    Ok(stdout.trim_end().to_owned())
+}