blob: a9672ce3fe9020f0f5fcc17612f5a2299a730f18 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
//! This crate adds a helper method to
//! [`std::process::Command`](::std::process::Command) (and optionally its
//! equivalent in various async frameworks) to allocate a pty to spawn the
//! process into. This allows for manipulation of interactive programs.
//!
//! The basic functionality is provided by the [`Command`](Command) trait in
//! this crate:
//!
//! ```no_run
//! use pty_process::Command as _;
//!
//! let mut cmd = std::process::Command::new("nethack");
//! let child = cmd.spawn_pty(Some(&pty_process::Size::new(24, 80))).unwrap();
//! ```
//!
//! The `child` instance returned by the call to
//! [`spawn_pty`](Command::spawn_pty) is a thin wrapper around the `Child`
//! struct associated with the `Command` module used. You can use it
//! identically to how you would use the normal
//! [`std::process::Child`](::std::process::Child) instance, but it also
//! provides additional methods for interacting with the pty:
//!
//! ```no_run
//! # use pty_process::Command as _;
//! #
//! # let mut cmd = std::process::Command::new("nethack");
//! # let mut child = cmd
//! # .spawn_pty(Some(&pty_process::Size::new(24, 80))).unwrap();
//! use std::io::Write as _;
//!
//! child.pty().write_all(b"foo\n").unwrap();
//! child.resize_pty(&pty_process::Size::new(30, 100)).unwrap();
//! let status = child.wait().unwrap();
//! ```
//!
//! The available implementations are gated by features:
//! * `backend-std`: Add an implementation for
//! [`std::process::Command`](::std::process::Command). Enabled by default.
//! * `backend-smol`: Add an implementation for
//! [`smol::process::Command`](::smol::process::Command).
//! * `backend-async-std`: Add an implementation for
//! [`async_std::process::Command`](::async_std::process::Command).
//! * `backend-tokio`: Add an implementation for
//! [`tokio::process::Command`](::tokio::process::Command).
//!
//! Any number of backends may be enabled, depending on your needs.
mod command;
pub use command::{Child, Command};
mod error;
pub use error::{Error, Result};
mod pty;
pub use pty::Size;
#[cfg(feature = "backend-async-std")]
pub mod async_std;
#[cfg(feature = "backend-smol")]
pub mod smol;
#[cfg(feature = "backend-std")]
pub mod std;
#[cfg(feature = "backend-tokio")]
pub mod tokio;
|
