6eefef5 cli/unfollow: Use clap — heartwood

heartwood

Radicle Heartwood Protocol & Stack

cli/unfollow: Use clap

✗ CI failure Lorenz Leutgeb committed 7 months ago

commit 6eefef57110c58ee745fbc366e327f8e958c925b
parent f1c7c9860716e5db88f657c61d39d6081fb5645f

1 failed (1 total) View logs

3 files changed +37 -66

modified crates/radicle-cli/src/commands/help.rs

@@ -61,7 +61,10 @@ const COMMANDS: &[CommandItem] = &[

     CommandItem::Lexopt(crate::commands::seed::HELP),
     CommandItem::Lexopt(crate::commands::follow::HELP),
     CommandItem::Lexopt(crate::commands::unblock::HELP),
     CommandItem::Lexopt(crate::commands::unfollow::HELP),
     CommandItem::Clap {
         name: "unfollow",
         about: crate::commands::unfollow::ABOUT,
     },
     CommandItem::Lexopt(crate::commands::unseed::HELP),
     CommandItem::Lexopt(crate::commands::remote::HELP),
     CommandItem::Lexopt(crate::commands::stats::HELP),

modified crates/radicle-cli/src/commands/unfollow.rs

@@ -1,77 +1,46 @@

 use std::ffi::OsString;
 use clap::Parser;
 use anyhow::anyhow;
 use thiserror::Error;
 use radicle::node::{Handle, NodeId};
 use radicle::prelude::Did;
 use crate::terminal as term;
 use crate::terminal::args::{Args, Error, Help};
 pub const HELP: Help = Help {
     name: "unfollow",
     description: "Unfollow a peer",
     version: env!("RADICLE_VERSION"),
     usage: r#"
 Usage
 pub(crate) const ABOUT: &str = "Unfollow a peer";
     rad unfollow <nid> [<option>...]
 const LONG_ABOUT: &str = r#"
 The `unfollow` command takes a Node ID, optionally in DID format,
 and removes the follow policy for that peer."#;
     The `unfollow` command takes a Node ID (<nid>), optionally in DID format,
     and removes the follow policy for that peer.
 Options
     --verbose, -v          Verbose output
     --help                 Print help
 "#,
 };
 #[derive(Debug)]
 pub struct Options {
     pub nid: NodeId,
     pub verbose: bool,
 #[derive(Debug, Error)]
 #[error("invalid Node ID specified (Node ID parsing failed with: '{nid}', DID parsing failed with: '{did}'))")]
 struct NodeIdParseError {
     did: radicle::identity::did::DidError,
     nid: radicle::crypto::PublicKeyError,
 }
 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 nid: Option<NodeId> = None;
         let mut verbose = false;
 fn parse_nid(value: &str) -> Result<NodeId, NodeIdParseError> {
     value.parse::<Did>().map(NodeId::from).or_else(|did| {
         value
             .parse::<NodeId>()
             .map_err(|nid| NodeIdParseError { nid, did })
     })
 }
         while let Some(arg) = parser.next()? {
             match &arg {
                 Value(val) if nid.is_none() => {
                     if let Ok(did) = term::args::did(val) {
                         nid = Some(did.into());
                     } else if let Ok(val) = term::args::nid(val) {
                         nid = Some(val);
                     } else {
                         anyhow::bail!("invalid Node ID `{}` specified", val.to_string_lossy());
                     }
                 }
                 Long("verbose") | Short('v') => verbose = true,
                 Long("help") | Short('h') => {
                     return Err(Error::Help.into());
                 }
                 _ => {
                     return Err(anyhow!(arg.unexpected()));
                 }
             }
         }
 #[derive(Debug, Parser)]
 #[command(about = ABOUT, long_about = LONG_ABOUT, disable_version_flag = true)]
 pub struct Args {
     /// Node ID (optionally in DID format) of the peer to unfollow
     #[arg(value_name = "NID", value_parser = parse_nid)]
     pub nid: NodeId,
         Ok((
             Options {
                 nid: nid.ok_or_else(|| anyhow!("a Node ID must be specified"))?,
                 verbose,
             },
             vec![],
         ))
     }
     /// Verbose output
     #[arg(short, long)]
     pub verbose: bool,
 }
 pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
 pub fn run(options: Args, ctx: impl term::Context) -> anyhow::Result<()> {
     let profile = ctx.profile()?;
     let mut node = radicle::Node::new(profile.socket());
     let nid = options.nid;

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

@@ -46,6 +46,7 @@ struct CliArgs {

 #[derive(Subcommand, Debug)]
 enum Commands {
     Issue(issue::Args),
     Unfollow(unfollow::Args),
 }
 #[derive(Debug)]

@@ -270,11 +271,9 @@ fn run_other(exe: &str, args: &[OsString]) -> Result<(), Option<anyhow::Error>>

             );
         }
         "unfollow" => {
             term::run_command_args::<unfollow::Options, _>(
                 unfollow::HELP,
                 unfollow::run,
                 args.to_vec(),
             );
             if let Some(Commands::Unfollow(args)) = CliArgs::parse().command {
                 term::run_command_fn(unfollow::run, args);
             }
         }
         "unseed" => {
             term::run_command_args::<unseed::Options, _>(unseed::HELP, unseed::run, args.to_vec());