refactor: rename command mod to process, move restart_application (#1667)

* refactor: rename `command` mod to `process`, move restart_application

* refactor(api): move `exit`, `relaunch` APIs to `process` module

Author: lucasfernog

.changes/command-api-module.md

@@ -0,0 +1,5 @@
+---
+"tauri": patch
+---
+
+Renamed the `command` API module to `process`.

.changes/process-api.md

@@ -0,0 +1,5 @@
+---
+"api": patch
+---
+
+Move `exit` and `relaunch` APIs from `app` to `process` module.

.changes/restart-application.md

@@ -0,0 +1,5 @@
+---
+"tauri": patch
+---
+
+Move `restart_application` API from `app` module to `process` module.

core/tauri/scripts/bundle.js

@@ -6,11 +6,7 @@
 #![warn(missing_docs)]
 // #![feature(const_int_pow)]
 
-/// The App API module allows you to manage application processes.
-pub mod app;
-/// The Command API module allows you to manage child processes.
-pub mod command;
-/// The Dialog API module allows you to show messages and prompt for file paths.
+/// A module for working with processes.
 pub mod dialog;
 /// The Dir module is a helper for file system directory management.
 pub mod dir;
@@ -20,6 +16,8 @@ pub mod file;
 pub mod http;
 /// The file system path operations API.
 pub mod path;
+/// The Command API module allows you to manage child processes.
+pub mod process;
 /// The RPC module includes utilities to send messages to the JS layer of the webview.
 pub mod rpc;
 /// The shell api.

core/tauri/src/api/app.rs

@@ -4,9 +4,10 @@
 
 use std::{
   collections::HashMap,
+  env,
   io::{BufRead, BufReader, Write},
   path::PathBuf,
-  process::{Command as StdCommand, Stdio},
+  process::{exit, Command as StdCommand, Stdio},
   sync::Arc,
 };
 
@@ -67,6 +68,38 @@ macro_rules! get_std_command {
   }};
 }
 
+/// Get the current binary
+pub fn current_binary() -> Option<PathBuf> {
+  let mut current_binary = None;
+
+  // if we are running with an APP Image, we should return the app image path
+  #[cfg(target_os = "linux")]
+  if let Some(app_image_path) = env::var_os("APPIMAGE") {
+    current_binary = Some(PathBuf::from(app_image_path));
+  }
+
+  // if we didn't extracted binary in previous step,
+  // let use the current_exe from current environment
+  if current_binary.is_none() {
+    if let Ok(current_process) = env::current_exe() {
+      current_binary = Some(current_process);
+    }
+  }
+
+  current_binary
+}
+
+/// Restart the process.
+pub fn restart() {
+  if let Some(path) = current_binary() {
+    StdCommand::new(path)
+      .spawn()
+      .expect("application failed to start");
+  }
+
+  exit(0);
+}
+
 /// API to spawn commands.
 pub struct Command {
   program: String,

core/tauri/src/api/mod.rs

@@ -19,6 +19,7 @@ mod global_shortcut;
 mod http;
 mod internal;
 mod notification;
+mod process;
 mod shell;
 mod window;
 
@@ -39,6 +40,7 @@ impl<T: Serialize> From<T> for InvokeResponse {
 #[serde(tag = "module", content = "message")]
 enum Module {
   App(app::Cmd),
+  Process(process::Cmd),
   Fs(file_system::Cmd),
   Window(Box<window::Cmd>),
   Shell(shell::Cmd),
@@ -61,6 +63,8 @@ impl Module {
           .and_then(|r| r.json)
           .map_err(|e| e.to_string())
       }),
+      Self::Process(cmd) => message
+        .respond_async(async move { cmd.run().and_then(|r| r.json).map_err(|e| e.to_string()) }),
       Self::Fs(cmd) => message
         .respond_async(async move { cmd.run().and_then(|r| r.json).map_err(|e| e.to_string()) }),
       Self::Window(cmd) => message.respond_async(async move {

core/tauri/src/api/command.rs core/tauri/src/api/process.rscore/tauri/src/api/command.rs renamed to core/tauri/src/api/process.rs

@@ -2,10 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use std::process::exit;
-
 use super::InvokeResponse;
-use crate::api::{app::restart_application, PackageInfo};
+use crate::api::PackageInfo;
 use serde::Deserialize;
 
 /// The API descriptor.
@@ -18,11 +16,6 @@ pub enum Cmd {
   GetAppName,
   /// Get Tauri Version
   GetTauriVersion,
-  /// Relaunch application
-  Relaunch,
-  /// Close application with provided exit_code
-  #[serde(rename_all = "camelCase")]
-  Exit { exit_code: i32 },
 }
 
 impl Cmd {
@@ -31,16 +24,6 @@ impl Cmd {
       Self::GetAppVersion => Ok(package_info.version.into()),
       Self::GetAppName => Ok(package_info.name.into()),
       Self::GetTauriVersion => Ok(env!("CARGO_PKG_VERSION").into()),
-      Self::Relaunch => Ok({
-        restart_application(None);
-        ().into()
-      }),
-      Self::Exit { exit_code } => {
-        // would be great if we can have a handler inside tauri
-        // who close all window and emit an event that user can catch
-        // if they want to process something before closing the app
-        exit(exit_code);
-      }
     }
   }
 }

core/tauri/src/endpoints.rs

@@ -0,0 +1,37 @@
+// Copyright 2019-2021 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use std::process::exit;
+
+use super::InvokeResponse;
+use crate::api::process::restart;
+use serde::Deserialize;
+
+/// The API descriptor.
+#[derive(Deserialize)]
+#[serde(tag = "cmd", rename_all = "camelCase")]
+pub enum Cmd {
+  /// Relaunch application
+  Relaunch,
+  /// Close application with provided exit_code
+  #[serde(rename_all = "camelCase")]
+  Exit { exit_code: i32 },
+}
+
+impl Cmd {
+  pub fn run(self) -> crate::Result<InvokeResponse> {
+    match self {
+      Self::Relaunch => Ok({
+        restart();
+        ().into()
+      }),
+      Self::Exit { exit_code } => {
+        // would be great if we can have a handler inside tauri
+        // who close all window and emit an event that user can catch
+        // if they want to process something before closing the app
+        exit(exit_code);
+      }
+    }
+  }
+}