Refactors and move lua stdlib

- Moved lua stdlib from the rust autorun-env package to be a standalone
  plugin.

- To do this reliably, added plugin "ordering" field which can allow a
  plugin to specify the ordering it desires, lower number means higher
  priority / starts first. Higher number starts later. Plugins are
  sorted by this before being run.

- Added Autorun.load() which is the equivalent of lua's loadstring() or
  gmod's CompileString, except it is also available on the menu.

- Implement FromLua for Option<FromLua>

- Simplify loadbuffer and pcall internals

Author: vurvdev

packages/autorun-core/src/plugins.rs

@@ -8,15 +8,13 @@ pub struct Plugin {
 	/// Directory for mutable data.
 	data_dir: Dir,
 
-	config: std::sync::OnceLock<Config>,
+	config: Config,
 }
 
 impl core::fmt::Display for Plugin {
 	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-		match self.get_config() {
-			Ok(cfg) => write!(f, "{} v{} by {}", cfg.plugin.name, cfg.plugin.version, cfg.plugin.author),
-			Err(_) => write!(f, "Invalid Plugin"),
-		}
+		let cfg = &self.config;
+		write!(f, "{} v{} by {}", cfg.plugin.name, cfg.plugin.version, cfg.plugin.author)
 	}
 }
 
@@ -48,28 +46,28 @@ impl Plugin {
 		self.src()?.open_dir("menu")
 	}
 
+	pub fn shared(&self) -> std::io::Result<Dir> {
+		self.src()?.open_dir("shared")
+	}
+
 	pub fn try_clone(&self) -> std::io::Result<Self> {
 		Ok(Self {
 			dir: self.dir.try_clone()?,
 			data_dir: self.data_dir.try_clone()?,
-			config: std::sync::OnceLock::new(),
+			config: self.config.clone(),
 		})
 	}
 
 	pub fn read_client_init(&self) -> std::io::Result<Vec<u8>> {
 		self.client()?.read(Self::INIT_FILE)
 	}
 
-	pub fn client_exists(&self) -> std::io::Result<bool> {
-		self.client()?.try_exists(Self::INIT_FILE)
-	}
-
 	pub fn read_menu_init(&self) -> std::io::Result<Vec<u8>> {
-		self.menu()?.read("init.lua")
+		self.menu()?.read(Self::INIT_FILE)
 	}
 
-	pub fn menu_exists(&self) -> std::io::Result<bool> {
-		self.menu()?.try_exists(Self::INIT_FILE)
+	pub fn read_shared_init(&self) -> std::io::Result<Vec<u8>> {
+		self.shared()?.read(Self::INIT_FILE)
 	}
 
 	pub fn from_dir(dir: Dir) -> anyhow::Result<Self> {
@@ -85,34 +83,26 @@ impl Plugin {
 			}
 		};
 
-		Ok(Self {
-			dir,
-			data_dir,
-			config: std::sync::OnceLock::new(),
-		})
-	}
-
-	pub fn get_config(&self) -> anyhow::Result<&Config> {
-		if let Some(cfg) = self.config.get() {
-			return Ok(cfg);
-		}
-
-		let config_data = self.dir.read_to_string(Self::PLUGIN_CONFIG)?;
+		let config_data = dir.read_to_string(Self::PLUGIN_CONFIG)?;
 		let config: Config = toml::from_str(&config_data)?;
-		self.config.set(config).expect("Shouldn't be set");
 
-		Ok(self.config.get().expect("Should be set"))
+		Ok(Self { dir, data_dir, config })
+	}
+
+	pub fn config(&self) -> &Config {
+		&self.config
 	}
 }
 
 nestify::nest! {
-	#[derive(Debug, Serialize, Deserialize)]*
+	#[derive(Debug, Clone, Serialize, Deserialize)]*
 	pub struct Config {
 		pub plugin: pub struct ConfigPlugin {
 			pub name: String,
 			pub author: String,
 			pub version: String,
 			pub description: String,
+			pub ordering: Option<u32>,
 
 			pub language: #[serde(rename_all = "lowercase")] #[non_exhaustive] pub enum ConfigPluginLanguage {
 				Lua,

packages/autorun-env/api.json

@@ -277,6 +277,28 @@
 							"description": "The original function that was detoured"
 						}
 					]
+				},
+				{
+					"name": "load",
+					"description": "Compiles a Lua string into a callable function without executing it. Similar to Lua's loadstring/load function. Use this to dynamically compile code at runtime. NOTE: The environment inside defaults to the global environment, NOT Autorun's environment.",
+					"realm": "shared",
+					"parameters": [
+						{
+							"name": "code",
+							"type": "string",
+							"description": "The Lua code to compile"
+						}
+					],
+					"returns": [
+						{
+							"type": "function?",
+							"description": "The compiled function, or nil if compilation failed"
+						},
+						{
+							"type": "string?",
+							"description": "Error message if compilation failed"
+						}
+					]
 				}
 			]
 		}

packages/autorun-env/src/env.rs

@@ -122,6 +122,10 @@ impl EnvHandle {
 		lua.push(state, as_env_lua_function!(crate::functions::detour_get_original));
 		lua.set_table(state, -3);
 
+		lua.push(state, c"load");
+		lua.push(state, as_env_lua_function!(crate::functions::load));
+		lua.set_table(state, -3);
+
 		lua.push(state, c"VERSION");
 		lua.push(state, env!("CARGO_PKG_VERSION").to_string());
 		lua.set_table(state, -3);
@@ -158,15 +162,7 @@ impl EnvHandle {
 
 		// Can unwrap since we are sure there is something on the stack
 		let handle = RawHandle::from_stack(lua, state).unwrap();
-
-		// Create lua standard library
-		let this = Self(handle);
-		this.execute(lua, state, c"@stdlib", include_bytes!("./lua/builtins.lua"))?;
-		this.execute(lua, state, c"@stdlib", include_bytes!("./lua/include.lua"))?;
-		this.execute(lua, state, c"@stdlib", include_bytes!("./lua/require.lua"))?;
-		this.execute(lua, state, c"@stdlib", include_bytes!("./lua/event.lua"))?;
-
-		Ok(this)
+		Ok(Self(handle))
 	}
 
 	fn push_autorun_table(&self, lua: &LuaApi, state: *mut LuaState) {

packages/autorun-env/src/functions.rs

@@ -18,3 +18,6 @@ pub use append::*;
 
 mod detour;
 pub use detour::*;
+
+mod load;
+pub use load::*;

packages/autorun-env/src/functions/load.rs

@@ -0,0 +1,16 @@
+use autorun_lua::{LuaApi, RawLuaReturn};
+use autorun_types::LuaState;
+
+pub fn load(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<RawLuaReturn> {
+	let source = lua.check_string(state, 1);
+	let chunk_name = lua.to::<Option<&[u8]>>(state, 2).unwrap_or(b"loadstring");
+	let chunk_name = std::ffi::CString::new(chunk_name)?;
+
+	if let Err(why) = lua.load_buffer_x(state, source.as_bytes(), &chunk_name, c"t") {
+		lua.push_nil(state);
+		lua.push(state, &why);
+		return Ok(RawLuaReturn(2));
+	}
+
+	Ok(RawLuaReturn(1))
+}

packages/autorun-env/src/lua/include.lua

@@ -403,16 +403,10 @@ impl LuaApi {
 			LUA_OK | LUA_YIELD => Ok(()),
 
 			_ => {
-				let err_msg = self.to_lstring(state, -1, std::ptr::null_mut());
+				let err = self.check_string(state, -1);
 				self.pop(state, 1);
 
-				let err_str = if !err_msg.is_null() {
-					unsafe { std::ffi::CStr::from_ptr(err_msg) }.to_string_lossy()
-				} else {
-					std::borrow::Cow::Borrowed("Unknown error")
-				};
-
-				Err(err_str)
+				Err(err)
 			}
 		}
 	}
@@ -428,16 +422,10 @@ impl LuaApi {
 			LUA_OK | LUA_YIELD => Ok(()),
 
 			_ => {
-				let err_msg = self.to_lstring(state, -1, std::ptr::null_mut());
+				let err = self.check_string(state, -1);
 				self.pop(state, 1);
 
-				let err_str = if !err_msg.is_null() {
-					unsafe { std::ffi::CStr::from_ptr(err_msg) }.to_string_lossy()
-				} else {
-					std::borrow::Cow::Borrowed("Unknown error")
-				};
-
-				Err(err_str)
+				Err(err)
 			}
 		}
 	}
@@ -480,6 +468,15 @@ impl<T: IntoLua> LuaReturn for T {
 	}
 }
 
+#[repr(transparent)]
+pub struct RawLuaReturn(pub i32);
+
+impl LuaReturn for RawLuaReturn {
+	fn into_lua_return(self, _lua: &LuaApi, _state: *mut LuaState) -> i32 {
+		self.0
+	}
+}
+
 // Macro to implement LuaReturn for tuples
 macro_rules! impl_lua_return_tuple {
     ($($T:ident),+) => {

packages/autorun-lua/src/lua.rs

@@ -104,6 +104,16 @@ impl FromLua for Option<LuaFunction> {
 	}
 }
 
+impl<T: FromLua> FromLua for Option<T> {
+	fn from_lua(lua: &LuaApi, state: *mut LuaState, stack_idx: i32) -> Self {
+		if lua.type_id(state, stack_idx) == crate::LuaTypeId::Nil {
+			None
+		} else {
+			Some(T::from_lua(lua, state, stack_idx))
+		}
+	}
+}
+
 impl IntoLua for &std::borrow::Cow<'_, str> {
 	fn into_lua(self, lua: &LuaApi, state: *mut LuaState) {
 		lua.push_lstring(state, self.as_ptr() as _, self.len());

packages/autorun-lua/src/value.rs

@@ -0,0 +1,7 @@
+[plugin]
+name = "std"
+author = "vurv"
+version = "0.1.0"
+description = "Standard library for Autorun-ng"
+language = "lua"
+ordering = 0

plugins/std/plugin.toml

@@ -107,3 +107,5 @@ tostring = _G.tostring
 type = _G.type
 xpcall = _G.xpcall
 _VERSION = _G._VERSION
+getfenv = _G.getfenv
+setfenv = _G.setfenv