reimplement push and fetch mutations with the new three-mode setup

Author: gulbanana

src-tauri/src/callbacks.rs

@@ -11,7 +11,11 @@ use anyhow::Result;
 use jj_lib::{git::RemoteCallbacks, repo::MutableRepo};
 use tauri::{Manager, Window};
 
-use crate::{messages::InputRequest, worker::WorkerCallbacks, AppState};
+use crate::{
+    messages::{InputField, InputRequest},
+    worker::WorkerCallbacks,
+    AppState,
+};
 
 pub struct FrontendCallbacks(pub Window);
 
@@ -29,7 +33,7 @@ impl WorkerCallbacks for FrontendCallbacks {
         let get_password = &mut |url: &str, username: &str| {
             self.request_input(
                 format!("Please enter a password for {} at {}", username, url),
-                ["Password".into()],
+                ["Password"],
             )
             .and_then(|mut fields| fields.remove("Password"))
         };
@@ -38,7 +42,7 @@ impl WorkerCallbacks for FrontendCallbacks {
         let get_username_password = &mut |url: &str| {
             self.request_input(
                 format!("Please enter a username and password for {}", url),
-                ["Username".into(), "Password".into()],
+                ["Username", "Password"],
             )
             .and_then(|mut fields| {
                 fields.remove("Username").and_then(|username| {
@@ -52,10 +56,22 @@ impl WorkerCallbacks for FrontendCallbacks {
 
         f(repo, cb)
     }
+
+    fn select_remote(&self, choices: &[&str]) -> Option<String> {
+        let response = self.request_input(
+            format!("Select a remote"),
+            [InputField {
+                label: "Select Remote".into(),
+                choices: choices.iter().map(|choice| choice.to_string()).collect(),
+            }],
+        );
+
+        response.and_then(|mut fields| fields.remove("Select Remote").to_owned())
+    }
 }
 
 impl FrontendCallbacks {
-    fn request_input<T: IntoIterator<Item = String>>(
+    fn request_input<T: IntoIterator<Item = U>, U: Into<InputField>>(
         &self,
         detail: String,
         fields: T,
@@ -72,7 +88,7 @@ impl FrontendCallbacks {
             InputRequest {
                 title: String::from("Git Login"),
                 detail,
-                fields: fields.into_iter().collect(),
+                fields: fields.into_iter().map(|field| field.into()).collect(),
             },
         ) {
             Ok(_) => (),

src-tauri/src/main.rs

@@ -26,8 +26,8 @@ use tauri_plugin_window_state::StateFlags;
 
 use messages::{
     AbandonRevisions, CheckoutRevision, CopyChanges, CreateRef, CreateRevision, DeleteRef,
-    DescribeRevision, DuplicateRevisions, FetchRemote, InputResponse, InsertRevision, MoveChanges,
-    MoveRef, MoveRevision, MoveSource, MutationResult, PushRemote, RenameBranch, RevId,
+    DescribeRevision, DuplicateRevisions, GitFetch, GitPush, InputResponse, InsertRevision,
+    MoveChanges, MoveRef, MoveRevision, MoveSource, MutationResult, RenameBranch, RevId,
     TrackBranch, UndoOperation, UntrackBranch,
 };
 use worker::{Mutation, Session, SessionEvent, WorkerSession};
@@ -140,6 +140,7 @@ fn main() -> Result<()> {
             query_log,
             query_log_next_page,
             query_revision,
+            query_remotes,
             checkout_revision,
             create_revision,
             insert_revision,
@@ -156,8 +157,8 @@ fn main() -> Result<()> {
             create_ref,
             delete_ref,
             move_ref,
-            push_remote,
-            fetch_remote,
+            git_push,
+            git_fetch,
             undo_operation
         ])
         .menu(menu::build_main)
@@ -316,6 +317,27 @@ fn query_revision(
         .map_err(InvokeError::from_anyhow)
 }
 
+#[tauri::command(async)]
+fn query_remotes(
+    window: Window,
+    app_state: State<AppState>,
+    tracking_branch: Option<String>,
+) -> Result<Vec<String>, InvokeError> {
+    let session_tx: Sender<SessionEvent> = app_state.get_session(window.label());
+    let (call_tx, call_rx) = channel();
+
+    session_tx
+        .send(SessionEvent::QueryRemotes {
+            tx: call_tx,
+            tracking_branch,
+        })
+        .map_err(InvokeError::from_error)?;
+    call_rx
+        .recv()
+        .map_err(InvokeError::from_error)?
+        .map_err(InvokeError::from_anyhow)
+}
+
 #[tauri::command(async)]
 fn checkout_revision(
     window: Window,
@@ -461,19 +483,19 @@ fn move_ref(
 }
 
 #[tauri::command(async)]
-fn push_remote(
+fn git_push(
     window: Window,
     app_state: State<AppState>,
-    mutation: PushRemote,
+    mutation: GitPush,
 ) -> Result<MutationResult, InvokeError> {
     try_mutate(window, app_state, mutation)
 }
 
 #[tauri::command(async)]
-fn fetch_remote(
+fn git_fetch(
     window: Window,
     app_state: State<AppState>,
-    mutation: FetchRemote,
+    mutation: GitFetch,
 ) -> Result<MutationResult, InvokeError> {
     try_mutate(window, app_state, mutation)
 }

src-tauri/src/messages/mod.rs

@@ -8,6 +8,7 @@ pub use queries::*;
 
 use std::{collections::HashMap, path::Path};
 
+use anyhow::{anyhow, Result};
 use chrono::{DateTime, FixedOffset, Local, LocalResult, TimeZone, Utc};
 use jj_lib::backend::{Signature, Timestamp};
 use serde::{Deserialize, Serialize};
@@ -143,6 +144,16 @@ pub enum StoreRef {
     },
 }
 
+impl StoreRef {
+    pub fn as_branch(&self) -> Result<&str> {
+        match self {
+            StoreRef::LocalBranch { branch_name, .. } => Ok(&branch_name),
+            StoreRef::RemoteBranch { branch_name, .. } => Ok(&branch_name),
+            _ => Err(anyhow!("not a local branch")),
+        }
+    }
+}
+
 /// Refers to one of the repository's manipulatable objects
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(tag = "type")]
@@ -182,7 +193,7 @@ pub enum Operand {
 pub struct InputRequest {
     pub title: String,
     pub detail: String,
-    pub fields: Vec<String>,
+    pub fields: Vec<InputField>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -195,3 +206,23 @@ pub struct InputResponse {
     pub cancel: bool,
     pub fields: HashMap<String, String>,
 }
+
+#[derive(Serialize, Debug, Clone)]
+#[cfg_attr(
+    feature = "ts-rs",
+    derive(TS),
+    ts(export, export_to = "../src/messages/")
+)]
+pub struct InputField {
+    pub label: String,
+    pub choices: Vec<String>,
+}
+
+impl From<&str> for InputField {
+    fn from(label: &str) -> Self {
+        InputField {
+            label: label.to_owned(),
+            choices: vec![],
+        }
+    }
+}

src-tauri/src/messages/mutations.rs

@@ -202,26 +202,45 @@ pub struct MoveRef {
     pub to_id: RevId,
 }
 
+/// XXX pushes all branches of a remote, all remotes of a branch, or one remotes of a branch - split up?
 #[derive(Deserialize, Debug)]
+#[serde(tag = "type")]
 #[cfg_attr(
     feature = "ts-rs",
     derive(TS),
     ts(export, export_to = "../src/messages/")
 )]
-pub struct PushRemote {
-    pub remote_name: String,
-    pub r#ref: Option<StoreRef>,
+pub enum GitPush {
+    AllBranches {
+        remote_name: String,
+    },
+    AllRemotes {
+        branch_ref: StoreRef,
+    },
+    RemoteBranch {
+        remote_name: String,
+        branch_ref: StoreRef,
+    },
 }
 
 #[derive(Deserialize, Debug)]
+#[serde(tag = "type")]
 #[cfg_attr(
     feature = "ts-rs",
     derive(TS),
     ts(export, export_to = "../src/messages/")
 )]
-pub struct FetchRemote {
-    pub remote_name: String,
-    pub r#ref: Option<StoreRef>,
+pub enum GitFetch {
+    AllBranches {
+        remote_name: String,
+    },
+    AllRemotes {
+        branch_ref: StoreRef,
+    },
+    RemoteBranch {
+        remote_name: String,
+        branch_ref: StoreRef,
+    },
 }
 
 #[derive(Deserialize, Debug)]

src-tauri/src/worker/mod.rs

@@ -45,6 +45,8 @@ pub trait WorkerCallbacks {
         repo: &mut MutableRepo,
         f: &dyn Fn(&mut MutableRepo, RemoteCallbacks<'_>) -> Result<()>,
     ) -> Result<()>;
+
+    fn select_remote(&self, choices: &[&str]) -> Option<String>;
 }
 
 struct NoCallbacks;
@@ -57,6 +59,10 @@ impl WorkerCallbacks for NoCallbacks {
     ) -> Result<()> {
         f(repo, RemoteCallbacks::default())
     }
+
+    fn select_remote(&self, choices: &[&str]) -> Option<String> {
+        choices.get(0).map(|choice| choice.to_string())
+    }
 }
 
 /// state that doesn't depend on jj-lib borrowings