Strip ANSI Escapes

https://docs.rs/strip-ansi-escapes/0.2.1
Admin
A crate for stripping ANSI escape sequences from byte sequences. This can be used to take output...
Tokens:4,341
Snippets:53
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Usage of Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Demonstrates how to use the Writer to strip ANSI escape sequences from bytes before writing them to stdout. Ensure the strip_ansi_escapes crate is added as a dependency.

```rust
use std::io::{self, Write};
use strip_ansi_escapes::Writer;

let bytes_with_colors = b"\x1b[32mfoo\x1b[m bar";
let mut writer = Writer::new(io::stdout());
// Only `foo bar` will be written to stdout
writer.write_all(bytes_with_colors)?;

```

--------------------------------

### Unwrap the Writer to get the inner writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Retrieves the underlying writer from the Writer. This operation flushes the internal buffer and may return an error.

```rust
pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>>
Unwraps this `Writer`, returning the underlying writer.
The internal buffer is written out before returning the writer, which may produce an `IntoInnerError`.

```

--------------------------------

### Strip ANSI Escapes from Byte Slice

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes

Use the `strip` function to remove ANSI escape sequences from a byte slice and get the cleaned bytes. This is useful for preparing output for environments that do not support color codes.

```rust
use std::io::{self, Write};

let bytes_with_colors = b"\x1b[32mfoo\x1b[m bar";
let plain_bytes = strip_ansi_escapes::strip(&bytes_with_colors);
io::stdout().write_all(&plain_bytes)?;

```

--------------------------------

### Create a new Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Instantiates a new Writer by wrapping an existing type that implements the Write trait.

```rust
pub fn new(inner: W) -> Writer<W>ⓘ
Create a new `Writer` that writes to `inner`.

```

--------------------------------

### Writer::new

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Creates a new Writer that wraps an inner Write implementation, stripping ANSI escape sequences.

```APIDOC
## Writer::new

### Description
Creates a new `Writer` that writes to `inner`.

### Method

```
pub fn new(inner: W) -> Writer<W>
```

### Parameters

* `inner` - The underlying writer to wrap.
```

--------------------------------

### Write for Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Implementation of the Write trait for the Writer struct, allowing it to be used wherever a Write is expected.

```APIDOC
## impl Write for Writer

This implementation allows `Writer` to be used wherever a `Write` trait is expected. It handles the stripping of ANSI escape sequences during write operations.

### Methods:

*   **`write(&mut self, buf: &[u8]) -> Result<usize>`**: Writes a buffer into this writer, returning how many bytes were written.
*   **`flush(&mut self) -> Result<()>`**: Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.
*   **`write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>`**: Writes from a slice of buffers.
*   **`write_all(&mut self, buf: &[u8]) -> Result<(), Error>`**: Attempts to write an entire buffer into this writer.
*   **`write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>`**: Writes a formatted string into this writer.
```

--------------------------------

### Write all bytes to the Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Attempts to write an entire buffer of bytes to the Writer, stripping ANSI escape sequences. This is a convenience method provided by the Write trait.

```rust
fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>
Attempts to write an entire buffer into this writer. Read more

```

--------------------------------

### Rust Test for Simple ANSI Escape Stripping

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

Tests the `strip` function with a basic string containing ANSI escape codes for color and formatting.

```rust
assert_parsed(b"\x1b[m\x1b[m\x1b[32m\x1b[1m    Finished\x1b[m dev [unoptimized + debuginfo] target(s) in 0.0 secs",
                  b"    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs");
```

--------------------------------

### Writer::into_inner

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Unwraps the Writer, returning the underlying writer. The internal buffer is written out before returning, which may produce an error.

```APIDOC
## Writer::into_inner

### Description
Unwraps this `Writer`, returning the underlying writer. The internal buffer is written out before returning the writer, which may produce an `IntoInnerError`.

### Method

```
pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>>
```

### Returns

Returns the underlying writer or an `IntoInnerError` if flushing the buffer fails.
```

--------------------------------

### strip_str

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/fn.strip_str.html

Strips ANSI escape codes from a given string slice and returns the cleaned string.

```APIDOC
## strip_str

### Description
Strips ANSI escape codes from `data` and returns the remaining contents as a `String`.

### Signature
```rust
pub fn strip_str<T>(data: T) -> String
where
    T: AsRef<str>,
```

### Parameters
* `data` - A value that can be referenced as a string slice (`AsRef<str>`).

### Returns
A `String` with all ANSI escape codes removed.

### Example
```rust
let str_with_colors = "\x1b[32mfoo\x1b[m bar";
let string_without_colors = strip_ansi_escapes::strip_str(str_with_colors);
assert_eq!(string_without_colors, "foo bar");
```
```

--------------------------------

### Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/index.html

A struct that wraps an underlying writer and strips ANSI escape sequences from bytes written to it.

```APIDOC
## Struct: Writer

### Description
`Writer` wraps an underlying type that implements `Write`, stripping ANSI escape sequences from bytes written to it before passing them to the underlying writer.

### Methods
#### `new(inner: W)`
Creates a new `Writer` that wraps the given `inner` writer.

#### `write(&mut self, buf: &[u8]) -> io::Result<usize>`
Writes a buffer of bytes to the writer, stripping ANSI escape sequences.

#### `flush(&mut self) -> io::Result<()>`
Flushes the underlying writer.

### Example
```rust
use std::io::{self, Write};
use strip_ansi_escapes::Writer;

let mut buffer = Vec::new();
let mut writer = Writer::new(&mut buffer);

writer.write_all(b"\x1b[32mHello\x1b[m World!")?;

assert_eq!(buffer, b"Hello World!");
```
```

--------------------------------

### Writer

Source: https://docs.rs/strip-ansi-escapes/0.2.1/index.html

Wraps an underlying type that implements `Write`, stripping ANSI escape sequences from bytes written to it before passing them to the underlying writer. This is useful for streaming data.

```APIDOC
## Writer

### Description
`Writer` wraps an underlying type that implements `Write`, stripping ANSI escape sequences from bytes written to it before passing them to the underlying writer.

### Struct Definition
```rust
struct Writer<W: Write> {
    // internal fields not exposed for direct manipulation
}
```

### Methods
#### `new(inner: W)`
Creates a new `Writer` that wraps the given `inner` writer.

#### `write(&mut self, buf: &[u8]) -> Result<usize, io::Error>`
Writes a byte slice to the writer, stripping ANSI escape sequences.

#### `flush(&mut self) -> Result<(), io::Error>`
Flushes the underlying writer.

### Example
```rust
use std::io::{self, Write};

let mut buffer = Vec::new();
let mut writer = strip_ansi_escapes::Writer::new(&mut buffer);

writer.write_all(b"\x1b[32mHello\x1b[m World!")?;
writer.flush()?;

// buffer now contains b"Hello World!"
```
```

--------------------------------

### Rust Test for Complex ANSI Escape and Newline Stripping

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

Tests the `strip` function with a more complex scenario involving multiple lines, ANSI escape codes, and text.

```rust
assert_parsed(b"\x1b[m\x1b[m\x1b[32m\x1b[1m   Compiling\x1b[m utf8parse v0.1.0
\x1b[m\x1b[m\x1b[32m\x1b[1m   Compiling\x1b[m vte v0.3.2
\x1b[m\x1b[m\x1b[32m\x1b[1m   Compiling\x1b[m strip-ansi-escapes v0.1.0-pre (file:///build/strip-ansi-escapes)
\x1b[m\x1b[m\x1b[32m\x1b[1m    Finished\x1b[m dev [unoptimized + debuginfo] target(s) in 0.66 secs
",
                      b"   Compiling utf8parse v0.1.0
   Compiling vte v0.3.2
   Compiling strip-ansi-escapes v0.1.0-pre (file:///build/strip-ansi-escapes)
    Finished dev [unoptimized + debuginfo] target(s) in 0.66 secs
");
```

--------------------------------

### Rust Test for Newline Handling

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

Tests that the `strip` function preserves newline characters when no ANSI escape codes are present.

```rust
assert_parsed(b"foo\nbar\n", b"foo\nbar\n");
```

--------------------------------

### Writer Struct

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

A writer that wraps an underlying `Write` implementor, stripping ANSI escape sequences from bytes written to it before passing them to the inner writer.

```APIDOC
## Writer Struct

### Description
Wraps an underlying type that implements `Write`, stripping ANSI escape sequences from bytes written to it before passing them to the underlying writer.

### Methods
#### `new(inner: W)`
Creates a new `Writer` that writes to `inner`.

* **Parameters**
  * `inner` - The underlying writer implementing `std::io::Write`.
* **Returns**
  A new `Writer<W>` instance.

#### `into_inner(self)`
Unwraps this `Writer`, returning the underlying writer. The internal buffer is written out before returning the writer, which may produce an [`IntoInnerError`].

* **Returns**
  A `Result` containing the underlying writer on success, or an `IntoInnerError` if flushing fails.

### Example
```rust
use std::io::{self, Write};
use strip_ansi_escapes::Writer;

let bytes_with_colors = b"\x1b[32mfoo\x1b[m bar";
let mut writer = Writer::new(io::stdout());
// Only `foo bar` will be written to stdout
writer.write_all(bytes_with_colors)?; 
```
```

--------------------------------

### Write to a writer while stripping ANSI escapes

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

Use the `Writer` struct to wrap an existing `Write` implementation. It automatically strips ANSI escape sequences from data written to it before passing it to the underlying writer. This is ideal for real-time output processing.

```rust
use std::io::{self, Write};
use strip_ansi_escapes::Writer;

# fn foo() -> io::Result<()> {
let bytes_with_colors = b"\x1b[32mfoo\x1b[m bar";
let mut writer = Writer::new(io::stdout());
// Only `foo bar` will be written to stdout
writer.write_all(bytes_with_colors)?;
# Ok(())
# }

```

--------------------------------

### strip Function

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/fn.strip.html

Strips ANSI escape codes from input byte data. This function takes any type that can be referenced as a byte slice and returns a new Vec<u8> with the ANSI escape codes removed.

```APIDOC
## strip

### Description

Strip ANSI escapes from `data` and return the remaining bytes as a `Vec<u8>`.

### Signature

```rust
pub fn strip<T>(data: T) -> Vec<u8>
where
    T: AsRef<[u8]>
```

### Parameters

* `data` - A reference to a byte slice (`AsRef<[u8]>`) from which ANSI escapes will be stripped.

### Returns

A `Vec<u8>` containing the input data with ANSI escape codes removed.

### Example

```rust
// Assuming the function is available in the current scope
let input = b"\x1b[31mHello, \x1b[0mWorld!\n";
let output = strip(input);
assert_eq!(output, b"Hello, World!\n");
```
```

--------------------------------

### Writer Struct Definition

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/struct.Writer.html

Defines the Writer struct, which requires an inner type that implements the Write trait.

```rust
pub struct Writer<W>
where
    W: Write,
{ /* private fields */ }

```

--------------------------------

### Strip ANSI escapes from a string slice

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

Use the `strip_str` function to remove ANSI escape sequences from a string slice and return a new `String` without them. This function internally uses `strip` and converts the resulting bytes back to a UTF-8 string.

```rust
let str_with_colors = "\x1b[32mfoo\x1b[m bar";
let string_without_colors = strip_ansi_escapes::strip_str(str_with_colors);
assert_eq!(string_without_colors, "foo bar");

```

--------------------------------

### Rust Test Function for Stripping ANSI Escapes

Source: https://docs.rs/strip-ansi-escapes/0.2.1/src/strip_ansi_escapes/lib.rs.html

A helper function used in tests to assert that ANSI escape codes are correctly stripped from input byte slices.

```rust
fn assert_parsed(input: &[u8], expected: &[u8]) {
    let bytes = strip(input);
    assert_eq!(bytes, expected);
}
```

--------------------------------

### Strip ANSI escapes from a byte slice

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/fn.strip.html

Use the `strip` function to remove ANSI escape codes from input data. The function accepts any type that can be referenced as a byte slice (`AsRef<[u8]>`) and returns a `Vec<u8>` containing the data without the escape sequences.

```rust
pub fn strip<T>(data: T) -> Vec<u8> 
where
    T: AsRef<[u8]>,

```

--------------------------------

### Strip ANSI escapes from a string

Source: https://docs.rs/strip-ansi-escapes/0.2.1/strip_ansi_escapes/fn.strip_str.html

Use the strip_str function to remove ANSI escape codes from a string. It accepts any type that can be referenced as a string (e.g., &str, String).

```rust
let str_with_colors = "\x1b[32mfoo\x1b[m bar";
let string_without_colors = strip_ansi_escapes::strip_str(str_with_colors);
assert_eq!(string_without_colors, "foo bar");
```
Tokens:
Raw