We cannot delete a repository, since that can cause data integrity

issues. However, we can clean the storage of remotes that are not the

local peer or the repository delegates. To do this we can use the `rad

clean` command.

First let's look at what we have locally:

```

$ rad ls

╭───────────────────────────────────────────────────────────────────────────────────────────────────────────╮

│ Name        RID                                 Visibility   Head      Description                        │

├───────────────────────────────────────────────────────────────────────────────────────────────────────────┤

│ heartwood   rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji   public       f2de534   Radicle Heartwood Protocol & Stack │

╰───────────────────────────────────────────────────────────────────────────────────────────────────────────╯

```

Let's also inspect what remotes are in the repository:

```

$ rad inspect --sigrefs

z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi f209c9f68aa689af24220a20462e13ee9dfb2a95

z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk 161b775a3509c8098de67f57f750972bba015b31

```

Now let's clean the `heartwood` project:

```

$ rad clean rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --no-confirm

Removed z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk

✓ Successfully cleaned rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

```

Inspecting the remotes again, we see that Bob is now gone:

```

$ rad inspect --sigrefs

z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi f209c9f68aa689af24220a20462e13ee9dfb2a95

```

Note that Bob will be fetched again if we do not untrack his

node. Currently, there is no per repository tracking so it's not

possible to stop fetching Bob for this particular repository.

Cleaning a repository again will remove no remotes, since we're

already at the minimal set of remotes:

```

$ rad clean rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --no-confirm

✓ Successfully cleaned rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

```

And attempting to clean a non-existent repository has no effect on the

storage at all:

``` (fail)

$ rad clean rad:z42hL2jL4XNk6K8oHQaSWdeadbeef --no-confirm

✗ Error: repository rad:z42hL2jL4XNk6K8oHQaSWdeadbeef was not found

```

#[path = "commands/clean.rs"]

pub mod rad_clean;

use std::ffi::OsString;

use anyhow::anyhow;

use radicle::identity::Id;

use radicle::storage;

use radicle::storage::WriteStorage;

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

pub const HELP: Help = Help {

    name: "clean",

    description: "Clean a project",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad clean <rid> [<option>...]

    Removes all remotes from a repository, as long as they are not the

    local operator or a delegate of the repository.

    Note that remotes will still be fetched as long as they are

    tracked and/or the tracking scope is "all".

Options

    --no-confirm        Do not ask for confirmation before removal (default: false)

    --help              Print help

"#,

};

pub struct Options {

    rid: Id,

    confirm: bool,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_args(args);

        let mut id: Option<Id> = None;

        let mut confirm = true;

        while let Some(arg) = parser.next()? {

            match arg {

                Long("no-confirm") => {

                    confirm = false;

                }

                Long("help") | Short('h') => {

                    return Err(Error::Help.into());

                }

                Value(val) if id.is_none() => {

                    id = Some(term::args::rid(&val)?);

                }

                _ => return Err(anyhow::anyhow!(arg.unexpected())),

            }

        }

        Ok((

            Options {

                rid: id

                    .ok_or_else(|| anyhow!("an RID must be provided; see `rad clean --help`"))?,

                confirm,

            },

            vec![],

        ))

    }

}

pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

    let profile = ctx.profile()?;

    let storage = &profile.storage;

    let rid = options.rid;

    let path = storage::git::paths::repository(storage, &rid);

    if !path.exists() {

        anyhow::bail!("repository {rid} was not found");

    }

    if !options.confirm || term::confirm(format!("Remove {rid}?")) {

        let cleaned = storage.clean(rid)?;

        for remote in cleaned {

            term::info!("Removed {remote}");

        }

        term::success!("Successfully cleaned {rid}");

    }

    Ok(())

}

    rad_clean::HELP,

        "clean" => {

            term::run_command_args::<rad_clean::Options, _>(

                rad_clean::HELP,

                rad_clean::run,

                args.to_vec(),

            );

fn rad_clean() {

    let alice = environment.node(Config::test(Alias::new("alice")));

    let bob = environment.node(Config::test(Alias::new("bob")));

    let working = environment.tmp().join("working");

    // Setup a test project.

    let acme = Id::from_str("z42hL2jL4XNk6K8oHQaSWfMgCL7ji").unwrap();

    fixtures::repository(working.join("acme"));

    test(

        "examples/rad-init.md",

        working.join("acme"),

        Some(&alice.home),

        [],

    )

    .unwrap();

    let mut alice = alice.spawn();

    let mut bob = bob.spawn();

    alice.handle.track_repo(acme, Scope::All).unwrap();

    bob.connect(&alice).converge([&alice]);

    test(

        "examples/rad-clone.md",

        working.join("bob"),

        Some(&bob.home),

        [],

    )

    .unwrap();

    bob.has_inventory_of(&acme, &alice.id);

    alice.has_inventory_of(&acme, &bob.id);

    test(

        "examples/rad-clean.md",

        working.join("acme"),

        Some(&alice.home),

        [],

    )

    .unwrap();