Revisit bare repositories — heartwood

This patchset starts off with changes to radicle-remote-helper: Maintainence such as making the crate binary-only and a small clean up. Then, handling of GIT_DIR is simplified throughout radicle{,-remote-helper,-cli}, which unlocks usage of the remote helper with bare repositories. Next, the commands rad init and rad clone learn to handle bare repositories. Finally, code paths that would error or degrade upon detecting a bare repository are removed or fixed.

Overall, this patch should significantly improve interoperability with bare repositories.

 ## New Features
 - `rad clone` now supports the flag `--bare` which works analoguously to
   `git clone --bare`.
 - `rad init --setup-signing` now works on bare repositories.
 - `git-remote-rad` now correctly reports the default branch to Git by listing
   the symbolic reference `HEAD`.
 ## Fixed Bugs
 - `rad init --setup-signing` now works in combination with `--existing`.
 ## 1.4.0
 ## Release Highlights
 ## Deprecations
 ## New Features
 - `rad cob log` now supports the arguments `--from` and `--to` which can be used
   to range over particular operations on a COB.

 ```
 $ git rev-parse --is-bare-repository
 true
 ```
 \ No newline at end of file

 $ git commit -m "Alice's commit" --allow-empty -q
 $ git push rad -o no-sync
 $ git ls-remote rad
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	HEAD
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	refs/heads/master
 ```

 $ git commit -m "Bob's commit" -q
 $ git push rad -o no-sync
 $ git ls-remote rad
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	HEAD
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	refs/heads/master
 ```

 $ git commit -m "Eve's commit" -q
 $ git push rad -o no-sync
 $ git ls-remote rad
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	HEAD
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354	refs/heads/master
 ```

 To create a local bare copy of a repository on the radicle network, we use the
 `clone` command, followed by the identifier or *RID* of the repository:
 ```
 $ rad clone rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --scope followed --bare
 ✓ Seeding policy updated for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji with scope 'followed'
 Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from the network, found [..] potential seed(s).
 ✓ Target met: [..] seed(s)
 ✓ Creating checkout in ./heartwood..
 ✓ Remote alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi added
 ✓ Remote-tracking branch alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master created for z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
 ✓ Repository successfully cloned under [..]/heartwood/
 ╭────────────────────────────────────╮
 │ heartwood                          │
 │ Radicle Heartwood Protocol & Stack │
 │ 0 issues · 0 patches               │
 ╰────────────────────────────────────╯
 Run `cd ./heartwood` to go to the repository directory.
 ```
 We can now have a look at the new directory that was created from the cloned
 repository:
 ```
 $ cd heartwood
 $ ls
 FETCH_HEAD
 HEAD
 config
 description
 hooks
 info
 objects
 refs
 ```
 As expected, some `git` commands fail:
 ``` (stderr) (fail)
 $ git status
 fatal: this operation must be run in a work tree
 ```
 Let's check that the remote tracking branch was setup correctly:
 ```
 $ git branch --remotes
   alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master
   rad/master
 ```
 The first branch is ours, and the second points to the repository delegate.
 We can also take a look at the remotes:
 ```
 $ git remote -v
 alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (fetch)
 alice@z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (push)
 rad	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji (fetch)
 rad	rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk (push)
 ```
 Let's check the last commit!
 ```
 $ git log -n 1
 commit f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354
 Author: anonymous <anonymous@radicle.xyz>
 Date:   Mon Jan 1 14:39:16 2018 +0000
     Second commit
 ```
 Cloned repositories show up in `rad ls`:
 ```
 $ rad ls --seeded
 ╭───────────────────────────────────────────────────────────────────────────────────────────────────────────╮
 │ Name        RID                                 Visibility   Head      Description                        │
 ├───────────────────────────────────────────────────────────────────────────────────────────────────────────┤
 │ heartwood   rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji   public       f2de534   Radicle Heartwood Protocol & Stack │
 ╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 ```

 Let's clone a regular repository via plain Git:
 ```
 $ git clone --bare $URL heartwood
 $ cd heartwood
 $ git rev-parse HEAD
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354
 ```
 We can see it's not a Radicle working copy:
 ``` (fail)
 $ rad .
 ✗ Error: Current directory is not a Radicle repository
 ```
 Let's pick an existing repository:
 ```
 $ rad inspect rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
 rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
 ```
 And initialize this working copy as that existing repository:
 ```
 $ rad init --setup-signing --existing rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
 Configuring radicle signing key SHA256:UIedaL6Cxm6OUErh9GQUzzglSk7VpQlVTI1TAFB/HWA...
 ✓ Signing configured in [..]/heartwood/config
 ! Not writing .gitsigners file.
 ✓ Initialized existing repository rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji in [..]/heartwood/..
 ```
 The warning about not writing `.gitsigners` is expected, as this requires a
 working directory, which a bare repository does not have.
 We can confirm that the working copy is initialized:
 ```
 $ rad .
 rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji
 $ git remote show rad
 * remote rad
   Fetch URL: rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji
   Push  URL: rad://z42hL2jL4XNk6K8oHQaSWfMgCL7ji/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi
   HEAD branch: master
   Remote branch:
     master new (next fetch will store in remotes/rad)
   Local ref configured for 'git push':
     master pushes to master (up to date)
 ```

 $ git pull
 Already up to date.
 $ git branch -r
   rad/HEAD -> rad/master
   rad/master
   rad/patches/5e2dedcc5d515fcbc1cca483d3376609fe889bfb
 ```

 $ git show-ref
 d894a83c9c356552a57af09ccdbd5587a99045 refs/heads/feature/1
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354 refs/heads/master
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354 refs/remotes/rad/HEAD
 f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354 refs/remotes/rad/master
 d894a83c9c356552a57af09ccdbd5587a99045 refs/remotes/rad/patches/6035d2f582afbe01ff23ea87528ae523d76875b6
 ```

     }
     let mut spinner = term::spinner("Performing checkout...");
     let repo = match radicle::rad::checkout(options.id, &remote, path.clone(), &storage) {
     let repo = match radicle::rad::checkout(options.id, &remote, path.clone(), &storage, false) {
         Ok(repo) => repo,
         Err(err) => {
             spinner.failed();

 Options
         --bare              Make a bare repository
         --scope <scope>     Follow scope: `followed` or `all` (default: all)
     -s, --seed <nid>        Clone from this seed (may be specified multiple times)
         --timeout <secs>    Timeout for fetching repository (default: 9)

     scope: Scope,
     /// Sync settings.
     sync: SyncSettings,
     bare: bool,
 }
 impl Args for Options {

         let mut scope = Scope::All;
         let mut sync = SyncSettings::default();
         let mut directory = None;
         let mut bare = false;
         while let Some(arg) = parser.next()? {
             match arg {

                     // We keep this flag here for consistency though it doesn't have any effect,
                     // since the command is fully non-interactive.
                 }
                 Long("bare") => {
                     bare = true;
                 }
                 Long("help") | Short('h') => {
                     return Err(Error::Help.into());
                 }

         options.sync.with_profile(&profile),
         &mut node,
         &profile,
         options.bare,
     )?
     .print_or_success()
     .ok_or_else(|| anyhow::anyhow!("failed to clone {}", options.id))?;

         .filter(|id| id != profile.id())
         .collect::<Vec<_>>();
     let default_branch = proj.default_branch().clone();
     let path = working.workdir().unwrap(); // SAFETY: The working copy is not bare.
     let path = if !options.bare {
         working.workdir().unwrap()
     } else {
         working.path()
     };
     // Configure repository and setup tracking for repository delegates.
     radicle::git::configure_repository(&working)?;

     repository: storage::git::Repository,
     doc: Doc,
     project: Project,
     bare: bool,
 }
 impl Checkout {

         repository: storage::git::Repository,
         profile: &Profile,
         directory: Option<PathBuf>,
         bare: bool,
     ) -> Result<Self, CheckoutFailure> {
         let rid = repository.rid();
         let doc = repository

             repository,
             doc: doc.doc,
             project: proj,
             bare,
         })
     }

             "Creating checkout in ./{}..",
             term::format::tertiary(destination.display())
         ));
         match rad::checkout(self.id, &self.remote, self.path, storage) {
         match rad::checkout(self.id, &self.remote, self.path, storage, self.bare) {
             Err(err) => {
                 spinner.message(format!(
                     "Failed to checkout in ./{}",

     settings: SyncSettings,
     node: &mut Node,
     profile: &Profile,
     bare: bool,
 ) -> Result<CloneResult, CloneError> {
     // Seed repository.
     if node.seed(id, scope)? {

                 node::sync::FetcherResult::TargetReached(_) => {
                     profile.storage.repository(id).map_or_else(
                         |err| Ok(CloneResult::RepositoryMissing { rid: id, err }),
                         |repository| Ok(perform_checkout(repository, profile, directory)?),
                         |repository| Ok(perform_checkout(repository, profile, directory, bare)?),
                     )
                 }
                 node::sync::FetcherResult::TargetError(failure) => {

                 }
             }
         }
         Ok(repository) => Ok(perform_checkout(repository, profile, directory)?),
         Ok(repository) => Ok(perform_checkout(repository, profile, directory, bare)?),
     }
 }

     repository: storage::git::Repository,
     profile: &Profile,
     directory: Option<PathBuf>,
     bare: bool,
 ) -> Result<CloneResult, rad::CheckoutError> {
     Checkout::new(repository, profile, directory).map_or_else(
     Checkout::new(repository, profile, directory, bare).map_or_else(
         |failure| Ok(CloneResult::Failure(failure)),
         |checkout| checkout.run(&profile.storage),
     )

         )?;
     }
     if options.setup_signing {
         // Setup radicle signing key.
         self::setup_signing(profile.id(), &working, options.interactive)?;
     }
     term::success!(
         "Initialized existing repository {} in {}..",
         term::format::tertiary(rid),

     repo: &git::Repository,
     interactive: Interactive,
 ) -> anyhow::Result<()> {
     let repo = repo
         .workdir()
         .ok_or(anyhow!("cannot setup signing in bare repository"))?;
     const SIGNERS: &str = ".gitsigners";
     let path = repo.path();
     let config = path.join("config");
     let key = ssh::fmt::fingerprint(node_id);
     let yes = if !git::is_signing_configured(repo)? {
     let yes = if !git::is_signing_configured(path)? {
         term::headline(format!(
             "Configuring radicle signing key {}...",
             term::format::tertiary(key)

         true
     } else if interactive.yes() {
         term::confirm(format!(
             "Configure radicle signing key {} in local checkout?",
             "Configure radicle signing key {} in {}?",
             term::format::tertiary(key),
             term::format::tertiary(config.display()),
         ))
     } else {
         true
     };
     if yes {
     if !yes {
         return Ok(());
     }
     git::configure_signing(path, node_id)?;
     term::success!(
         "Signing configured in {}",
         term::format::tertiary(config.display())
     );
     if let Some(repo) = repo.workdir() {
         match git::write_gitsigners(repo, [node_id]) {
             Ok(file) => {
                 git::ignore(repo, file.as_path())?;

             }
             Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
                 let ssh_key = ssh::fmt::key(node_id);
                 let gitsigners = term::format::tertiary(".gitsigners");
                 let gitsigners = term::format::tertiary(SIGNERS);
                 term::success!("Found existing {} file", gitsigners);
                 let ssh_keys =
                     git::read_gitsigners(repo).context("error reading .gitsigners file")?;
                     git::read_gitsigners(repo).context(format!("error reading {SIGNERS} file"))?;
                 if ssh_keys.contains(&ssh_key) {
                     term::success!("Signing key is already in {gitsigners} file");

                 return Err(err.into());
             }
         }
         git::configure_signing(repo, node_id)?;
         term::success!(
             "Signing configured in {}",
             term::format::tertiary(".git/config")
         );
     } else {
         term::notice!("Not writing {SIGNERS} file.")
     }
     Ok(())
 }

     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()),

     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!(

         .and_then(|(peer, r)| NodeId::from_str(peer).ok().map(|p| (p, r)))
 }
 pub fn view_diff(
     repo: &git2::Repository,
     left: &git2::Oid,
     right: &git2::Oid,
 ) -> anyhow::Result<()> {
     // TODO(erikli): Replace with repo.diff()
     let workdir = repo
         .workdir()
         .ok_or_else(|| anyhow!("Could not get workdir current repository."))?;
     let left = format!("{:.7}", left.to_string());
     let right = format!("{:.7}", right.to_string());
     let mut git = Command::new("git")
         .current_dir(workdir)
         .args(["diff", &left, &right])
         .spawn()?;
     git.wait()?;
     Ok(())
 }
 pub fn add_tag(
     repo: &git2::Repository,
     message: &str,

 }
 #[test]
 fn rad_init_bare() {
     let mut env = Environment::new();
     let alice = env.profile("alice");
     radicle::test::fixtures::bare_repository(env.work(&alice).as_path());
     env.tests(["git/git-is-bare-repository", "rad-init"], &alice)
         .unwrap();
 }
 #[test]
 fn rad_init_existing() {
     let mut environment = Environment::new();
     let mut profile = environment.node("alice");

 }
 #[test]
 fn rad_init_existing_bare() {
     let mut environment = Environment::new();
     let mut profile = environment.node("alice");
     let working = tempfile::tempdir().unwrap();
     let rid = profile.project("heartwood", "Radicle Heartwood Protocol & Stack");
     test(
         "examples/rad-init-existing-bare.md",
         working.path(),
         Some(&profile.home),
         [(
             "URL",
             git::url::File::new(profile.storage.path())
                 .rid(rid)
                 .to_string()
                 .as_str(),
         )],
     )
     .unwrap();
 }
 #[test]
 fn rad_init_no_seed() {
     Environment::alice(["rad-init-no-seed"]);
 }

 }
 #[test]
 fn rad_clone_bare() {
     let mut environment = Environment::new();
     let mut alice = environment.node("alice");
     let bob = environment.node("bob");
     let working = environment.tempdir().join("working");
     // Setup a test project.
     let acme = alice.project("heartwood", "Radicle Heartwood Protocol & Stack");
     let mut alice = alice.spawn();
     let mut bob = bob.spawn();
     // Prevent Alice from fetching Bob's fork, as we're not testing that and it may cause errors.
     alice.handle.seed(acme, Scope::Followed).unwrap();
     bob.connect(&alice).converge([&alice]);
     test("examples/rad-clone-bare.md", working, Some(&bob.home), []).unwrap();
 }
 #[test]
 fn rad_clone_directory() {
     let mut environment = Environment::new();
     let mut alice = environment.node("alice");