dust-lang 0.3.91

Data-Oriented Programming Language
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

use std::fs::read_to_string;

use serde::{Deserialize, Serialize};
use tree_sitter::Node;

use crate::{interpret_with_context, AbstractTree, Error, Map, Result, Type, Value};

/// Abstract representation of a use statement.
///
/// Use will evaluate the Dust file at the given path. It will create an empty
/// context to do so, then apply every value from that context to the current
/// context.
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
pub struct Use {
    path: String,
}

impl AbstractTree for Use {
    fn from_syntax_node(source: &str, node: Node, _context: &Map) -> Result<Self> {
        Error::expect_syntax_node(source, "use", node)?;

        let string_node = node.child(1).unwrap();
        let path = source[string_node.start_byte() + 1..string_node.end_byte() - 1].to_string();

        Ok(Use { path })
    }

    fn run(&self, _source: &str, context: &Map) -> Result<Value> {
        let file_contents = read_to_string(&self.path)?;
        let mut file_context = Map::new();

        interpret_with_context(&file_contents, &mut file_context)?;

        for (key, (value, r#type)) in file_context.variables()?.iter() {
            context.set(key.clone(), value.clone(), Some(r#type.clone()))?;
        }

        Ok(Value::Map(file_context))
    }

    fn expected_type(&self, _context: &Map) -> Result<Type> {
        Ok(Type::Map)
    }
}