markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
use googletest::prelude::*;
use std::path::Path;

use crate::{WorkspaceFile, WorkspaceIndex};

fn workspace(entries: &[(&str, &str)]) -> WorkspaceIndex {
    let root = Path::new("/ws");
    let files = entries
        .iter()
        .map(|(path, contents)| WorkspaceFile {
            path: root.join(path),
            contents: Some(Box::from(*contents)),
        })
        .collect();

    WorkspaceIndex::new(root.to_path_buf(), files)
}

fn build(entries: &[(&str, &str)], paths: &[String], depth: Option<u32>) -> String {
    super::build(&workspace(entries), Path::new("/ws"), paths, depth)
}

fn extract_file_doc(path: &str, contents: &str) -> Option<String> {
    let workspace = workspace(&[(path, contents)]);

    crate::domain::file_description(&workspace, &Path::new("/ws").join(path))
}

#[gtest]
fn build_empty_for_missing_dir() -> Result<()> {
    verify_that!(build(&[], &["src".to_string()], None), eq(""))
}

#[gtest]
fn build_generates_tree() {
    let result = build(
        &[
            ("src/lib.rs", ""),
            ("src/main.rs", ""),
            ("src/sub/mod.rs", ""),
        ],
        &["src".to_string()],
        None,
    );

    assert_eq!(
        result,
        "```\nsrc/\n  sub/\n    mod.rs\n  lib.rs\n  main.rs\n```"
    );
}

#[gtest]
fn build_with_doc_comments() {
    let result = build(
        &[
            ("src/main.rs", "//! CLI entry point.\nfn main() {}"),
            ("src/utils.rs", "//! Shared utilities.\npub fn foo() {}"),
            ("src/plain.rs", "pub(crate) fn bar() {}"),
        ],
        &["src".to_string()],
        None,
    );

    assert_eq!(
        result,
        "```\nsrc/\n  main.rs - CLI entry point.\n  plain.rs\n  utils.rs - Shared utilities.\n```"
    );
}

#[gtest]
fn build_skips_empty_dirs() {
    let result = build(
        &[("src/populated/main.rs", "fn main() {}")],
        &["src".to_string()],
        None,
    );

    assert_eq!(result, "```\nsrc/\n  populated/\n    main.rs\n```");
}

#[gtest]
fn build_skips_empty_dir_at_max_depth() {
    let result = build(
        &[("src/a/b/keep.rs", "fn k() {}")],
        &["src".to_string()],
        None,
    );

    assert_eq!(result, "```\nsrc/\n  a/\n    b/\n      keep.rs\n```");
}

#[gtest]
fn extract_file_doc_none_without_doc() -> Result<()> {
    verify_that!(extract_file_doc("plain.rs", "fn main() {}"), none())
}

#[gtest]
fn build_multiple_paths() {
    let result = build(
        &[("src/main.rs", ""), ("ui/app.slint", "")],
        &["src".to_string(), "ui".to_string()],
        None,
    );

    assert_eq!(result, "```\nsrc/\n  main.rs\nui/\n  app.slint\n```");
}

#[gtest]
fn build_respects_max_depth() {
    let entries = [
        ("src/a/b/c/deep.rs", "//! Deep file."),
        ("src/a/top.rs", "//! Top file."),
    ];
    let shallow = build(&entries, &["src".to_string()], Some(1));

    assert_eq!(shallow, "```\nsrc/\n  a/\n```");

    let deep = build(&entries, &["src".to_string()], None);

    assert_eq!(
        deep,
        "```\nsrc/\n  a/\n    b/\n      c/\n        deep.rs - Deep file.\n    top.rs - Top file.\n```"
    );
}

#[gtest]
fn extract_js_single_line_jsdoc() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "index.ts",
            "/** Auth utilities for OAuth2 flow. */\nexport function auth() {}",
        ),
        some(eq("Auth utilities for OAuth2 flow."))
    )
}

#[gtest]
fn extract_js_multiline_jsdoc() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "utils.tsx",
            "/**\n * React hook for theme switching.\n * @param initial - starting theme\n */\nexport function useTheme() {}",
        ),
        some(eq("React hook for theme switching."))
    )
}

#[gtest]
fn extract_js_single_line_comment() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "helper.js",
            "// String manipulation helpers.\nmodule.exports = {};",
        ),
        some(eq("String manipulation helpers."))
    )
}

#[gtest]
fn extract_js_no_doc() -> Result<()> {
    verify_that!(
        extract_file_doc("bare.jsx", "export default function App() {}"),
        none()
    )
}

#[gtest]
fn extract_py_single_line_docstring() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "mod.py",
            "\"\"\"Database connection pool.\"\"\"\nimport sqlite3",
        ),
        some(eq("Database connection pool."))
    )
}

#[gtest]
fn extract_py_multiline_docstring() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "app.py",
            "\"\"\"Flask application factory.\n\nCreates and configures the app.\n\"\"\"\nfrom flask import Flask",
        ),
        some(eq("Flask application factory."))
    )
}

#[gtest]
fn extract_py_single_quotes() -> Result<()> {
    verify_that!(
        extract_file_doc("util.py", "'''Utility functions.'''\ndef foo(): pass"),
        some(eq("Utility functions."))
    )
}

#[gtest]
fn extract_py_with_leading_comment() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "script.py",
            "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"CLI entry point.\"\"\"\nimport sys",
        ),
        some(eq("CLI entry point."))
    )
}

#[gtest]
fn extract_py_no_doc() -> Result<()> {
    verify_that!(
        extract_file_doc("bare.py", "import os\nprint('hello')"),
        none()
    )
}

#[gtest]
fn extracts_go_package_comment() -> Result<()> {
    verify_that!(
        extract_file_doc(
            "server.go",
            "// Package server handles HTTP.\npackage server"
        ),
        some(eq("Package server handles HTTP."))
    )
}

#[gtest]
fn extracts_lua_module_comment() -> Result<()> {
    verify_that!(
        extract_file_doc("addon.lua", "--- Addon bootstrap.\nlocal addon = {}"),
        some(eq("Addon bootstrap."))
    )
}

#[gtest]
fn extracts_php_docblock() -> Result<()> {
    verify_that!(
        extract_file_doc("api.php", "/** API routes. */\nfinal class Api {}"),
        some(eq("API routes."))
    )
}