Just like with other project management systems, the issue can be assigned to

others to work on.  This is to ensure work is not duplicated.

Let's assign ourselves to this one.

$ rad assign d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 --to did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

It will now show in the list of issues assigned to us.

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

│ ●   ID        Title                         Author                    Labels   Assignees         Opened │

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

│ ●   d185ee1   flux capacitor underpowered   z6MknSL…StBU8Vi   (you)            z6MknSL…StBU8Vi   now    │

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

14019611935fd1c66458111a5b49f0a7350c226f

$ rad issue comment d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 --reply-to 14019611935fd1c66458111a5b49f0a7350c226f --message 'More power!' -q

e342e47b7dd93451d47c806a0faeb0b5e957da2c

│ z6MknSL…StBU8Vi (you) now 1401961                       │

│ z6MknSL…StBU8Vi (you) now e342e47                       │

Labeling an issue is easy, let's add the `bug` and `good-first-issue` labels to

some issue:

```

$ rad label d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 bug good-first-issue

```

We can now show the issue to check whether those labels were added:

```

$ rad issue show d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 --format header

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

│ Title   flux capacitor underpowered                     │

│ Issue   d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61        │

│ Author  z6MknSL…StBU8Vi (you)                           │

│ Labels  bug, good-first-issue                           │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

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

```

Untagging an issue is very similar:

```

$ rad unlabel d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 good-first-issue

```

Notice that the `good-first-issue` label has disappeared:

```

$ rad issue show d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61 --format header

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

│ Title   flux capacitor underpowered                     │

│ Issue   d185ee16a00bac874c0bcbc2a8ad80fdce5e1e61        │

│ Author  z6MknSL…StBU8Vi (you)                           │

│ Labels  bug                                             │

│ Status  open                                            │

│                                                         │

│ Flux capacitor power requirements exceed current supply │

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

```

✓ Patch 6ff4f09 updated to 0c0942e2ff2488617d950ede15567ca39a29972e

│ z6MknSL…StBU8Vi (you) now cd811db     │

$ rad patch comment 6ff4f09c1b5a81347981f59b02ef43a31a07cdae --message 'My favorite decade!' --reply-to cd811db -q

b6a76fe394de87eb34cbc3823a0edc80ff98cb97

│ ↑ updated to 0c0942e2ff2488617d950ede15567ca39a29972e (27857ec) now │

│ ↑ updated to 0c0942e2ff2488617d950ede15567ca39a29972e (27857ec) now │

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

pub mod rad_label;

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

pub mod rad_unlabel;

    rad_label::HELP,

    rad_unlabel::HELP,

                Long("label") if op == Some(OperationName::Open) => {

use std::ffi::OsString;

use std::str::FromStr;

use anyhow::anyhow;

use nonempty::NonEmpty;

use radicle::cob;

use radicle::cob::common::Label;

use radicle::cob::{issue, patch, store};

use radicle::crypto::Signer;

use radicle::storage::{self, WriteStorage};

use crate::terminal as term;

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

pub const HELP: Help = Help {

    name: "label",

    description: "Label an issue or patch",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad label <issue-id> <label>... [<option>...]

    Adds the given labels to the patch or issue.

Options

    --help      Print help

"#,

};

#[derive(Debug)]

pub struct Options {

    pub id: cob::ObjectId,

    pub labels: NonEmpty<Label>,

}

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<cob::ObjectId> = None;

        let mut labels: Vec<Label> = Vec::new();

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

            match arg {

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

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

                }

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

                    id = Some(term::args::cob(val)?);

                }

                Value(ref val) if id.is_some() => {

                    let s: String = val.parse()?;

                    let label = Label::from_str(&s)?;

                    labels.push(label);

                }

                _ => {

                    return Err(anyhow!(arg.unexpected()));

                }

            }

        }

        Ok((

            Options {

                id: id.ok_or_else(|| anyhow!("an issue or patch must be specified"))?,

                labels: NonEmpty::from_vec(labels)

                    .ok_or_else(|| anyhow!("at least one label must be specified"))?,

            },

            vec![],

        ))

    }

}

fn label(

    options: Options,

    repo: &storage::git::Repository,

    signer: impl Signer,

) -> anyhow::Result<()> {

    let mut issues = issue::Issues::open(repo)?;

    match issues.get_mut(&options.id) {

        Ok(mut issue) => {

            let labels = issue

                .labels()

                .cloned()

                .chain(options.labels)

                .collect::<Vec<_>>();

            issue.label(labels, &signer)?;

            return Ok(());

        }

        Err(store::Error::NotFound(_, _)) => {}

        Err(e) => return Err(e.into()),

    }

    let mut patches = patch::Patches::open(repo)?;

    match patches.get_mut(&options.id) {

        Ok(mut patch) => {

            let labels = patch

                .labels()

                .cloned()

                .chain(options.labels)

                .collect::<Vec<_>>();

            patch.label(labels, &signer)?;

            return Ok(());

        }

        Err(store::Error::NotFound(_, _)) => {}

        Err(e) => return Err(e.into()),

    }

    anyhow::bail!("Couldn't find issue or patch {}", options.id)

}

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

    let profile = ctx.profile()?;

    let (_, id) = radicle::rad::cwd()?;

    let repo = profile.storage.repository_mut(id)?;

    let signer = term::signer(&profile)?;

    label(options, &repo, signer)?;

    Ok(())

}

use radicle::cob::patch;

use std::ffi::OsString;

use std::str::FromStr;

use anyhow::anyhow;

use nonempty::NonEmpty;

use radicle::cob;

use radicle::cob::common::Label;

use radicle::cob::{issue, patch, store};

use radicle::crypto::Signer;

use radicle::storage::{self, WriteStorage};

use crate::terminal as term;

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

pub const HELP: Help = Help {

    name: "untag",

    description: "Untag an issue or patch",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad untag <cob-id> <tag>... [<option>...]

Options

    --help      Print help

"#,

};

#[derive(Debug)]

pub struct Options {

    pub id: cob::ObjectId,

    pub labels: NonEmpty<Label>,

}

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<cob::ObjectId> = None;

        let mut labels: Vec<Label> = Vec::new();

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

            match arg {

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

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

                }

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

                    id = Some(term::args::cob(val)?);

                }

                Value(ref val) if id.is_some() => {

                    let s: String = val.parse()?;

                    let label = Label::from_str(&s)?;

                    labels.push(label);

                }

                _ => {

                    return Err(anyhow!(arg.unexpected()));

                }

            }

        }

        Ok((

            Options {

                id: id.ok_or_else(|| anyhow!("an issue or patch must be specified"))?,

                labels: NonEmpty::from_vec(labels)

                    .ok_or_else(|| anyhow!("at least one label must be specified"))?,

            },

            vec![],

        ))

    }

}

fn unlabel(

    options: Options,

    repo: &storage::git::Repository,

    signer: impl Signer,

) -> anyhow::Result<()> {

    let mut issues = issue::Issues::open(repo)?;

    match issues.get_mut(&options.id) {

        Ok(mut issue) => {

            let labels = issue

                .labels()

                .filter(|&l| !options.labels.contains(l))

                .cloned()

                .collect::<Vec<_>>();

            issue.label(labels, &signer)?;

            return Ok(());

        }

        Err(store::Error::NotFound(_, _)) => {}

        Err(e) => return Err(e.into()),

    }

    let mut patches = patch::Patches::open(repo)?;

    match patches.get_mut(&options.id) {

        Ok(mut patch) => {

            let labels = patch

                .labels()

                .filter(|&l| !options.labels.contains(l))

                .cloned()

                .collect::<Vec<_>>();

            patch.label(labels, &signer)?;

            return Ok(());

        }

        Err(store::Error::NotFound(_, _)) => {}

        Err(e) => return Err(e.into()),

    }

    anyhow::bail!("Couldn't find issue or patch {}", options.id)

}

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

    let profile = ctx.profile()?;

    let (_, id) = radicle::rad::cwd()?;

    let repo = profile.storage.repository_mut(id)?;

    let signer = term::signer(&profile)?;

    unlabel(options, &repo, signer)?;

    Ok(())

}

        "label" => {

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

                rad_label::HELP,

                rad_label::run,

                args.to_vec(),

            );

        }

        "unlabel" => {

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

                rad_unlabel::HELP,

                rad_unlabel::run,

                args.to_vec(),

            );

        }

fn rad_label() {

    let mut environment = Environment::new();

    let profile = environment.profile("alice");

    let home = &profile.home;

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

    // Setup a test repository.

    fixtures::repository(&working);

    test("examples/rad-init.md", &working, Some(home), []).unwrap();

    test("examples/rad-issue.md", &working, Some(home), []).unwrap();

    test("examples/rad-label.md", &working, Some(home), []).unwrap();

}

#[test]