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

convert indentation to tabs

Browse Source
This commit is contained in:
rhpidfyre 2024-12-29 01:46:30 -05:00
parent c4559b8aa1
commit c08d0a20e2
5 changed files with 179 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
src/commands.rs
View File

@ -1,9 +1,9 @@
use uzers::User;
use std::{
io,
process,
str::SplitWhitespace,
path::{Path, PathBuf},
io,
process,
str::SplitWhitespace,
path::{Path, PathBuf},
};
enum ValidStatus {
@ -22,31 +22,31 @@ trait PathBufIsValid {
}
trait ChangeDirectory {
fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf>;
fn set_current_dir(&self, new_path: &Path) -> Option<PathBuf>;
fn specific_user_dir(&self, user: String) -> Option<PathBuf>;
fn cd_args(&self, vec_args: Vec<String>) -> Option<PathBuf>;
fn previous_dir(&self) -> Option<PathBuf>;
fn home_dir(&self) -> Option<PathBuf>;
fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf>;
fn set_current_dir(&self, new_path: &Path) -> Option<PathBuf>;
fn specific_user_dir(&self, user: String) -> Option<PathBuf>;
fn cd_args(&self, vec_args: Vec<String>) -> Option<PathBuf>;
fn previous_dir(&self) -> Option<PathBuf>;
fn home_dir(&self) -> Option<PathBuf>;
}
impl PathBufIsValid for PathBuf {
fn is_valid(&self) -> Result<PathBuf, ValidStatus> {
match self.try_exists() {
Ok(true) => Ok(self.to_path_buf()),
Ok(false) => Err(ValidStatus::NoRootFolder),
Err(trye_error) => Err(ValidStatus::TryExists(trye_error))
}
Ok(true) => Ok(self.to_path_buf()),
Ok(false) => Err(ValidStatus::NoRootFolder),
Err(trye_error) => Err(ValidStatus::TryExists(trye_error))
}
}
fn is_valid_or_home(&self) -> Option<PathBuf> {
match self.is_valid() {
Ok(valid) => Some(valid),
Err(valid_status) => {
Ok(valid) => Some(valid),
Err(valid_status) => {
match valid_status {
ValidStatus::NoRootFolder => println!("cd: /root: No such file or directory"),
ValidStatus::TryExists(error) => println!("cd: {error}"),
};
ValidStatus::NoRootFolder => println!("cd: /root: No such file or directory"),
ValidStatus::TryExists(error) => println!("cd: {error}"),
};
None
},
}
@ -55,99 +55,99 @@ 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(|cd_err| display_none(cd_err), |()| Some(new_path.to_path_buf()))
}
fn home_dir(&self) -> Option<PathBuf> {
home::home_dir().map_or(self.set_current_dir(Path::new("/")), |home_pathbuf| self.set_current_dir(&home_pathbuf))
home::home_dir().map_or(self.set_current_dir(Path::new("/")), |home_pathbuf| self.set_current_dir(&home_pathbuf))
}
fn previous_dir(&self) -> Option<PathBuf> {
unimplemented!()
}
fn specific_user_dir(&self, requested_user: String) -> Option<PathBuf> {
match requested_user.as_str() {
"root" => PathBuf::from("/root").is_valid_or_home(),
fn specific_user_dir(&self, requested_user: String) -> Option<PathBuf> {
match requested_user.as_str() {
"root" => PathBuf::from("/root").is_valid_or_home(),
_ => {
for user in unsafe { uzers::all_users().collect::<Vec<User>>() } {
let user_name = user.name();
if *requested_user == *user_name {
let mut user_dir = PathBuf::from("/home");
user_dir.push(user_name);
return user_dir.is_valid_or_home();
}
}
None
let user_name = user.name();
if *requested_user == *user_name {
let mut user_dir = PathBuf::from("/home");
user_dir.push(user_name);
return user_dir.is_valid_or_home();
}
}
None
}
}
}
}
fn cd_args(&self, vec_args: Vec<String>) -> Option<PathBuf> {
let string_path = vec_args.concat();
let new_path = Path::new(string_path.as_str());
match new_path.is_dir() {
true => self.set_current_dir(new_path),
false => {
match new_path.file_name() {
Some(file_name) => println!("cd: {:?} is not a directory.", file_name),
None => println!("cd: Failed to resolve the file name of a file that is not a directory."),
}
None
}
}
}
fn cd_args(&self, vec_args: Vec<String>) -> Option<PathBuf> {
let string_path = vec_args.concat();
let new_path = Path::new(string_path.as_str());
match new_path.is_dir() {
true => self.set_current_dir(new_path),
false => {
match new_path.file_name() {
Some(file_name) => println!("cd: {:?} is not a directory.", file_name),
None => println!("cd: Failed to resolve the file name of a file that is not a directory."),
}
None
}
}
}
fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf> {
let vec_args: Vec<String> = args.map(|arg| arg.to_owned()).collect();
match vec_args.first() {
None => self.home_dir(),
Some(arg) => match arg.as_str() {
"/" => self.set_current_dir(Path::new("/")),
"-" => self.previous_dir(),
_ => {
let mut arg_chars = arg.chars();
match arg_chars.next() {
Some(char) => match char == '~' {
true => self.specific_user_dir(arg_chars.collect::<String>()),
false => self.cd_args(vec_args),
},
None => self.home_dir(),
}
}
},
}
}
fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf> {
let vec_args: Vec<String> = args.map(|arg| arg.to_owned()).collect();
match vec_args.first() {
None => self.home_dir(),
Some(arg) => match arg.as_str() {
"/" => self.set_current_dir(Path::new("/")),
"-" => self.previous_dir(),
_ => {
let mut arg_chars = arg.chars();
match arg_chars.next() {
Some(char) => match char == '~' {
true => self.specific_user_dir(arg_chars.collect::<String>()),
false => self.cd_args(vec_args),
},
None => self.home_dir(),
}
}
},
}
}
}
pub type ProcessExitStatus = Option<process::ExitStatus>;
pub struct Command(String);
impl Command {
pub fn new(input: String) -> Self {
Self(input)
}
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>) -> 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 exec(&self) -> ProcessExitStatus {
let mut args = self.0.split_whitespace();
args.next().and_then(|command| match command {
"cd" => {
self.change_directory(args);
None
}
command => self.spawn(process::Command::new(command).args(args).spawn()),
})
}
pub fn exec(&self) -> ProcessExitStatus {
let mut args = self.0.split_whitespace();
args.next().and_then(|command| match command {
"cd" => {
self.change_directory(args);
None
}
command => self.spawn(process::Command::new(command).args(args).spawn()),
})
}
}

12
src/luau/vm.rs
View File

@ -24,10 +24,10 @@ fn luau_out(luau_args: MultiValue) -> String {
luau_args.iter()
.map(|arg| arg.to_string().unwrap_or("<SHELL CONVERSION ERROR>".to_owned()))
.for_each(|arg| {
if !print.is_empty() {
print.push('\u{0009}'.to_string());
};
print.push(arg);
if !print.is_empty() {
print.push('\u{0009}'.to_string());
};
print.push(arg);
}
);
print.concat()
@ -71,9 +71,9 @@ impl Vm {
Ok(())
}
pub fn exec(&self, source: String) -> Option<()> {
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(()))
})
});
}
}

22
src/ps.rs
View File

@ -4,18 +4,18 @@ use color_print::{cformat, cprint};
pub const DEFAULT_PS: &str = formatcp!("lambdashell-{}", env!("CARGO_PKG_VERSION"));
pub fn working_dir_name() -> String {
std::env::current_dir().map_or("?".to_owned(), |path| {
path.file_name().map_or("?".to_owned(), |name| {
let name_os_string = name.to_os_string();
match name_os_string == whoami::username_os() && name_os_string != "root" {
true => "~".to_owned(),
false => name.to_string_lossy().to_string(),
}
})
})
std::env::current_dir().map_or("?".to_owned(), |path| {
path.file_name().map_or("?".to_owned(), |name| {
let name_os_string = name.to_os_string();
match name_os_string == whoami::username_os() && name_os_string != "root" {
true => "~".to_owned(),
false => name.to_string_lossy().to_string(),
}
})
})
}
pub fn display(ps1: &String) {
let working_dir_name = cformat!(" <bold>{}</> ", working_dir_name());
cprint!("{}{}λ ", ps1, working_dir_name);
let working_dir_name = cformat!(" <bold>{}</> ", working_dir_name());
cprint!("{}{}λ ", ps1, working_dir_name);
}

26
src/rc.rs
View File

@ -1,7 +1,7 @@
use std::{fs::{self, File}, io::{self, Write}, path::PathBuf};
use thiserror::Error;
const DEFAULT_CONFIG_CONTENT: &str = r#"--!strict
pub const DEFAULT_CONFIG_CONTENT: &str = r#"--!strict
local username = SHELL.SYSTEM.USERNAME
local hostname = SHELL.SYSTEM.HOSTNAME
@ -61,10 +61,10 @@ impl IsValid for PathBuf {
IsValidDirErr::NotAnEntry | IsValidDirErr::Missing => CreateErr::Passable
});
match possible_content {
Ok(p) => Some(p),
Err(e) => match e {
CreateErr::TryExists(_) => None,
CreateErr::Passable => f()
Ok(p) => Some(p),
Err(e) => match e {
CreateErr::TryExists(_) => None,
CreateErr::Passable => f()
},
}
}
@ -72,8 +72,8 @@ impl IsValid for PathBuf {
fn is_valid_dir_or_create(&self) -> Option<PathBuf> {
self.is_valid_or(self.is_dir(), || {
match fs::create_dir(self) {
Ok(()) => Some(self.to_path_buf()),
Err(create_e) => display_none(create_e),
Ok(()) => Some(self.to_path_buf()),
Err(create_e) => display_none(create_e),
}
})
}
@ -81,11 +81,11 @@ impl IsValid for PathBuf {
fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf> {
self.is_valid_or(self.is_file(), || {
match File::create(self) {
Ok(mut file) => match file.write_all(default_file_bytes) {
Ok(()) => Some(self.to_path_buf()),
Err(write_e) => display_none(write_e),
Ok(mut file) => match file.write_all(default_file_bytes) {
Ok(()) => Some(self.to_path_buf()),
Err(write_e) => display_none(write_e),
},
Err(create_e) => display_none(create_e)
Err(create_e) => display_none(create_e)
}
})
}
@ -114,8 +114,4 @@ 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())
}
pub fn none() -> Option<PathBuf> {
None
}

128
src/shell.rs
View File

@ -1,95 +1,85 @@
use crate::{ps, commands, rc, vm};
use std::{fs, io::{self}};
use core::fmt;
fn display_none<T, E>(err: E) -> Option<T>
where
E: fmt::Display
{
println!("{err}");
None
}
pub struct Config {
pub norc: bool
pub norc: bool
}
struct Storage {
pub command_exit_status: commands::ProcessExitStatus,
pub ps1: String,
pub command_exit_status: commands::ProcessExitStatus,
pub ps1: String,
}
trait ShellLuauVm {
fn shell_vm_exec(&self, source: String) -> Option<()>;
fn shell_vm_exec(&self, source: String);
}
impl ShellLuauVm for LambdaShell {
fn shell_vm_exec(&self, source: String) -> Option<()> {
vm::Vm::new().map_or(None, |vm| vm.exec(source))
fn shell_vm_exec(&self, source: String) {
vm::Vm::new().map(|vm| vm.exec(source));
}
}
pub struct LambdaShell {
terminating: bool,
storage: Storage,
config: Config,
terminating: bool,
storage: Storage,
config: Config,
}
impl LambdaShell {
pub fn create(config: Config) -> Self {
Self {
storage: Storage {
command_exit_status: None,
ps1: ps::DEFAULT_PS.to_owned(),
},
terminating: false,
config,
}
}
pub fn create(config: Config) -> Self {
Self {
storage: Storage {
command_exit_status: None,
ps1: ps::DEFAULT_PS.to_owned(),
},
terminating: false,
config,
}
}
fn input(&mut self) {
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 {
//special casey
"exit" => self.terminating = true,
_ => self.storage.command_exit_status = commands::Command::new(trimmed_input.to_owned()).exec()
};
})
}
fn input(&mut self) {
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 {
//special casey
"exit" => self.terminating = true,
_ => self.storage.command_exit_status = commands::Command::new(trimmed_input.to_owned()).exec()
};
})
}
pub fn wait(&mut self) -> Result<(), io::Error> {
io::Write::flush(&mut io::stdout()).map_or_else(|flush_error| Err(flush_error), |()| {
self.input();
pub fn wait(&mut self) -> Result<(), io::Error> {
io::Write::flush(&mut io::stdout()).map_or_else(|flush_error| Err(flush_error), |()| {
self.input();
Ok(())
})
}
})
}
fn rc_parse(&self) {
let rc_file = match self.config.norc {
true => rc::none(),
false => rc::config_file(),
};
rc_file.map(|conf_file| fs::read_to_string(conf_file)
.map_or_else(|read_err| display_none(read_err), |conf| self.shell_vm_exec(conf))
);
}
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)
));
}
}
pub fn start(&mut self) {
self.rc_parse();
pub fn start(&mut self) {
self.rc_parse();
ps::display(&self.storage.ps1);
ps::display(&self.storage.ps1);
loop {
match self.terminating {
true => break,
false => match self.wait() {
Ok(()) => ps::display(&self.storage.ps1),
Err(flush_error) => {
println!("{flush_error}");
break;
}
},
}
}
}
loop {
match self.terminating {
true => break,
false => match self.wait() {
Ok(()) => ps::display(&self.storage.ps1),
Err(flush_error) => {
println!("{flush_error}");
break;
}
},
}
}
}
}