lemma 0.8.20

A language that means business.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use ariadne::{Color, Label, Report, ReportKind, Source};
use lemma::Error;
use lemma::ErrorDetails;
use std::collections::HashMap;

fn format_details(
    error_type: &str,
    details: &ErrorDetails,
    label_message: &str,
    sources: &HashMap<lemma::SourceType, String>,
) -> String {
    let Some(ref src) = details.source else {
        return format!("{}: {}", error_type, details.message);
    };

    let source_type_str = src.source_type.to_string();

    let Some(full_content) = sources.get(&src.source_type) else {
        return format!(
            "{}: {} ({}:{})",
            error_type, details.message, source_type_str, src.span.line
        );
    };

    let mut output = Vec::new();

    let header = match details.spec_context.as_ref() {
        Some(spec) => format!(
            "{}: {} (in spec '{}', file {}:{})",
            error_type, details.message, spec.name, source_type_str, src.span.line
        ),
        None => format!(
            "{}: {} ({}:{})",
            error_type, details.message, source_type_str, src.span.line
        ),
    };

    let span = (source_type_str.as_str(), src.span.start..src.span.end);
    let mut report = Report::build(ReportKind::Error, span.clone())
        .with_message(header)
        .with_label(
            Label::new(span)
                .with_message(label_message)
                .with_color(Color::Red),
        );

    if let Some(suggestion) = &details.suggestion {
        report = report.with_help(suggestion);
    }

    let content: &str = full_content.as_str();
    if report
        .finish()
        .write(
            (source_type_str.as_str(), Source::from(content)),
            &mut output,
        )
        .is_err()
    {
        return format!(
            "{}: {} ({}:{})",
            error_type, details.message, source_type_str, src.span.line
        );
    }
    String::from_utf8_lossy(&output).to_string()
}

#[must_use]
pub fn format_error(error: &Error, sources: &HashMap<lemma::SourceType, String>) -> String {
    let fmt = |typ: &str, details: &ErrorDetails, label: &str| {
        format_details(typ, details, label, sources)
    };
    match error {
        Error::Parsing(details) => fmt("Parse error", details, ""),
        Error::Inversion(details) => fmt("Inversion error", details, ""),
        Error::Validation(details) => fmt("Validation error", details, ""),
        Error::Registry {
            details,
            identifier,
            kind,
        } => fmt(&format!("Registry error ({})", kind), details, identifier),
        Error::MissingRepository {
            details,
            repository,
        } => fmt("Missing repository", details, repository),
        Error::ResourceLimitExceeded {
            details,
            limit_name,
            limit_value,
            actual_value,
        } => fmt(
            &format!("Resource limit exceeded: {limit_name} (limit: {limit_value}, actual: {actual_value})"),
            details,
            "",
        ),
        Error::Request { details, .. } => fmt("Request error", details, ""),
    }
}