diskplan-traversal 0.1.0

A library component of Diskplan for applying schemas to disk
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

use std::fmt::Display;

use anyhow::{anyhow, Result};

use diskplan_filesystem::PlantedPath;
use diskplan_schema::{Expression, Special, Token};

use super::stack;

pub enum Value<'a> {
    Expression(&'a Expression<'a>),
    String(&'a str),
}

pub(super) fn evaluate(
    expr: &Expression<'_>,
    stack: &stack::StackFrame,
    path: &PlantedPath,
) -> Result<String> {
    tracing::trace!(r#"Evaluating expression "{}""#, expr);
    let mut value = String::new();
    for token in expr.tokens() {
        match token {
            Token::Text(text) => value.push_str(text),
            Token::Variable(var) => {
                let sub = stack.lookup(var).ok_or_else(|| {
                    anyhow!(r#"Undefined variable "{}" in expression "{}""#, var, expr)
                })?;
                tracing::trace!(r#"Variable ${{{}}} = "{}""#, var, sub);
                match sub {
                    Value::Expression(expr) => {
                        tracing::trace!("Going deeper...");
                        value.push_str(&evaluate(expr, stack, path)?)
                    }
                    Value::String(s) => value.push_str(s),
                }
            }
            Token::Special(special) => {
                let it = match special {
                    Special::PathAbsolute => path.absolute().as_str(),
                    Special::PathRelative => path.relative().as_str(),
                    Special::PathNameOnly => path.relative().file_name().unwrap(),
                    Special::ParentAbsolute => path
                        .absolute()
                        .parent()
                        .ok_or_else(|| anyhow!("Path has no parent: {}", path.absolute()))?
                        .as_str(),

                    Special::ParentRelative => path
                        .relative()
                        .parent()
                        .ok_or_else(|| anyhow!("Path has no parent: {}", path.relative()))?
                        .as_str(),
                    Special::ParentNameOnly => path
                        .relative()
                        .parent()
                        .and_then(|p| p.file_name())
                        .ok_or_else(|| anyhow!("Path has no parent: {}", path.relative()))?,
                    Special::RootPath => path.root().as_str(),
                };
                tracing::trace!(r#"Special {} = "{}""#, special, it);
                value.push_str(it);
            }
        }
    }
    tracing::trace!(r#"Expression "{}" fully evaluated as "{}""#, expr, value);
    Ok(value)
}

impl Display for Value<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Value::Expression(e) => write!(f, "{e}"),
            Value::String(s) => write!(f, "{s}"),
        }
    }
}