diplodocus 0.15.0

Build coherent documentation websites for polyglot software projects.
Documentation
use std::collections::BTreeMap;

use arity_parser::{ast::AstNode, dcf};

use crate::diagnostics::{Diagnostic, DiagnosticCode, Severity};
use crate::ir::SourceLocation;
pub use crate::ir::{RDependency, RMetadata, RMetadataField, RVersionConstraint};

use super::{diagnostic, located};

pub(crate) fn license_files(value: &str) -> impl Iterator<Item = &str> {
    value.split(['+', '|']).filter_map(|declaration| {
        declaration
            .trim()
            .trim_matches(['(', ')'])
            .trim()
            .strip_prefix("file ")
            .map(str::trim)
    })
}

pub(super) fn parse(
    text: &str,
    source: &SourceLocation,
    diagnostics: &mut Vec<Diagnostic>,
) -> Option<RMetadata> {
    let before = diagnostics.len();
    let parsed = dcf::parse(text);
    for error in &parsed.diagnostics {
        diagnostics.push(diagnostic(
            DiagnosticCode::RMetadata,
            Severity::Error,
            &error.message,
            &located(source, error.start, error.end),
        ));
    }
    let document = parsed.document();
    if document.records().count() != 1 {
        diagnostics.push(diagnostic(
            DiagnosticCode::RMetadata,
            Severity::Error,
            "DESCRIPTION must contain exactly one DCF record.",
            source,
        ));
    }
    let mut fields = BTreeMap::new();
    let mut dependencies = BTreeMap::new();
    for field in document.fields() {
        let name = field.name().to_string();
        let range = field.syntax().text_range();
        let location = located(source, usize::from(range.start()), usize::from(range.end()));
        let value = field.folded_value();
        if fields
            .insert(
                name.clone(),
                RMetadataField {
                    value: value.clone(),
                    source: location.clone(),
                },
            )
            .is_some()
        {
            diagnostics.push(diagnostic(
                DiagnosticCode::RMetadata,
                Severity::Error,
                format!("Duplicate DESCRIPTION field `{name}`."),
                &location,
            ));
        }
        if dcf::is_dependency_field(&name) {
            let mut entries = vec![];
            for entry in dcf::dependency_entries(&field) {
                let entry_source = located(
                    source,
                    usize::from(entry.range.start()),
                    usize::from(entry.range.end()),
                );
                let raw = &text[entry_source.span.unwrap().start..entry_source.span.unwrap().end];
                let compact: String = raw
                    .lines()
                    .filter(|line| !line.trim_start().starts_with('#'))
                    .flat_map(str::chars)
                    .filter(|c| !c.is_whitespace())
                    .collect();
                let mut constraints = vec![];
                for constraint in &entry.constraints {
                    let operator = match constraint.op {
                        dcf::VersionOp::Lt => "<",
                        dcf::VersionOp::Le => "<=",
                        dcf::VersionOp::Eq => "==",
                        dcf::VersionOp::Ge => ">=",
                        dcf::VersionOp::Gt => ">",
                        dcf::VersionOp::Ne => "!=",
                    };
                    constraints.push(RVersionConstraint {
                        operator: operator.into(),
                        version: constraint.version.to_string(),
                        source: located(
                            source,
                            usize::from(constraint.range.start()),
                            usize::from(constraint.range.end()),
                        ),
                    });
                }
                let mut expected = entry.name.to_string();
                if entry.constraint_text.is_some() {
                    expected.push('(');
                    expected.push_str(
                        &constraints
                            .iter()
                            .map(|c| format!("{}{}", c.operator, c.version))
                            .collect::<Vec<_>>()
                            .join(","),
                    );
                    expected.push(')');
                }
                if !package_name(&entry.name)
                    || entry.malformed_constraint()
                    || compact != expected
                    || constraints
                        .iter()
                        .any(|c| !version(&c.version) || c.operator == "!=")
                {
                    diagnostics.push(diagnostic(
                        DiagnosticCode::RMetadata,
                        Severity::Error,
                        format!("Malformed dependency declaration for `{}`.", entry.name),
                        &entry_source,
                    ));
                }
                entries.push(RDependency {
                    name: entry.name.to_string(),
                    constraints,
                    source: entry_source,
                });
            }
            dependencies.insert(name, entries);
        }
    }
    for name in ["Package", "Version", "Title"] {
        if fields
            .get(name)
            .is_none_or(|field| field.value.trim().is_empty())
        {
            diagnostics.push(diagnostic(
                DiagnosticCode::RMetadata,
                Severity::Error,
                format!("DESCRIPTION requires a nonempty `{name}` field."),
                source,
            ));
        }
    }
    for (name, valid) in [
        ("Package", package_name as fn(&str) -> bool),
        ("Version", version),
    ] {
        if let Some(field) = fields.get(name)
            && !valid(&field.value)
        {
            diagnostics.push(diagnostic(
                DiagnosticCode::RMetadata,
                Severity::Error,
                format!("Invalid DESCRIPTION `{name}`."),
                &field.source,
            ));
        }
    }
    if let Some(field) = fields.get("Encoding")
        && !field.value.eq_ignore_ascii_case("UTF-8")
    {
        diagnostics.push(diagnostic(
            DiagnosticCode::RMetadata,
            Severity::Error,
            "Only UTF-8 package encoding is supported.",
            &field.source,
        ));
    }
    if diagnostics.len() != before {
        return None;
    }
    Some(RMetadata {
        name: fields["Package"].value.clone(),
        version: fields["Version"].value.clone(),
        title: fields["Title"].value.clone(),
        description: fields.get("Description").map(|f| f.value.clone()),
        license: fields.get("License").map(|f| f.value.clone()),
        dependencies,
        fields,
        source: source.clone(),
    })
}

fn package_name(name: &str) -> bool {
    name.as_bytes().first().is_some_and(u8::is_ascii_alphabetic)
        && !name.ends_with('.')
        && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'.')
}

fn version(value: &str) -> bool {
    let parts: Vec<_> = value.split(['.', '-']).collect();
    parts.len() >= 2
        && parts
            .iter()
            .all(|part| !part.is_empty() && part.bytes().all(|b| b.is_ascii_digit()))
}