Merge pull request #1349 from SierraSoftworks/feat/temp

feat: Add a `gt temp` command to create a temporary directory

Author: notheotherben

Cargo.toml

@@ -37,6 +37,7 @@ serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
 serde_yaml = "0.9"
 shell-words = "1.1"
+tempfile = "3.16"
 tokio = { version = "1.43", features = [
   "rt",
   "time",
@@ -50,7 +51,6 @@ trust-dns-resolver = { version = "0.23", features = ["tokio-runtime"] }
 
 [dev-dependencies]
 mockall = "0.13.1"
-tempfile = "3.16"
 sentry = { version = "0.36", default-features = false, features = [
   "reqwest",
   "rustls",

docs/.vuepress/components/Releases.vue

@@ -4,32 +4,17 @@
 
     <div class="release-platforms">
       <div>Select your Platform:</div>
-      <button
-        class="release-button release-platform"
-        :class="{ active: platform === selectedPlatform }"
-        v-for="(name, platform) in platforms"
-        :key="platform"
-        v-on:click="selectedPlatform = platform"
-      >
+      <button class="release-button release-platform" :class="{ active: platform === selectedPlatform }"
+        v-for="(name, platform) in platforms" :key="platform" v-on:click="selectedPlatform = platform">
         {{ name }}
       </button>
     </div>
 
     <div class="release-list" v-if="selectedPlatform">
-      <div
-        class="release"
-        v-for="release in applicableReleases"
-        :key="release.id"
-      >
+      <div class="release" v-for="release in applicableReleases" :key="release.id">
         <h4 class="release__name">
-          <a
-            class="release-button"
-            :href="
-              getReleaseAsset(release, selectedPlatform).browser_download_url
-            "
-            target="_blank"
-            >Download</a
-          >
+          <a class="release-button no-external-link-icon" :href="getReleaseAsset(release, selectedPlatform).browser_download_url
+            " target="_blank">Download</a>
 
           {{ release.name }}
           <Badge v-if="release.prerelease" text="Early Access" type="warning" />
@@ -137,6 +122,11 @@ export default defineComponent({
   margin: 20px;
 }
 
+.release__name {
+  margin-top: 1em;
+  padding-top: 0;
+}
+
 .release__notes {
   white-space: pre-wrap;
   word-break: break-word;
@@ -152,8 +142,8 @@ export default defineComponent({
 }
 
 .release-platform.active {
-  background: var(--c-brand);
-  color: var(--c-bg);
+  background: var(--vp-c-accent-bg);
+  color: var(--vp-c-accent-text);
 }
 
 .release-assets {
@@ -173,17 +163,22 @@ export default defineComponent({
 .release-button {
   background: none;
   border-radius: 5px;
-  color: var(--c-brand);
-  border: 1px solid var(--c-brand);
+  background: var();
+  color: var(--vp-c-accent-bg);
+  border: 1px solid var(--vp-c-accent-bg);
   font-size: 80%;
   padding: 7px;
   margin: 5px;
   cursor: pointer;
 }
 
+a.release-button {
+  text-decoration: none;
+}
+
 .release-button:hover,
 .release-button:focus {
-  background: var(--c-brand-light);
-  color: var(--c-bg);
+  background: var(--vp-c-accent-hover);
+  color: var(--vp-c-accent-text);
 }
-</style>
+</style>

docs/commands/scratch.md

@@ -50,9 +50,39 @@ gt s code
 # Open a specially named scratchpad folder
 gt s 2021w10-super-important
 ```
- 
+
 ::: tip
 You don't need to use our naming scheme if you don't want to, just run `gt s something` and
 we'll create a `something` folder for you with no complaints. *This can be useful if you
 have an important project which you don't want to lose track of.*
 :::
+
+## temp <Badge text="v3.6.0+" />
+The `gt temp` command is a shortcut for opening a temporary scratchpad which is automatically
+deleted when you close the launched application. This is useful when you want to quickly test
+something without leaving a mess behind.
+
+::: tip
+The `gt temp` command creates a temporary folder in your current user's temporary directory
+and launches the specified application in that folder. When the application exits, the folder
+will be automatically deleted.
+:::
+
+#### Example
+```powershell
+# Open a temporary scratchpad in your default app
+gt t
+
+# Open a temporary scratchpad in PowerShell
+gt temp pwsh
+
+# Open a temporary scratchpad and don't delete it when you're done
+gt temp --keep
+```
+
+::: warning
+Applications which exit immediately after launching (like VSCode's `code` command) will cause
+the temporary folder to be deleted immediately after the application is launched. You can prevent
+this by using the `--keep` flag to prevent the folder from being deleted - however you will need
+to manually clean it up when you're done (in this case it works much the same as a standard scratchpad).
+:::

docs/package-lock.json

@@ -111,6 +111,7 @@
           nativeBuildInputs = with pkgs; [
             cargo
             rustc
+            nodejs
           ] ++ nativeBuildInputs ++ buildInputs;
         };
       });

flake.nix

@@ -30,6 +30,7 @@ mod services;
 mod setup;
 mod shell_init;
 mod switch;
+mod temp;
 mod update;
 
 inventory::collect!(Command);

src/commands/mod.rs

@@ -0,0 +1,220 @@
+use super::async_trait;
+use super::*;
+use crate::core::Target;
+use clap::Arg;
+use tracing_batteries::prelude::*;
+
+pub struct TempCommand;
+crate::command!(TempCommand);
+
+#[async_trait]
+impl CommandRunnable for TempCommand {
+    fn name(&self) -> String {
+        String::from("temp")
+    }
+
+    fn app(&self) -> clap::Command {
+        clap::Command::new(self.name())
+            .version("1.0")
+            .visible_alias("t")
+            .about("opens a temporary folder which will be removed when the shell is closed")
+            .arg(
+                Arg::new("app")
+                    .help("The name of the application to launch.")
+                    .index(1),
+            )
+            .arg(
+                Arg::new("keep")
+                    .long("keep")
+                    .short('k')
+                    .help("do not remove the temp directory when the app exits.")
+                    .action(clap::ArgAction::SetTrue),
+            )
+    }
+
+    #[tracing::instrument(name = "gt temp", err, skip(self, core, matches))]
+    async fn run(&self, core: &Core, matches: &ArgMatches) -> Result<i32, errors::Error> {
+        let app = if let Some(app) = matches.get_one::<String>("app") {
+            core.config().get_app(app).ok_or_else(|| errors::user(
+            "The specified application does not exist.",
+            "Make sure you have added the application to your config file using 'git-tool config add apps/bash' or similar."))?
+        } else {
+            core.config().get_default_app().ok_or_else(|| errors::user(
+              "No default application available.",
+              "Make sure that you add an app to your config file using 'git-tool config add apps/bash' or similar."))?
+        };
+
+        let keep = matches.get_one::<bool>("keep").copied().unwrap_or_default();
+
+        let temp = core.resolver().get_temp(keep)?;
+
+        if keep {
+            writeln!(core.output(), "temp path: {}", temp.get_path().display())?;
+        }
+
+        let status = core.launcher().run(app, &temp).await?;
+        temp.close()?;
+
+        return Ok(status);
+    }
+
+    #[tracing::instrument(name = "gt complete -- gt temp", skip(self, core, completer, _matches))]
+    async fn complete(&self, core: &Core, completer: &Completer, _matches: &ArgMatches) {
+        completer.offer_many(core.config().get_apps().map(|a| a.get_name()));
+        completer.offer("--keep");
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::core::*;
+    use std::sync::{Arc, RwLock};
+
+    #[tokio::test]
+    async fn run_no_args() {
+        let cmd = TempCommand {};
+
+        let args = cmd.app().get_matches_from(vec!["temp"]);
+
+        let temp = tempfile::tempdir().unwrap();
+        let cfg = Config::from_str(&format!(
+            "
+directory: {}=
+
+apps:
+  - name: test-app
+    command: test
+    args:
+        - '{{ .Target.Name }}'
+",
+            temp.path().display(),
+        ))
+        .unwrap();
+
+        let temp_path = Arc::new(RwLock::new(None));
+        let core = Core::builder()
+            .with_config(cfg)
+            .with_mock_resolver(|mock| {
+                let temp_path = temp_path.clone();
+                mock.expect_get_temp().returning(move |keep| {
+                    let temp = TempTarget::new(keep).unwrap();
+                    *temp_path.write().unwrap() = Some(temp.get_path().to_owned());
+                    Ok(temp)
+                });
+            })
+            .with_mock_launcher(|mock| {
+                let temp_path = temp_path.clone();
+                mock.expect_run()
+                    .once()
+                    .withf(move |app, target| {
+                        app.get_name() == "test-app"
+                            && target.get_path() == *temp_path.read().unwrap().as_ref().unwrap()
+                    })
+                    .returning(|_, _| Box::pin(async { Ok(5) }));
+            })
+            .build();
+
+        match cmd.run(&core, &args).await {
+            Ok(status) => {
+                assert_eq!(status, 5, "it should forward the status code from the app");
+            }
+            Err(err) => panic!("{}", err.message()),
+        }
+
+        assert!(
+            !temp_path.read().unwrap().as_ref().unwrap().exists(),
+            "the temp dir should be removed when the app exits"
+        );
+    }
+
+    #[tokio::test]
+    async fn run_only_app() {
+        let cmd = TempCommand {};
+
+        let args = cmd.app().get_matches_from(vec!["temp", "test-app"]);
+
+        let temp = tempfile::tempdir().unwrap();
+        let cfg = Config::from_str(&format!(
+            "
+directory: {}
+
+apps:
+  - name: test-app
+    command: test
+    args:
+        - '{{ .Target.Name }}'
+",
+            temp.path().display(),
+        ))
+        .unwrap();
+
+        let temp_path = Arc::new(RwLock::new(None));
+        let core = Core::builder()
+            .with_config(cfg)
+            .with_mock_resolver(|mock| {
+                let temp_path = temp_path.clone();
+                mock.expect_get_temp().returning(move |keep| {
+                    let temp = TempTarget::new(keep).unwrap();
+                    *temp_path.write().unwrap() = Some(temp.get_path().to_owned());
+                    Ok(temp)
+                });
+            })
+            .with_mock_launcher(|mock| {
+                let temp_path = temp_path.clone();
+                mock.expect_run()
+                    .once()
+                    .withf(move |app, target| {
+                        app.get_name() == "test-app"
+                            && target.get_path() == *temp_path.read().unwrap().as_ref().unwrap()
+                    })
+                    .returning(|_, _| Box::pin(async { Ok(0) }));
+            })
+            .build();
+
+        match cmd.run(&core, &args).await {
+            Ok(_) => {}
+            Err(err) => panic!("{}", err.message()),
+        }
+
+        assert!(
+            !temp_path.read().unwrap().as_ref().unwrap().exists(),
+            "the temp dir should be removed when the app exits"
+        );
+    }
+
+    #[tokio::test]
+    async fn run_unknown_app() {
+        let cmd = TempCommand {};
+
+        let args = cmd.app().get_matches_from(vec!["temp", "unknown-app"]);
+
+        let temp = tempfile::tempdir().unwrap();
+        let cfg = Config::from_str(&format!(
+            "
+directory: {}
+
+apps:
+  - name: test-app
+    command: test
+    args:
+        - '{{ .Target.Name }}'
+",
+            temp.path().display(),
+        ))
+        .unwrap();
+
+        let core = Core::builder()
+            .with_config(cfg)
+            .with_mock_resolver(|mock| {
+                mock.expect_get_temp()
+                    .returning(|keep| Ok(TempTarget::new(keep).unwrap()));
+            })
+            .with_mock_launcher(|mock| {
+                mock.expect_run().never();
+            })
+            .build();
+
+        cmd.run(&core, &args).await.unwrap_or_default();
+    }
+}