markupwright 0.1.3

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

use serde::{Deserialize, Serialize};

use super::{ContextEntry, Metadata, MetadataContext};
use crate::RenderCtx;

mod source;

#[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(Clone, Debug, Serialize)]
struct Script {
    name: String,
    command: String,
}

#[derive(Clone, Debug, Serialize)]
struct Dependency {
    name: String,
    version: String,
}

#[derive(Debug, Default)]
pub(crate) struct Package {
    node_version: Option<String>,
    scripts: Vec<Script>,
    dependencies: Vec<Dependency>,
}

#[derive(Debug, Serialize)]
struct TemplateContext<'a> {
    node_version: &'a Option<String>,
    scripts: &'a [Script],
    dependencies: &'a [Dependency],
}

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

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

    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>, super::Error> {
        let path = context.manifest_path;
        let manifest: Manifest = serde_json::from_str(context.manifest_source)
            .map_err(|error| super::Error::parse(path, "package.json", error))?;
        let scripts = manifest
            .scripts
            .into_iter()
            .map(|(name, command)| Script { name, command })
            .collect();
        let dependencies = manifest
            .dependencies
            .into_iter()
            .map(|(name, version)| Dependency { name, version })
            .collect();

        let mut metadata = Metadata {
            name: manifest.name,
            description: manifest.description,
            version: manifest.version,
            kind: "package",
            ..Metadata::default()
        };

        metadata.insert_data(
            Self::NAME,
            Package {
                node_version: manifest.engines.and_then(|engines| engines.node),
                scripts,
                dependencies,
            },
        );

        Ok(Some(metadata))
    }

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

        Ok(vec![("node".into(), super::to_value(&value))])
    }

    fn source_description(
        config: &Self::Config,
        _state: &Self::State,
        path: &Path,
        source: &str,
    ) -> Option<String> {
        config
            .source_documentation
            .then(|| source::extract(path, source))
            .flatten()
    }

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

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

#[derive(Deserialize)]
struct Manifest {
    name: Option<String>,
    description: Option<String>,
    version: Option<String>,
    engines: Option<Engines>,
    #[serde(default)]
    scripts: BTreeMap<String, String>,
    #[serde(default)]
    dependencies: BTreeMap<String, String>,
}

#[derive(Deserialize)]
struct Engines {
    node: Option<String>,
}

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

    use super::Package;
    use crate::{WorkspaceFile, WorkspaceIndex};

    #[gtest]
    fn parses_node_metadata() -> Result<()> {
        let root = Path::new("/ws");
        let workspace = WorkspaceIndex::new_domain(
            root.to_path_buf(),
            vec![WorkspaceFile {
                path: root.join("package.json"),
                contents: Some(
                    r#"{"name":"web","version":"1.0.0","engines":{"node":">=24"},"scripts":{"test":"vitest"}}"#
                        .into(),
                ),
            }],
            "node",
            toml::Value::Table(toml::toml! { manifests = ["package.json"] }),
        );
        let metadata = workspace.metadata(root).or_fail()?;
        let package = metadata.data::<Package>("node").or_fail()?;

        verify_eq!(metadata.name.as_deref(), Some("web"))?;
        verify_eq!(package.node_version.as_deref(), Some(">=24"))?;
        verify_that!(&package.scripts, len(eq(1)))
    }
}