mogglo 0.1.0

Multi-language AST-based code search and rewriting
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

use regex::Regex;
use rlua::{prelude::LuaError, Lua};
use tree_sitter::Node;

use crate::env::{Env, Metavar};

pub(crate) mod node;

#[derive(Debug, Eq, PartialEq)]
pub(crate) struct LuaData<'a> {
    pub(crate) env: &'a Env<'a>,
    pub(crate) text: &'a str,
}

impl<'a> LuaData<'a> {
    fn node_text(&self, node: &Node) -> &str {
        node.utf8_text(self.text.as_bytes()).unwrap()
    }
}

pub(crate) fn eval_lua_scope<
    'lua,
    'scope,
    T: Clone + Default + for<'l> rlua::FromLua<'l> + 'static,
>(
    lua_ctx: rlua::prelude::LuaContext<'lua>,
    scope: &rlua::Scope<'lua, 'scope>,
    chunk: rlua::Chunk,
    data: &'scope LuaData<'scope>,
) -> Result<T, LuaError>
where
    'lua: 'scope,
{
    let globals = lua_ctx.globals();
    for (mvar, val) in &data.env.0 {
        if let Some(v) = val.iter().next() {
            globals.set(mvar.0.clone(), data.node_text(v))?;
        }
    }

    globals.set(
        "meta",
        scope.create_function(|_, k: String| {
            Ok(data.env.0.get(&Metavar(k)).and_then(|s| {
                let v: Vec<_> = s.iter().collect();
                if v.len() == 1 {
                    Some(v[0].utf8_text(data.text.as_bytes()).unwrap())
                } else {
                    None
                }
            }))
        })?,
    )?;

    globals.set(
        "rx",
        scope.create_function(|_, (r, s): (String, String)| match Regex::new(&r) {
            Err(_) => {
                eprintln!("Bad regex in Lua code: {r}");
                Ok(false)
            }
            Ok(x) => Ok(x.is_match(&s)),
        })?,
    )?;

    chunk.eval::<T>()
}

pub(crate) fn eval_lua_ctx<T: Clone + Default + for<'l> rlua::FromLua<'l> + 'static>(
    lua_ctx: rlua::prelude::LuaContext,
    code: &str,
    data: &LuaData,
) -> Result<T, LuaError>
where
{
    let loaded = lua_ctx.load(code.as_bytes());
    lua_ctx.scope(|scope| eval_lua_scope(lua_ctx, scope, loaded, data))
}

pub(crate) fn eval_lua<T: Clone + Default + for<'l> rlua::FromLua<'l> + 'static>(
    lua: &Lua,
    code: &str,
    data: &LuaData,
) -> Result<T, LuaError>
where
{
    lua.context(|lua_ctx| eval_lua_ctx(lua_ctx, code, data))
}