beuvy 0.1.0

Facade crate for beuvy-runtime plus optional declarative UI authoring.
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

use super::*;
use crate::ast::DeclarativeRuntimeExpr;

mod parser_block;
mod parser_core;

pub(crate) use parser_core::RuntimeExprParser;

pub(crate) fn parse_runtime_expr(
    node: XmlNode<'_, '_>,
    attr_name: &str,
    raw: &str,
) -> Result<DeclarativeRuntimeExpr, DeclarativeUiAssetLoadError> {
    let mut parser = RuntimeExprParser::new(node, attr_name, raw);
    let expr = parser.parse_expression()?;
    parser.expect_eof()?;
    Ok(expr)
}

pub(crate) fn parse_runtime_block(
    node: XmlNode<'_, '_>,
    attr_name: &str,
    raw: &str,
) -> Result<DeclarativeRuntimeExpr, DeclarativeUiAssetLoadError> {
    let mut parser = RuntimeExprParser::new(node, attr_name, raw);
    let statements = parser.parse_block_statements()?;
    parser.expect_eof()?;
    Ok(DeclarativeRuntimeExpr::Block(statements))
}

pub(crate) fn parse_runtime_number(raw: &str) -> Result<DeclarativeNumber, ()> {
    if raw.contains('.') {
        raw.parse::<f64>()
            .map(DeclarativeNumber::F64)
            .map_err(|_| ())
    } else if let Ok(value) = raw.parse::<i32>() {
        Ok(DeclarativeNumber::I32(value))
    } else {
        raw.parse::<i64>()
            .map(DeclarativeNumber::I64)
            .map_err(|_| ())
    }
}

pub(crate) fn expr_binding_path<'a>(
    expr: &'a DeclarativeRuntimeExpr,
) -> Option<std::borrow::Cow<'a, str>> {
    match expr {
        DeclarativeRuntimeExpr::BindingPath(path) => Some(std::borrow::Cow::Borrowed(path)),
        DeclarativeRuntimeExpr::FieldAccess { base, field } => {
            let mut path = expr_binding_path(base)?.into_owned();
            path.push('.');
            path.push_str(field);
            Some(std::borrow::Cow::Owned(path))
        }
        _ => None,
    }
}