Trait cradle::input::Input [−][src]
pub trait Input { fn run<O>(self) -> O
where
Self: Sized,
O: Output, { ... } fn run_unit(self)
where
Self: Sized, { ... } fn run_result<O>(self) -> Result<O, Error>
where
Self: Sized,
O: Output, { ... } }
Expand description
All types that are possible arguments to cmd!
, cmd_unit!
or
cmd_result!
must implement this trait.
This makes cradle
very flexible.
For example you can pass in an executable as a String,
and a variable number of arguments as a Vec
:
use cradle::prelude::*; let executable = "echo"; let arguments = vec!["foo", "bar"]; let StdoutUntrimmed(output) = cmd!(executable, arguments); assert_eq!(output, "foo bar\n");
For more documentation on all possible input types,
see the documentation for the individual impls of Input
.
Here’s a non-exhaustive list of the most commonly used types to get you started:
String
and&str
,Split
(and its shortcut%
) to split commands by whitespace,PathBuf
and&Path
,- multiple sequence types, like
vectors
,slices
and (since version 1.51)arrays
, CurrentDir
,Env
for setting environment variables,Stdin
, andLogCommand
.
Tuples
cradle
also implements Input
for tuples of types that themselves implement Input
.
Instead of passing multiple arguments to cmd!
, they can be passed in a single tuple:
use cradle::prelude::*; let args = ("echo", "foo"); let StdoutTrimmed(output) = cmd!(args); assert_eq!(output, "foo");
This can be used to group arguments:
use cradle::prelude::*; let to_hex_command = ("xxd", "-ps", "-u", LogCommand); let StdoutTrimmed(output) = cmd!(to_hex_command, Stdin(&[14, 15, 16])); assert_eq!(output, "0E0F10");
Also, tuples make it possible to write wrappers around cmd!
without requiring the use of macros:
use cradle::prelude::*; fn to_hex<I: Input>(input: I) -> String { let StdoutTrimmed(hex) = cmd!(%"xxd -ps -u", input); hex } // It works for slices: let hex = to_hex(Stdin(&[14, 15, 16])); assert_eq!(hex, "0E0F10"); // Vectors: let hex = to_hex(Stdin(vec![14, 15, 16])); assert_eq!(hex, "0E0F10"); // And multiple arguments using tuples: let hex = to_hex((Stdin(&[14, 15, 16]), Stdin(&[17, 18, 19]))); assert_eq!(hex, "0E0F10111213");
Provided methods
input.run()
runs input
as a child process.
It’s equivalent to cmd!(input)
.
use cradle::prelude::*; let StdoutTrimmed(output) = ("echo", "foo").run(); assert_eq!(output, "foo");
input.run_unit()
runs input
as a child process.
It’s equivalent to cmd_unit!(input)
.
use cradle::prelude::*; ("touch", "foo").run_unit();
input.run_result()
runs input
as a child process.
It’s equivalent to cmd_result!(input)
.
use cradle::prelude::*; // make sure build tools are installed cmd_result!(%"which make")?; cmd_result!(%"which gcc")?; cmd_result!(%"which ld")?; cmd_result!(%"make build")?;
Implementations on Foreign Types
Blanket implementation for &_
.
Arguments of type OsString
are passed to the child process
as arguments.
use cradle::prelude::*; cmd_unit!("ls", std::env::var_os("HOME").unwrap());
Arguments of type &OsStr
are passed to the child process
as arguments.
use cradle::prelude::*; cmd_unit!("echo", std::env::current_dir().unwrap().file_name().unwrap());
Arguments of type &str
are passed to the child process as arguments.
This is especially useful because it allows you to use string literals:
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!("echo", "foo"); assert_eq!(output, "foo");
Arguments of type String
are passed to the child process
as arguments. Executables can also be passed as String
s:
use cradle::prelude::*; let executable: String = "echo".to_string(); let argument: String = "foo".to_string(); let StdoutTrimmed(output) = cmd!(executable, argument); assert_eq!(output, "foo");
Allows to use split
to split your argument into words:
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!("echo foo".split(' ')); assert_eq!(output, "foo");
Allows to use split_whitespace
to split your argument into words:
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!("echo foo".split_whitespace()); assert_eq!(output, "foo");
Allows to use split_ascii_whitespace
to split your argument into words:
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!("echo foo".split_ascii_whitespace()); assert_eq!(output, "foo");
impl<A, B, C, D, E> Input for (A, B, C, D, E) where
A: Input,
B: Input,
C: Input,
D: Input,
E: Input,
impl<A, B, C, D, E, F> Input for (A, B, C, D, E, F) where
A: Input,
B: Input,
C: Input,
D: Input,
E: Input,
F: Input,
impl<A, B, C, D, E, F, G> Input for (A, B, C, D, E, F, G) where
A: Input,
B: Input,
C: Input,
D: Input,
E: Input,
F: Input,
G: Input,
All elements of the given Vec
are used as arguments to cmd!
.
Same as passing in the elements separately.
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!(vec!["echo", "foo"]); assert_eq!(output, "foo");
Similar to the implementation for Vec<T>
.
All elements of the array will be used as arguments.
use cradle::prelude::*; let StdoutTrimmed(output) = cmd!(["echo", "foo"]); assert_eq!(output, "foo");
Only works on rust version 1.51
and up.
Similar to the implementation for Vec<T>
.
All elements of the slice will be used as arguments.
Arguments of type PathBuf
are passed to the child process
as arguments.
use cradle::prelude::*; use std::path::PathBuf; let current_dir: PathBuf = std::env::current_dir().unwrap(); cmd_unit!("ls", current_dir);
Arguments of type &Path
are passed to the child process
as arguments.
use cradle::prelude::*; use std::path::Path; let file: &Path = Path::new("./foo"); cmd_unit!("touch", file);