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

use super::Expression;
use crate::Identifier;
use serde::Deserialize;

/// Represents a function call expression with zero or more arguments.
#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct FuncCall {
    /// The name of the function.
    pub name: Identifier,
    /// The function arguments.
    pub args: Vec<Expression>,
    /// If `true`, the final argument should be an array which will expand to be one argument per
    /// element.
    pub expand_final: bool,
}

impl FuncCall {
    /// Creates a new `FuncCall` for the function with given name.
    pub fn new<T>(name: T) -> FuncCall
    where
        T: Into<Identifier>,
    {
        FuncCall {
            name: name.into(),
            args: Vec::new(),
            expand_final: false,
        }
    }

    /// Creates a new `FuncCallBuilder` for the function with given name.
    pub fn builder<T>(name: T) -> FuncCallBuilder
    where
        T: Into<Identifier>,
    {
        FuncCallBuilder {
            f: FuncCall::new(name),
        }
    }
}

/// A builder for function calls.
#[derive(Debug)]
pub struct FuncCallBuilder {
    f: FuncCall,
}

impl FuncCallBuilder {
    /// Adds an argument to the function call.
    pub fn arg<T>(mut self, arg: T) -> FuncCallBuilder
    where
        T: Into<Expression>,
    {
        self.f.args.push(arg.into());
        self
    }

    /// If `true`, the final argument should be an array which will expand to be one argument per
    /// element.
    pub fn expand_final(mut self, yes: bool) -> FuncCallBuilder {
        self.f.expand_final = yes;
        self
    }

    /// Consumes the `FuncCallBuilder` and returns the `FuncCall`.
    pub fn build(self) -> FuncCall {
        self.f
    }
}