use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum TextTier {
Block,
Warn,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TextRule {
pub name: String,
#[serde(default)]
pub label: Option<String>,
pub pattern: String,
pub tier: TextTier,
#[serde(default)]
pub class: Option<String>,
#[serde(default)]
pub exempt_path_regex: Option<String>,
#[serde(default)]
pub rationale: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TextViolation {
pub rule: String,
pub tier: TextTier,
pub message: String,
}
impl TextRule {
#[must_use]
pub fn applies(&self, rel: &str) -> bool {
match &self.exempt_path_regex {
Some(exempt) => match regex::Regex::new(exempt) {
Ok(re) => !re.is_match(rel),
Err(_) => true,
},
None => true,
}
}
#[must_use]
pub fn violations(&self, introduced: &str, rel: &str) -> Vec<TextViolation> {
if !self.applies(rel) {
return Vec::new();
}
let Ok(re) = regex::Regex::new(&self.pattern) else {
return Vec::new();
};
let mut seen: Vec<&str> = Vec::new();
for m in re.find_iter(introduced) {
if !seen.contains(&m.as_str()) {
seen.push(m.as_str());
}
}
seen.into_iter()
.map(|token| TextViolation {
rule: self.name.clone(),
tier: self.tier,
message: self.message_for(token),
})
.collect()
}
fn message_for(&self, token: &str) -> String {
let what = self.label.as_deref().unwrap_or(&self.name);
let class = self
.class
.as_deref()
.map(|c| format!(" ({c})"))
.unwrap_or_default();
let why = self
.rationale
.as_deref()
.map(|r| format!(" {r}"))
.unwrap_or_default();
format!(
"governed text rule `{}`: the edit introduces `{token}`{class} — {what}.{why}",
self.name
)
}
}
#[must_use]
pub fn errors(rules: &[TextRule]) -> Vec<(String, String)> {
let mut out = Vec::new();
for rule in rules {
if let Err(e) = regex::Regex::new(&rule.pattern) {
out.push((rule.name.clone(), format!("pattern does not compile: {e}")));
}
if let Some(exempt) = &rule.exempt_path_regex {
if let Err(e) = regex::Regex::new(exempt) {
out.push((
rule.name.clone(),
format!("exemptPathRegex does not compile (rule applies EVERYWHERE): {e}"),
));
}
}
}
out
}
#[must_use]
pub fn evaluate(rules: &[TextRule], introduced: &str, rel: &str) -> Vec<TextViolation> {
rules
.iter()
.flat_map(|r| r.violations(introduced, rel))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn lan_rule() -> TextRule {
TextRule {
name: "pattern_internal-lan-host".into(),
label: Some("internal .lan hostname".into()),
pattern: r"\b[a-z0-9][a-z0-9-]*\.lan\b".into(),
tier: TextTier::Block,
class: Some("hostname".into()),
exempt_path_regex: Some(r"(^|/)no_internal_identifiers\.rs$".into()),
rationale: Some("Maps the private estate.".into()),
}
}
fn bead_rule() -> TextRule {
TextRule {
name: "pattern_bead-reference".into(),
label: Some("bead reference".into()),
pattern: r"\b(?:aegis|hq)-[a-z0-9]{3,6}\b".into(),
tier: TextTier::Warn,
class: None,
exempt_path_regex: None,
rationale: None,
}
}
#[test]
fn a_forbidden_token_in_any_file_type_is_a_violation() {
for rel in ["README.md", "deploy.yml", "notes.txt", "src/a.rs"] {
let v = lan_rule().violations("host: dolt.lan\n", rel);
assert_eq!(v.len(), 1, "must fire in {rel}");
assert!(v[0].message.contains("`dolt.lan`"));
assert!(v[0].message.contains("internal .lan hostname"));
}
}
#[test]
fn clean_text_is_silent() {
assert!(lan_rule()
.violations("host: db.example.invalid\n", "a.md")
.is_empty());
}
#[test]
fn an_exempt_path_is_not_judged() {
let v = lan_rule().violations("assert dolt.lan", "src/no_internal_identifiers.rs");
assert!(v.is_empty());
assert_eq!(
lan_rule().violations("assert dolt.lan", "src/lib.rs").len(),
1
);
}
#[test]
fn a_malformed_exemption_exempts_nothing_and_is_reported() {
let mut rule = lan_rule();
rule.exempt_path_regex = Some("([unclosed".into());
assert_eq!(
rule.violations("dolt.lan", "src/no_internal_identifiers.rs")
.len(),
1
);
let errs = errors(&[rule]);
assert_eq!(errs.len(), 1);
assert!(errs[0].1.contains("exemptPathRegex"));
}
#[test]
fn a_malformed_pattern_is_an_error_not_a_silent_pass() {
let mut rule = lan_rule();
rule.pattern = "([unclosed".into();
assert!(rule.violations("dolt.lan", "a.md").is_empty()); let errs = errors(&[rule]);
assert_eq!(
errs.len(),
1,
"...and errors() surfaces it for the loud fail-open"
);
}
#[test]
fn repeated_tokens_are_one_violation_each_distinct_token() {
let v = lan_rule().violations("dolt.lan dolt.lan git.lan", "a.md");
assert_eq!(v.len(), 2, "dedup by token, not by occurrence");
}
#[test]
fn tiers_ride_the_violation() {
let rules = [lan_rule(), bead_rule()];
let v = evaluate(&rules, "see aegis-x1y2 on dolt.lan", "a.md");
assert_eq!(v.len(), 2);
assert!(v.iter().any(|x| x.tier == TextTier::Block));
assert!(v.iter().any(|x| x.tier == TextTier::Warn));
}
#[test]
fn word_boundaries_hold_the_false_positive_line() {
let node = TextRule {
name: "pattern_internal-node-name".into(),
label: None,
pattern: r"\b(?:kota|vati)\b".into(),
tier: TextTier::Block,
class: None,
exempt_path_regex: None,
rationale: None,
};
assert!(node
.violations("activation of a private key", "a.md")
.is_empty());
assert_eq!(node.violations("deploy to vati", "a.md").len(), 1);
}
}