Add env module

Author: khvzak

src/env.rs

@@ -0,0 +1,69 @@
+use std::path::PathBuf;
+use std::result::Result as StdResult;
+
+use mlua::{Lua, Result, Table};
+
+/// Returns the current working directory
+fn current_dir(_lua: &Lua, _: ()) -> Result<StdResult<PathBuf, String>> {
+    let dir = lua_try!(std::env::current_dir());
+    Ok(Ok(dir))
+}
+
+/// Changes the current working directory to the specified path
+fn set_current_dir(_lua: &Lua, path: String) -> Result<StdResult<bool, String>> {
+    lua_try!(std::env::set_current_dir(path));
+    Ok(Ok(true))
+}
+
+/// Returns the full filesystem path of the current running executable
+fn current_exe(_lua: &Lua, _: ()) -> Result<StdResult<PathBuf, String>> {
+    let exe = lua_try!(std::env::current_exe());
+    Ok(Ok(exe))
+}
+
+/// Returns the path of the current user’s home directory if known
+fn home_dir(_lua: &Lua, _: ()) -> Result<Option<PathBuf>> {
+    Ok(std::env::home_dir())
+}
+
+/// Fetches the environment variable key from the current process
+fn var(_lua: &Lua, key: String) -> Result<Option<String>> {
+    Ok(std::env::var(key).ok())
+}
+
+/// Returns a table containing all environment variables of the current process
+fn vars(lua: &Lua, _: ()) -> Result<Table> {
+    lua.create_table_from(std::env::vars())
+}
+
+/// Sets the environment variable key to the value in the current process
+///
+/// If value is Nil, the environment variable will be removed
+fn set_var(_lua: &Lua, (key, value): (String, Option<String>)) -> Result<()> {
+    match value {
+        Some(v) => unsafe { std::env::set_var(key, v) },
+        None => unsafe { std::env::remove_var(key) },
+    }
+    Ok(())
+}
+
+/// A loader for the `env` module.
+fn loader(lua: &Lua) -> Result<Table> {
+    let t = lua.create_table()?;
+    t.set("current_dir", lua.create_function(current_dir)?)?;
+    t.set("set_current_dir", lua.create_function(set_current_dir)?)?;
+    t.set("current_exe", lua.create_function(current_exe)?)?;
+    t.set("home_dir", lua.create_function(home_dir)?)?;
+    t.set("var", lua.create_function(var)?)?;
+    t.set("vars", lua.create_function(vars)?)?;
+    t.set("set_var", lua.create_function(set_var)?)?;
+    Ok(t)
+}
+
+/// Registers the `yaml` module in the given Lua state.
+pub fn register(lua: &Lua, name: Option<&str>) -> Result<Table> {
+    let name = name.unwrap_or("@env");
+    let value = loader(lua)?;
+    lua.register_module(name, &value)?;
+    Ok(value)
+}

src/lib.rs

@@ -11,6 +11,7 @@ pub(crate) mod time;
 
 pub mod assertions;
 pub mod bytes;
+pub mod env;
 pub mod testing;
 
 #[cfg(feature = "json")]

tests/lib.rs

@@ -9,6 +9,7 @@ fn run_file(modname: &str) -> Result<()> {
 
     // Preload all modules
     mlua_stdlib::assertions::register(&lua, None)?;
+    mlua_stdlib::env::register(&lua, None)?;
     let testing = mlua_stdlib::testing::register(&lua, None)?;
 
     #[cfg(feature = "json")]
@@ -50,6 +51,7 @@ macro_rules! include_tests {
 
 include_tests! {
     assertions,
+    env,
     #[cfg(feature = "json")] json,
     #[cfg(feature = "regex")] regex,
     #[cfg(feature = "yaml")] yaml,

tests/lua/env_tests.lua

@@ -0,0 +1,104 @@
+local env = require("@env")
+
+testing:test("current_dir", function(t)
+    local dir, err = env.current_dir()
+    t.assert_eq(err, nil)
+    t.assert(type(dir) == "string", "current_dir should return a string")
+    t.assert(#dir > 0, "current_dir should not be empty")
+end)
+
+testing:test("set_current_dir", function(t)
+    local original_dir = env.current_dir()
+    local parent_dir = original_dir .. "/.."
+    local ok, err1 = env.set_current_dir(parent_dir)
+    t.assert_eq(err1, nil)
+    t.assert_eq(ok, true)
+
+    -- Verify the directory changed
+    local new_dir, err2 = env.current_dir()
+    t.assert_eq(err2, nil)
+    t.assert(new_dir ~= original_dir, "directory should have changed")
+
+    -- Change back to original directory
+    local _, err3 = env.set_current_dir(original_dir)
+    t.assert_eq(err3, nil)
+
+    -- Test invalid directory
+    local _, err5 = env.set_current_dir("/nonexistent/directory/path")
+    t.assert(err5 ~= nil, "should fail for nonexistent directory")
+    t.assert(type(err5) == "string", "error should be a string")
+end)
+
+testing:test("current_exe", function(t)
+    local exe, err = env.current_exe()
+    t.assert_eq(err, nil)
+    t.assert(type(exe) == "string", "current_exe should return a string")
+    t.assert(#exe > 0, "current_exe should not be empty")
+    -- The executable path should be a valid path (contains forward slash on Unix systems)
+    t.assert(exe:match("/"), "executable should be a full path")
+end)
+
+testing:test("home_dir", function(t)
+    local home = env.home_dir()
+    -- home_dir can return nil if home directory is not known
+    if home ~= nil then
+        t.assert(type(home) == "string", "home_dir should return a string when available")
+        t.assert(#home > 0, "home_dir should not be empty when available")
+    end
+end)
+
+testing:test("var", function(t)
+    -- Test getting a variable that likely doesn't exist
+    local value = env.var("MLUA_STDLIB_NONEXISTENT_VAR")
+    t.assert_eq(value, nil, "nonexistent variable should return nil")
+
+    -- Test getting PATH (should exist on most systems)
+    local path = env.var("PATH")
+    if path ~= nil then
+        t.assert(type(path) == "string", "PATH should be a string")
+        t.assert(#path > 0, "PATH should not be empty")
+    end
+end)
+
+testing:test("set_var", function(t)
+    local test_key = "MLUA_STDLIB_TEST_VAR"
+    local test_value = "test_value_123"
+
+    -- Ensure the variable doesn't exist initially
+    local initial = env.var(test_key)
+    t.assert_eq(initial, nil, "test variable should not exist initially")
+
+    -- Set the variable
+    env.set_var(test_key, test_value)
+    t.assert_eq(env.var(test_key), test_value, "variable should be set correctly")
+
+    -- Update the variable
+    local new_value = "updated_value_456"
+    env.set_var(test_key, new_value)
+    t.assert_eq(env.var(test_key), new_value, "variable should be updated correctly")
+
+    -- Remove the variable
+    env.set_var(test_key, nil)
+    t.assert_eq(env.var(test_key), nil, "variable should be removed when set to nil")
+end)
+
+testing:test("vars", function(t)
+    local all_vars = env.vars()
+    t.assert(type(all_vars) == "table", "vars should return a table")
+
+    -- Check that common environment variables exist
+    local path = all_vars["PATH"]
+    if path ~= nil then
+        t.assert(type(path) == "string", "PATH in vars should be a string")
+    end
+
+    -- Set a test variable and verify it appears in vars
+    local test_key = "MLUA_STDLIB_TEST_VARS"
+    local test_value = "test_vars_value"
+    env.set_var(test_key, test_value)
+    t.assert_eq(env.vars()[test_key], test_value, "test variable should appear in vars")
+
+    -- Clean up
+    env.set_var(test_key, nil)
+    t.assert_eq(env.vars()[test_key], nil, "test variable should be removed from vars")
+end)