csvpp 0.5.0

Compile csvpp source code to a target spreadsheet format
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

use super::{Ast, FunctionArgs, FunctionName, VariableName, VariableValue};

/// The most basic building block of our language AST.  The AST is made recursive by the fact that
/// function calls and infix function calls can be composed.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub enum Node {
    /// A wrapper around a `bool`, in spreadsheets it will come out as TRUE or FALSE
    Boolean(bool),

    /// A date, time or both
    DateTime(crate::DateTime),

    /// A float (with a decimal) value
    Float(f64),

    /// A function definition
    ///
    /// * `args` - The arguments that the function can take.  When called, each of the args will be
    /// expanded in the `body`
    ///
    /// * `body` - An AST of any kind which can contain references to it's various `args`.  They'll
    /// be resolved each time it's called (just as you'd expect for a function call)
    ///
    /// * `name` - The name you can call the function by.  Letters, numbers and underscore are
    /// allowed.
    Function {
        args: FunctionArgs,
        body: Ast,
        name: FunctionName,
    },

    /// The calling of a function.  When calling a function each of the given args will be
    /// evaluated in turn, then interpolated into the `body` of the `Node::Function`.
    FunctionCall { args: Vec<Ast>, name: FunctionName },

    /// Like a `Node::FunctionCall` but it has two and only two params.  Think of `1 + 1`, `2 * 2`,
    /// etc.
    InfixFunctionCall {
        left: Ast,
        operator: FunctionName,
        right: Ast,
    },

    /// An integer
    Integer(i64),

    /// Somewhat of a catch-all type - when parsing the source code we come across a string like
    /// "abc" which could either be a valid A1 reference or a reference to a variable.  If it's an
    /// A1 we want to leave it alone in the final result, if it's a variable we need to resolve it
    Reference(String),

    /// A string.
    Text(String),

    /// A variable definition.
    Variable {
        name: VariableName,
        value: VariableValue,
    },
}

/// Most of these just make testing easier to not have to call .to_string() constantly, but they're
/// also nice for some of the code that needs to build ASTs.
impl Node {
    #[cfg(test)]
    pub(crate) fn fn_def<N, A>(name: N, args: &[&str], body: A) -> Self
    where
        N: Into<String>,
        A: Into<Ast>,
    {
        Self::Function {
            name: name.into(),
            args: args.iter().map(|a| a.to_string()).collect(),
            body: body.into(),
        }
    }

    #[cfg(test)]
    pub(crate) fn fn_call<N, A>(name: N, args: &[A]) -> Self
    where
        N: Into<String>,
        A: Into<Ast> + Clone,
    {
        Self::FunctionCall {
            name: name.into(),
            args: args.iter().map(|a| (*a).clone().into()).collect(),
        }
    }

    #[cfg(test)]
    pub(crate) fn infix_fn_call<L, O, R>(left: L, operator: O, right: R) -> Self
    where
        L: Into<Ast>,
        O: Into<String>,
        R: Into<Ast>,
    {
        Self::InfixFunctionCall {
            left: left.into(),
            operator: operator.into(),
            right: right.into(),
        }
    }

    pub(crate) fn reference<S: Into<String>>(r: S) -> Self {
        Self::Reference(r.into())
    }

    pub(crate) fn text<S: Into<String>>(t: S) -> Self {
        Self::Text(t.into())
    }

    pub(crate) fn var<S: Into<String>>(name: S, value: VariableValue) -> Self {
        Self::Variable {
            name: name.into(),
            value,
        }
    }
}