512 lines
14 KiB
Rust
512 lines
14 KiB
Rust
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);
|
|
}
|
|
}
|
|
}
|