3ade4a7 radicle: Handle `GIT_DIR` more uniformly — heartwood

modified crates/radicle-cli/src/commands/patch/checkout.rs

@@ -125,14 +125,26 @@ fn find_patch_commit<'a>(

     working: &'a git::raw::Repository,
 ) -> anyhow::Result<git::raw::Commit<'a>> {
     let head = *revision.head();
     let workdir = working
         .workdir()
         .ok_or(anyhow::anyhow!("repository is a bare git repository "))?;
     match working.find_commit(head) {
         Ok(commit) => Ok(commit),
         Err(e) if git::ext::is_not_found_err(&e) => {
             git::process::fetch_local(workdir, stored, [head.into()], git::Verbosity::default())?;
             let output = git::process::fetch_local(
                 Some(working.path()),
                 stored,
                 [head.into()],
                 git::Verbosity::default(),
             )?;
             if !output.status.success() {
                 anyhow::bail!(
                     "`git fetch` exited with status {}, stderr and stdout follow:\n{}\n{}\n",
                     output.status,
                     String::from_utf8_lossy(&output.stderr),
                     String::from_utf8_lossy(&output.stdout)
                 );
             }
             working.find_commit(head).map_err(|e| e.into())
         }
         Err(e) => Err(e.into()),

modified crates/radicle-cli/src/git.rs

@@ -137,7 +137,7 @@ pub fn git<S: AsRef<std::ffi::OsStr>>(

     repo: &std::path::Path,
     args: impl IntoIterator<Item = S>,
 ) -> anyhow::Result<std::process::Output> {
     let output = radicle::git::run::<_, _, &str, &str>(repo, args, [])?;
     let output = radicle::git::run(Some(repo), args)?;
     if !output.status.success() {
         anyhow::bail!(

modified crates/radicle-remote-helper/src/fetch.rs

@@ -63,7 +63,7 @@ pub fn run<R: ReadRepository>(

     // used in the working copy, this will always result in the object
     // missing. This seems to only be an issue with `libgit2`/`git2`
     // and not `git` itself.
     git::process::fetch_local(working, &stored, oids, verbosity.into())?;
     git::process::fetch_local(None, &stored, oids, verbosity.into())?;
     // Nb. An empty line means we're done.
     println!();

modified crates/radicle-remote-helper/src/push.rs

@@ -908,7 +908,7 @@ fn push_ref(

     args.extend([url.to_string(), refspec.to_string()]);
     let output = radicle::git::run::<_, _, &str, &str>(repo, args, [])?;
     let output = radicle::git::run(None, args)?;
     if !output.status.success() {
         return Err(Error::InternalPushFailed {

modified crates/radicle/src/git.rs

@@ -756,23 +756,24 @@ pub fn head_refname(repo: &git2::Repository) -> Result<Option<String>, git2::Err

     }
 }
 /// Execute a git command by spawning a child process.
 pub fn run<P, S, K, V>(
     repo: P,
 /// Execute a `git` command by spawning a child process and collect its output.
 /// If `working` is [`Some`], the command is run as if `git` was started in
 /// `working` instead of the current working directory, by prepending
 /// `-C <working>` to the command line.
 pub fn run<S>(
     working: Option<&std::path::Path>,
     args: impl IntoIterator<Item = S>,
     envs: impl IntoIterator<Item = (K, V)>,
 ) -> io::Result<std::process::Output>
 where
     P: AsRef<Path>,
     S: AsRef<std::ffi::OsStr>,
     K: AsRef<std::ffi::OsStr>,
     V: AsRef<std::ffi::OsStr>,
 {
     Command::new("git")
         .current_dir(repo)
         .envs(envs)
         .args(args)
         .output()
     let mut cmd = Command::new("git");
     if let Some(working) = working {
         cmd.arg("-C").arg(dunce::canonicalize(working)?);
     }
     cmd.args(args).output()
 }
 /// Functions that call to the `git` CLI instead of `git2`.

@@ -789,7 +790,7 @@ pub mod process {

     /// `oids` are the set of [`Oid`]s that are being fetched from the
     /// `storage`.
     pub fn fetch_local<R>(
         working: &Path,
         working: Option<&Path>,
         storage: &R,
         oids: impl IntoIterator<Item = Oid>,
         verbosity: Verbosity,

@@ -797,16 +798,15 @@ pub mod process {

     where
         R: ReadRepository,
     {
         let mut fetch = vec![
         let mut args = vec![
             "fetch".to_string(),
             // Avoid writing fetch head since we're only fetching objects
             "--no-write-fetch-head".to_string(),
         ];
         fetch.extend(verbosity.into_flag());
         fetch.push(url::File::new(storage.path()).to_string());
         fetch.extend(oids.into_iter().map(|oid| oid.to_string()));
         // N.b. `.` is used since we're fetching within the working copy
         run::<_, _, &str, &str>(working, fetch, [])
         args.extend(verbosity.into_flag());
         args.push(url::File::new(storage.path()).to_string());
         args.extend(oids.into_iter().map(|oid| oid.to_string()));
         run(working, args)
     }
 }

modified crates/radicle/src/rad.rs

@@ -1,6 +1,6 @@

 #![allow(clippy::let_unit_value)]
 use std::io;
 use std::path::{Path, PathBuf};
 use std::path::Path;
 use std::str::FromStr;
 use std::sync::LazyLock;

@@ -32,10 +32,6 @@ pub static PATCHES_REFNAME: LazyLock<git::RefString> =

 #[derive(Error, Debug)]
 pub enum InitError {
     #[error(
         "the Git repository found at {path:?} is a bare repository, expected a working directory"
     )]
     BareRepository { path: PathBuf },
     #[error("doc: {0}")]
     Doc(#[from] DocError),
     #[error("repository: {0}")]

@@ -115,23 +111,22 @@ where

     git::configure_repository(repo)?;
     git::configure_remote(repo, &REMOTE_NAME, url, &url.clone().with_namespace(*pk))?;
     let branch = git::Qualified::from(git::fmt::lit::refs_heads(default_branch));
     // Pushes to default branch to the namespace of the `signer`
     let pushspec = git::Refspec {
         src: branch.clone(),
         dst: branch.with_namespace(git::Component::from(pk)),
         force: false,
     };
     git::run::<_, _, &str, &str>(
         repo.workdir().ok_or(InitError::BareRepository {
             path: repo.path().to_path_buf(),
         })?,
         [
             "push",
             &format!("{}", dunce::canonicalize(stored.path())?.display()),
             &pushspec.to_string(),
         ],
         [],
     )?;
     {
         // Push branch to storage.
         let stored = dunce::canonicalize(stored.path())?.display().to_string();
         // Pushes to default branch to the namespace of the `signer`.
         let pushspec = git::Refspec {
             src: branch.clone(),
             dst: branch.with_namespace(git::Component::from(pk)),
             force: false,
         }
         .to_string();
         git::run(Some(repo.path()), ["push".to_string(), stored, pushspec])?;
     }
     // N.b. we need to create the remote branch for the default branch
     let rad_remote =
         git::Qualified::from(git::lit::refs_remotes(&*REMOTE_COMPONENT)).join(default_branch);

@@ -231,12 +226,14 @@ where

 #[derive(Error, Debug)]
 pub enum CheckoutError {
     #[error(
         "the Git repository found at {path:?} is a bare repository, expected a working directory"
     )]
     BareRepository { path: PathBuf },
     #[error("failed to fetch to working copy")]
     Fetch(#[source] std::io::Error),
     #[error("failed to fetch to working copy: {0}")]
     FetchIo(#[source] std::io::Error),
     #[error("internal fetch failed with exit status {status}, stderr and stdout follow:\n{stderr}\n{stdout}")]
     FetchGit {
         status: std::process::ExitStatus,
         stderr: String,
         stdout: String,
     },
     #[error("git: {0}")]
     Git(#[from] git2::Error),
     #[error("payload: {0}")]

@@ -277,33 +274,34 @@ pub fn checkout<P: AsRef<Path>, S: storage::ReadStorage>(

         &url,
         &url.clone().with_namespace(*remote),
     )?;
     let fetchspec = git::Refspec {
         src: git::refspec::pattern!("refs/heads/*"),
         dst: git::Qualified::from(git::lit::refs_remotes(&*REMOTE_NAME))
             .to_pattern(git::refspec::STAR)
             .into_patternstring(),
         force: false,
     };
     let stored = storage.repository(proj)?;
     let workdir = repo.workdir().ok_or(CheckoutError::BareRepository {
         path: repo.path().to_path_buf(),
     })?;
     git::run::<_, _, &str, &str>(
         workdir,
         [
             "fetch",
             &format!(
                 "{}",
                 dunce::canonicalize(stored.path())
                     .map_err(CheckoutError::Fetch)?
                     .display()
             ),
             &fetchspec.to_string(),
         ],
         [],
     )
     .map_err(CheckoutError::Fetch)?;
     {
         // Fetch remote head to working copy.
         let fetchspec = git::Refspec {
             src: git::refspec::pattern!("refs/heads/*"),
             dst: git::Qualified::from(git::lit::refs_remotes(&*REMOTE_NAME))
                 .to_pattern(git::refspec::STAR)
                 .into_patternstring(),
             force: false,
         }
         .to_string();
         let stored = dunce::canonicalize(storage.repository(proj)?.path())
             .map_err(CheckoutError::FetchIo)?
             .display()
             .to_string();
         let output = git::run(Some(repo.path()), ["fetch", &stored, &fetchspec]).map_err(CheckoutError::FetchIo)?;
         if !output.status.success() {
             return Err(CheckoutError::FetchGit {
                 status: output.status,
                 stdout: String::from_utf8_lossy(&output.stdout).to_string(),
                 stderr: String::from_utf8_lossy(&output.stderr).to_string(),
             });
         }
     }
     {
         // Setup default branch.