markupwright 0.1.3

Template-driven workspace documentation generator
Documentation
mod context;
mod metadata;
mod model;
mod source;

use std::{
    collections::BTreeSet,
    path::{Path, PathBuf},
};

use serde::Deserialize;

pub(crate) use model::Workspace;

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

#[derive(Debug, Default)]
pub(crate) struct State {
    workspace: Workspace,
    manifests: Vec<PathBuf>,
    manifest_directories: BTreeSet<PathBuf>,
}

#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Config {
    manifests: crate::config::Patterns,
    workspace: Option<crate::config::RepositoryPath>,
    aliases: Option<crate::config::RepositoryPath>,
    #[serde(default, rename = "dependency-graph")]
    dependency_graph: bool,
    #[serde(default, rename = "source-documentation")]
    source_documentation: bool,
}

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

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

    fn initialize(
        config: &Self::Config,
        root: &Path,
        files: &crate::domain::IndexedFiles,
    ) -> Result<Self::State, crate::domain::Error> {
        let workspace = config.workspace.as_ref().map_or_else(
            || Ok(Workspace::default()),
            |workspace| Workspace::load(&root.join(workspace.as_path()), files),
        )?;
        let manifests = crate::config::matching_files(root, files, &config.manifests);
        let manifest_directories = manifests
            .iter()
            .filter_map(|path| path.parent().map(Path::to_path_buf))
            .collect();

        Ok(State {
            workspace,
            manifests,
            manifest_directories,
        })
    }

    fn manifests(
        _config: &Self::Config,
        state: &Self::State,
        _root: &Path,
        _files: &crate::domain::IndexedFiles,
    ) -> Result<Vec<PathBuf>, crate::domain::Error> {
        Ok(state.manifests.clone())
    }

    fn metadata(
        _config: &Self::Config,
        state: &Self::State,
        context: &crate::domain::MetadataContext<'_>,
    ) -> Result<Option<crate::domain::Metadata>, crate::domain::Error> {
        metadata::resolve(context, &state.workspace, &state.manifest_directories)
    }

    fn context(
        config: &Self::Config,
        _state: &Self::State,
        context: &crate::RenderCtx<'_>,
    ) -> Result<Vec<crate::domain::ContextEntry>, crate::domain::Error> {
        context::collect(config, context).map(|entry| entry.into_iter().collect())
    }

    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);