implement ClosureSearcher

expose `UserData` created from Rust

manipulate the `rlua::Context` in Rust and return string to load as chunk

primarily intended to enable constructing Lua modules in Rust
- particularly Lua modules involving `UserData`

tests/tests.rs

@@ -1,4 +1,4 @@
-use rlua::{Lua, Table, Value};
+use rlua::{Context, Lua, Table, UserData, UserDataMethods, Value};
 use rlua_searcher::{AddSearcher, Result};
 use std::collections::HashMap;
 use std::fs::File;
@@ -160,6 +160,73 @@ fn module_reloading_works() {
     assert_eq!("hello lume", hello);
 }
 
+#[test]
+fn add_closure_searcher_works() {
+    let lua = Lua::new();
+
+    let mut modules: HashMap<
+        &'static str,
+        Box<dyn Fn(Context) -> rlua::Result<&'static str> + Send>,
+    > = HashMap::new();
+
+    let instrument_loader = Box::new(|lua_ctx: Context| {
+        let globals = lua_ctx.globals();
+        let new = lua_ctx.create_function(|_, (name, sound): (String, String)| {
+            Ok(Instrument::new(name, sound))
+        })?;
+        let tbl = lua_ctx.create_table()?;
+        tbl.set("new", new)?;
+        globals.set("instrument", tbl)?;
+        Ok("return instrument")
+    });
+
+    modules.insert("instrument", instrument_loader);
+
+    let sound = lua
+        .context::<_, Result<String>>(|lua_ctx| {
+            lua_ctx.add_closure_searcher(modules)?;
+
+            // Ensure global variable `instrument` is unset.
+            let nil: String = lua_ctx.load("return type(instrument)").eval()?;
+            assert_eq!(nil, "nil");
+
+            Ok(lua_ctx
+                .load(
+                    r#"local instrument = require("instrument")
+                       local ukulele = instrument.new("ukulele", "twang")
+                       return ukulele:play()"#,
+                )
+                .eval()?)
+        })
+        .unwrap();
+
+    assert_eq!(sound, "The ukulele goes twang");
+}
+
+struct Instrument {
+    name: String,
+    sound: String,
+}
+
+impl Instrument {
+    pub fn new(name: String, sound: String) -> Self {
+        Self { name, sound }
+    }
+
+    pub fn play(&self) -> String {
+        format!("The {} goes {}", self.name, self.sound)
+    }
+}
+
+impl UserData for Instrument {
+    fn add_methods<'lua, M>(methods: &mut M)
+    where
+        M: UserDataMethods<'lua, Self>,
+    {
+        methods.add_method("play", |_, instrument, ()| Ok(instrument.play()));
+    }
+}
+
 fn read_lume_to_string() -> String {
     r#"return "hello lume""#.to_string()
 }