tectonic_engine_spx2html 0.4.2

The Tectonic engine that converts SPX output to HTML.
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// Copyright 2018-2022 the Tectonic Project
// Licensed under the MIT License.

//! TeX `\special` items recognized by the spx2html emitter.

use std::fmt::{Display, Error, Formatter};
use tectonic_status_base::{tt_warning, StatusBackend};

#[allow(clippy::enum_variant_names)]
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub(crate) enum Special<'a> {
    AddTemplate(&'a str),
    AutoStartParagraph,
    AutoEndParagraph,
    CanvasEnd(&'a str),
    CanvasStart(&'a str),
    ContentFinished,
    DirectText(&'a str),
    EndDefineFontFamily,
    EndFontFamilyTagAssociations,
    Emit,
    ManualEnd(&'a str),
    ManualFlexibleStart(&'a str),
    ProvideFile(&'a str),
    ProvideSpecial(&'a str),
    SetOutputPath(&'a str),
    SetTemplate(&'a str),
    SetTemplateVariable(&'a str),
    StartDefineFontFamily,
    StartFontFamilyTagAssociations,
}

impl<'a> Special<'a> {
    pub(crate) fn parse(text: &'a str, status: &mut dyn StatusBackend) -> Option<Self> {
        // str.split_once() would be nice but it was introduced in 1.52 which is
        // a bit recent for us.

        let mut pieces = text.splitn(2, ' ');

        let (cmd, remainder) = if let Some(p) = pieces.next() {
            if let Some(cmd) = p.strip_prefix("tdux:") {
                (cmd, pieces.next().unwrap_or_default())
            } else {
                return None;
            }
        } else {
            return None;
        };

        Some(match cmd {
            "asp" => Special::AutoStartParagraph,
            "aep" => Special::AutoEndParagraph,
            "cs" => Special::CanvasStart(remainder),
            "ce" => Special::CanvasEnd(remainder),
            "mfs" => Special::ManualFlexibleStart(remainder),
            "me" => Special::ManualEnd(remainder),
            "dt" => Special::DirectText(remainder),
            "emit" => Special::Emit,
            "addTemplate" => Special::AddTemplate(remainder),
            "setTemplate" => Special::SetTemplate(remainder),
            "setOutputPath" => Special::SetOutputPath(remainder),
            "setTemplateVariable" => Special::SetTemplateVariable(remainder),
            "provideFile" => Special::ProvideFile(remainder),
            "provideSpecial" => Special::ProvideSpecial(remainder),
            "contentFinished" => Special::ContentFinished,
            "startDefineFontFamily" => Special::StartDefineFontFamily,
            "endDefineFontFamily" => Special::EndDefineFontFamily,
            "startFontFamilyTagAssociations" => Special::StartFontFamilyTagAssociations,
            "endFontFamilyTagAssociations" => Special::EndFontFamilyTagAssociations,
            _ => {
                tt_warning!(
                    status,
                    "ignoring unrecognized Tectonic special: tdux:{} {}",
                    cmd,
                    remainder
                );
                return None;
            }
        })
    }

    pub fn ends_initialization(&self) -> bool {
        matches!(
            self,
            Special::Emit
                | Special::ProvideFile(_)
                | Special::ProvideSpecial(_)
                | Special::AutoStartParagraph
                | Special::AutoEndParagraph
                | Special::CanvasStart(_)
                | Special::CanvasEnd(_)
                | Special::ManualFlexibleStart(_)
                | Special::ManualEnd(_)
                | Special::DirectText(_)
        )
    }
}

impl Display for Special<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let (cmd, rest) = match self {
            Special::AddTemplate(t) => ("addTemplate", Some(t)),
            Special::AutoStartParagraph => ("asp", None),
            Special::AutoEndParagraph => ("aep", None),
            Special::CanvasEnd(t) => ("ce", Some(t)),
            Special::CanvasStart(t) => ("cs", Some(t)),
            Special::ContentFinished => ("contentFinished", None),
            Special::DirectText(t) => ("dt", Some(t)),
            Special::EndDefineFontFamily => ("endDefineFontFamily", None),
            Special::EndFontFamilyTagAssociations => ("endFontFamilyTagAssociations", None),
            Special::Emit => ("emit", None),
            Special::ManualEnd(t) => ("me", Some(t)),
            Special::ManualFlexibleStart(t) => ("mfs", Some(t)),
            Special::ProvideFile(t) => ("provideFile", Some(t)),
            Special::ProvideSpecial(t) => ("provideSpecial", Some(t)),
            Special::SetOutputPath(t) => ("setOutputPath", Some(t)),
            Special::SetTemplate(t) => ("setTemplate", Some(t)),
            Special::SetTemplateVariable(t) => ("setTemplateVariable", Some(t)),
            Special::StartDefineFontFamily => ("startDefineFontFamily", None),
            Special::StartFontFamilyTagAssociations => ("startFontFamilyTagAssociations", None),
        };

        if let Some(t) = rest {
            write!(f, "tdux:{cmd} {t}")
        } else {
            write!(f, "tdux:{cmd}")
        }
    }
}