markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

use crate::domain::{ContextEntry, Metadata, MetadataContext};

#[derive(Debug)]
pub(crate) struct Domain;

#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Config {
    manifests: crate::config::Patterns,
    #[serde(default, rename = "source-documentation")]
    source_documentation: bool,
}

#[derive(Debug, Serialize)]
struct TemplateContext {
    version: Option<String>,
}

#[derive(Debug, thiserror::Error)]
#[error("{0}")]
struct ParseError(String);

impl crate::domain::registry::Domain for Domain {
    type Config = Config;
    type State = ();

    const NAME: &'static str = "go";

    fn manifests(
        config: &Self::Config,
        _state: &Self::State,
        root: &Path,
        files: &crate::domain::IndexedFiles,
    ) -> Result<Vec<PathBuf>, crate::domain::Error> {
        Ok(crate::config::matching_files(
            root,
            files,
            &config.manifests,
        ))
    }

    fn metadata(
        _config: &Self::Config,
        _state: &Self::State,
        context: &MetadataContext<'_>,
    ) -> Result<Option<Metadata>, crate::domain::Error> {
        let manifest = parse(context.manifest_source)
            .map_err(|error| crate::domain::Error::parse(context.manifest_path, "go.mod", error))?;

        if manifest.module.is_empty() {
            return Err(crate::domain::Error::message(
                context.manifest_path,
                "go.mod",
                "missing module directive",
            ));
        }

        let mut metadata = Metadata {
            name: manifest.module.rsplit('/').next().map(str::to_string),
            kind: "go",
            ..Metadata::default()
        };

        metadata.insert_data(
            Self::NAME,
            TemplateContext {
                version: manifest.go,
            },
        );

        Ok(Some(metadata))
    }

    fn context(
        _config: &Self::Config,
        _state: &Self::State,
        context: &crate::RenderCtx<'_>,
    ) -> Result<Vec<ContextEntry>, crate::domain::Error> {
        let Some(value) = context.metadata.data::<TemplateContext>(Self::NAME) else {
            return Ok(Vec::new());
        };

        Ok(vec![("go".into(), crate::domain::to_value(value))])
    }

    fn source_description(
        config: &Self::Config,
        _state: &Self::State,
        path: &Path,
        source: &str,
    ) -> Option<String> {
        config.source_documentation.then_some(())?;
        (path.extension()?.to_str()? == "go").then_some(())?;

        source.lines().take(10).find_map(|line| {
            line.trim()
                .strip_prefix("//")
                .map(str::trim)
                .filter(|description| !description.is_empty())
                .map(str::to_string)
        })
    }

    fn namespaces(_config: &Self::Config) -> Vec<Box<str>> {
        vec![Self::NAME.into()]
    }
}

fn parse(source: &str) -> Result<gomod_parser::GoMod, ParseError> {
    source.parse().map_err(ParseError)
}

crate::domain::registry::register_domain!(Domain);

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    #[gtest]
    fn parses_go_manifest() -> Result<()> {
        let source = "module github.com/example/server\n\ngo 1.24\n";
        let manifest = parse(source).or_fail()?;

        verify_eq!(manifest.module, "github.com/example/server")?;
        verify_eq!(manifest.go.as_deref(), Some("1.24"))
    }
}