Clean up impl a bit

crates/plugin_runtime/src/main.rs

@@ -2,30 +2,6 @@ use mlua::Lua;
 
 use runner::*;
 
-// pub fn main() -> Result<(), mlua::Error> {
-//     let source = include_str!("../plugin/cargo_test.lua").to_string();
-
-//     let module = LuaPlugin::new(source);
-//     let mut lua: Lua = Runtime::init(module)?;
-//     let runner: TestRunner = lua.as_interface::<TestRunner>().unwrap();
-
-//     println!("extracted interface: {:#?}", &runner);
-
-//     let contents = runner.run_test(&mut lua, "it_works".into());
-
-//     println!("test results:{}", contents.unwrap());
-
-//     Ok(())
-// }
-
-// pub fn main() -> mlua::Result<()> {
-//     let module = LuaPlugin::new(include_str!("../plugin/cargo_test.lua").to_string());
-//     let mut lua: Lua = Runtime::init(module)?;
-//     let runner = lua.as_interface::<TestRunner>().unwrap();
-//     let test_results = runner.run_test(&mut lua, "it_works".into());
-//     Ok(())
-// }
-
 pub fn main() -> anyhow::Result<()> {
     let plugin = WasmPlugin {
         source_bytes: include_bytes!(
@@ -35,55 +11,42 @@ pub fn main() -> anyhow::Result<()> {
         store_data: (),
     };
 
-    let mut wasm: Wasm<()> = Runtime::init(plugin)?;
-    let banana = wasm.as_interface::<Banana>().unwrap();
-    let result = banana.banana(&mut wasm, 420.69);
+    let mut sum = Wasm::init(plugin)?;
+    let strings = "I hope you have a nice day".split(" ").iter().collect();
+    let result = sum.sum_lengths(strings);
 
-    dbg!("{}", result);
+    dbg!(result);
 
     Ok(())
 }
 
-struct Banana {
-    banana: Handle,
+// struct SumLengths {
+//     sum_lengths: Handle,
+// }
+
+// impl Interface for SumLengths {
+//     fn from_runtime<T: Runtime>(runtime: &mut T) -> Option<Self> {
+//         Some(SumLengths {
+//             sum_lengths: runtime.handle_for("sum_lengths")?,
+//         })
+//     }
+// }
+
+// impl SumLengths {
+//     fn sum_lengths<T: Runtime>(&self, runtime: &mut T, strings: Vec<String>) -> Option<usize> {
+//         runtime.call(&self.sum_lengths, strings).ok()
+//     }
+// }
+
+// #[plugin::interface]
+trait SumLengths {
+    fn sum_lengths(&mut self, strings: Vec<String>) -> usize;
 }
 
-impl Interface for Banana {
-    fn from_runtime<T: Runtime>(runtime: &mut T) -> Option<Self> {
-        let banana = runtime.handle_for("banana")?;
-        Some(Banana { banana })
+impl<T: Runtime> SumLengths for T {
+    fn sum_lengths(&mut self, strings: Vec<String>) -> usize {
+        let handle = self.handle_for("sum_lengths").unwrap();
+        let result = self.call(&handle, strings).ok().unwrap();
+        return result;
     }
 }
-
-impl Banana {
-    fn banana<T: Runtime>(&self, runtime: &mut T, number: f64) -> Option<f64> {
-        runtime.call(&self.banana, number).ok()
-    }
-}
-
-#[allow(dead_code)]
-#[derive(Debug)]
-struct TestRunner {
-    pub query: String,
-    run_test: Handle,
-}
-
-impl Interface for TestRunner {
-    fn from_runtime<T: Runtime>(runtime: &mut T) -> Option<Self> {
-        let run_test = runtime.handle_for("run_test")?;
-        let query = runtime.handle_for("query")?;
-        let query: String = runtime.constant(&query).ok()?;
-        Some(TestRunner { query, run_test })
-    }
-}
-
-impl TestRunner {
-    pub fn run_test<T: Runtime>(&self, runtime: &mut T, test_name: String) -> Option<String> {
-        runtime.call(&self.run_test, test_name).ok()
-    }
-}
-
-#[test]
-pub fn it_works() {
-    panic!("huh, that was surprising...");
-}