robinpath 0.2.0

RobinPath - A lightweight, fast scripting language interpreter for automation and data processing
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

use super::operators::{BinaryOp, UnaryOp};
use super::span::Span;
use super::stmt::Stmt;
use crate::value::AttributePathSegment;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectProperty {
    pub key: String,
    pub value: Expr,
    pub span: Span,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Expr {
    /// Literal value: number, string, bool, null
    Literal {
        value: LiteralValue,
        span: Span,
    },
    /// Variable reference: $var, $obj.prop, $arr[0]
    Variable {
        name: String,
        path: Vec<AttributePathSegment>,
        span: Span,
    },
    /// Last value: $
    LastValue {
        span: Span,
    },
    /// Binary operation: a + b, a == b, etc.
    Binary {
        op: BinaryOp,
        left: Box<Expr>,
        right: Box<Expr>,
        span: Span,
    },
    /// Unary operation: not x, -x
    Unary {
        op: UnaryOp,
        argument: Box<Expr>,
        span: Span,
    },
    /// Function/command call used as expression: math.add(5, 3)
    Call {
        callee: String,
        args: Vec<Expr>,
        span: Span,
    },
    /// Object literal: { key: value, ... }
    ObjectLiteral {
        properties: Vec<ObjectProperty>,
        span: Span,
    },
    /// Array literal: [a, b, c]
    ArrayLiteral {
        elements: Vec<Expr>,
        span: Span,
    },
    /// Subexpression: $( ... )
    Subexpression {
        body: Vec<Stmt>,
        span: Span,
    },
    /// Template string: `hello ${name}`
    TemplateLiteral {
        raw: String,
        span: Span,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LiteralValue {
    Null,
    Bool(bool),
    Number(f64),
    String(String),
}

impl Expr {
    pub fn span(&self) -> &Span {
        match self {
            Expr::Literal { span, .. }
            | Expr::Variable { span, .. }
            | Expr::LastValue { span }
            | Expr::Binary { span, .. }
            | Expr::Unary { span, .. }
            | Expr::Call { span, .. }
            | Expr::ObjectLiteral { span, .. }
            | Expr::ArrayLiteral { span, .. }
            | Expr::Subexpression { span, .. }
            | Expr::TemplateLiteral { span, .. } => span,
        }
    }
}