Skip to content

The design language that makes your AI harness better at design.

JavaScript
4.5 KB
Raw Blame
//! The static HTML engine's half of the rule-pack extension point: the
//! document hook runs on the parsed page after every built-in pass, the
//! engine-wide text hook covers HTML files when no document hook is set, and
//! a run with no pack is identical to the built-in output.

use impeccable_core::findings::{finding_for, Finding};
use impeccable_core::registry::Antipattern;
use impeccable_core::rule_pack::RulePack;
use impeccable_html::dom::StaticDocument;
use impeccable_html::{detect_html_source, DetectHtmlOptions, StaticRulePack};
use std::path::Path;

const MARKER: &str = "TODO(pack)";

static ROWS: &[Antipattern] = &[Antipattern {
    id: "testpack/todo-marker",
    category: "quality",
    scopes: None,
    severity: Some("warning"),
    name: "Unfinished copy marker",
    description: "Text still carries a TODO marker from drafting.",
    skill_section: None,
    skill_guideline: None,
}];

#[derive(Debug)]
struct TestPack;
static PACK: TestPack = TestPack;

impl RulePack for TestPack {
    fn registry(&self) -> &'static [Antipattern] {
        ROWS
    }
    fn check_text(&self, content: &str, file_path: &str, _ext: &str) -> Vec<Finding> {
        content
            .split('\n')
            .enumerate()
            .filter(|(_, line)| line.contains(MARKER))
            .map(|(i, line)| finding_for(&ROWS[0], file_path, line.trim(), (i + 1) as f64))
            .collect()
    }
}

impl StaticRulePack for TestPack {
    fn check_document(&self, doc: &StaticDocument, file_path: &str) -> Vec<Finding> {
        doc.query_selector_all("*")
            .into_iter()
            .filter(|el| el.direct_text().contains(MARKER))
            .map(|el| {
                finding_for(
                    &ROWS[0],
                    file_path,
                    &format!("<{}> {}", el.tag_lower(), el.direct_text().trim()),
                    0.0,
                )
            })
            .collect()
    }
}

/// A full page with one built-in finding (the side-tab stripe) plus a line
/// the pack is about.
const PAGE: &str = r#"<!DOCTYPE html>
<html><head><title>t</title><style>
.card { border-left: 4px solid #6366f1; border-radius: 10px; background: #fff; }
</style></head>
<body>
<div class="card">A card</div>
<p>TODO(pack) write the real headline</p>
</body></html>
"#;

fn scan(options: &DetectHtmlOptions<'_>) -> Vec<Finding> {
    detect_html_source(PAGE, Path::new("/app/index.html"), options)
}

#[test]
fn document_hook_fires_and_no_pack_is_unchanged() {
    let built_in = scan(&DetectHtmlOptions::default());
    assert!(
        !built_in.is_empty(),
        "the fixture must trip a built-in rule"
    );

    impeccable_core::rule_pack::install(&PACK);
    let with_pack = scan(&DetectHtmlOptions {
        static_rule_pack: Some(&PACK),
        rule_pack: Some(&PACK),
        ..Default::default()
    });

    // Built-in findings come first, unchanged, in the same order.
    assert_eq!(&with_pack[..built_in.len()], &built_in[..]);

    // Exactly one pack finding: the document hook wins over the text hook, so
    // a pack that implements both does not report the same file twice.
    let extra = &with_pack[built_in.len()..];
    assert_eq!(extra.len(), 1);
    assert_eq!(extra[0].antipattern, "testpack/todo-marker");
    assert_eq!(extra[0].snippet, "<p> TODO(pack) write the real headline");
    assert_eq!(extra[0].line, 0.0);
}

#[test]
fn text_hook_covers_html_when_no_document_hook_is_set() {
    impeccable_core::rule_pack::install(&PACK);
    let with_text_only = scan(&DetectHtmlOptions {
        rule_pack: Some(&PACK),
        ..Default::default()
    });
    let pack_findings: Vec<&Finding> = with_text_only
        .iter()
        .filter(|f| f.antipattern.starts_with("testpack/"))
        .collect();
    assert_eq!(pack_findings.len(), 1);
    // The text hook reports the source line, not the element.
    assert_eq!(pack_findings[0].line, 7.0);
    assert_eq!(
        pack_findings[0].snippet,
        "<p>TODO(pack) write the real headline</p>"
    );
}

#[test]
fn pack_findings_are_waivable_inline() {
    impeccable_core::rule_pack::install(&PACK);
    let page = PAGE.replace(
        "<body>",
        "<body>\n<!-- impeccable-disable testpack/todo-marker -->",
    );
    let findings = detect_html_source(
        &page,
        Path::new("/app/index.html"),
        &DetectHtmlOptions {
            static_rule_pack: Some(&PACK),
            ..Default::default()
        },
    );
    assert!(findings
        .iter()
        .all(|f| !f.antipattern.starts_with("testpack/")));
}