boltbuild 0.1.0

BoltBuild is a programmable build system.
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

use crate::context::Context;
use mlua::prelude::{LuaError, LuaFunction, LuaResult, LuaValue};
use mlua::{AnyUserData, Lua};

pub(super) fn debug(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.debug(message.as_str());
    Ok(())
}

pub(super) fn info(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.info(message.as_str());
    Ok(())
}

pub(super) fn warn(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.warning(message.as_str());
    Ok(())
}

pub(super) fn error(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.error(message.as_str());
    Ok(())
}

pub(super) fn raise_error(_lua: &Lua, _this: &mut Context, message: String) -> LuaResult<()> {
    Err(LuaError::RuntimeError(message))
}

pub(super) fn print(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.print(message.as_str());
    Ok(())
}

pub(super) fn colored_print(_lua: &Lua, this: &mut Context, message: String) -> LuaResult<()> {
    this.logger.colored_print(message.as_str());
    Ok(())
}

pub(super) fn lua_try(_lua: &Lua, args: (AnyUserData, String, LuaFunction)) -> LuaResult<bool> {
    args.0.borrow_mut_scoped::<Context, _>(|this| {
        this.logger.begin(args.1.as_str());
    })?;
    let result: LuaResult<LuaValue> = args.2.call(());
    args.0
        .borrow_mut_scoped::<Context, _>(|this| match result {
            Ok(v) => {
                if v.is_nil() {
                    this.logger.end("Ok", true);
                } else {
                    this.logger.end(v.to_string()?.as_str(), true);
                }
                Ok(true)
            }
            Err(e) => {
                match &e {
                    LuaError::RuntimeError(s) => {
                        this.logger.end(s.as_str(), false);
                    }
                    LuaError::CallbackError {
                        traceback: _,
                        cause,
                    } => match cause.as_ref() {
                        LuaError::RuntimeError(s) => {
                            this.logger.end(s.as_str(), false);
                        }
                        _ => {
                            this.logger.end(e.to_string().as_str(), false);
                        }
                    },
                    _ => {
                        this.logger.end(e.to_string().as_str(), false);
                    }
                }
                Ok(false)
            }
        })?
}