Radish alpha
h
heartwood
Radicle Heartwood Protocol & Stack
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
cli: Add minimal `rad comment`
Slack Coder committed 3 years ago
commit 9243b9fdeb4b700c5f820ce0d7df3db385a50598
parent 3bc07195f5cee586cd9949ad9414807f4fcce726
4 files changed +135 -0
modified radicle-cli/examples/rad-issue.md
@@ -37,3 +37,12 @@ Note: this can always be undone with the `unassign` subcommand.
```

$ rad unassign de81d97d7fe07a80bfb339200c6af862d4526b6a z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

```
+
+ 
Great, now we have communicated to the world about our car's defect.
+
+ 
But wait! We've found an important detail about the car's power requirements.
+ 
It will help whoever works on a fix.
+
+ 
```
+ 
$ rad comment de81d97d7fe07a80bfb339200c6af862d4526b6a --message 'The flux capacitor needs 1.21 Gigawatts'
+ 
```
modified radicle-cli/src/commands.rs
@@ -6,6 +6,8 @@ pub mod rad_auth;
pub mod rad_checkout;

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

pub mod rad_clone;
+ 
#[path = "commands/comment.rs"]
+ 
pub mod rad_comment;

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

pub mod rad_delegate;

#[path = "commands/edit.rs"]
added radicle-cli/src/commands/comment.rs
@@ -0,0 +1,116 @@
+ 
use std::ffi::OsString;
+ 
use std::str::FromStr;
+
+ 
use anyhow::anyhow;
+
+ 
use radicle::cob;
+ 
use radicle::cob::issue::Issues;
+ 
use radicle::cob::store;
+ 
use radicle::prelude::*;
+ 
use radicle::storage;
+ 
use radicle::storage::WriteStorage;
+
+ 
use crate::terminal as term;
+ 
use crate::terminal::args::{Args, Error, Help};
+ 
use crate::terminal::patch::Comment;
+
+ 
pub const HELP: Help = Help {
+ 
    name: "comment",
+ 
    description: env!("CARGO_PKG_DESCRIPTION"),
+ 
    version: env!("CARGO_PKG_VERSION"),
+ 
    usage: r#"
+ 
Usage
+
+ 
    rad comment <id> [-m <text>]
+
+ 
Options
+
+ 
    -m, --message               Comment message
+ 
        --help                  Print help
+ 
"#,
+ 
};
+
+ 
#[derive(Debug)]
+ 
pub struct Options {
+ 
    pub id: cob::ObjectId,
+ 
    pub message: Comment,
+ 
}
+
+ 
#[inline]
+ 
fn parse_cob_id(val: OsString) -> anyhow::Result<cob::ObjectId> {
+ 
    let val = val
+ 
        .to_str()
+ 
        .ok_or_else(|| anyhow!("object id specified is not UTF-8"))?;
+ 
    cob::ObjectId::from_str(val).map_err(|_| anyhow!("invalid object id '{}'", val))
+ 
}
+
+ 
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 message = Comment::default();
+
+ 
        while let Some(arg) = parser.next()? {
+ 
            match arg {
+ 
                // Options.
+ 
                Long("message") | Short('m') => {
+ 
                    if message != Comment::Blank {
+ 
                        // We skip this code when `no-message` is specified.
+ 
                        let txt: String = parser.value()?.to_string_lossy().into();
+ 
                        message.append(&txt);
+ 
                    }
+ 
                }
+ 
                Long("no-message") => message = Comment::Blank,
+
+ 
                // Common.
+ 
                Long("help") => return Err(Error::Help.into()),
+
+ 
                Value(val) if id.is_none() => id = Some(parse_cob_id(val)?),
+ 
                _ => return Err(anyhow::anyhow!(arg.unexpected())),
+ 
            }
+ 
        }
+
+ 
        Ok((
+ 
            Options {
+ 
                id: id.ok_or_else(|| anyhow!("an issue id to comment on must be provided"))?,
+ 
                message,
+ 
            },
+ 
            vec![],
+ 
        ))
+ 
    }
+ 
}
+
+ 
fn comment(
+ 
    options: &Options,
+ 
    repo: &storage::git::Repository,
+ 
    signer: impl Signer,
+ 
) -> anyhow::Result<()> {
+ 
    let message = options.message.clone().get("Enter a comment...");
+ 
    if message.is_empty() {
+ 
        return Ok(());
+ 
    }
+
+ 
    let mut issues = Issues::open(*signer.public_key(), repo)?;
+ 
    let mut issue = issues.get_mut(&options.id).map_err(|e| match e {
+ 
        store::Error::NotFound(_, _) => anyhow::anyhow!("Could not find issue {}", options.id),
+ 
        _ => e.into(),
+ 
    })?;
+ 
    let (comment_id, _) = issue.root().expect("root comment always exists");
+
+ 
    issue.comment(message, *comment_id, &signer)?;
+ 
    Ok(())
+ 
}
+
+ 
pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
+ 
    let (_, id) = radicle::rad::cwd()
+ 
        .map_err(|_| anyhow!("this command must be run in the context of a project"))?;
+ 
    let profile = ctx.profile()?;
+ 
    let repo = profile.storage.repository(id)?;
+ 
    let signer = term::signer(&profile)?;
+
+ 
    comment(&options, &repo, signer)?;
+
+ 
    Ok(())
+ 
}
modified radicle-cli/src/main.rs
@@ -134,6 +134,14 @@ fn run_other(exe: &str, args: &[OsString]) -> Result<(), Option<anyhow::Error>>
                args.to_vec(),

            );

        }
+ 
        "comment" => {
+ 
            term::run_command_args::<rad_comment::Options, _>(
+ 
                rad_comment::HELP,
+ 
                "Comment",
+ 
                rad_comment::run,
+ 
                args.to_vec(),
+ 
            );
+ 
        }

        "delegate" => {

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

                rad_delegate::HELP,