Make some module methods public

Author: khvzak

src/bytes.rs

@@ -21,7 +21,8 @@ impl<T: AsRef<[u8]> + MaybeSend + 'static> From<T> for BytesBox {
 
 impl UserData for BytesBox {}
 
-pub(crate) enum StringOrBytes {
+/// A type that can represent either a Lua string or a `BytesBox` userdata.
+pub enum StringOrBytes {
     String(LuaString),
     Bytes(UserDataRef<BytesBox>),
 }

src/env.rs

@@ -4,42 +4,42 @@ 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>> {
+pub 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>> {
+pub 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>> {
+pub 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>> {
+pub 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>> {
+pub 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> {
+pub 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<()> {
+pub 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) },

src/json.rs

@@ -188,7 +188,11 @@ struct LuaJsonMapIter {
     iter: serde_json::map::Iter<'this>,
 }
 
-fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<StdResult<Value, String>> {
+/// Decodes a JSON string or bytes into a Lua value.
+///
+/// The optional `opts` table can contain:
+/// - `set_array_metatable` (boolean): If true, sets a metatable for arrays. Default is false.
+pub fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<StdResult<Value, String>> {
     let opts = opts.as_ref();
     let mut options = SerializeOptions::new();
     if let Some(enabled) = opts.and_then(|t| t.get::<bool>("set_array_metatable").ok()) {
@@ -199,20 +203,28 @@ fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<Std
     Ok(Ok(lua.to_value_with(&json, options)?))
 }
 
-fn decode_native(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
+/// Decodes a JSON string or bytes as a native Rust object.
+///
+/// The returned value can be a primitive type or userdata.
+pub fn decode_native(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
     let json: serde_json::Value = lua_try!(serde_json::from_slice(&data.as_bytes_deref()));
     Ok(Ok(lua_try!(JsonObject::from(json).into_lua(lua))))
 }
 
-fn encode(value: Value, options: Option<Table>) -> StdResult<String, String> {
+/// Encodes a Lua value into a JSON string.
+///
+/// The optional `opts` table can contain:
+/// - `pretty` (boolean): If true, pretty formats the JSON string. Default is false.
+/// - `relaxed` (boolean): If true, skip recursive tables and unsupported types. Default is false.
+pub fn encode(value: Value, opts: Option<Table>) -> StdResult<String, String> {
     let mut value = value.to_serializable();
-    let options = options.as_ref();
+    let opts = opts.as_ref();
 
-    if options.and_then(|t| t.get::<bool>("relaxed").ok()) == Some(true) {
+    if opts.and_then(|t| t.get::<bool>("relaxed").ok()) == Some(true) {
         value = value.deny_recursive_tables(false).deny_unsupported_types(false);
     }
 
-    if options.and_then(|t| t.get::<bool>("pretty").ok()) == Some(true) {
+    if opts.and_then(|t| t.get::<bool>("pretty").ok()) == Some(true) {
         value = value.sort_keys(true);
         return serde_json::to_string_pretty(&value).map_err(|e| e.to_string());
     }

src/regex.rs

@@ -9,6 +9,7 @@ use quick_cache::sync::Cache;
 // A reasonable cache size for regexes. This can be adjusted as needed.
 const REGEX_CACHE_SIZE: usize = 256;
 
+/// A compiled regular expression.
 #[derive(Clone, Debug)]
 pub struct Regex(regex::bytes::Regex);
 
@@ -152,25 +153,25 @@ impl UserData for RegexSet {
 /// Compiles a regular expression.
 ///
 /// Once compiled, it can be used repeatedly to search, split or replace substrings in a text.
-fn regex_new(lua: &Lua, re: LuaString) -> Result<StdResult<Regex, String>> {
+pub fn regex_new(lua: &Lua, re: LuaString) -> Result<StdResult<Regex, String>> {
     let re = re.to_str()?;
     Ok(Ok(lua_try!(Regex::new(lua, &re))))
 }
 
 /// Escapes a string so that it can be used as a literal in a regular expression.
-fn regex_escape(_: &Lua, text: LuaString) -> Result<String> {
+pub fn regex_escape(_: &Lua, text: LuaString) -> Result<String> {
     Ok(regex::escape(&text.to_str()?))
 }
 
 /// Returns true if there is a match for the regex anywhere in the given text.
-fn regex_is_match(lua: &Lua, (re, text): (LuaString, LuaString)) -> Result<StdResult<bool, String>> {
+pub fn regex_is_match(lua: &Lua, (re, text): (LuaString, LuaString)) -> Result<StdResult<bool, String>> {
     let re = re.to_str()?;
     let re = lua_try!(Regex::new(lua, &re));
     Ok(Ok(re.is_match(&text.as_bytes())))
 }
 
 /// Returns all matches of the regex in the given text or nil if there is no match.
-fn regex_match(lua: &Lua, (re, text): (LuaString, LuaString)) -> Result<StdResult<Value, String>> {
+pub fn regex_match(lua: &Lua, (re, text): (LuaString, LuaString)) -> Result<StdResult<Value, String>> {
     let re = re.to_str()?;
     let re = lua_try!(Regex::new(lua, &re));
     match re.captures(&text.as_bytes()) {

src/yaml.rs

@@ -194,7 +194,11 @@ struct LuaYamlMapIter {
     iter: serde_yaml::mapping::Iter<'this>,
 }
 
-fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<StdResult<Value, String>> {
+/// Decodes a YAML string or byte array into a Lua value.
+///
+/// The `opts` table can contain the following options:
+/// - `set_array_metatable` (boolean): If true, sets a metatable for arrays. Default is false.
+pub fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<StdResult<Value, String>> {
     let opts = opts.as_ref();
     let mut options = SerializeOptions::new();
     if let Some(enabled) = opts.and_then(|t| t.get::<bool>("set_array_metatable").ok()) {
@@ -206,13 +210,20 @@ fn decode(lua: &Lua, (data, opts): (StringOrBytes, Option<Table>)) -> Result<Std
     Ok(Ok(lua.to_value_with(&yaml, options)?))
 }
 
-fn decode_native(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
+/// Decodes a YAML string or bytes as a native Rust object.
+///
+/// The returned value can be a primitive type or userdata.
+pub fn decode_native(lua: &Lua, data: StringOrBytes) -> Result<StdResult<Value, String>> {
     let mut yaml: serde_yaml::Value = lua_try!(serde_yaml::from_slice(&data.as_bytes_deref()));
     lua_try!(yaml.apply_merge());
     Ok(Ok(lua_try!(YamlObject::from(yaml).into_lua(lua))))
 }
 
-fn encode(value: Value, opts: Option<Table>) -> StdResult<String, String> {
+/// Encodes a Lua value into a YAML string.
+///
+/// The optional `opts` table can contain:
+/// - `relaxed` (boolean): If true, skip recursive tables and unsupported types. Default is false.
+pub fn encode(value: Value, opts: Option<Table>) -> StdResult<String, String> {
     let opts = opts.as_ref();
     let mut value = value.to_serializable();