build(ariadne): vendor clap
This commit was merged in pull request #30.
This commit is contained in:
364
third_party/crates/anstream-1.0.0/src/_macros.rs
vendored
Normal file
364
third_party/crates/anstream-1.0.0/src/_macros.rs
vendored
Normal file
@@ -0,0 +1,364 @@
|
||||
/// Prints to [`stdout`][crate::stdout].
|
||||
///
|
||||
/// Equivalent to the [`println!`] macro except that a newline is not printed at
|
||||
/// the end of the message.
|
||||
///
|
||||
/// Note that stdout is frequently line-buffered by default so it may be
|
||||
/// necessary to use [`std::io::Write::flush()`] to ensure the output is emitted
|
||||
/// immediately.
|
||||
///
|
||||
/// **NOTE:** The `print!` macro will lock the standard output on each call. If you call
|
||||
/// `print!` within a hot loop, this behavior may be the bottleneck of the loop.
|
||||
/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]:
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use std::io::Write as _;
|
||||
///
|
||||
/// let mut lock = anstream::stdout().lock();
|
||||
/// write!(lock, "hello world").unwrap();
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Use `print!` only for the primary output of your program. Use
|
||||
/// [`eprint!`] instead to print error and progress messages.
|
||||
///
|
||||
/// **NOTE:** Not all `print!` calls will be captured in tests like [`std::print!`]
|
||||
/// - Capturing will automatically be activated in test binaries
|
||||
/// - Otherwise, only when the `test` feature is enabled
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if writing to `stdout` fails for any reason **except** broken pipe.
|
||||
///
|
||||
/// Writing to non-blocking stdout can cause an error, which will lead
|
||||
/// this macro to panic.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use std::io::Write as _;
|
||||
/// use anstream::print;
|
||||
/// use anstream::stdout;
|
||||
///
|
||||
/// print!("this ");
|
||||
/// print!("will ");
|
||||
/// print!("be ");
|
||||
/// print!("on ");
|
||||
/// print!("the ");
|
||||
/// print!("same ");
|
||||
/// print!("line ");
|
||||
///
|
||||
/// stdout().flush().unwrap();
|
||||
///
|
||||
/// print!("this string has a newline, why not choose println! instead?\n");
|
||||
///
|
||||
/// stdout().flush().unwrap();
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "auto")]
|
||||
#[macro_export]
|
||||
macro_rules! print {
|
||||
($($arg:tt)*) => {{
|
||||
if cfg!(test) || $crate::_macros::FEATURE_TEST_ACTIVATED {
|
||||
let target_stream = std::io::stdout();
|
||||
let buffer = $crate::_macros::to_adapted_string(&format_args!($($arg)*), &target_stream);
|
||||
::std::print!("{}", buffer)
|
||||
} else {
|
||||
use std::io::Write as _;
|
||||
|
||||
let mut stream = $crate::stdout();
|
||||
match ::std::write!(&mut stream, $($arg)*) {
|
||||
Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
|
||||
::std::panic!("failed printing to stdout: {e}");
|
||||
}
|
||||
Err(_) | Ok(_) => {}
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
/// Prints to [`stdout`][crate::stdout], with a newline.
|
||||
///
|
||||
/// On all platforms, the newline is the LINE FEED character (`\n`/`U+000A`) alone
|
||||
/// (no additional CARRIAGE RETURN (`\r`/`U+000D`)).
|
||||
///
|
||||
/// This macro uses the same syntax as [`format!`], but writes to the standard output instead.
|
||||
/// See [`std::fmt`] for more information.
|
||||
///
|
||||
/// **NOTE:** The `println!` macro will lock the standard output on each call. If you call
|
||||
/// `println!` within a hot loop, this behavior may be the bottleneck of the loop.
|
||||
/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]:
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use std::io::Write as _;
|
||||
///
|
||||
/// let mut lock = anstream::stdout().lock();
|
||||
/// writeln!(lock, "hello world").unwrap();
|
||||
/// # }
|
||||
/// ```
|
||||
///
|
||||
/// Use `println!` only for the primary output of your program. Use
|
||||
/// [`eprintln!`] instead to print error and progress messages.
|
||||
///
|
||||
/// **NOTE:** Not all `println!` calls will be captured in tests like [`std::println!`]
|
||||
/// - Capturing will automatically be activated in test binaries
|
||||
/// - Otherwise, only when the `test` feature is enabled
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if writing to `stdout` fails for any reason **except** broken pipe.
|
||||
///
|
||||
/// Writing to non-blocking stdout can cause an error, which will lead
|
||||
/// this macro to panic.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use anstream::println;
|
||||
///
|
||||
/// println!(); // prints just a newline
|
||||
/// println!("hello there!");
|
||||
/// println!("format {} arguments", "some");
|
||||
/// let local_variable = "some";
|
||||
/// println!("format {local_variable} arguments");
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "auto")]
|
||||
#[macro_export]
|
||||
macro_rules! println {
|
||||
() => {
|
||||
$crate::print!("\n")
|
||||
};
|
||||
($($arg:tt)*) => {{
|
||||
if cfg!(test) || $crate::_macros::FEATURE_TEST_ACTIVATED {
|
||||
let target_stream = std::io::stdout();
|
||||
let buffer = $crate::_macros::to_adapted_string(&format_args!($($arg)*), &target_stream);
|
||||
::std::println!("{}", buffer)
|
||||
} else {
|
||||
use std::io::Write as _;
|
||||
|
||||
let mut stream = $crate::stdout();
|
||||
match ::std::writeln!(&mut stream, $($arg)*) {
|
||||
Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
|
||||
::std::panic!("failed printing to stdout: {e}");
|
||||
}
|
||||
Err(_) | Ok(_) => {}
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
/// Prints to [`stderr`][crate::stderr].
|
||||
///
|
||||
/// Equivalent to the [`print!`] macro, except that output goes to
|
||||
/// `stderr` instead of `stdout`. See [`print!`] for
|
||||
/// example usage.
|
||||
///
|
||||
/// Use `eprint!` only for error and progress messages. Use `print!`
|
||||
/// instead for the primary output of your program.
|
||||
///
|
||||
/// **NOTE:** Not all `eprint!` calls will be captured in tests like [`std::eprint!`]
|
||||
/// - Capturing will automatically be activated in test binaries
|
||||
/// - Otherwise, only when the `test` feature is enabled
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if writing to `stderr` fails for any reason **except** broken pipe.
|
||||
///
|
||||
/// Writing to non-blocking stdout can cause an error, which will lead
|
||||
/// this macro to panic.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use anstream::eprint;
|
||||
///
|
||||
/// eprint!("Error: Could not complete task");
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "auto")]
|
||||
#[macro_export]
|
||||
macro_rules! eprint {
|
||||
($($arg:tt)*) => {{
|
||||
if cfg!(test) || $crate::_macros::FEATURE_TEST_ACTIVATED {
|
||||
let target_stream = std::io::stderr();
|
||||
let buffer = $crate::_macros::to_adapted_string(&format_args!($($arg)*), &target_stream);
|
||||
::std::eprint!("{}", buffer)
|
||||
} else {
|
||||
use std::io::Write as _;
|
||||
|
||||
let mut stream = $crate::stderr();
|
||||
match ::std::write!(&mut stream, $($arg)*) {
|
||||
Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
|
||||
::std::panic!("failed printing to stderr: {e}");
|
||||
}
|
||||
Err(_) | Ok(_) => {}
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
/// Prints to [`stderr`][crate::stderr], with a newline.
|
||||
///
|
||||
/// Equivalent to the [`println!`] macro, except that output goes to
|
||||
/// `stderr` instead of `stdout`. See [`println!`] for
|
||||
/// example usage.
|
||||
///
|
||||
/// Use `eprintln!` only for error and progress messages. Use `println!`
|
||||
/// instead for the primary output of your program.
|
||||
///
|
||||
/// **NOTE:** Not all `eprintln!` calls will be captured in tests like [`std::eprintln!`]
|
||||
/// - Capturing will automatically be activated in test binaries
|
||||
/// - Otherwise, only when the `test` feature is enabled
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// Panics if writing to `stderr` fails for any reason **except** broken pipe.
|
||||
///
|
||||
/// Writing to non-blocking stdout can cause an error, which will lead
|
||||
/// this macro to panic.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// use anstream::eprintln;
|
||||
///
|
||||
/// eprintln!("Error: Could not complete task");
|
||||
/// # }
|
||||
/// ```
|
||||
#[cfg(feature = "auto")]
|
||||
#[macro_export]
|
||||
macro_rules! eprintln {
|
||||
() => {
|
||||
$crate::eprint!("\n")
|
||||
};
|
||||
($($arg:tt)*) => {{
|
||||
if cfg!(test) || $crate::_macros::FEATURE_TEST_ACTIVATED {
|
||||
let target_stream = std::io::stderr();
|
||||
let buffer = $crate::_macros::to_adapted_string(&format_args!($($arg)*), &target_stream);
|
||||
::std::eprintln!("{}", buffer)
|
||||
} else {
|
||||
use std::io::Write as _;
|
||||
|
||||
let mut stream = $crate::stderr();
|
||||
match ::std::writeln!(&mut stream, $($arg)*) {
|
||||
Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
|
||||
::std::panic!("failed printing to stderr: {e}");
|
||||
}
|
||||
Err(_) | Ok(_) => {}
|
||||
}
|
||||
}
|
||||
}};
|
||||
}
|
||||
|
||||
/// Panics the current thread.
|
||||
///
|
||||
/// This allows a program to terminate immediately and provide feedback
|
||||
/// to the caller of the program.
|
||||
///
|
||||
/// This macro is the perfect way to assert conditions in example code and in
|
||||
/// tests. `panic!` is closely tied with the `unwrap` method of both
|
||||
/// [`Option`][ounwrap] and [`Result`][runwrap] enums. Both implementations call
|
||||
/// `panic!` when they are set to [`None`] or [`Err`] variants.
|
||||
///
|
||||
/// When using `panic!()` you can specify a string payload, that is built using
|
||||
/// the [`format!`] syntax. That payload is used when injecting the panic into
|
||||
/// the calling Rust thread, causing the thread to panic entirely.
|
||||
///
|
||||
/// The behavior of the default `std` hook, i.e. the code that runs directly
|
||||
/// after the panic is invoked, is to print the message payload to
|
||||
/// `stderr` along with the file/line/column information of the `panic!()`
|
||||
/// call. You can override the panic hook using [`std::panic::set_hook()`].
|
||||
/// Inside the hook a panic can be accessed as a `&dyn Any + Send`,
|
||||
/// which contains either a `&str` or `String` for regular `panic!()` invocations.
|
||||
/// To panic with a value of another other type, [`panic_any`] can be used.
|
||||
///
|
||||
/// See also the macro [`compile_error!`], for raising errors during compilation.
|
||||
///
|
||||
/// # When to use `panic!` vs `Result`
|
||||
///
|
||||
/// The Rust language provides two complementary systems for constructing /
|
||||
/// representing, reporting, propagating, reacting to, and discarding errors. These
|
||||
/// responsibilities are collectively known as "error handling." `panic!` and
|
||||
/// `Result` are similar in that they are each the primary interface of their
|
||||
/// respective error handling systems; however, the meaning these interfaces attach
|
||||
/// to their errors and the responsibilities they fulfill within their respective
|
||||
/// error handling systems differ.
|
||||
///
|
||||
/// The `panic!` macro is used to construct errors that represent a bug that has
|
||||
/// been detected in your program. With `panic!` you provide a message that
|
||||
/// describes the bug and the language then constructs an error with that message,
|
||||
/// reports it, and propagates it for you.
|
||||
///
|
||||
/// `Result` on the other hand is used to wrap other types that represent either
|
||||
/// the successful result of some computation, `Ok(T)`, or error types that
|
||||
/// represent an anticipated runtime failure mode of that computation, `Err(E)`.
|
||||
/// `Result` is used alongside user defined types which represent the various
|
||||
/// anticipated runtime failure modes that the associated computation could
|
||||
/// encounter. `Result` must be propagated manually, often with the help of the
|
||||
/// `?` operator and `Try` trait, and they must be reported manually, often with
|
||||
/// the help of the `Error` trait.
|
||||
///
|
||||
/// For more detailed information about error handling check out the [book] or the
|
||||
/// [`std::result`] module docs.
|
||||
///
|
||||
/// [ounwrap]: Option::unwrap
|
||||
/// [runwrap]: Result::unwrap
|
||||
/// [`std::panic::set_hook()`]: ../std/panic/fn.set_hook.html
|
||||
/// [`panic_any`]: ../std/panic/fn.panic_any.html
|
||||
/// [`Box`]: ../std/boxed/struct.Box.html
|
||||
/// [`format!`]: ../std/macro.format.html
|
||||
/// [book]: ../book/ch09-00-error-handling.html
|
||||
/// [`std::result`]: ../std/result/index.html
|
||||
///
|
||||
/// # Current implementation
|
||||
///
|
||||
/// If the main thread panics it will terminate all your threads and end your
|
||||
/// program with code `101`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```should_panic
|
||||
/// # #![allow(unreachable_code)]
|
||||
/// use anstream::panic;
|
||||
/// panic!();
|
||||
/// panic!("this is a terrible mistake!");
|
||||
/// panic!("this is a {} {message}", "fancy", message = "message");
|
||||
/// ```
|
||||
#[cfg(feature = "auto")]
|
||||
#[macro_export]
|
||||
macro_rules! panic {
|
||||
() => {
|
||||
::std::panic!()
|
||||
};
|
||||
($($arg:tt)*) => {{
|
||||
let target_stream = std::io::stderr();
|
||||
let buffer = $crate::_macros::to_adapted_string(&format_args!($($arg)*), &target_stream);
|
||||
::std::panic!("{}", buffer)
|
||||
}};
|
||||
}
|
||||
|
||||
#[cfg(feature = "auto")]
|
||||
pub const FEATURE_TEST_ACTIVATED: bool = cfg!(feature = "test");
|
||||
|
||||
#[cfg(feature = "auto")]
|
||||
pub fn to_adapted_string(
|
||||
display: &dyn std::fmt::Display,
|
||||
stream: &impl crate::stream::RawStream,
|
||||
) -> String {
|
||||
use std::io::Write as _;
|
||||
|
||||
let choice = crate::AutoStream::choice(stream);
|
||||
let buffer = Vec::new();
|
||||
let mut stream = crate::AutoStream::new(buffer, choice);
|
||||
// Ignore errors rather than panic
|
||||
let _ = ::std::write!(&mut stream, "{display}");
|
||||
let buffer = stream.into_inner();
|
||||
// Should be UTF-8 but not wanting to panic
|
||||
let buffer = String::from_utf8_lossy(&buffer).into_owned();
|
||||
buffer
|
||||
}
|
||||
15
third_party/crates/anstream-1.0.0/src/adapter/mod.rs
vendored
Normal file
15
third_party/crates/anstream-1.0.0/src/adapter/mod.rs
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
//! Gracefully degrade styled output
|
||||
|
||||
mod strip;
|
||||
mod wincon;
|
||||
|
||||
pub use strip::strip_bytes;
|
||||
pub use strip::strip_str;
|
||||
pub use strip::StripBytes;
|
||||
pub use strip::StripBytesIter;
|
||||
pub use strip::StripStr;
|
||||
pub use strip::StripStrIter;
|
||||
pub use strip::StrippedBytes;
|
||||
pub use strip::StrippedStr;
|
||||
pub use wincon::WinconBytes;
|
||||
pub use wincon::WinconBytesIter;
|
||||
511
third_party/crates/anstream-1.0.0/src/adapter/strip.rs
vendored
Normal file
511
third_party/crates/anstream-1.0.0/src/adapter/strip.rs
vendored
Normal file
@@ -0,0 +1,511 @@
|
||||
use anstyle_parse::state::state_change;
|
||||
use anstyle_parse::state::Action;
|
||||
use anstyle_parse::state::State;
|
||||
|
||||
/// Strip ANSI escapes from a `&str`, returning the printable content
|
||||
///
|
||||
/// This can be used to take output from a program that includes escape sequences and write it
|
||||
/// somewhere that does not easily support them, such as a log file.
|
||||
///
|
||||
/// For non-contiguous data, see [`StripStr`].
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::io::Write as _;
|
||||
///
|
||||
/// let styled_text = "\x1b[32mfoo\x1b[m bar";
|
||||
/// let plain_str = anstream::adapter::strip_str(&styled_text).to_string();
|
||||
/// assert_eq!(plain_str, "foo bar");
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn strip_str(data: &str) -> StrippedStr<'_> {
|
||||
StrippedStr::new(data)
|
||||
}
|
||||
|
||||
/// See [`strip_str`]
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub struct StrippedStr<'s> {
|
||||
bytes: &'s [u8],
|
||||
state: State,
|
||||
}
|
||||
|
||||
impl<'s> StrippedStr<'s> {
|
||||
#[inline]
|
||||
fn new(data: &'s str) -> Self {
|
||||
Self {
|
||||
bytes: data.as_bytes(),
|
||||
state: State::Ground,
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a [`String`] of the printable content
|
||||
#[inline]
|
||||
#[allow(clippy::inherent_to_string_shadow_display)] // Single-allocation implementation
|
||||
pub fn to_string(&self) -> String {
|
||||
use std::fmt::Write as _;
|
||||
let mut stripped = String::with_capacity(self.bytes.len());
|
||||
let _ = write!(&mut stripped, "{self}");
|
||||
stripped
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for StrippedStr<'_> {
|
||||
/// **Note:** this does *not* exhaust the [`Iterator`]
|
||||
#[inline]
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
let iter = Self {
|
||||
bytes: self.bytes,
|
||||
state: self.state,
|
||||
};
|
||||
for printable in iter {
|
||||
printable.fmt(f)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'s> Iterator for StrippedStr<'s> {
|
||||
type Item = &'s str;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
next_str(&mut self.bytes, &mut self.state)
|
||||
}
|
||||
}
|
||||
|
||||
/// Incrementally strip non-contiguous data
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub struct StripStr {
|
||||
state: State,
|
||||
}
|
||||
|
||||
impl StripStr {
|
||||
/// Initial state
|
||||
pub fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
/// Strip the next segment of data
|
||||
pub fn strip_next<'s>(&'s mut self, data: &'s str) -> StripStrIter<'s> {
|
||||
StripStrIter {
|
||||
bytes: data.as_bytes(),
|
||||
state: &mut self.state,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// See [`StripStr`]
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct StripStrIter<'s> {
|
||||
bytes: &'s [u8],
|
||||
state: &'s mut State,
|
||||
}
|
||||
|
||||
impl<'s> Iterator for StripStrIter<'s> {
|
||||
type Item = &'s str;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
next_str(&mut self.bytes, self.state)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn next_str<'s>(bytes: &mut &'s [u8], state: &mut State) -> Option<&'s str> {
|
||||
let offset = bytes.iter().copied().position(|b| {
|
||||
let (next_state, action) = state_change(*state, b);
|
||||
if next_state != State::Anywhere {
|
||||
*state = next_state;
|
||||
}
|
||||
is_printable_bytes(action, b)
|
||||
});
|
||||
let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len()));
|
||||
*bytes = next;
|
||||
*state = State::Ground;
|
||||
|
||||
let offset = bytes.iter().copied().position(|b| {
|
||||
let (_next_state, action) = state_change(State::Ground, b);
|
||||
!(is_printable_bytes(action, b) || is_utf8_continuation(b))
|
||||
});
|
||||
let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len()));
|
||||
*bytes = next;
|
||||
if printable.is_empty() {
|
||||
None
|
||||
} else {
|
||||
let printable = unsafe {
|
||||
from_utf8_unchecked(
|
||||
printable,
|
||||
"`bytes` was validated as UTF-8, the parser preserves UTF-8 continuations",
|
||||
)
|
||||
};
|
||||
Some(printable)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn from_utf8_unchecked<'b>(bytes: &'b [u8], safety_justification: &'static str) -> &'b str {
|
||||
unsafe {
|
||||
if cfg!(debug_assertions) {
|
||||
// Catch problems more quickly when testing
|
||||
std::str::from_utf8(bytes).expect(safety_justification)
|
||||
} else {
|
||||
std::str::from_utf8_unchecked(bytes)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_utf8_continuation(b: u8) -> bool {
|
||||
matches!(b, 0x80..=0xbf)
|
||||
}
|
||||
|
||||
/// Strip ANSI escapes from bytes, returning the printable content
|
||||
///
|
||||
/// This can be used to take output from a program that includes escape sequences and write it
|
||||
/// somewhere that does not easily support them, such as a log file.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// use std::io::Write as _;
|
||||
///
|
||||
/// let styled_text = "\x1b[32mfoo\x1b[m bar";
|
||||
/// let plain_str = anstream::adapter::strip_bytes(styled_text.as_bytes()).into_vec();
|
||||
/// assert_eq!(plain_str.as_slice(), &b"foo bar"[..]);
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn strip_bytes(data: &[u8]) -> StrippedBytes<'_> {
|
||||
StrippedBytes::new(data)
|
||||
}
|
||||
|
||||
/// See [`strip_bytes`]
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub struct StrippedBytes<'s> {
|
||||
bytes: &'s [u8],
|
||||
state: State,
|
||||
utf8parser: Utf8Parser,
|
||||
}
|
||||
|
||||
impl<'s> StrippedBytes<'s> {
|
||||
/// See [`strip_bytes`]
|
||||
#[inline]
|
||||
pub fn new(bytes: &'s [u8]) -> Self {
|
||||
Self {
|
||||
bytes,
|
||||
state: State::Ground,
|
||||
utf8parser: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Strip the next slice of bytes
|
||||
///
|
||||
/// Used when the content is in several non-contiguous slices
|
||||
///
|
||||
/// # Panic
|
||||
///
|
||||
/// May panic if it is not exhausted / empty
|
||||
#[inline]
|
||||
pub fn extend(&mut self, bytes: &'s [u8]) {
|
||||
debug_assert!(
|
||||
self.is_empty(),
|
||||
"current bytes must be processed to ensure we end at the right state"
|
||||
);
|
||||
self.bytes = bytes;
|
||||
}
|
||||
|
||||
/// Report the bytes has been exhausted
|
||||
#[inline]
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.bytes.is_empty()
|
||||
}
|
||||
|
||||
/// Create a [`Vec`] of the printable content
|
||||
#[inline]
|
||||
pub fn into_vec(self) -> Vec<u8> {
|
||||
let mut stripped = Vec::with_capacity(self.bytes.len());
|
||||
for printable in self {
|
||||
stripped.extend(printable);
|
||||
}
|
||||
stripped
|
||||
}
|
||||
}
|
||||
|
||||
impl<'s> Iterator for StrippedBytes<'s> {
|
||||
type Item = &'s [u8];
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
next_bytes(&mut self.bytes, &mut self.state, &mut self.utf8parser)
|
||||
}
|
||||
}
|
||||
|
||||
/// Incrementally strip non-contiguous data
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub struct StripBytes {
|
||||
state: State,
|
||||
utf8parser: Utf8Parser,
|
||||
}
|
||||
|
||||
impl StripBytes {
|
||||
/// Initial state
|
||||
pub fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
/// Strip the next segment of data
|
||||
pub fn strip_next<'s>(&'s mut self, bytes: &'s [u8]) -> StripBytesIter<'s> {
|
||||
StripBytesIter {
|
||||
bytes,
|
||||
state: &mut self.state,
|
||||
utf8parser: &mut self.utf8parser,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// See [`StripBytes`]
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct StripBytesIter<'s> {
|
||||
bytes: &'s [u8],
|
||||
state: &'s mut State,
|
||||
utf8parser: &'s mut Utf8Parser,
|
||||
}
|
||||
|
||||
impl<'s> Iterator for StripBytesIter<'s> {
|
||||
type Item = &'s [u8];
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
next_bytes(&mut self.bytes, self.state, self.utf8parser)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn next_bytes<'s>(
|
||||
bytes: &mut &'s [u8],
|
||||
state: &mut State,
|
||||
utf8parser: &mut Utf8Parser,
|
||||
) -> Option<&'s [u8]> {
|
||||
let offset = bytes.iter().copied().position(|b| {
|
||||
if *state == State::Utf8 {
|
||||
true
|
||||
} else {
|
||||
let (next_state, action) = state_change(*state, b);
|
||||
if next_state != State::Anywhere {
|
||||
*state = next_state;
|
||||
}
|
||||
is_printable_bytes(action, b)
|
||||
}
|
||||
});
|
||||
let (_, next) = bytes.split_at(offset.unwrap_or(bytes.len()));
|
||||
*bytes = next;
|
||||
|
||||
let offset = bytes.iter().copied().position(|b| {
|
||||
if *state == State::Utf8 {
|
||||
if utf8parser.add(b) {
|
||||
*state = State::Ground;
|
||||
}
|
||||
false
|
||||
} else {
|
||||
let (next_state, action) = state_change(State::Ground, b);
|
||||
if next_state != State::Anywhere {
|
||||
*state = next_state;
|
||||
}
|
||||
if *state == State::Utf8 {
|
||||
utf8parser.add(b);
|
||||
false
|
||||
} else {
|
||||
!is_printable_bytes(action, b)
|
||||
}
|
||||
}
|
||||
});
|
||||
let (printable, next) = bytes.split_at(offset.unwrap_or(bytes.len()));
|
||||
*bytes = next;
|
||||
if printable.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(printable)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub(crate) struct Utf8Parser {
|
||||
utf8_parser: utf8parse::Parser,
|
||||
}
|
||||
|
||||
impl Utf8Parser {
|
||||
fn add(&mut self, byte: u8) -> bool {
|
||||
let mut b = false;
|
||||
let mut receiver = VtUtf8Receiver(&mut b);
|
||||
self.utf8_parser.advance(&mut receiver, byte);
|
||||
b
|
||||
}
|
||||
}
|
||||
|
||||
struct VtUtf8Receiver<'a>(&'a mut bool);
|
||||
|
||||
impl utf8parse::Receiver for VtUtf8Receiver<'_> {
|
||||
fn codepoint(&mut self, _: char) {
|
||||
*self.0 = true;
|
||||
}
|
||||
|
||||
fn invalid_sequence(&mut self) {
|
||||
*self.0 = true;
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn is_printable_bytes(action: Action, byte: u8) -> bool {
|
||||
// VT320 considered 0x7f to be `Print`able but we expect to be working in UTF-8 systems and not
|
||||
// ISO Latin-1, making it DEL and non-printable
|
||||
const DEL: u8 = 0x7f;
|
||||
|
||||
// Continuations aren't included as they may also be control codes, requiring more context
|
||||
(action == Action::Print && byte != DEL)
|
||||
|| action == Action::BeginUtf8
|
||||
|| (action == Action::Execute && byte.is_ascii_whitespace())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use proptest::prelude::*;
|
||||
|
||||
/// Model based off full parser
|
||||
fn parser_strip(bytes: &[u8]) -> String {
|
||||
#[derive(Default)]
|
||||
struct Strip(String);
|
||||
impl Strip {
|
||||
fn with_capacity(capacity: usize) -> Self {
|
||||
Self(String::with_capacity(capacity))
|
||||
}
|
||||
}
|
||||
impl anstyle_parse::Perform for Strip {
|
||||
fn print(&mut self, c: char) {
|
||||
self.0.push(c);
|
||||
}
|
||||
|
||||
fn execute(&mut self, byte: u8) {
|
||||
if byte.is_ascii_whitespace() {
|
||||
self.0.push(byte as char);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut stripped = Strip::with_capacity(bytes.len());
|
||||
let mut parser = anstyle_parse::Parser::<anstyle_parse::DefaultCharAccumulator>::new();
|
||||
for byte in bytes {
|
||||
parser.advance(&mut stripped, *byte);
|
||||
}
|
||||
stripped.0
|
||||
}
|
||||
|
||||
/// Model verifying incremental parsing
|
||||
fn strip_char(mut s: &str) -> String {
|
||||
let mut result = String::new();
|
||||
let mut state = StripStr::new();
|
||||
while !s.is_empty() {
|
||||
let mut indices = s.char_indices();
|
||||
indices.next(); // current
|
||||
let offset = indices.next().map(|(i, _)| i).unwrap_or_else(|| s.len());
|
||||
let (current, remainder) = s.split_at(offset);
|
||||
for printable in state.strip_next(current) {
|
||||
result.push_str(printable);
|
||||
}
|
||||
s = remainder;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Model verifying incremental parsing
|
||||
fn strip_byte(s: &[u8]) -> Vec<u8> {
|
||||
let mut result = Vec::new();
|
||||
let mut state = StripBytes::default();
|
||||
for start in 0..s.len() {
|
||||
let current = &s[start..=start];
|
||||
for printable in state.strip_next(current) {
|
||||
result.extend(printable);
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_strip_bytes_multibyte() {
|
||||
let bytes = [240, 145, 141, 139];
|
||||
let expected = parser_strip(&bytes);
|
||||
let actual = String::from_utf8(strip_bytes(&bytes).into_vec()).unwrap();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_strip_byte_multibyte() {
|
||||
let bytes = [240, 145, 141, 139];
|
||||
let expected = parser_strip(&bytes);
|
||||
let actual = String::from_utf8(strip_byte(&bytes).clone()).unwrap();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_strip_str_del() {
|
||||
let input = std::str::from_utf8(&[0x7f]).unwrap();
|
||||
let expected = "";
|
||||
let actual = strip_str(input).to_string();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_strip_byte_del() {
|
||||
let bytes = [0x7f];
|
||||
let expected = "";
|
||||
let actual = String::from_utf8(strip_byte(&bytes).clone()).unwrap();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_strip_str_handles_broken_sequence() {
|
||||
// valid utf8: \xc3\xb6 then \x1b then \xf0\x9f\x98\x80
|
||||
let s = "ö\x1b😀hello😀goodbye";
|
||||
let mut it = strip_str(s);
|
||||
assert_eq!("ö", it.next().unwrap());
|
||||
assert_eq!("ello😀goodbye", it.next().unwrap());
|
||||
}
|
||||
|
||||
proptest! {
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn strip_str_no_escapes(s in "\\PC*") {
|
||||
let expected = parser_strip(s.as_bytes());
|
||||
let actual = strip_str(&s).to_string();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn strip_char_no_escapes(s in "\\PC*") {
|
||||
let expected = parser_strip(s.as_bytes());
|
||||
let actual = strip_char(&s);
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn strip_bytes_no_escapes(s in "\\PC*") {
|
||||
dbg!(&s);
|
||||
dbg!(s.as_bytes());
|
||||
let expected = parser_strip(s.as_bytes());
|
||||
let actual = String::from_utf8(strip_bytes(s.as_bytes()).into_vec()).unwrap();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn strip_byte_no_escapes(s in "\\PC*") {
|
||||
dbg!(&s);
|
||||
dbg!(s.as_bytes());
|
||||
let expected = parser_strip(s.as_bytes());
|
||||
let actual = String::from_utf8(strip_byte(s.as_bytes()).clone()).unwrap();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
}
|
||||
}
|
||||
378
third_party/crates/anstream-1.0.0/src/adapter/wincon.rs
vendored
Normal file
378
third_party/crates/anstream-1.0.0/src/adapter/wincon.rs
vendored
Normal file
@@ -0,0 +1,378 @@
|
||||
/// Incrementally convert to wincon calls for non-contiguous data
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
pub struct WinconBytes {
|
||||
parser: anstyle_parse::Parser,
|
||||
capture: WinconCapture,
|
||||
}
|
||||
|
||||
impl WinconBytes {
|
||||
/// Initial state
|
||||
pub fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
/// Strip the next segment of data
|
||||
pub fn extract_next<'s>(&'s mut self, bytes: &'s [u8]) -> WinconBytesIter<'s> {
|
||||
self.capture.reset();
|
||||
self.capture.printable.reserve(bytes.len());
|
||||
WinconBytesIter {
|
||||
bytes,
|
||||
parser: &mut self.parser,
|
||||
capture: &mut self.capture,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// See [`WinconBytes`]
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct WinconBytesIter<'s> {
|
||||
bytes: &'s [u8],
|
||||
parser: &'s mut anstyle_parse::Parser,
|
||||
capture: &'s mut WinconCapture,
|
||||
}
|
||||
|
||||
impl Iterator for WinconBytesIter<'_> {
|
||||
type Item = (anstyle::Style, String);
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
next_bytes(&mut self.bytes, self.parser, self.capture)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn next_bytes(
|
||||
bytes: &mut &[u8],
|
||||
parser: &mut anstyle_parse::Parser,
|
||||
capture: &mut WinconCapture,
|
||||
) -> Option<(anstyle::Style, String)> {
|
||||
capture.reset();
|
||||
while capture.ready.is_none() {
|
||||
let byte = if let Some((byte, remainder)) = (*bytes).split_first() {
|
||||
*bytes = remainder;
|
||||
*byte
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
parser.advance(capture, byte);
|
||||
}
|
||||
if capture.printable.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let style = capture.ready.unwrap_or(capture.style);
|
||||
Some((style, std::mem::take(&mut capture.printable)))
|
||||
}
|
||||
|
||||
#[derive(Default, Clone, Debug, PartialEq, Eq)]
|
||||
struct WinconCapture {
|
||||
style: anstyle::Style,
|
||||
printable: String,
|
||||
ready: Option<anstyle::Style>,
|
||||
}
|
||||
|
||||
impl WinconCapture {
|
||||
fn reset(&mut self) {
|
||||
self.ready = None;
|
||||
}
|
||||
}
|
||||
|
||||
impl anstyle_parse::Perform for WinconCapture {
|
||||
/// Draw a character to the screen and update states.
|
||||
fn print(&mut self, c: char) {
|
||||
self.printable.push(c);
|
||||
}
|
||||
|
||||
/// Execute a C0 or C1 control function.
|
||||
fn execute(&mut self, byte: u8) {
|
||||
if byte.is_ascii_whitespace() {
|
||||
self.printable.push(byte as char);
|
||||
}
|
||||
}
|
||||
|
||||
fn csi_dispatch(
|
||||
&mut self,
|
||||
params: &anstyle_parse::Params,
|
||||
_intermediates: &[u8],
|
||||
ignore: bool,
|
||||
action: u8,
|
||||
) {
|
||||
if ignore {
|
||||
return;
|
||||
}
|
||||
if action != b'm' {
|
||||
return;
|
||||
}
|
||||
|
||||
let mut style = self.style;
|
||||
// param/value differences are dependent on the escape code
|
||||
let mut state = CsiState::Normal;
|
||||
let mut r = None;
|
||||
let mut g = None;
|
||||
let mut color_target = ColorTarget::Fg;
|
||||
for param in params {
|
||||
for value in param {
|
||||
match (state, *value) {
|
||||
(CsiState::Normal, 0) => {
|
||||
style = anstyle::Style::default();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 1) => {
|
||||
style = style.bold();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 2) => {
|
||||
style = style.dimmed();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 3) => {
|
||||
style = style.italic();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 4) => {
|
||||
style = style.underline();
|
||||
state = CsiState::Underline;
|
||||
}
|
||||
(CsiState::Normal, 21) => {
|
||||
style |= anstyle::Effects::DOUBLE_UNDERLINE;
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 7) => {
|
||||
style = style.invert();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 8) => {
|
||||
style = style.hidden();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 9) => {
|
||||
style = style.strikethrough();
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 30..=37) => {
|
||||
let color = to_ansi_color(value - 30).expect("within 4-bit range");
|
||||
style = style.fg_color(Some(color.into()));
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 38) => {
|
||||
color_target = ColorTarget::Fg;
|
||||
state = CsiState::PrepareCustomColor;
|
||||
}
|
||||
(CsiState::Normal, 39) => {
|
||||
style = style.fg_color(None);
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 40..=47) => {
|
||||
let color = to_ansi_color(value - 40).expect("within 4-bit range");
|
||||
style = style.bg_color(Some(color.into()));
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 48) => {
|
||||
color_target = ColorTarget::Bg;
|
||||
state = CsiState::PrepareCustomColor;
|
||||
}
|
||||
(CsiState::Normal, 49) => {
|
||||
style = style.bg_color(None);
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 58) => {
|
||||
color_target = ColorTarget::Underline;
|
||||
state = CsiState::PrepareCustomColor;
|
||||
}
|
||||
(CsiState::Normal, 90..=97) => {
|
||||
let color = to_ansi_color(value - 90)
|
||||
.expect("within 4-bit range")
|
||||
.bright(true);
|
||||
style = style.fg_color(Some(color.into()));
|
||||
break;
|
||||
}
|
||||
(CsiState::Normal, 100..=107) => {
|
||||
let color = to_ansi_color(value - 100)
|
||||
.expect("within 4-bit range")
|
||||
.bright(true);
|
||||
style = style.bg_color(Some(color.into()));
|
||||
break;
|
||||
}
|
||||
(CsiState::PrepareCustomColor, 5) => {
|
||||
state = CsiState::Ansi256;
|
||||
}
|
||||
(CsiState::PrepareCustomColor, 2) => {
|
||||
state = CsiState::Rgb;
|
||||
r = None;
|
||||
g = None;
|
||||
}
|
||||
(CsiState::Ansi256, n) => {
|
||||
let color = anstyle::Ansi256Color(n as u8);
|
||||
style = match color_target {
|
||||
ColorTarget::Fg => style.fg_color(Some(color.into())),
|
||||
ColorTarget::Bg => style.bg_color(Some(color.into())),
|
||||
ColorTarget::Underline => style.underline_color(Some(color.into())),
|
||||
};
|
||||
break;
|
||||
}
|
||||
(CsiState::Rgb, b) => match (r, g) {
|
||||
(None, _) => {
|
||||
r = Some(b);
|
||||
}
|
||||
(Some(_), None) => {
|
||||
g = Some(b);
|
||||
}
|
||||
(Some(r), Some(g)) => {
|
||||
let color = anstyle::RgbColor(r as u8, g as u8, b as u8);
|
||||
style = match color_target {
|
||||
ColorTarget::Fg => style.fg_color(Some(color.into())),
|
||||
ColorTarget::Bg => style.bg_color(Some(color.into())),
|
||||
ColorTarget::Underline => style.underline_color(Some(color.into())),
|
||||
};
|
||||
break;
|
||||
}
|
||||
},
|
||||
(CsiState::Underline, 0) => {
|
||||
style =
|
||||
style.effects(style.get_effects().remove(anstyle::Effects::UNDERLINE));
|
||||
}
|
||||
(CsiState::Underline, 1) => {
|
||||
// underline already set
|
||||
}
|
||||
(CsiState::Underline, 2) => {
|
||||
style = style
|
||||
.effects(style.get_effects().remove(anstyle::Effects::UNDERLINE))
|
||||
| anstyle::Effects::DOUBLE_UNDERLINE;
|
||||
}
|
||||
(CsiState::Underline, 3) => {
|
||||
style = style
|
||||
.effects(style.get_effects().remove(anstyle::Effects::UNDERLINE))
|
||||
| anstyle::Effects::CURLY_UNDERLINE;
|
||||
}
|
||||
(CsiState::Underline, 4) => {
|
||||
style = style
|
||||
.effects(style.get_effects().remove(anstyle::Effects::UNDERLINE))
|
||||
| anstyle::Effects::DOTTED_UNDERLINE;
|
||||
}
|
||||
(CsiState::Underline, 5) => {
|
||||
style = style
|
||||
.effects(style.get_effects().remove(anstyle::Effects::UNDERLINE))
|
||||
| anstyle::Effects::DASHED_UNDERLINE;
|
||||
}
|
||||
_ => {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if style != self.style && !self.printable.is_empty() {
|
||||
self.ready = Some(self.style);
|
||||
}
|
||||
self.style = style;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
|
||||
enum CsiState {
|
||||
Normal,
|
||||
PrepareCustomColor,
|
||||
Ansi256,
|
||||
Rgb,
|
||||
Underline,
|
||||
}
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
|
||||
enum ColorTarget {
|
||||
Fg,
|
||||
Bg,
|
||||
Underline,
|
||||
}
|
||||
|
||||
fn to_ansi_color(digit: u16) -> Option<anstyle::AnsiColor> {
|
||||
match digit {
|
||||
0 => Some(anstyle::AnsiColor::Black),
|
||||
1 => Some(anstyle::AnsiColor::Red),
|
||||
2 => Some(anstyle::AnsiColor::Green),
|
||||
3 => Some(anstyle::AnsiColor::Yellow),
|
||||
4 => Some(anstyle::AnsiColor::Blue),
|
||||
5 => Some(anstyle::AnsiColor::Magenta),
|
||||
6 => Some(anstyle::AnsiColor::Cyan),
|
||||
7 => Some(anstyle::AnsiColor::White),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use proptest::prelude::*;
|
||||
|
||||
#[track_caller]
|
||||
fn verify(input: &str, expected: Vec<(anstyle::Style, &str)>) {
|
||||
let expected = expected
|
||||
.into_iter()
|
||||
.map(|(style, value)| (style, value.to_owned()))
|
||||
.collect::<Vec<_>>();
|
||||
let mut state = WinconBytes::new();
|
||||
let actual = state.extract_next(input.as_bytes()).collect::<Vec<_>>();
|
||||
assert_eq!(expected, actual, "{input:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn start() {
|
||||
let green_on_red = anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red);
|
||||
let input = format!("{green_on_red}Hello{green_on_red:#} world!");
|
||||
let expected = vec![
|
||||
(green_on_red, "Hello"),
|
||||
(anstyle::Style::default(), " world!"),
|
||||
];
|
||||
verify(&input, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn middle() {
|
||||
let green_on_red = anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red);
|
||||
let input = format!("Hello {green_on_red}world{green_on_red:#}!");
|
||||
let expected = vec![
|
||||
(anstyle::Style::default(), "Hello "),
|
||||
(green_on_red, "world"),
|
||||
(anstyle::Style::default(), "!"),
|
||||
];
|
||||
verify(&input, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn end() {
|
||||
let green_on_red = anstyle::AnsiColor::Green.on(anstyle::AnsiColor::Red);
|
||||
let input = format!("Hello {green_on_red}world!{green_on_red:#}");
|
||||
let expected = vec![
|
||||
(anstyle::Style::default(), "Hello "),
|
||||
(green_on_red, "world!"),
|
||||
];
|
||||
verify(&input, expected);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ansi256_colors() {
|
||||
let ansi_11 = anstyle::Ansi256Color(11).on_default();
|
||||
// termcolor only supports "brights" via these
|
||||
let input = format!("Hello {ansi_11}world{ansi_11:#}!");
|
||||
let expected = vec![
|
||||
(anstyle::Style::default(), "Hello "),
|
||||
(ansi_11, "world"),
|
||||
(anstyle::Style::default(), "!"),
|
||||
];
|
||||
verify(&input, expected);
|
||||
}
|
||||
|
||||
proptest! {
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn wincon_no_escapes(s in "\\PC*") {
|
||||
let expected = if s.is_empty() {
|
||||
vec![]
|
||||
} else {
|
||||
vec![(anstyle::Style::default(), s.clone())]
|
||||
};
|
||||
let mut state = WinconBytes::new();
|
||||
let actual = state.extract_next(s.as_bytes()).collect::<Vec<_>>();
|
||||
assert_eq!(expected, actual);
|
||||
}
|
||||
}
|
||||
}
|
||||
313
third_party/crates/anstream-1.0.0/src/auto.rs
vendored
Normal file
313
third_party/crates/anstream-1.0.0/src/auto.rs
vendored
Normal file
@@ -0,0 +1,313 @@
|
||||
use crate::stream::AsLockedWrite;
|
||||
use crate::stream::RawStream;
|
||||
use crate::ColorChoice;
|
||||
use crate::StripStream;
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
use crate::WinconStream;
|
||||
|
||||
/// [`std::io::Write`] that adapts ANSI escape codes to the underlying `Write`s capabilities
|
||||
///
|
||||
/// This includes
|
||||
/// - Stripping colors for non-terminals
|
||||
/// - Respecting env variables like [NO_COLOR](https://no-color.org/) or [CLICOLOR](https://bixense.com/clicolors/)
|
||||
/// - *(windows)* Falling back to the wincon API where [ENABLE_VIRTUAL_TERMINAL_PROCESSING](https://learn.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#output-sequences) is unsupported
|
||||
///
|
||||
/// You can customize auto-detection by calling into
|
||||
/// [anstyle_query](https://docs.rs/anstyle-query/latest/anstyle_query/)
|
||||
/// to get a [`ColorChoice`] and then calling [`AutoStream::new(stream, choice)`].
|
||||
#[derive(Debug)]
|
||||
pub struct AutoStream<S: RawStream> {
|
||||
inner: StreamInner<S>,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum StreamInner<S: RawStream> {
|
||||
PassThrough(S),
|
||||
Strip(StripStream<S>),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
Wincon(WinconStream<S>),
|
||||
}
|
||||
|
||||
impl<S> AutoStream<S>
|
||||
where
|
||||
S: RawStream,
|
||||
{
|
||||
/// Runtime control over styling behavior
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```rust
|
||||
/// # #[cfg(feature = "auto")] {
|
||||
/// # use std::io::IsTerminal as _;
|
||||
/// // Like `AutoStream::choice` but without `NO_COLOR`, `CLICOLOR_FORCE`, `CI`
|
||||
/// fn choice(raw: &dyn anstream::stream::RawStream) -> anstream::ColorChoice {
|
||||
/// let choice = anstream::ColorChoice::global();
|
||||
/// if choice == anstream::ColorChoice::Auto {
|
||||
/// if raw.is_terminal() && anstyle_query::term_supports_color() {
|
||||
/// anstream::ColorChoice::Always
|
||||
/// } else {
|
||||
/// anstream::ColorChoice::Never
|
||||
/// }
|
||||
/// } else {
|
||||
/// choice
|
||||
/// }
|
||||
/// }
|
||||
///
|
||||
/// let stream = std::io::stdout();
|
||||
/// let choice = choice(&stream);
|
||||
/// let auto = anstream::AutoStream::new(stream, choice);
|
||||
/// # }
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn new(raw: S, choice: ColorChoice) -> Self {
|
||||
match choice {
|
||||
#[cfg(feature = "auto")]
|
||||
ColorChoice::Auto => Self::auto(raw),
|
||||
#[cfg(not(feature = "auto"))]
|
||||
ColorChoice::Auto => Self::never(raw),
|
||||
ColorChoice::AlwaysAnsi => Self::always_ansi(raw),
|
||||
ColorChoice::Always => Self::always(raw),
|
||||
ColorChoice::Never => Self::never(raw),
|
||||
}
|
||||
}
|
||||
|
||||
/// Auto-adapt for the stream's capabilities
|
||||
#[cfg(feature = "auto")]
|
||||
#[inline]
|
||||
pub fn auto(raw: S) -> Self {
|
||||
let choice = Self::choice(&raw);
|
||||
debug_assert_ne!(choice, ColorChoice::Auto);
|
||||
Self::new(raw, choice)
|
||||
}
|
||||
|
||||
/// Report the desired choice for the given stream
|
||||
#[cfg(feature = "auto")]
|
||||
pub fn choice(raw: &S) -> ColorChoice {
|
||||
choice(raw)
|
||||
}
|
||||
|
||||
/// Force ANSI escape codes to be passed through as-is, no matter what the inner `Write`
|
||||
/// supports.
|
||||
#[inline]
|
||||
pub fn always_ansi(raw: S) -> Self {
|
||||
#[cfg(feature = "auto")]
|
||||
{
|
||||
if raw.is_terminal() {
|
||||
let _ = anstyle_query::windows::enable_ansi_colors();
|
||||
}
|
||||
}
|
||||
Self::always_ansi_(raw)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn always_ansi_(raw: S) -> Self {
|
||||
let inner = StreamInner::PassThrough(raw);
|
||||
AutoStream { inner }
|
||||
}
|
||||
|
||||
/// Force color, no matter what the inner `Write` supports.
|
||||
#[inline]
|
||||
pub fn always(raw: S) -> Self {
|
||||
if cfg!(windows) {
|
||||
#[cfg(feature = "auto")]
|
||||
let use_wincon = raw.is_terminal()
|
||||
&& !anstyle_query::windows::enable_ansi_colors().unwrap_or(true)
|
||||
&& !anstyle_query::term_supports_ansi_color();
|
||||
#[cfg(not(feature = "auto"))]
|
||||
let use_wincon = true;
|
||||
if use_wincon {
|
||||
Self::wincon(raw).unwrap_or_else(|raw| Self::always_ansi_(raw))
|
||||
} else {
|
||||
Self::always_ansi_(raw)
|
||||
}
|
||||
} else {
|
||||
Self::always_ansi(raw)
|
||||
}
|
||||
}
|
||||
|
||||
/// Only pass printable data to the inner `Write`.
|
||||
#[inline]
|
||||
pub fn never(raw: S) -> Self {
|
||||
let inner = StreamInner::Strip(StripStream::new(raw));
|
||||
AutoStream { inner }
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn wincon(raw: S) -> Result<Self, S> {
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
{
|
||||
Ok(Self {
|
||||
inner: StreamInner::Wincon(WinconStream::new(raw)),
|
||||
})
|
||||
}
|
||||
#[cfg(not(all(windows, feature = "wincon")))]
|
||||
{
|
||||
Err(raw)
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the wrapped [`RawStream`]
|
||||
#[inline]
|
||||
pub fn into_inner(self) -> S {
|
||||
match self.inner {
|
||||
StreamInner::PassThrough(w) => w,
|
||||
StreamInner::Strip(w) => w.into_inner(),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.into_inner(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the wrapped [`RawStream`]
|
||||
#[inline]
|
||||
pub fn as_inner(&self) -> &S {
|
||||
match &self.inner {
|
||||
StreamInner::PassThrough(w) => w,
|
||||
StreamInner::Strip(w) => w.as_inner(),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.as_inner(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the descriptor/handle refers to a terminal/tty.
|
||||
#[inline]
|
||||
pub fn is_terminal(&self) -> bool {
|
||||
match &self.inner {
|
||||
StreamInner::PassThrough(w) => w.is_terminal(),
|
||||
StreamInner::Strip(w) => w.is_terminal(),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(_) => true, // its only ever a terminal
|
||||
}
|
||||
}
|
||||
|
||||
/// Prefer [`AutoStream::choice`]
|
||||
///
|
||||
/// This doesn't report what is requested but what is currently active.
|
||||
#[inline]
|
||||
#[cfg(feature = "auto")]
|
||||
pub fn current_choice(&self) -> ColorChoice {
|
||||
match &self.inner {
|
||||
StreamInner::PassThrough(_) => ColorChoice::AlwaysAnsi,
|
||||
StreamInner::Strip(_) => ColorChoice::Never,
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(_) => ColorChoice::Always,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "auto")]
|
||||
fn choice(raw: &dyn RawStream) -> ColorChoice {
|
||||
let choice = ColorChoice::global();
|
||||
match choice {
|
||||
ColorChoice::Auto => {
|
||||
let clicolor = anstyle_query::clicolor();
|
||||
let clicolor_enabled = clicolor.unwrap_or(false);
|
||||
let clicolor_disabled = !clicolor.unwrap_or(true);
|
||||
if anstyle_query::no_color() {
|
||||
ColorChoice::Never
|
||||
} else if anstyle_query::clicolor_force() {
|
||||
ColorChoice::Always
|
||||
} else if clicolor_disabled {
|
||||
ColorChoice::Never
|
||||
} else if raw.is_terminal()
|
||||
&& (anstyle_query::term_supports_color()
|
||||
|| clicolor_enabled
|
||||
|| anstyle_query::is_ci())
|
||||
{
|
||||
ColorChoice::Always
|
||||
} else {
|
||||
ColorChoice::Never
|
||||
}
|
||||
}
|
||||
ColorChoice::AlwaysAnsi | ColorChoice::Always | ColorChoice::Never => choice,
|
||||
}
|
||||
}
|
||||
|
||||
impl AutoStream<std::io::Stdout> {
|
||||
/// Get exclusive access to the `AutoStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> AutoStream<std::io::StdoutLock<'static>> {
|
||||
let inner = match self.inner {
|
||||
StreamInner::PassThrough(w) => StreamInner::PassThrough(w.lock()),
|
||||
StreamInner::Strip(w) => StreamInner::Strip(w.lock()),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => StreamInner::Wincon(w.lock()),
|
||||
};
|
||||
AutoStream { inner }
|
||||
}
|
||||
}
|
||||
|
||||
impl AutoStream<std::io::Stderr> {
|
||||
/// Get exclusive access to the `AutoStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> AutoStream<std::io::StderrLock<'static>> {
|
||||
let inner = match self.inner {
|
||||
StreamInner::PassThrough(w) => StreamInner::PassThrough(w.lock()),
|
||||
StreamInner::Strip(w) => StreamInner::Strip(w.lock()),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => StreamInner::Wincon(w.lock()),
|
||||
};
|
||||
AutoStream { inner }
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> std::io::Write for AutoStream<S>
|
||||
where
|
||||
S: RawStream + AsLockedWrite,
|
||||
{
|
||||
// Must forward all calls to ensure locking happens appropriately
|
||||
#[inline]
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
match &mut self.inner {
|
||||
StreamInner::PassThrough(w) => w.as_locked_write().write(buf),
|
||||
StreamInner::Strip(w) => w.write(buf),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.write(buf),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
|
||||
match &mut self.inner {
|
||||
StreamInner::PassThrough(w) => w.as_locked_write().write_vectored(bufs),
|
||||
StreamInner::Strip(w) => w.write_vectored(bufs),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.write_vectored(bufs),
|
||||
}
|
||||
}
|
||||
// is_write_vectored: nightly only
|
||||
#[inline]
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
match &mut self.inner {
|
||||
StreamInner::PassThrough(w) => w.as_locked_write().flush(),
|
||||
StreamInner::Strip(w) => w.flush(),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.flush(),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
|
||||
match &mut self.inner {
|
||||
StreamInner::PassThrough(w) => w.as_locked_write().write_all(buf),
|
||||
StreamInner::Strip(w) => w.write_all(buf),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.write_all(buf),
|
||||
}
|
||||
}
|
||||
// write_all_vectored: nightly only
|
||||
#[inline]
|
||||
fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) -> std::io::Result<()> {
|
||||
match &mut self.inner {
|
||||
StreamInner::PassThrough(w) => w.as_locked_write().write_fmt(args),
|
||||
StreamInner::Strip(w) => w.write_fmt(args),
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
StreamInner::Wincon(w) => w.write_fmt(args),
|
||||
}
|
||||
}
|
||||
}
|
||||
56
third_party/crates/anstream-1.0.0/src/buffer.rs
vendored
Normal file
56
third_party/crates/anstream-1.0.0/src/buffer.rs
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
#![allow(deprecated)]
|
||||
|
||||
/// In-memory [`RawStream`][crate::stream::RawStream]
|
||||
#[derive(Clone, Default, Debug, PartialEq, Eq)]
|
||||
#[deprecated(since = "0.6.2", note = "Use Vec")]
|
||||
#[doc(hidden)]
|
||||
pub struct Buffer(Vec<u8>);
|
||||
|
||||
impl Buffer {
|
||||
#[inline]
|
||||
pub fn new() -> Self {
|
||||
Default::default()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn with_capacity(capacity: usize) -> Self {
|
||||
Self(Vec::with_capacity(capacity))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn as_bytes(&self) -> &[u8] {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl AsRef<[u8]> for Buffer {
|
||||
#[inline]
|
||||
fn as_ref(&self) -> &[u8] {
|
||||
self.as_bytes()
|
||||
}
|
||||
}
|
||||
|
||||
impl std::io::Write for Buffer {
|
||||
#[inline]
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
self.0.extend(buf);
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
impl anstyle_wincon::WinconStream for Buffer {
|
||||
fn write_colored(
|
||||
&mut self,
|
||||
fg: Option<anstyle::AnsiColor>,
|
||||
bg: Option<anstyle::AnsiColor>,
|
||||
data: &[u8],
|
||||
) -> std::io::Result<usize> {
|
||||
self.0.write_colored(fg, bg, data)
|
||||
}
|
||||
}
|
||||
54
third_party/crates/anstream-1.0.0/src/fmt.rs
vendored
Normal file
54
third_party/crates/anstream-1.0.0/src/fmt.rs
vendored
Normal file
@@ -0,0 +1,54 @@
|
||||
/// A shim which allows a [`std::io::Write`] to be implemented in terms of a [`std::fmt::Write`]
|
||||
///
|
||||
/// This saves off I/O errors. instead of discarding them
|
||||
pub(crate) struct Adapter<W>
|
||||
where
|
||||
W: FnMut(&[u8]) -> std::io::Result<()>,
|
||||
{
|
||||
writer: W,
|
||||
error: std::io::Result<()>,
|
||||
}
|
||||
|
||||
impl<W> Adapter<W>
|
||||
where
|
||||
W: FnMut(&[u8]) -> std::io::Result<()>,
|
||||
{
|
||||
pub(crate) fn new(writer: W) -> Self {
|
||||
Adapter {
|
||||
writer,
|
||||
error: Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn write_fmt(mut self, fmt: std::fmt::Arguments<'_>) -> std::io::Result<()> {
|
||||
match std::fmt::write(&mut self, fmt) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(..) => {
|
||||
// check if the error came from the underlying `Write` or not
|
||||
if self.error.is_err() {
|
||||
self.error
|
||||
} else {
|
||||
Err(std::io::Error::new(
|
||||
std::io::ErrorKind::Other,
|
||||
"formatter error",
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<W> std::fmt::Write for Adapter<W>
|
||||
where
|
||||
W: FnMut(&[u8]) -> std::io::Result<()>,
|
||||
{
|
||||
fn write_str(&mut self, s: &str) -> std::fmt::Result {
|
||||
match (self.writer)(s.as_bytes()) {
|
||||
Ok(()) => Ok(()),
|
||||
Err(e) => {
|
||||
self.error = Err(e);
|
||||
Err(std::fmt::Error)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
90
third_party/crates/anstream-1.0.0/src/lib.rs
vendored
Normal file
90
third_party/crates/anstream-1.0.0/src/lib.rs
vendored
Normal file
@@ -0,0 +1,90 @@
|
||||
//! **Auto-adapting [`stdout`] / [`stderr`] streams**
|
||||
//!
|
||||
//! *A portmanteau of "ansi stream"*
|
||||
//!
|
||||
//! [`AutoStream`] always accepts [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code),
|
||||
//! [adapting to the user's terminal's capabilities][AutoStream].
|
||||
//!
|
||||
//! Benefits
|
||||
//! - Allows the caller to not be concerned with the terminal's capabilities
|
||||
//! - Semver safe way of passing styled text between crates as ANSI escape codes offer more
|
||||
//! compatibility than most crate APIs.
|
||||
//!
|
||||
//! Available styling crates:
|
||||
//! - [anstyle](https://docs.rs/anstyle) for minimal runtime styling, designed to go in public APIs
|
||||
//! - [owo-colors](https://docs.rs/owo-colors) for feature-rich runtime styling
|
||||
//! - [color-print](https://docs.rs/color-print) for feature-rich compile-time styling
|
||||
//!
|
||||
//! # Example
|
||||
//!
|
||||
//! ```
|
||||
//! # #[cfg(feature = "auto")] {
|
||||
//! use anstream::println;
|
||||
//! use owo_colors::OwoColorize as _;
|
||||
//!
|
||||
//! // Foreground colors
|
||||
//! println!("My number is {:#x}!", 10.green());
|
||||
//! // Background colors
|
||||
//! println!("My number is not {}!", 4.on_red());
|
||||
//! # }
|
||||
//! ```
|
||||
//!
|
||||
//! And this will correctly handle piping to a file, etc
|
||||
|
||||
#![cfg_attr(docsrs, feature(doc_cfg))]
|
||||
#![warn(missing_docs)]
|
||||
#![warn(clippy::print_stderr)]
|
||||
#![warn(clippy::print_stdout)]
|
||||
|
||||
pub mod adapter;
|
||||
pub mod stream;
|
||||
#[doc(hidden)]
|
||||
#[macro_use]
|
||||
pub mod _macros;
|
||||
|
||||
mod auto;
|
||||
mod buffer;
|
||||
mod fmt;
|
||||
mod strip;
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
mod wincon;
|
||||
|
||||
pub use auto::AutoStream;
|
||||
pub use strip::StripStream;
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
pub use wincon::WinconStream;
|
||||
|
||||
#[allow(deprecated)]
|
||||
pub use buffer::Buffer;
|
||||
|
||||
/// An adaptive wrapper around the global standard output stream of the current process
|
||||
pub type Stdout = AutoStream<std::io::Stdout>;
|
||||
/// An adaptive wrapper around the global standard error stream of the current process
|
||||
pub type Stderr = AutoStream<std::io::Stderr>;
|
||||
|
||||
/// Create an ANSI escape code compatible stdout
|
||||
///
|
||||
/// **Note:** Call [`AutoStream::lock`] in loops to avoid the performance hit of acquiring/releasing
|
||||
/// from the implicit locking in each [`std::io::Write`] call
|
||||
#[cfg(feature = "auto")]
|
||||
pub fn stdout() -> Stdout {
|
||||
let stdout = std::io::stdout();
|
||||
AutoStream::auto(stdout)
|
||||
}
|
||||
|
||||
/// Create an ANSI escape code compatible stderr
|
||||
///
|
||||
/// **Note:** Call [`AutoStream::lock`] in loops to avoid the performance hit of acquiring/releasing
|
||||
/// from the implicit locking in each [`std::io::Write`] call
|
||||
#[cfg(feature = "auto")]
|
||||
pub fn stderr() -> Stderr {
|
||||
let stderr = std::io::stderr();
|
||||
AutoStream::auto(stderr)
|
||||
}
|
||||
|
||||
/// Selection for overriding color output
|
||||
pub use colorchoice::ColorChoice;
|
||||
|
||||
#[doc = include_str!("../README.md")]
|
||||
#[cfg(doctest)]
|
||||
pub struct ReadmeDoctests;
|
||||
316
third_party/crates/anstream-1.0.0/src/stream.rs
vendored
Normal file
316
third_party/crates/anstream-1.0.0/src/stream.rs
vendored
Normal file
@@ -0,0 +1,316 @@
|
||||
//! Higher-level traits to describe writeable streams
|
||||
|
||||
/// Required functionality for underlying [`std::io::Write`] for adaptation
|
||||
#[cfg(not(all(windows, feature = "wincon")))]
|
||||
pub trait RawStream: std::io::Write + IsTerminal + private::Sealed {}
|
||||
|
||||
/// Required functionality for underlying [`std::io::Write`] for adaptation
|
||||
#[cfg(all(windows, feature = "wincon"))]
|
||||
pub trait RawStream:
|
||||
std::io::Write + IsTerminal + anstyle_wincon::WinconStream + private::Sealed
|
||||
{
|
||||
}
|
||||
|
||||
impl<T: RawStream + ?Sized> RawStream for &mut T {}
|
||||
impl<T: RawStream + ?Sized> RawStream for Box<T> {}
|
||||
|
||||
impl RawStream for std::io::Stdout {}
|
||||
|
||||
impl RawStream for std::io::StdoutLock<'_> {}
|
||||
|
||||
impl RawStream for std::io::Stderr {}
|
||||
|
||||
impl RawStream for std::io::StderrLock<'_> {}
|
||||
|
||||
impl RawStream for dyn std::io::Write {}
|
||||
impl RawStream for dyn std::io::Write + Send {}
|
||||
impl RawStream for dyn std::io::Write + Send + Sync {}
|
||||
|
||||
impl RawStream for Vec<u8> {}
|
||||
|
||||
impl RawStream for std::fs::File {}
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl RawStream for crate::Buffer {}
|
||||
|
||||
/// Trait to determine if a descriptor/handle refers to a terminal/tty.
|
||||
pub trait IsTerminal: private::Sealed {
|
||||
/// Returns `true` if the descriptor/handle refers to a terminal/tty.
|
||||
fn is_terminal(&self) -> bool;
|
||||
}
|
||||
|
||||
impl<T: IsTerminal + ?Sized> IsTerminal for &T {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
(**self).is_terminal()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: IsTerminal + ?Sized> IsTerminal for &mut T {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
(**self).is_terminal()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: IsTerminal + ?Sized> IsTerminal for Box<T> {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
(**self).is_terminal()
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for std::io::Stdout {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
is_terminal_polyfill::IsTerminal::is_terminal(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for std::io::StdoutLock<'_> {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
is_terminal_polyfill::IsTerminal::is_terminal(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for std::io::Stderr {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
is_terminal_polyfill::IsTerminal::is_terminal(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for std::io::StderrLock<'_> {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
is_terminal_polyfill::IsTerminal::is_terminal(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for dyn std::io::Write {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for dyn std::io::Write + Send {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for dyn std::io::Write + Send + Sync {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for Vec<u8> {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
impl IsTerminal for std::fs::File {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
is_terminal_polyfill::IsTerminal::is_terminal(self)
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl IsTerminal for crate::Buffer {
|
||||
#[inline]
|
||||
fn is_terminal(&self) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// Lock a stream
|
||||
pub trait AsLockedWrite: private::Sealed {
|
||||
/// Locked writer type
|
||||
type Write<'w>: RawStream + 'w
|
||||
where
|
||||
Self: 'w;
|
||||
|
||||
/// Lock a stream
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_>;
|
||||
}
|
||||
|
||||
impl<T: AsLockedWrite + ?Sized> AsLockedWrite for &mut T {
|
||||
type Write<'w>
|
||||
= T::Write<'w>
|
||||
where
|
||||
Self: 'w;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
(**self).as_locked_write()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: AsLockedWrite + ?Sized> AsLockedWrite for Box<T> {
|
||||
type Write<'w>
|
||||
= T::Write<'w>
|
||||
where
|
||||
Self: 'w;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
(**self).as_locked_write()
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for std::io::Stdout {
|
||||
type Write<'w> = std::io::StdoutLock<'w>;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self.lock()
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for std::io::StdoutLock<'static> {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for std::io::Stderr {
|
||||
type Write<'w> = std::io::StderrLock<'w>;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self.lock()
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for std::io::StderrLock<'static> {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for dyn std::io::Write {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for dyn std::io::Write + Send {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for dyn std::io::Write + Send + Sync {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for Vec<u8> {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl AsLockedWrite for std::fs::File {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl AsLockedWrite for crate::Buffer {
|
||||
type Write<'w> = &'w mut Self;
|
||||
|
||||
#[inline]
|
||||
fn as_locked_write(&mut self) -> Self::Write<'_> {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
mod private {
|
||||
#[allow(unnameable_types)]
|
||||
pub trait Sealed {}
|
||||
|
||||
impl<T: Sealed + ?Sized> Sealed for &T {}
|
||||
impl<T: Sealed + ?Sized> Sealed for &mut T {}
|
||||
impl<T: Sealed + ?Sized> Sealed for Box<T> {}
|
||||
|
||||
impl Sealed for std::io::Stdout {}
|
||||
|
||||
impl Sealed for std::io::StdoutLock<'_> {}
|
||||
|
||||
impl Sealed for std::io::Stderr {}
|
||||
|
||||
impl Sealed for std::io::StderrLock<'_> {}
|
||||
|
||||
impl Sealed for dyn std::io::Write {}
|
||||
impl Sealed for dyn std::io::Write + Send {}
|
||||
impl Sealed for dyn std::io::Write + Send + Sync {}
|
||||
|
||||
impl Sealed for Vec<u8> {}
|
||||
|
||||
impl Sealed for std::fs::File {}
|
||||
|
||||
#[allow(deprecated)]
|
||||
impl Sealed for crate::Buffer {}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn assert_raw_stream<T: RawStream>()
|
||||
where
|
||||
crate::AutoStream<T>: std::io::Write,
|
||||
{
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test() {
|
||||
assert_raw_stream::<Box<dyn std::io::Write>>();
|
||||
assert_raw_stream::<Box<dyn std::io::Write + 'static>>();
|
||||
assert_raw_stream::<Box<dyn std::io::Write + Send>>();
|
||||
assert_raw_stream::<Box<dyn std::io::Write + Send + Sync>>();
|
||||
|
||||
assert_raw_stream::<&mut dyn std::io::Write>();
|
||||
assert_raw_stream::<&mut (dyn std::io::Write + 'static)>();
|
||||
assert_raw_stream::<&mut (dyn std::io::Write + Send)>();
|
||||
assert_raw_stream::<&mut (dyn std::io::Write + Send + Sync)>();
|
||||
|
||||
assert_raw_stream::<Vec<u8>>();
|
||||
assert_raw_stream::<&mut Vec<u8>>();
|
||||
|
||||
assert_raw_stream::<std::fs::File>();
|
||||
assert_raw_stream::<&mut std::fs::File>();
|
||||
}
|
||||
}
|
||||
233
third_party/crates/anstream-1.0.0/src/strip.rs
vendored
Normal file
233
third_party/crates/anstream-1.0.0/src/strip.rs
vendored
Normal file
@@ -0,0 +1,233 @@
|
||||
use crate::adapter::StripBytes;
|
||||
use crate::stream::AsLockedWrite;
|
||||
use crate::stream::IsTerminal;
|
||||
|
||||
/// Only pass printable data to the inner `Write`
|
||||
#[derive(Debug)]
|
||||
pub struct StripStream<S>
|
||||
where
|
||||
S: std::io::Write,
|
||||
{
|
||||
raw: S,
|
||||
state: StripBytes,
|
||||
}
|
||||
|
||||
impl<S> StripStream<S>
|
||||
where
|
||||
S: std::io::Write,
|
||||
{
|
||||
/// Only pass printable data to the inner `Write`
|
||||
#[inline]
|
||||
pub fn new(raw: S) -> Self {
|
||||
Self {
|
||||
raw,
|
||||
state: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the wrapped [`std::io::Write`]
|
||||
#[inline]
|
||||
pub fn into_inner(self) -> S {
|
||||
self.raw
|
||||
}
|
||||
|
||||
/// Get the wrapped [`std::io::Write`]
|
||||
#[inline]
|
||||
pub fn as_inner(&self) -> &S {
|
||||
&self.raw
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> StripStream<S>
|
||||
where
|
||||
S: std::io::Write,
|
||||
S: IsTerminal,
|
||||
{
|
||||
/// Returns `true` if the descriptor/handle refers to a terminal/tty.
|
||||
#[inline]
|
||||
pub fn is_terminal(&self) -> bool {
|
||||
self.raw.is_terminal()
|
||||
}
|
||||
}
|
||||
|
||||
impl StripStream<std::io::Stdout> {
|
||||
/// Get exclusive access to the `StripStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> StripStream<std::io::StdoutLock<'static>> {
|
||||
StripStream {
|
||||
raw: self.raw.lock(),
|
||||
state: self.state,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl StripStream<std::io::Stderr> {
|
||||
/// Get exclusive access to the `StripStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> StripStream<std::io::StderrLock<'static>> {
|
||||
StripStream {
|
||||
raw: self.raw.lock(),
|
||||
state: self.state,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> std::io::Write for StripStream<S>
|
||||
where
|
||||
S: std::io::Write,
|
||||
S: AsLockedWrite,
|
||||
{
|
||||
// Must forward all calls to ensure locking happens appropriately
|
||||
#[inline]
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
write(&mut self.raw.as_locked_write(), &mut self.state, buf)
|
||||
}
|
||||
#[inline]
|
||||
fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
|
||||
let buf = bufs
|
||||
.iter()
|
||||
.find(|b| !b.is_empty())
|
||||
.map(|b| &**b)
|
||||
.unwrap_or(&[][..]);
|
||||
self.write(buf)
|
||||
}
|
||||
// is_write_vectored: nightly only
|
||||
#[inline]
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
self.raw.as_locked_write().flush()
|
||||
}
|
||||
#[inline]
|
||||
fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
|
||||
write_all(&mut self.raw.as_locked_write(), &mut self.state, buf)
|
||||
}
|
||||
// write_all_vectored: nightly only
|
||||
#[inline]
|
||||
fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) -> std::io::Result<()> {
|
||||
write_fmt(&mut self.raw.as_locked_write(), &mut self.state, args)
|
||||
}
|
||||
}
|
||||
|
||||
fn write(
|
||||
raw: &mut dyn std::io::Write,
|
||||
state: &mut StripBytes,
|
||||
buf: &[u8],
|
||||
) -> std::io::Result<usize> {
|
||||
let initial_state = state.clone();
|
||||
|
||||
for printable in state.strip_next(buf) {
|
||||
let possible = printable.len();
|
||||
let written = raw.write(printable)?;
|
||||
if possible != written {
|
||||
let divergence = &printable[written..];
|
||||
let offset = offset_to(buf, divergence);
|
||||
let consumed = &buf[offset..];
|
||||
*state = initial_state;
|
||||
state.strip_next(consumed).last();
|
||||
return Ok(offset);
|
||||
}
|
||||
}
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
fn write_all(
|
||||
raw: &mut dyn std::io::Write,
|
||||
state: &mut StripBytes,
|
||||
buf: &[u8],
|
||||
) -> std::io::Result<()> {
|
||||
for printable in state.strip_next(buf) {
|
||||
raw.write_all(printable)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(
|
||||
raw: &mut dyn std::io::Write,
|
||||
state: &mut StripBytes,
|
||||
args: std::fmt::Arguments<'_>,
|
||||
) -> std::io::Result<()> {
|
||||
let write_all = |buf: &[u8]| write_all(raw, state, buf);
|
||||
crate::fmt::Adapter::new(write_all).write_fmt(args)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn offset_to(total: &[u8], subslice: &[u8]) -> usize {
|
||||
let total = total.as_ptr();
|
||||
let subslice = subslice.as_ptr();
|
||||
|
||||
debug_assert!(
|
||||
total <= subslice,
|
||||
"`Offset::offset_to` only accepts slices of `self`"
|
||||
);
|
||||
subslice as usize - total as usize
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use proptest::prelude::*;
|
||||
use std::io::Write as _;
|
||||
|
||||
proptest! {
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_all_no_escapes(s in "\\PC*") {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = StripStream::new(buffer);
|
||||
stream.write_all(s.as_bytes()).unwrap();
|
||||
let buffer = stream.into_inner();
|
||||
let actual = std::str::from_utf8(buffer.as_ref()).unwrap();
|
||||
assert_eq!(s, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_byte_no_escapes(s in "\\PC*") {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = StripStream::new(buffer);
|
||||
for byte in s.as_bytes() {
|
||||
stream.write_all(&[*byte]).unwrap();
|
||||
}
|
||||
let buffer = stream.into_inner();
|
||||
let actual = std::str::from_utf8(buffer.as_ref()).unwrap();
|
||||
assert_eq!(s, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_all_random(s in any::<Vec<u8>>()) {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = StripStream::new(buffer);
|
||||
stream.write_all(s.as_slice()).unwrap();
|
||||
let buffer = stream.into_inner();
|
||||
if let Ok(actual) = std::str::from_utf8(buffer.as_ref()) {
|
||||
for char in actual.chars() {
|
||||
assert!(!char.is_ascii() || !char.is_control() || char.is_ascii_whitespace(), "{:?} -> {:?}: {:?}", String::from_utf8_lossy(&s), actual, char);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_byte_random(s in any::<Vec<u8>>()) {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = StripStream::new(buffer);
|
||||
for byte in s.as_slice() {
|
||||
stream.write_all(&[*byte]).unwrap();
|
||||
}
|
||||
let buffer = stream.into_inner();
|
||||
if let Ok(actual) = std::str::from_utf8(buffer.as_ref()) {
|
||||
for char in actual.chars() {
|
||||
assert!(!char.is_ascii() || !char.is_control() || char.is_ascii_whitespace(), "{:?} -> {:?}: {:?}", String::from_utf8_lossy(&s), actual, char);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
232
third_party/crates/anstream-1.0.0/src/wincon.rs
vendored
Normal file
232
third_party/crates/anstream-1.0.0/src/wincon.rs
vendored
Normal file
@@ -0,0 +1,232 @@
|
||||
use crate::adapter::WinconBytes;
|
||||
use crate::stream::AsLockedWrite;
|
||||
use crate::stream::IsTerminal;
|
||||
|
||||
/// Only pass printable data to the inner `Write`
|
||||
#[cfg(feature = "wincon")] // here mostly for documentation purposes
|
||||
#[derive(Debug)]
|
||||
pub struct WinconStream<S>
|
||||
where
|
||||
S: anstyle_wincon::WinconStream,
|
||||
{
|
||||
raw: S,
|
||||
// `WinconBytes` is especially large compared to other variants of `AutoStream`, so boxing it
|
||||
// here so `AutoStream` doesn't have to discard one allocation and create another one when
|
||||
// calling `AutoStream::lock`
|
||||
state: Box<WinconBytes>,
|
||||
}
|
||||
|
||||
impl<S> WinconStream<S>
|
||||
where
|
||||
S: anstyle_wincon::WinconStream,
|
||||
{
|
||||
/// Only pass printable data to the inner `Write`
|
||||
#[inline]
|
||||
pub fn new(raw: S) -> Self {
|
||||
Self {
|
||||
raw,
|
||||
state: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the wrapped [`anstyle_wincon::WinconStream`]
|
||||
#[inline]
|
||||
pub fn into_inner(self) -> S {
|
||||
self.raw
|
||||
}
|
||||
|
||||
/// Get the wrapped [`std::io::Write`]
|
||||
#[inline]
|
||||
pub fn as_inner(&self) -> &S {
|
||||
&self.raw
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> WinconStream<S>
|
||||
where
|
||||
S: anstyle_wincon::WinconStream,
|
||||
S: IsTerminal,
|
||||
{
|
||||
/// Returns `true` if the descriptor/handle refers to a terminal/tty.
|
||||
#[inline]
|
||||
pub fn is_terminal(&self) -> bool {
|
||||
self.raw.is_terminal()
|
||||
}
|
||||
}
|
||||
|
||||
impl WinconStream<std::io::Stdout> {
|
||||
/// Get exclusive access to the `WinconStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> WinconStream<std::io::StdoutLock<'static>> {
|
||||
WinconStream {
|
||||
raw: self.raw.lock(),
|
||||
state: self.state,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl WinconStream<std::io::Stderr> {
|
||||
/// Get exclusive access to the `WinconStream`
|
||||
///
|
||||
/// Why?
|
||||
/// - Faster performance when writing in a loop
|
||||
/// - Avoid other threads interleaving output with the current thread
|
||||
#[inline]
|
||||
pub fn lock(self) -> WinconStream<std::io::StderrLock<'static>> {
|
||||
WinconStream {
|
||||
raw: self.raw.lock(),
|
||||
state: self.state,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<S> std::io::Write for WinconStream<S>
|
||||
where
|
||||
S: anstyle_wincon::WinconStream,
|
||||
S: AsLockedWrite,
|
||||
{
|
||||
// Must forward all calls to ensure locking happens appropriately
|
||||
#[inline]
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
write(&mut self.raw.as_locked_write(), &mut self.state, buf)
|
||||
}
|
||||
#[inline]
|
||||
fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
|
||||
let buf = bufs
|
||||
.iter()
|
||||
.find(|b| !b.is_empty())
|
||||
.map(|b| &**b)
|
||||
.unwrap_or(&[][..]);
|
||||
self.write(buf)
|
||||
}
|
||||
// is_write_vectored: nightly only
|
||||
#[inline]
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
self.raw.as_locked_write().flush()
|
||||
}
|
||||
#[inline]
|
||||
fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
|
||||
write_all(&mut self.raw.as_locked_write(), &mut self.state, buf)
|
||||
}
|
||||
// write_all_vectored: nightly only
|
||||
#[inline]
|
||||
fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) -> std::io::Result<()> {
|
||||
write_fmt(&mut self.raw.as_locked_write(), &mut self.state, args)
|
||||
}
|
||||
}
|
||||
|
||||
fn write(
|
||||
raw: &mut dyn anstyle_wincon::WinconStream,
|
||||
state: &mut WinconBytes,
|
||||
buf: &[u8],
|
||||
) -> std::io::Result<usize> {
|
||||
for (style, printable) in state.extract_next(buf) {
|
||||
let fg = style.get_fg_color().and_then(cap_wincon_color);
|
||||
let bg = style.get_bg_color().and_then(cap_wincon_color);
|
||||
let written = raw.write_colored(fg, bg, printable.as_bytes())?;
|
||||
let possible = printable.len();
|
||||
if possible != written {
|
||||
// HACK: Unsupported atm
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(buf.len())
|
||||
}
|
||||
|
||||
fn write_all(
|
||||
raw: &mut dyn anstyle_wincon::WinconStream,
|
||||
state: &mut WinconBytes,
|
||||
buf: &[u8],
|
||||
) -> std::io::Result<()> {
|
||||
for (style, printable) in state.extract_next(buf) {
|
||||
let mut buf = printable.as_bytes();
|
||||
let fg = style.get_fg_color().and_then(cap_wincon_color);
|
||||
let bg = style.get_bg_color().and_then(cap_wincon_color);
|
||||
while !buf.is_empty() {
|
||||
match raw.write_colored(fg, bg, buf) {
|
||||
Ok(0) => {
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::WriteZero,
|
||||
"failed to write whole buffer",
|
||||
));
|
||||
}
|
||||
Ok(n) => buf = &buf[n..],
|
||||
Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => {}
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_fmt(
|
||||
raw: &mut dyn anstyle_wincon::WinconStream,
|
||||
state: &mut WinconBytes,
|
||||
args: std::fmt::Arguments<'_>,
|
||||
) -> std::io::Result<()> {
|
||||
let write_all = |buf: &[u8]| write_all(raw, state, buf);
|
||||
crate::fmt::Adapter::new(write_all).write_fmt(args)
|
||||
}
|
||||
|
||||
fn cap_wincon_color(color: anstyle::Color) -> Option<anstyle::AnsiColor> {
|
||||
match color {
|
||||
anstyle::Color::Ansi(c) => Some(c),
|
||||
anstyle::Color::Ansi256(c) => c.into_ansi(),
|
||||
anstyle::Color::Rgb(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
use proptest::prelude::*;
|
||||
use std::io::Write as _;
|
||||
|
||||
proptest! {
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_all_no_escapes(s in "\\PC*") {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = WinconStream::new(buffer);
|
||||
stream.write_all(s.as_bytes()).unwrap();
|
||||
let buffer = stream.into_inner();
|
||||
let actual = std::str::from_utf8(buffer.as_ref()).unwrap();
|
||||
assert_eq!(s, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_byte_no_escapes(s in "\\PC*") {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = WinconStream::new(buffer);
|
||||
for byte in s.as_bytes() {
|
||||
stream.write_all(&[*byte]).unwrap();
|
||||
}
|
||||
let buffer = stream.into_inner();
|
||||
let actual = std::str::from_utf8(buffer.as_ref()).unwrap();
|
||||
assert_eq!(s, actual);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_all_random(s in any::<Vec<u8>>()) {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = WinconStream::new(buffer);
|
||||
stream.write_all(s.as_slice()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg_attr(miri, ignore)] // See https://github.com/AltSysrq/proptest/issues/253
|
||||
fn write_byte_random(s in any::<Vec<u8>>()) {
|
||||
let buffer = Vec::new();
|
||||
let mut stream = WinconStream::new(buffer);
|
||||
for byte in s.as_slice() {
|
||||
stream.write_all(&[*byte]).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user