weavatrix-rust 2.2.1

use super::TokenizedAdapter;
use crate::language::{LanguageAdapter, SourceFile};
use weavatrix_graph::NodeKind;

fn adapter(extension: &str) -> TokenizedAdapter {
    TokenizedAdapter::defaults()
        .find(|adapter| adapter.extensions().contains(&extension))
        .expect("extension is served")
}

#[test]
fn declaration_span_ends_at_the_name() {
    let text = "export function start(port: number) {}\n";
    let facts = adapter("ts")
        .parse(SourceFile {
            path: "src/app.ts",
            text,
        })
        .expect("parses");
    let symbol = &facts.symbols[0];
    assert_eq!(symbol.name, "start");
    assert_eq!(symbol.kind, NodeKind::Function);
    assert_eq!(symbol.span.start.line, 1);
    assert!(
        u32::try_from(text.trim_end().len()).is_ok_and(|width| symbol.span.end.column < width),
        "the span must not reach the end of the line: {:?}",
        symbol.span
    );
}

#[test]
fn comments_do_not_create_import_facts() {
    let facts = adapter("js")
        .parse(SourceFile {
            path: "src/routes.js",
            text: "// import ghost from './ghost.js';\nimport real from './real.js';\n",
        })
        .expect("parses");
    assert_eq!(
        facts
            .imports
            .iter()
            .map(|import| import.target.as_str())
            .collect::<Vec<_>>(),
        ["./real.js"]
    );
}

#[test]
fn map_lookup_is_not_an_http_route() {
    let facts = adapter("js")
        .parse(SourceFile {
            path: "src/routes.js",
            text: "map.get('key');\nrouter.get('/items', list);\n",
        })
        .expect("parses");
    assert_eq!(
        facts
            .domains
            .iter()
            .filter(|domain| domain.kind == NodeKind::Endpoint)
            .map(|domain| domain.name.as_str())
            .collect::<Vec<_>>(),
        ["GET /items"]
    );
}

#[test]
fn stylesheet_and_document_share_selector_evidence() {
    let styles = adapter("css")
        .parse(SourceFile {
            path: "web/app.css",
            text: ".panel { color: red; }\n",
        })
        .expect("parses");
    assert!(styles.symbols.iter().any(|symbol| symbol.name == ".panel"));
    let page = adapter("html")
        .parse(SourceFile {
            path: "web/index.html",
            text: "<div class=\"panel\"></div>\n",
        })
        .expect("parses");
    assert!(
        page.references
            .iter()
            .any(|reference| reference.name == ".panel")
    );
}

#[test]
fn shell_scripts_are_parsed() {
    let facts = adapter("sh")
        .parse(SourceFile {
            path: "ci/deploy.sh",
            text: "source ./lib/common.sh\ndeploy() { curl -sf http://svc/ready; }\n",
        })
        .expect("parses");
    assert_eq!(
        facts
            .imports
            .iter()
            .map(|import| import.target.as_str())
            .collect::<Vec<_>>(),
        ["./lib/common.sh"]
    );
    assert!(facts.symbols.iter().any(|symbol| symbol.name == "deploy"));
}