build(ariadne): vendor clap
This commit was merged in pull request #30.
This commit is contained in:
alexion committed
1 parent
e6af135702
commit
8855b6d379
681 files changed
+400416
No files matched your search
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user