o- 0.4.1

Multi-Engine JavaScript Runtime
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

use std::process::Command;

use o_core::{
    engine::JSEngine,
    error::{JSError, JSResult},
};

pub struct BinEngine {
    path: String
}

impl BinEngine {
    pub fn new(path: String) -> Self {
        Self {
            path
        }
    }
}


impl JSEngine for BinEngine {
    fn run(&self, code: &str, filename: &str) -> Result<o_core::error::JSResult, o_core::error::JSError> {
        let result = Command::new(self.path.clone())
            .arg("-c")
            .arg(filename)
            .arg(code)
            .output()
            .map_err(|source| {
                JSError::internal(format!(
                    "failed to execute toolchain binary `{}`: {source}",
                    self.path
                ))
                .with_filename(filename)
                .with_source(code)
            })?;

        if !result.status.success() {
            let stderr = String::from_utf8_lossy(&result.stderr);
            let message = if stderr.trim().is_empty() {
                format!(
                    "toolchain binary `{}` exited with status {}",
                    self.path, result.status
                )
            } else {
                format!(
                    "toolchain binary `{}` failed: {}",
                    self.path,
                    stderr.trim()
                )
            };

            return Err(JSError::runtime(message)
                .with_filename(filename)
                .with_source(code));
        }

        let output = String::from_utf8(result.stdout).map_err(|source| {
            JSError::internal(format!(
                "toolchain binary `{}` returned invalid UTF-8 output: {source}",
                self.path
            ))
            .with_filename(filename)
            .with_source(code)
        })?;
        Ok(JSResult::String(output))
    }
}