Add ShellCommand newtype

Cargo.toml

@@ -19,6 +19,7 @@ anyhow = {version = "1.0.65", features = ["backtrace"]}
 atty = "0.2.14"
 clap = {version = "4.0.17", features = ["derive"]}
 ctrlc = "3.2.3"
+derive_more = "0.99.17"
 dialoguer = {version = "0.10.2", default-features = false}
 dotenv-parser = {version = "0.1.3", default-features = false}
 env_logger = {version = "0.9.1", default-features = false, features = ["atty", "termcolor"]}

src/config/mod.rs

@@ -6,6 +6,7 @@ mod qualify;
 mod tests;
 
 use anyhow::{anyhow, bail, Context};
+use derive_more::{Deref, Display, From};
 use indexmap::{IndexMap, IndexSet};
 use log::{debug, error, info, trace};
 use serde::{Deserialize, Serialize};
@@ -44,7 +45,7 @@ pub struct Application {
 
 /// An application or profile name. Newtype allows us to apply validation during
 /// deserialization.
-#[derive(Clone, Debug, Default, Serialize, Hash, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Display, Serialize, Hash, Eq, PartialEq)]
 pub struct Name(String);
 
 /// A profile is a set of fixed variable mappings, i.e. each variable maps to
@@ -128,7 +129,7 @@ pub enum ValueSourceKind {
     /// A command that will be executed via the shell. Allows access to
     /// aliases, pipes, etc.
     #[serde(rename = "shell")]
-    ShellCommand { command: String },
+    ShellCommand { command: ShellCommand },
 
     /// Run a command in a kubernetes pod.
     #[serde(rename = "kubernetes")]
@@ -168,7 +169,7 @@ pub struct SideEffect {
 #[serde(untagged)]
 pub enum SideEffectCommand {
     Native(NativeCommand),
-    Shell(String),
+    Shell(ShellCommand),
 }
 
 /// A native command is a program name/path, with zero or more arguments. This
@@ -182,6 +183,23 @@ pub struct NativeCommand {
     pub arguments: Vec<String>,
 }
 
+/// A shell command is just a string, which will be parsed by the shell
+
+#[derive(
+    Clone,
+    Debug,
+    Display,
+    Deref,
+    Eq,
+    From,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize,
+)]
+#[display(fmt = "`{}`", "0")]
+pub struct ShellCommand(String);
+
 impl Config {
     /// Load config from the current directory and all parents. Any config
     /// file in any directory in the hierarchy will be loaded and merged into
@@ -240,12 +258,6 @@ impl Config {
     }
 }
 
-impl Display for Name {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
 // Validate application/profile name. We do a bit of sanity checking here to
 // prevent stuff that might be confusing, or collide with env-select features
 impl FromStr for Name {
@@ -353,7 +365,7 @@ impl Display for ValueSource {
                 write!(f, "{command} (native)")
             }
             ValueSourceKind::ShellCommand { command } => {
-                write!(f, "`{command}` (shell)")
+                write!(f, "{command} (shell)")
             }
             ValueSourceKind::KubernetesCommand {
                 command,
@@ -396,6 +408,12 @@ impl From<NativeCommand> for Vec<String> {
     }
 }
 
+impl From<&str> for ShellCommand {
+    fn from(value: &str) -> Self {
+        Self(value.to_owned())
+    }
+}
+
 // For deserialization
 impl TryFrom<Vec<String>> for NativeCommand {
     type Error = anyhow::Error;

src/config/tests.rs

@@ -174,7 +174,7 @@ pub fn native<const N: usize>(
 /// Helper to create a shell command
 pub fn shell(command: &str) -> ValueSource {
     ValueSourceKind::ShellCommand {
-        command: command.to_owned(),
+        command: command.into(),
     }
     .into()
 }
@@ -434,18 +434,21 @@ fn test_parse_side_effects() {
                 name: "SideEffect",
                 len: 2,
             },
+            //
             Token::Str("setup"),
             Token::Some,
             Token::Seq { len: Some(2) },
             Token::Str("echo"),
             Token::Str("setup"),
             Token::SeqEnd,
+            //
             Token::Str("teardown"),
             Token::Some,
             Token::Seq { len: Some(2) },
             Token::Str("echo"),
             Token::Str("teardown"),
             Token::SeqEnd,
+            //
             Token::StructEnd,
         ],
     );
@@ -458,12 +461,21 @@ fn test_parse_side_effects() {
                 name: "SideEffect",
                 len: 2,
             },
+            //
             Token::Str("setup"),
             Token::Some,
+            Token::NewtypeStruct {
+                name: "ShellCommand",
+            },
             Token::Str("echo setup"),
+            //
             Token::Str("teardown"),
             Token::Some,
+            Token::NewtypeStruct {
+                name: "ShellCommand",
+            },
             Token::Str("echo teardown"),
+            //
             Token::StructEnd,
         ],
     );
@@ -516,6 +528,9 @@ fn test_parse_shell_command() {
             Token::Str("type"),
             Token::Str("shell"),
             Token::Str("command"),
+            Token::NewtypeStruct {
+                name: "ShellCommand",
+            },
             Token::Str("echo test"),
             Token::StructEnd,
         ],

src/main.rs

@@ -280,7 +280,7 @@ impl Executor {
 
         let mut executable: Executable = if run_in_shell {
             // Undo the tokenization from clap
-            self.shell.executable(&command.join(" "))
+            self.shell.executable(&command.join(" ").into())
         } else {
             // This *shouldn't* fail because we marked the argument as required,
             // meaning clap will reject an empty command

src/shell.rs

@@ -1,6 +1,9 @@
-use crate::{environment::Environment, execute::Executable};
+use crate::{
+    config::ShellCommand, environment::Environment, execute::Executable,
+};
 use anyhow::anyhow;
 use clap::ValueEnum;
+use derive_more::Display;
 use log::{debug, info};
 use std::{
     env,
@@ -27,11 +30,15 @@ pub struct Shell {
     pub path: Option<String>,
 }
 
-/// A supported kind of shell
-#[derive(Copy, Clone, Debug, ValueEnum)]
+/// A supported kind of shell. The display implementation here defines the
+/// binary name that we'll use to invoke it
+#[derive(Copy, Clone, Debug, Display, ValueEnum)]
 pub enum ShellKind {
+    #[display(fmt = "bash")]
     Bash,
+    #[display(fmt = "zsh")]
     Zsh,
+    #[display(fmt = "fish")]
     Fish,
 }
 
@@ -103,7 +110,7 @@ impl Shell {
     }
 
     /// Get an [Executable] command to run in this shell
-    pub fn executable(&self, command: &str) -> Executable {
+    pub fn executable(&self, command: &ShellCommand) -> Executable {
         // Use the full shell path if we have it. Otherwise, just pass
         // the shell name and hope it's in PATH
         let shell_program =
@@ -116,17 +123,7 @@ impl Display for Shell {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match &self.path {
             Some(path) => write!(f, "{} (from $SHELL)", path),
-            None => write!(f, "{} (assumed to be in $PATH)", self.kind),
-        }
-    }
-}
-
-impl Display for ShellKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Bash => write!(f, "bash"),
-            Self::Zsh => write!(f, "zsh"),
-            Self::Fish => write!(f, "fish"),
+            None => write!(f, "{} (from $PATH)", self.kind),
         }
     }
 }