zuzu-rust 0.1.1

Rust implementation of ZuzuScript
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

use std::collections::HashMap;

use super::super::{Runtime, Value};
use crate::error::{Result, ZuzuRustError};

pub(super) fn exports() -> HashMap<String, Value> {
    HashMap::from([
        ("Task".to_owned(), Value::builtin_class("Task".to_owned())),
        (
            "Channel".to_owned(),
            Value::builtin_class("Channel".to_owned()),
        ),
        (
            "CancellationToken".to_owned(),
            Value::builtin_class("CancellationToken".to_owned()),
        ),
        (
            "CancellationSource".to_owned(),
            Value::builtin_class("CancellationSource".to_owned()),
        ),
        (
            "resolved".to_owned(),
            Value::native_function("task.resolved".to_owned()),
        ),
        (
            "failed".to_owned(),
            Value::native_function("task.failed".to_owned()),
        ),
        (
            "sleep".to_owned(),
            Value::native_function("task.sleep".to_owned()),
        ),
        (
            "yield".to_owned(),
            Value::native_function("task.yield".to_owned()),
        ),
        (
            "all".to_owned(),
            Value::native_function("task.all".to_owned()),
        ),
        (
            "race".to_owned(),
            Value::native_function("task.race".to_owned()),
        ),
        (
            "timeout".to_owned(),
            Value::native_function("task.timeout".to_owned()),
        ),
    ])
}

pub(super) fn call(runtime: &Runtime, name: &str, args: &[Value]) -> Option<Result<Value>> {
    let result = match name {
        "task.resolved" => Ok(runtime.task_resolved(args.first().cloned().unwrap_or(Value::Null))),
        "task.failed" => Ok(runtime.task_rejected(
            args.first()
                .cloned()
                .unwrap_or_else(|| Value::String("Task failed".to_owned()))
                .render(),
        )),
        "task.sleep" => Ok(runtime.task_sleep(
            args.first()
                .map(|value| value.to_number().unwrap_or(0.0))
                .unwrap_or(0.0),
        )),
        "task.yield" => Ok(runtime.task_yield()),
        "task.all" => {
            let tasks = match args.first() {
                Some(Value::Array(items)) => items.clone(),
                Some(_) => {
                    return Some(Err(ZuzuRustError::runtime(
                        "TypeException: task combinator expects Array",
                    )))
                }
                None => Vec::new(),
            };
            if tasks.iter().any(|task| !matches!(task, Value::Task(_))) {
                return Some(Err(ZuzuRustError::runtime("all expects only Task values")));
            }
            Ok(runtime.task_all(tasks))
        }
        "task.race" => {
            let tasks = match args.first() {
                Some(Value::Array(items)) => items.clone(),
                Some(_) => {
                    return Some(Err(ZuzuRustError::runtime(
                        "TypeException: task combinator expects Array",
                    )))
                }
                None => Vec::new(),
            };
            if tasks.is_empty() {
                return Some(Err(ZuzuRustError::runtime(
                    "race expects at least one task",
                )));
            }
            if tasks.iter().any(|task| !matches!(task, Value::Task(_))) {
                return Some(Err(ZuzuRustError::runtime("race expects only Task values")));
            }
            Ok(runtime.task_race(tasks))
        }
        "task.timeout" => {
            if args.len() != 2 {
                Err(ZuzuRustError::runtime("timeout() expects seconds and task"))
            } else if !matches!(args[1], Value::Task(_)) {
                Err(ZuzuRustError::runtime("timeout expects a Task"))
            } else {
                Ok(runtime.task_timeout(args[0].to_number().unwrap_or(0.0), args[1].clone()))
            }
        }
        _ => return None,
    };
    Some(result)
}