ryan 0.2.3

Ryan: a configuration language for the practical programmer
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

use std::{fmt::Display, rc::Rc};

use indexmap::IndexMap;
use pest::iterators::Pairs;

use crate::rc_world;

use super::{value::TemplatedValue, ErrorLogger, Expression, Rule, State, Value};

#[derive(Debug, Clone, PartialEq)]
pub struct TemplateString {
    chunks: Vec<TemplateStringChunk>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum TemplateStringChunk {
    Text(Rc<str>),
    Interpolation(Expression),
}

impl Display for TemplateString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "`")?;

        for chunk in &self.chunks {
            match chunk {
                TemplateStringChunk::Interpolation(expr) => write!(f, "${{{expr}}}")?,
                TemplateStringChunk::Text(text) => {
                    for char in text.chars() {
                        match char {
                            '`' => write!(f, "\\`")?,
                            '$' => write!(f, "\\$")?,
                            ch => write!(f, "{ch}")?,
                        }
                    }
                }
            }
        }

        write!(f, "`")?;

        Ok(())
    }
}

impl TemplateString {
    pub(super) fn parse(logger: &mut ErrorLogger, pairs: Pairs<'_, Rule>) -> Self {
        let mut chunks = vec![];
        let mut chunk_builder = String::new();

        for pair in pairs {
            match pair.as_rule() {
                Rule::templateEscaped => {
                    if let Some(escaped) = pair.clone().into_inner().next() {
                        match escaped.as_rule() {
                            Rule::templateControlCode => match escaped.as_str() {
                                "`" => chunk_builder.push('`'),
                                "$" => chunk_builder.push('$'),
                                _ => unreachable!(),
                            },
                            Rule::interpolation => {
                                let chunk = rc_world::string_to_rc(chunk_builder);
                                chunk_builder = String::new();
                                chunks.push(TemplateStringChunk::Text(chunk));

                                let expression = Expression::parse(
                                    logger,
                                    pair.into_inner()
                                        .next()
                                        .expect("an interpolation always has an expression")
                                        .into_inner(),
                                );
                                chunks.push(TemplateStringChunk::Interpolation(expression));
                            }
                            _ => unreachable!(),
                        }
                    } else {
                        chunk_builder += pair.as_str();
                    }
                }
                r => panic!("{r:?}"),
            }
        }

        if !chunk_builder.is_empty() {
            let chunk = rc_world::string_to_rc(chunk_builder);
            chunks.push(TemplateStringChunk::Text(chunk));
        }

        TemplateString { chunks }
    }

    #[must_use]
    pub(super) fn capture(
        &self,
        state: &mut State<'_>,
        provided: &mut [Rc<str>],
        values: &mut IndexMap<Rc<str>, Value>,
    ) -> Option<()> {
        for chunk in &self.chunks {
            if let TemplateStringChunk::Interpolation(expr) = chunk {
                expr.capture(state, provided, values)?;
            }
        }

        Some(())
    }

    pub(super) fn eval(&self, state: &mut State<'_>) -> Option<Value> {
        let mut builder = String::new();
        for chunk in &self.chunks {
            match chunk {
                TemplateStringChunk::Text(text) => builder += text,
                TemplateStringChunk::Interpolation(expr) => {
                    let outcome = expr.eval(state)?;
                    builder += &TemplatedValue(outcome).to_string();
                }
            }
        }

        Some(Value::Text(rc_world::string_to_rc(builder)))
    }
}