rhpidfyre/libpse
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

out.style.background and out.style.foreground

Browse Source
This commit is contained in:
rhpidfyre 2025-01-02 01:48:15 -05:00
parent 8b9302cb21
commit da2fe5d88e
7 changed files with 92 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock generated
View File

@ -428,9 +428,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
[[package]]
name = "syn"
version = "2.0.92"
version = "2.0.94"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
checksum = "987bc0be1cdea8b10216bd06e2ca407d40b9543468fafd3ddfb02f36e77f71f3"
dependencies = [
"proc-macro2",
"quote",

2
Cargo.toml
View File

@ -15,6 +15,6 @@ whoami = "1.5.2"
[profile.release]
strip = true
opt-level = "s"
opt-level = "z"
lto = true
codegen-units = 1

33
src/commands.rs
View File

@ -55,7 +55,7 @@ impl PathBufIsValid for PathBuf {
impl ChangeDirectory for Command {
fn set_current_dir(&self, new_path: &Path) -> Option<PathBuf> {
std::env::set_current_dir(new_path).map_or_else(|cd_err| display_none(cd_err), |()| Some(new_path.to_path_buf()))
std::env::set_current_dir(new_path).map_or_else(display_none, |()| Some(new_path.to_path_buf()))
}
fn home_dir(&self) -> Option<PathBuf> {
@ -120,34 +120,27 @@ impl ChangeDirectory for Command {
}
}
pub type ProcessExitStatus = Option<process::ExitStatus>;
pub struct Command(String);
impl Command {
pub fn new(input: String) -> Self {
Self(input)
}
pub fn spawn(&self, command_process: io::Result<process::Child>) -> ProcessExitStatus {
match command_process {
Err(e) => display_none(e),
Ok(mut child) => Some(match child.wait() {
Ok(exit_status) => exit_status,
Err(exit_status_err) => {
println!("{exit_status_err}");
return None
}
})
}
pub fn spawn(&self, command_process: io::Result<process::Child>) {
command_process.map_or_else(display_none, |mut child| Some(child.wait()));
}
pub fn exec(&self) -> ProcessExitStatus {
pub fn exec(&self) {
let mut args = self.0.split_whitespace();
args.next().and_then(|command| match command {
"cd" => {
self.change_directory(args);
None
if let Some(command) = args.next() {
match command {
"cd" => {
self.change_directory(args);
},
command => {
self.spawn(process::Command::new(command).args(args).spawn());
}
}
command => self.spawn(process::Command::new(command).args(args).spawn()),
})
}
}
}

77
src/luau/terminal.rs
View File

@ -2,47 +2,80 @@ use mlua::{Result as lResult, Table};
use crossterm::style::Stylize;
use crate::vm::Vm;
macro_rules! term_colors_luau {
($self:expr, $colors_table:expr, $($color:ident)+) => {
$(
let $color = $self.0.create_function(|_this, text: String| -> lResult<String> {
Ok(text.$color().to_string())
})?;
$colors_table.set(stringify!($color).to_ascii_uppercase(), $color)?;
macro_rules! foreground_styles_luau {
($self:expr, $style_table:expr, $($color:ident)+) => {
$(
$style_table.set(stringify!($color).to_ascii_uppercase(), $self.0.create_function(|_, text: String| -> lResult<String> {
Ok(text.$color().to_string())
})?)?;
)+
};
}
macro_rules! background_styles_luau {
($self:expr, $style_table:expr, $($color:ident)+) => {
$(
match stringify!($color).split_once("_") {
Some((_, color_name)) => $style_table.set(color_name.to_ascii_uppercase(), $self.0.create_function(|_, text: String| -> lResult<String> {
Ok(text.$color().to_string())
})?)?,
None => panic!("Luau set error: {:?}. There was nothing to split from delimiter: \"_\"", stringify!($color)),
}
)+
};
}
pub trait TerminalColors {
fn var_terminal_colors(&self, colors_table: &Table) -> lResult<()>;
fn var_terminal_style(&self) -> lResult<Table>;
fn var_terminal_colors_background(&self, style_table: &Table) -> lResult<()>;
fn var_terminal_colors_foreground(&self, style_table: &Table) -> lResult<()>;
fn var_terminal_text_styling(&self) -> lResult<Table>;
fn var_terminal(&self) -> lResult<()>;
}
impl TerminalColors for Vm {
fn var_terminal_colors(&self, colors_table: &Table) -> lResult<()> {
term_colors_luau!(self, colors_table,
fn var_terminal_colors_foreground(&self, style_table: &Table) -> lResult<()> {
let foreground_table = self.0.create_table()?;
foreground_styles_luau!(self, foreground_table,
dark_grey dark_red dark_green dark_cyan
dark_yellow dark_magenta dark_blue
red grey black
green yellow
blue magenta
cyan white
red grey black green yellow
blue magenta cyan white
underlined
underline_dark_grey underline_dark_red underline_dark_green underline_dark_cyan
underline_dark_yellow underline_dark_magenta underline_dark_blue underline_red
underline_grey underline_black underline_green underline_yellow
underline_blue underline_magenta underline_cyan underline_white
bold
);
Ok(())
style_table.set("FOREGROUND", foreground_table)?;
Ok(())
}
fn var_terminal_style(&self) -> lResult<Table> {
fn var_terminal_colors_background(&self, style_table: &Table) -> lResult<()> {
let background_table = self.0.create_table()?;
background_styles_luau!(self, background_table,
on_dark_grey on_dark_red on_dark_green on_dark_cyan
on_dark_yellow on_dark_magenta on_dark_blue
on_red on_grey on_black
on_green on_yellow
on_blue on_magenta
on_cyan on_white
);
style_table.set("BACKGROUND", background_table)?;
Ok(())
}
fn var_terminal_text_styling(&self) -> lResult<Table> {
let color_table = self.0.create_table()?;
let style = self.0.create_table()?;
self.var_terminal_colors(&style)?;
color_table.set("STYLE", &style)?;
let style_table = self.0.create_table()?;
self.var_terminal_colors_foreground(&style_table)?;
self.var_terminal_colors_background(&style_table)?;
color_table.set("STYLE", style_table)?;
Ok(color_table)
}
fn var_terminal(&self) -> lResult<()> {
let term_table = self.0.create_table()?;
let style_table = self.var_terminal_style()?;
term_table.set("OUT", style_table)?;
term_table.set("OUT", self.var_terminal_text_styling()?)?;
self.0.globals().set("TERMINAL", &term_table)?;
Ok(())
}

6
src/luau/vm.rs
View File

@ -27,7 +27,7 @@ fn luau_out(luau_args: MultiValue) -> String {
.map(|arg| arg.to_string().unwrap_or("<SHELL CONVERSION ERROR>".to_owned()))
.for_each(|arg| {
if !print.is_empty() {
print.push_str(&'\u{0009}'.to_string());
print.push('\u{0009}');
};
print.push_str(&arg);
}
@ -77,8 +77,8 @@ impl Vm {
}
pub fn exec(&self, source: String) {
self.set_shell_globals().map_or_else(|e| display_none(e), |()| {
self.0.load(source).exec().map_or_else(|e| luau_error(e), |()| Some(()))
self.set_shell_globals().map_or_else(display_none, |()| {
self.0.load(source).exec().map_or_else(luau_error, |()| Some(()))
});
}
}

6
src/rc.rs
View File

@ -91,7 +91,7 @@ impl IsValid for PathBuf {
}
fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf> {
self.is_valid(is_dir_or_file).map_or(None, |p| Some(p))
self.is_valid(is_dir_or_file).ok()
}
}
@ -109,9 +109,9 @@ pub fn config_file() -> Option<PathBuf> {
config_file.is_valid_file_or_create(DEFAULT_CONFIG_CONTENT.as_bytes())
}
//TODO: history.rs
// TODO: history.rs
pub fn history_file() -> Option<PathBuf> {
let mut config_file = config_dir()?;
config_file.push(".history");
config_file.is_valid_file_or_create("".as_bytes())
config_file.is_valid_file_or_create(b"")
}

38
src/shell.rs
View File

@ -5,11 +5,6 @@ pub struct Config {
pub norc: bool
}
struct Storage {
pub command_exit_status: commands::ProcessExitStatus,
pub ps1: String,
}
trait ShellLuauVm {
fn shell_vm_exec(&self, source: String);
}
@ -20,56 +15,53 @@ impl ShellLuauVm for LambdaShell {
}
pub struct LambdaShell {
terminating: bool,
storage: Storage,
ps1: String,
config: Config,
terminating: bool,
}
impl LambdaShell {
pub fn create(config: Config) -> Self {
Self {
storage: Storage {
command_exit_status: None,
ps1: ps::DEFAULT_PS.to_owned(),
},
ps1: ps::DEFAULT_PS.to_owned(),
terminating: false,
config,
}
}
pub fn wait(&mut self) -> Result<(), io::Error> {
io::Write::flush(&mut io::stdout()).map_or_else(|flush_error| Err(flush_error), |()| {
io::Write::flush(&mut io::stdout()).map(|()| {
let mut input = String::new();
io::stdin().read_line(&mut input).map_or_else(|read_error| println!("{read_error}"), |_size| {
let trimmed_input = input.trim();
match trimmed_input {
match input.trim() {
//special casey
"exit" => self.terminating = true,
_ => self.storage.command_exit_status = commands::Command::new(trimmed_input.to_owned()).exec()
trim => commands::Command::new(trim.to_owned()).exec()
};
});
Ok(())
})
})
}
fn rc_parse(&self) {
if !self.config.norc {
rc::config_file().map(|conf_file| fs::read_to_string(conf_file).map_or_else(
|read_err| println!("{read_err}"),
|luau_conf| self.shell_vm_exec(luau_conf)
));
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 start(&mut self) {
self.rc_parse();
ps::display(&self.storage.ps1);
ps::display(&self.ps1);
loop {
match self.terminating {
true => break,
false => match self.wait() {
Ok(()) => ps::display(&self.storage.ps1),
Ok(()) => ps::display(&self.ps1),
Err(flush_error) => {
println!("{flush_error}");
break;