Struct Text 

pub struct Text(/* private fields */);

Sanitized, display-safe text.

Constructing a Text always goes through Text::sanitize (directly, or indirectly via Deserialize), which strips control characters and terminal escape sequences, resolves backspace-overstrike, expands tabs, collapses whitespace runs, normalizes newlines (preserving paragraph breaks), and truncates to MAX_TEXT_CHARS. Widgets and other consumers may assume a Text is safe to place directly into a rendering surface.

Implementations

impl Text

pub fn sanitize(raw: &str) -> Text

The only way to build a Text from raw, untrusted input.

Pipeline (see spec §4.1 and §13.3 for the adversarial cases this must survive):

1. Strip ANSI/OSC/other terminal escape sequences.
2. Resolve backspace-overstrike (_\bX, X\bX, and any stray \b).
3. Strip remaining C0 control characters and DEL.
4. Expand tabs to spaces at 8-column stops.
5. Normalize line endings to \n.
6. Unwrap hard-wrapped paragraphs: a single \n inside a paragraph joins to a space (so a later re-wrap at the pane’s actual width produces clean lines instead of re-wrapping already-short, pre-broken lines raggedly); \n\n stays a paragraph break; indented/code-like lines and list items (- , * , 1. ) are never joined to a neighbor, preserving block structure.
7. Collapse runs of horizontal whitespace to a single space.
8. Trim leading/trailing whitespace.
9. Truncate to MAX_TEXT_CHARS characters, at a char boundary.

pub fn sanitize_markdown(raw: &str) -> Text

Like Text::sanitize, but for text known to originate as markdown-flavored prose (carapace-spec’s description/ documentation fields, which use [label](uri) links — including custom schemes like man:// and cmd:// — plus inline code, **bold**, and *em*/_em_ markers).

This is a conservative, targeted normalizer, not a general markdown parser: it recognizes exactly those four constructs and leaves anything else untouched. In particular it does not touch [value] usage-string brackets (no following (...)), and it requires non-word characters immediately outside *em*/_em_ delimiters so it doesn’t misfire on identifiers like GIT_DIR or globs. Recognized markup is replaced with its inner text; the surrounding URI/delimiters are discarded (plain-text fallback, since the detail pane doesn’t yet render hyperlinks).

pub fn as_str(&self) -> &str

Borrow the sanitized string.

pub fn is_empty(&self) -> bool

True if the sanitized text is empty.

pub fn single_line(&self) -> String

Collapse to a single display line (paragraph breaks and internal newlines become a single space), for contexts like tree rows that have no room for multi-line text. The tree pane is expected to call this at render time rather than store a second copy of the text.

Trait Implementations

impl Clone for Text

fn clone(&self) -> Text

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Text

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Text

fn default() -> Text

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Text

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialization re-runs Text::sanitize rather than trusting the stored bytes verbatim. This keeps the invariant airtight even when a Text is round-tripped through the on-disk cache (spec §11): a tampered or corrupted cache file cannot smuggle unsanitized bytes back into the IR. sanitize is idempotent, so this costs nothing extra for cache entries that were already clean.

impl Display for Text

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Text

impl Hash for Text

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Text

fn eq(&self, other: &Text) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Text

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Text