sofie-engine 0.2.0

Screens: the template parser and renderer, and the component catalog.
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

use std::borrow::Cow;

use crate::catalog::Component;
use crate::escape::push_escaped;
use crate::syntax::{Expression, Op};

#[derive(Debug)]
pub(crate) struct Program<C = Component> {
    ops: Vec<Op<C>>,
    pub(crate) markup: String,
}

impl<C> Default for Program<C> {
    fn default() -> Self {
        Self {
            ops: Vec::new(),
            markup: String::new(),
        }
    }
}

impl<C> Program<C> {
    pub fn into_ops(mut self) -> Vec<Op<C>> {
        self.end_markup();
        self.ops
    }

    pub fn push(&mut self, op: Op<C>) {
        if let Op::Markup(markup) = &op {
            self.markup.push_str(markup);
            return;
        }
        self.end_markup();
        self.ops.push(op);
    }

    pub fn push_markup(&mut self, markup: &str) {
        self.markup.push_str(markup);
    }

    /// A value known when parsing is escaped now; any other when rendering.
    pub fn push_text(&mut self, expression: Expression) {
        match constant(&expression) {
            Some(text) => push_escaped(&mut self.markup, &text),
            None => self.push(Op::Text(expression)),
        }
    }

    fn end_markup(&mut self) {
        if !self.markup.is_empty() {
            self.ops.push(Op::Markup(std::mem::take(&mut self.markup)));
        }
    }
}

pub(crate) fn constant(expression: &Expression) -> Option<Cow<'_, str>> {
    match expression {
        Expression::Text(text) | Expression::Authored(text) => Some(Cow::Borrowed(text)),
        Expression::Integer(number) => Some(Cow::Owned(number.to_string())),
        _ => None,
    }
}