chore(friendshipper): poll for pr mergeability in a separate thread

friendshipper/src-tauri/src/main.rs

@@ -79,11 +79,14 @@ fn force_window_to_front(window: Window) {
 const PORT: u16 = 8484;
 
 fn main() -> Result<(), CoreError> {
-    let arg = std::env::args().nth(1).unwrap_or_default();
-    if arg.starts_with("friendshipper://") {
-        tauri_plugin_deep_link::prepare("com.believer.friendshipper");
-    } else {
-        let _ = tauri_plugin_deep_link::set_identifier("com.believer.friendshipper");
+    #[cfg(not(target_os = "macos"))]
+    {
+        let arg = std::env::args().nth(1).unwrap_or_default();
+        if arg.starts_with("friendshipper://") {
+            tauri_plugin_deep_link::prepare("com.believer.friendshipper");
+        } else {
+            let _ = tauri_plugin_deep_link::set_identifier("com.believer.friendshipper");
+        }
     }
 
     // MacOS .app files don't inherit any PATH variables
@@ -358,28 +361,31 @@ fn main() -> Result<(), CoreError> {
                     }
                 });
 
-                let deep_link_handle = handle.clone();
-                tauri::async_runtime::spawn(async move {
-                    let deep_link_request = move |request| {
-                        info!("Received deep link: {:?}", request);
-                        match deep_link_handle.emit_all("scheme-request-received", request) {
+                #[cfg(not(target_os = "macos"))]
+                {
+                    let deep_link_handle = handle.clone();
+                    tauri::async_runtime::spawn(async move {
+                        let deep_link_request = move |request| {
+                            info!("Received deep link: {:?}", request);
+                            match deep_link_handle.emit_all("scheme-request-received", request) {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    error!("Failed to emit scheme-request-received: {:?}", e);
+                                }
+                            }
+
+                            if let Some(window) = deep_link_handle.get_window("main") {
+                                force_window_to_front(window);
+                            }
+                        };
+                        match tauri_plugin_deep_link::register("friendshipper", deep_link_request) {
                             Ok(_) => {}
                             Err(e) => {
-                                error!("Failed to emit scheme-request-received: {:?}", e);
+                                error!("Failed to register deep link handler: {:?}", e);
                             }
                         }
-
-                        if let Some(window) = deep_link_handle.get_window("main") {
-                            force_window_to_front(window);
-                        }
-                    };
-                    match tauri_plugin_deep_link::register("friendshipper", deep_link_request) {
-                        Ok(_) => {}
-                        Err(e) => {
-                            error!("Failed to register deep link handler: {:?}", e);
-                        }
-                    }
-                });
+                    });
+                }
 
                 Ok(())
             })

friendshipper/src-tauri/src/repo/operations/gh/submit.rs

@@ -79,7 +79,7 @@ impl Task for GitHubSubmitOp {
             repo = status.repo_name.clone();
         }
 
-        let mut pr = octocrab
+        let pr = octocrab
             .pulls(owner.clone(), repo.clone())
             .create(
                 format!("{} {}", SUBMIT_PREFIX, truncated_message),
@@ -89,16 +89,38 @@ impl Task for GitHubSubmitOp {
             .send()
             .await?;
 
-        pr = self
-            .poll_for_mergeable(octocrab, pr, owner.clone(), repo.clone())
-            .await?;
-
-        let id = self
-            .client
-            .get_pull_request_id(owner.clone(), repo.clone(), pr.number as i64)
-            .await?;
-
-        self.client.enqueue_pull_request(id).await?;
+        let octocrab_clone = octocrab.clone();
+        let owner_clone = owner.clone();
+        let repo_clone = repo.clone();
+        let client_clone = self.client.clone();
+        let self_clone = self.clone();
+
+        // There's a lot of variability in how long this takes, so we give the frontend
+        // a chance to return control to the user before it starts polling
+        tokio::spawn(async move {
+            match self_clone
+                .poll_for_mergeable(octocrab_clone, pr, owner_clone.clone(), repo_clone.clone())
+                .await
+            {
+                Ok(updated_pr) => {
+                    if let Ok(id) = client_clone
+                        .get_pull_request_id(
+                            owner_clone.clone(),
+                            repo_clone.clone(),
+                            updated_pr.number as i64,
+                        )
+                        .await
+                    {
+                        if let Err(e) = client_clone.enqueue_pull_request(id).await {
+                            warn!("Failed to enqueue pull request: {:?}", e);
+                        }
+                    } else {
+                        warn!("Failed to get pull request ID");
+                    }
+                }
+                Err(e) => warn!("Failed to poll for mergeable state: {:?}", e),
+            }
+        });
 
         Ok(())
     }