Struct TerminalRedactionRule

pub struct TerminalRedactionRule {
    pub name: String,
    pub pattern: String,
    pub replacement: String,
}

One named, literal text replacement rule.

The name is metadata only. Matching uses str::replace, is case-sensitive, and ignores a rule whose pattern is empty.

Examples

use ailloli_ui_terminal_core::TerminalRedactionRule;

let rule = TerminalRedactionRule::exact("account", "alice@example.com");
assert_eq!(rule.name, "account");
assert_eq!(rule.pattern, "alice@example.com");
assert_eq!(rule.replacement, "[redacted]");

Fields

name: String

Informational rule name; it does not affect matching.

pattern: String

Case-sensitive literal pattern; an empty pattern is ignored.

replacement: String

Text inserted for every match; it may be empty.

Implementations

impl TerminalRedactionRule

pub fn exact(name: impl Into<String>, pattern: impl Into<String>) -> Self

Creates a literal rule whose replacement is "[redacted]".

name and pattern are stored without validation. In particular, an empty pattern is accepted but later ignored by the policy.

Examples

use ailloli_ui_terminal_core::{TerminalRedactionPolicy, TerminalRedactionRule};

let mut policy = TerminalRedactionPolicy::default();
policy.rules.push(TerminalRedactionRule::exact("user", "alice"));
assert_eq!(policy.redact_text("alice and Alice"), "[redacted] and Alice");

Trait Implementations

impl Clone for TerminalRedactionRule

fn clone(&self) -> TerminalRedactionRule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TerminalRedactionRule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TerminalRedactionRule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TerminalRedactionRule

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TerminalRedactionRule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TerminalRedactionRule

impl StructuralPartialEq for TerminalRedactionRule