Struct SafeCommand 

pub struct SafeCommand<State = Unvalidated> { /* private fields */ }

A safe command builder with type-state pattern

Commands must be validated before they can be executed. The type-state pattern ensures this at compile time.

Type States

• SafeCommand<Unvalidated>: Command is being built, not yet validated
• SafeCommand<Validated>: Command has been validated and can be executed

Examples

use ggen_utils::safe_command::SafeCommand;

// Build and validate command
let cmd = SafeCommand::new("cargo")
    .unwrap()
    .arg("build")
    .unwrap()
    .arg("--release")
    .unwrap()
    .validate()
    .unwrap();

// Now cmd can be converted to std::process::Command
let process_cmd = cmd.into_command();

Implementations

impl SafeCommand<Unvalidated>

pub fn new<S: AsRef<str>>(command: S) -> Result<Self>

Create a new SafeCommand with a validated command name

Examples

use ggen_utils::safe_command::SafeCommand;

let cmd = SafeCommand::new("cargo").unwrap();
assert!(SafeCommand::new("rm").is_err());

pub fn arg<S: AsRef<str>>(self, arg: S) -> Result<Self>

Add an argument to the command

Examples

use ggen_utils::safe_command::SafeCommand;

let cmd = SafeCommand::new("cargo")
    .unwrap()
    .arg("build")
    .unwrap()
    .arg("--release")
    .unwrap();

pub fn arg_path(self, path: &SafePath) -> Self

Add a path argument to the command

This ensures path arguments are validated through SafePath.

Examples

use ggen_utils::safe_command::SafeCommand;
use ggen_utils::safe_path::SafePath;

let path = SafePath::new("src/generated").unwrap();
let cmd = SafeCommand::new("cargo")
    .unwrap()
    .arg("build")
    .unwrap()
    .arg_path(&path);

pub fn args<I, S>(self, args: I) -> Result<Self>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Add multiple arguments at once

Examples

use ggen_utils::safe_command::SafeCommand;

let cmd = SafeCommand::new("cargo")
    .unwrap()
    .args(&["build", "--release"])
    .unwrap();

pub fn validate(self) -> Result<SafeCommand<Validated>>

Validate the command and transition to Validated state

This performs final validation including total command length check.

Examples

use ggen_utils::safe_command::SafeCommand;

let cmd = SafeCommand::new("cargo")
    .unwrap()
    .arg("build")
    .unwrap()
    .validate()
    .unwrap();

impl SafeCommand<Validated>

pub fn into_command(self) -> Command

Convert this SafeCommand into a std::process::Command

This is only available for validated commands.

Examples

use ggen_utils::safe_command::SafeCommand;

let safe_cmd = SafeCommand::new("cargo")
    .unwrap()
    .arg("--version")
    .unwrap()
    .validate()
    .unwrap();

let mut cmd = safe_cmd.into_command();
// Now you can execute cmd with std::process::Command

pub fn command(&self) -> &CommandName

Get a reference to the command name

pub fn args(&self) -> &[CommandArg]

Get a reference to the arguments

pub fn to_string_debug(&self) -> String

Get the command as a string for display purposes

This does NOT execute the command, it just formats it as a string.

Trait Implementations

impl<State: Clone> Clone for SafeCommand<State>

fn clone(&self) -> SafeCommand<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for SafeCommand<State>

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

Formats the value using the given formatter.

impl Display for SafeCommand<Validated>

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

Formats the value using the given formatter.