workshop-rs 1.25.1

Canonical multi-locale Overwatch Workshop semantic core: catalog, parser, WIR, validation, emitter.
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

#![allow(dead_code)]

use workshop_rs::catalog::Locale;
use workshop_rs::{WorkshopError, emitter, parser, roundtrip, wir};

use super::common;

pub(crate) fn parse(source: &str) -> wir::Program {
    parse_in(source, &common::en())
}

pub(crate) fn parse_in(source: &str, locale: &Locale) -> wir::Program {
    try_parse_in(source, locale).expect("test source parses")
}

pub(crate) fn try_parse(source: &str) -> Result<wir::Program, WorkshopError> {
    try_parse_in(source, &common::en())
}

pub(crate) fn try_parse_in(source: &str, locale: &Locale) -> Result<wir::Program, WorkshopError> {
    parser::parse_wir_with_context(source, &common::catalog(), locale, &common::catalog())
}

pub(crate) fn emit(program: &wir::Program) -> String {
    emit_in(program, &common::en())
}

pub(crate) fn emit_in(program: &wir::Program, locale: &Locale) -> String {
    try_emit_in(program, locale).expect("test program emits")
}

pub(crate) fn try_emit(program: &wir::Program) -> Result<String, WorkshopError> {
    try_emit_in(program, &common::en())
}

pub(crate) fn try_emit_in(
    program: &wir::Program,
    locale: &Locale,
) -> Result<String, WorkshopError> {
    emitter::emit_wir(program, &common::catalog(), locale)
}

pub(crate) fn assert_emit_round_trip(program: &wir::Program) -> String {
    let emitted = emit(program);
    let reparsed = parse(&emitted);
    assert!(
        roundtrip::equivalent_wir(program, &reparsed),
        "emitted text must reparse to an equivalent WIR program"
    );
    assert_eq!(emitted, emit(&reparsed), "emission must be a fixed point");
    emitted
}

pub(crate) fn assert_reparse_equivalent(program: &wir::Program, emitted: &str) {
    assert_reparse_equivalent_in(program, emitted, &common::en())
}

pub(crate) fn assert_reparse_equivalent_in(program: &wir::Program, emitted: &str, locale: &Locale) {
    let reparsed = parse_in(emitted, locale);
    assert!(
        roundtrip::equivalent_wir(program, &reparsed),
        "emitted text must reparse to an equivalent WIR program"
    );
}