Enum ShellKind 

pub enum ShellKind {
    Posix,
    Csh,
    Tcsh,
    Rc,
    Fish,
    PowerShell,
    Pwsh,
    Nushell,
    Cmd,
    Xonsh,
    Elvish,
}

Variants

Posix

Csh

Tcsh

Rc

Fish

PowerShell

Pre-installed “legacy” powershell for windows

Pwsh

PowerShell 7.x

Nushell

Cmd

Xonsh

Elvish

Implementations

impl ShellKind

pub fn system() -> Self

pub fn supports_posix_chaining(&self) -> bool

Returns whether this shell’s command chaining syntax can be parsed by brush-parser.

This is used to determine if we can safely parse shell commands to extract sub-commands for security purposes (e.g., preventing shell injection in “always allow” patterns).

The brush-parser handles ; (sequential execution) and | (piping), which are supported by all common shells. It also handles && and || for conditional execution, $() and backticks for command substitution, and process substitution.

Shell Notes

• Nushell: Uses ; for sequential execution. The and/or keywords are boolean operators on values (e.g., $true and $false), not command chaining operators.
• Elvish: Uses ; to separate pipelines, which brush-parser handles. Elvish does not have && or || operators. Its and/or are special commands that operate on values, not command chaining (e.g., and $true $false).
• Rc (Plan 9): Uses ; for sequential execution and | for piping. Does not have &&/|| operators for conditional chaining. All current shell variants are listed here because brush-parser can handle their syntax. If a new ShellKind variant is added, evaluate whether brush-parser can safely parse its command chaining syntax before including it. Omitting a variant will cause tool_permissions::from_input to deny terminal commands that have always_allow patterns configured.

pub fn new(program: impl AsRef<Path>, is_windows: bool) -> Self

pub fn to_shell_variable(self, input: &str) -> String

pub fn args_for_shell( &self, interactive: bool, combined_command: String, ) -> Vec<String>

pub const fn command_prefix(&self) -> Option<char>

pub fn prepend_command_prefix<'a>(&self, command: &'a str) -> Cow<'a, str>

pub const fn sequential_commands_separator(&self) -> char

pub const fn sequential_and_commands_separator(&self) -> &'static str

pub fn try_quote<'a>(&self, arg: &'a str) -> Option<Cow<'a, str>>

pub fn quote_powershell(arg: &str) -> Cow<'_, str>

pub fn quote_pwsh(arg: &str) -> Cow<'_, str>

pub fn quote_cmd(arg: &str) -> Cow<'_, str>

pub fn try_quote_prefix_aware<'a>(&self, arg: &'a str) -> Option<Cow<'a, str>>

Quotes the given argument if necessary, taking into account the command prefix.

In other words, this will consider quoting arg without its command prefix to not break the command. You should use this over try_quote when you want to quote a shell command.

pub fn split(&self, input: &str) -> Option<Vec<String>>

pub const fn activate_keyword(&self) -> &'static str

pub const fn clear_screen_command(&self) -> &'static str

Trait Implementations

impl Clone for ShellKind

fn clone(&self) -> ShellKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ShellKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ShellKind

fn default() -> ShellKind

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ShellKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ShellKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ShellKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ShellKind

fn eq(&self, other: &ShellKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ShellKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ShellKind

impl Eq for ShellKind

impl StructuralPartialEq for ShellKind