From 31b16fca17f93d0e5e9117c588387d1642b4bbdc Mon Sep 17 00:00:00 2001 From: rhpidfyre Date: Fri, 3 Jan 2025 20:49:47 -0500 Subject: [PATCH] Introduce warn(S...) for yellow output, uses compile time coloring --- Cargo.lock | 8 ++--- src/luau/system.rs | 40 ++++++++++++++++----- src/luau/terminal.rs | 10 +++--- src/luau/vm.rs | 86 ++++++++++++++++++++++++++++---------------- src/shell.rs | 46 ++++++++++-------------- 5 files changed, 113 insertions(+), 77 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e534f70..30bb49c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -16,9 +16,9 @@ checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "bstr" -version = "1.11.1" +version = "1.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "786a307d683a5bf92e6fd5fd69a7eb613751668d1d8d67d802846dfe367c62c8" +checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0" dependencies = [ "memchr", "serde", @@ -32,9 +32,9 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" [[package]] name = "cc" -version = "1.2.6" +version = "1.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d6dbb628b8f8555f86d0323c2eb39e3ec81901f4b83e091db8a6a76d316a333" +checksum = "a012a0df96dd6d06ba9a1b29d6402d1a5d77c6befd2566afdc26e10603dc93d7" dependencies = [ "shlex", ] diff --git a/src/luau/system.rs b/src/luau/system.rs index df9a527..66e78c8 100644 --- a/src/luau/system.rs +++ b/src/luau/system.rs @@ -1,15 +1,35 @@ use mlua::{Result as lResult, Table}; use whoami::fallible; -use crate::vm::Vm; +use crate::vm::LuauVm; const DEFAULT_HOSTNAME: &str = "hostname"; -pub trait System { - fn details(&self, shell: &Table) -> lResult<()>; - fn global_shell(&self) -> lResult<()>; +pub trait PsPrompt { + fn ps_prompt(&self) -> lResult; } -impl System for Vm { - fn details(&self, shell: &Table) -> lResult<()> { +impl PsPrompt for LuauVm { + fn ps_prompt(&self) -> lResult
{ + let prompt_table = self.0.create_table()?; + let prompt_metatable = self.0.create_table()?; + prompt_metatable.set("__index", self.0.create_function(|_, (lua_self, index): (String, String)| -> lResult<()> { + println!("lua_self={} index={}", lua_self, index); + Ok(()) + })?)?; + prompt_metatable.set("__newindex", self.0.create_function(|_, _: String| -> lResult { + Ok("placeholder".to_owned()) + })?)?; + prompt_table.set("__metatable", mlua::Nil)?; + prompt_table.set_metatable(Some(prompt_metatable)); + Ok(prompt_table) + } +} + +pub trait System { + fn sys_details(&self, shell: &Table) -> lResult<()>; + fn shell_globals(&self, luau_globals: &Table) -> lResult<()>; +} +impl System for LuauVm { + fn sys_details(&self, shell: &Table) -> lResult<()> { let system = self.0.create_table()?; system.set("DESKTOP_ENV", whoami::desktop_env().to_string())?; system.set("DEVICENAME", whoami::devicename().to_string())?; @@ -22,10 +42,12 @@ impl System for Vm { Ok(()) } - fn global_shell(&self) -> lResult<()> { + fn shell_globals(&self, luau_globals: &Table) -> lResult<()> { let shell = self.0.create_table()?; - self.details(&shell)?; - self.0.globals().set("SHELL", shell)?; + let ps_prompt = self.ps_prompt()?; + self.sys_details(&shell)?; + shell.set("PROMPT", ps_prompt)?; + luau_globals.set("SHELL", shell)?; Ok(()) } } \ No newline at end of file diff --git a/src/luau/terminal.rs b/src/luau/terminal.rs index b81550f..cf5bd45 100644 --- a/src/luau/terminal.rs +++ b/src/luau/terminal.rs @@ -1,6 +1,6 @@ use mlua::{Result as lResult, Table}; use crossterm::style::Stylize; -use crate::vm::Vm; +use crate::vm::LuauVm; macro_rules! foreground_styles_luau { ($self:expr, $style_table:expr, $($color:ident)+) => { @@ -29,9 +29,9 @@ pub trait TerminalColors { fn background(&self, style_table: &Table) -> lResult<()>; fn foreground(&self, style_table: &Table) -> lResult<()>; fn styling(&self) -> lResult
; - fn terminal(&self) -> lResult<()>; + fn terminal(&self, luau_globals: &Table) -> lResult<()>; } -impl TerminalColors for Vm { +impl TerminalColors for LuauVm { fn background(&self, style_table: &Table) -> lResult<()> { let foreground_table = self.0.create_table()?; foreground_styles_luau!(self, foreground_table, @@ -71,10 +71,10 @@ impl TerminalColors for Vm { Ok(style_table) } - fn terminal(&self) -> lResult<()> { + fn terminal(&self, luau_globals: &Table) -> lResult<()> { let term_table = self.0.create_table()?; term_table.set("OUT", self.styling()?)?; - self.0.globals().set("TERMINAL", &term_table)?; + luau_globals.set("TERMINAL", &term_table)?; Ok(()) } } \ No newline at end of file diff --git a/src/luau/vm.rs b/src/luau/vm.rs index 26ce4d3..be616d2 100644 --- a/src/luau/vm.rs +++ b/src/luau/vm.rs @@ -1,52 +1,76 @@ use mlua::{ Lua as Luau, - Result as lResult + Result as lResult, + Function, + MultiValue, + Table }; -use crate::VERSION; -use crate::terminal::TerminalColors; -use crate::sytem::System; +use crate::{sytem::System, terminal::TerminalColors, VERSION}; +use color_print::{cformat, cprintln}; use core::fmt; -use color_print::cprintln; - -fn display_none(err: E) -> Option { - println!("{err}"); - None -} - -fn luau_error(err: mlua::Error) -> Option { - cprintln!("====\n[!] {err}\n===="); - None -} trait Globals { - fn version(&self) -> lResult<()>; + fn warn(&self, luau_globals: &Table) -> lResult<()>; + fn version(&self, luau_globals: &Table) -> lResult<()>; } -impl Globals for Vm { - fn version(&self) -> lResult<()> { - let luau_info = self.0.globals().get::("_VERSION")?; - self.0.globals().set("_VERSION", format!("{}, liblambdashell {}", luau_info, VERSION)) +impl Globals for LuauVm { + fn warn(&self, luau_globals: &Table) -> lResult<()> { + let luau_print = luau_globals.get::("print")?; + luau_globals.set("warn", self.0.create_function(move |this, args: MultiValue| -> lResult<()> { + let luau_multi_values = args.into_iter() + .map(|value| cformat!("{}", value.to_string().unwrap_or("".to_owned()))) + .collect::>(); + let back_to_luau_multi = luau_multi_values.into_iter() + .map(|arg_v| mlua::Value::String(this.create_string(&arg_v).unwrap())) + .collect::(); + luau_print.call::<()>(back_to_luau_multi).unwrap(); + Ok(()) + })?) + } + + fn version(&self, luau_globals: &Table) -> lResult<()> { + let luau_info = luau_globals.get::("_VERSION")?; + luau_globals.set("_VERSION", format!("{}, liblambdashell {}", luau_info, VERSION)) } } -pub struct Vm(pub Luau); -impl Vm { +trait Helpers { + fn option_display_none(&self, err: E) -> Option; + fn luau_error(&self, err: mlua::Error) -> Option; +} +impl Helpers for LuauVm { + fn option_display_none(&self, err: E) -> Option { + println!("{err}"); + None + } + fn luau_error(&self, err: mlua::Error) -> Option { + cprintln!("====\n[!]: {err}\n===="); + None + } +} + +pub struct LuauVm(pub Luau); +impl LuauVm { pub fn new() -> Self { Self(Luau::new()) } - fn set_shell_globals(&self) -> mlua::Result<()> { - self.version()?; - self.terminal()?; - self.global_shell()?; - self.0.globals().set("getfenv", mlua::Nil)?; - self.0.globals().set("setfenv", mlua::Nil)?; + fn set_shell_globals(&self) -> lResult<()> { + let luau_globals = self.0.globals(); + self.warn(&luau_globals)?; + self.version(&luau_globals)?; + self.terminal(&luau_globals)?; + self.shell_globals(&luau_globals)?; + luau_globals.set("getfenv", mlua::Nil)?; + luau_globals.set("setfenv", mlua::Nil)?; self.0.sandbox(true)?; Ok(()) } pub fn exec(&self, source: String) { - self.set_shell_globals().map_or_else(display_none, |()| { - self.0.load(source).exec().map_or_else(luau_error, Some) - }); + match self.set_shell_globals() { + Ok(()) => self.0.load(source).exec().map_or_else(|exec_err| self.luau_error(exec_err), Some), + Err(globals_err) => self.option_display_none(globals_err), + }; } } \ No newline at end of file diff --git a/src/shell.rs b/src/shell.rs index 87f53e6..22fdc2f 100644 --- a/src/shell.rs +++ b/src/shell.rs @@ -1,20 +1,12 @@ -use crate::{ps, commands, rc, vm}; +use crate::{commands, ps, rc, vm::{self, LuauVm}}; use std::{fs, io::{self}}; pub struct Config { pub norc: bool } -trait ShellLuauVm { - fn shell_vm_exec(&self, source: String); -} -impl ShellLuauVm for LambdaShell { - fn shell_vm_exec(&self, source: String) { - vm::Vm::new().exec(source); - } -} - pub struct LambdaShell { + vm: LuauVm, ps1: String, config: Config, terminating: bool, @@ -22,6 +14,7 @@ pub struct LambdaShell { impl LambdaShell { pub fn create(config: Config) -> Self { Self { + vm: vm::LuauVm::new(), ps1: ps::DEFAULT_PS.to_owned(), terminating: false, config, @@ -41,30 +34,27 @@ impl LambdaShell { }) } - fn rc_parse(&self) { - if !self.config.norc { - if let Some(conf_file) = rc::config_file() { - match fs::read_to_string(conf_file) { - Ok(luau_conf) => self.shell_vm_exec(luau_conf), - Err(read_err) => println!("{read_err}"), - } - } - } + pub fn vm_exec(&self, source: String) { + self.vm.exec(source); } pub fn start(&mut self) { - self.rc_parse(); - - ps::display(&self.ps1); - + if !self.config.norc { + if let Some(conf_file) = rc::config_file() { + fs::read_to_string(conf_file).map_or_else(|e| println!("{e}"), |luau_conf| self.vm_exec(luau_conf)); + } + } loop { match self.terminating { true => break, - false => match self.wait() { - Ok(()) => ps::display(&self.ps1), - Err(flush_error) => { - println!("{flush_error}"); - break; + false => { + + match self.wait() { + Ok(()) => {}, + Err(flush_error) => { + println!("{flush_error}"); + break; + } } }, }