9e745b6 cli: add caching commands for patch and issue — heartwood

modified radicle-cli/src/commands/issue.rs

@@ -1,3 +1,6 @@

 #[path = "issue/cache.rs"]
 mod cache;
 use std::collections::BTreeSet;
 use std::ffi::OsString;
 use std::str::FromStr;

@@ -44,6 +47,7 @@ Usage

     rad issue comment <issue-id> [--message <message>] [--reply-to <comment-id>] [<option>...]
     rad issue show <issue-id> [<option>...]
     rad issue state <issue-id> [--closed | --open | --solved] [<option>...]
     rad issue cache [<issue-id>] [<option>...]
 Assign options

@@ -85,6 +89,7 @@ pub enum OperationName {

     React,
     Show,
     State,
     Cache,
 }
 /// Command line Peer argument.

@@ -142,6 +147,9 @@ pub enum Operation {

         assigned: Option<Assigned>,
         state: Option<State>,
     },
     Cache {
         id: Option<Rev>,
     },
 }
 #[derive(Debug, Default, PartialEq, Eq)]

@@ -341,6 +349,7 @@ impl Args for Options {

                     "s" | "state" => op = Some(OperationName::State),
                     "assign" => op = Some(OperationName::Assign),
                     "label" => op = Some(OperationName::Label),
                     "cache" => op = Some(OperationName::Cache),
                     unknown => anyhow::bail!("unknown operation '{}'", unknown),
                 },

@@ -397,6 +406,7 @@ impl Args for Options {

                 opts: label_opts,
             },
             OperationName::List => Operation::List { assigned, state },
             OperationName::Cache => Operation::Cache { id },
         };
         Ok((

@@ -553,6 +563,10 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

             let id = id.resolve(&repo.backend)?;
             issues.remove(&id, &signer)?;
         }
         Operation::Cache { id } => {
             let id = id.map(|id| id.resolve(&repo.backend)).transpose()?;
             cache::run(id, &repo, &profile)?;
         }
     }
     if announce {

added radicle-cli/src/commands/issue/cache.rs

@@ -0,0 +1,28 @@

 use std::ops::ControlFlow;
 use radicle::issue::IssueId;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 use crate::terminal as term;
 pub fn run(id: Option<IssueId>, repository: &Repository, profile: &Profile) -> anyhow::Result<()> {
     let mut issues = profile.issues_mut(repository)?;
     match id {
         Some(id) => {
             issues.write(&id)?;
             term::success!("Successfully cached issue `{id}`");
         }
         None => issues.write_all(|result, progress| {
             match result {
                 Ok((id, _)) => term::success!("Successfully cached issue `{id}`"),
                 Err(e) => term::warning(format!("Failed to retrieve issue: {e}")),
             };
             term::info!("Cached {} of {}", progress.seen(), progress.total());
             ControlFlow::Continue(())
         })?,
     }
     Ok(())
 }

modified radicle-cli/src/commands/patch.rs

@@ -2,6 +2,8 @@

 mod archive;
 #[path = "patch/assign.rs"]
 mod assign;
 #[path = "patch/cache.rs"]
 mod cache;
 #[path = "patch/checkout.rs"]
 mod checkout;
 #[path = "patch/comment.rs"]

@@ -67,6 +69,7 @@ Usage

     rad patch edit <patch-id> [<option>...]
     rad patch set <patch-id> [<option>...]
     rad patch comment <patch-id | revision-id> [<option>...]
     rad patch cache [<patch-id>] [<option>...]
 Show options

@@ -166,6 +169,7 @@ pub enum OperationName {

     Edit,
     Redact,
     Set,
     Cache,
 }
 #[derive(Debug, Default, PartialEq, Eq)]

@@ -243,6 +247,9 @@ pub enum Operation {

     Set {
         patch_id: Rev,
     },
     Cache {
         patch_id: Option<Rev>,
     },
 }
 impl Operation {

@@ -262,7 +269,8 @@ impl Operation {

             Operation::Show { .. }
             | Operation::Diff { .. }
             | Operation::Checkout { .. }
             | Operation::List { .. } => false,
             | Operation::List { .. }
             | Operation::Cache { .. } => false,
         }
     }
 }

@@ -518,6 +526,7 @@ impl Args for Options {

                     "comment" => op = Some(OperationName::Comment),
                     "review" => op = Some(OperationName::Review),
                     "set" => op = Some(OperationName::Set),
                     "cache" => op = Some(OperationName::Cache),
                     unknown => anyhow::bail!("unknown operation '{}'", unknown),
                 },
                 Value(val) if op == Some(OperationName::Redact) => {

@@ -540,6 +549,7 @@ impl Args for Options {

                             Some(OperationName::Set),
                             Some(OperationName::Assign),
                             Some(OperationName::Label),
                             Some(OperationName::Cache),
                         ]
                         .contains(&op) =>
                 {

@@ -615,6 +625,7 @@ impl Args for Options {

             OperationName::Set => Operation::Set {
                 patch_id: patch_id.ok_or_else(|| anyhow!("a patch must be provided"))?,
             },
             OperationName::Cache => Operation::Cache { patch_id },
         };
         Ok((

@@ -790,6 +801,12 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

             radicle::rad::setup_patch_upstream(&patch_id, *patch.head(), &workdir, true)?;
         }
         Operation::Cache { patch_id } => {
             let patch_id = patch_id
                 .map(|id| id.resolve(&repository.backend))
                 .transpose()?;
             cache::run(patch_id, &repository, &profile)?;
         }
     }
     if announce {

added radicle-cli/src/commands/patch/cache.rs

@@ -0,0 +1,28 @@

 use std::ops::ControlFlow;
 use radicle::patch::PatchId;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 use crate::terminal as term;
 pub fn run(id: Option<PatchId>, repository: &Repository, profile: &Profile) -> anyhow::Result<()> {
     let mut patches = profile.patches_mut(repository)?;
     match id {
         Some(id) => {
             patches.write(&id)?;
             term::success!("Successfully cached patch `{id}`");
         }
         None => patches.write_all(|result, progress| {
             match result {
                 Ok((id, _)) => term::success!("Successfully cached patch `{id}`"),
                 Err(e) => term::warning(format!("Failed to retrieve patch: {e}")),
             };
             term::info!("Cached {} of {}", progress.seen(), progress.total());
             ControlFlow::Continue(())
         })?,
     }
     Ok(())
 }