Improve documentation

Author: Sytten

src/lib.rs

@@ -1,3 +1,12 @@
+//! An improved module system for rquickjs
+//!
+//! This is an extension to [rquickjs](https://github.com/DelSkayn/rquickjs)
+//! to allow the ecosystem to create more unified Rust modules.
+//!
+//! The goal was to create a better version of
+//! [`ModuleDef`](rquickjs::module::ModuleDef)
+//! that would allow it to have options as input and set global.
+
 pub use self::definition::{GlobalsOnly, ModuleDefExt, ModuleImpl};
 pub use self::loader::{GlobalInitializer, ModuleLoader, ModuleLoaderBuilder, ModuleResolver};
 
@@ -8,15 +17,12 @@ mod wrapper;
 
 #[cfg(test)]
 mod tests {
-
     use rquickjs::{
         async_with, class::Trace, context::EvalOptions, AsyncContext, AsyncRuntime, CatchResultExt,
         JsLifetime, Object, Result, Value,
     };
 
-    use crate::{globals_only_module, GlobalsOnly, ModuleImpl, ModuleLoader};
-
-    use super::ModuleDefExt;
+    use super::*;
 
     struct Example;
     impl ModuleDefExt for Example {
@@ -34,119 +40,4 @@ mod tests {
         // Custom globals initialization code here
         Ok(())
     });
-
-    #[derive(Clone, Trace, JsLifetime)]
-    #[rquickjs::class(frozen)]
-    struct Console {
-        target: String,
-        newline: bool,
-    }
-
-    impl Console {
-        pub fn new(target: String, newline: bool) -> Self {
-            Self { target, newline }
-        }
-    }
-
-    #[rquickjs::methods]
-    impl Console {
-        fn log(&self, value: Value<'_>) {
-            print!(
-                "{}: {:?}{}",
-                self.target,
-                value,
-                if self.newline { "\n" } else { "" }
-            );
-        }
-    }
-
-    #[derive(JsLifetime, Debug)]
-    struct ConsoleOptions {
-        target: String,
-        newline: bool,
-    }
-
-    struct ConsoleModule {
-        options: ConsoleOptions,
-    }
-
-    impl ConsoleModule {
-        pub fn new<T: Into<String>>(target: T, newline: bool) -> Self {
-            Self {
-                options: ConsoleOptions {
-                    target: target.into(),
-                    newline,
-                },
-            }
-        }
-    }
-
-    impl ModuleDefExt<ConsoleOptions> for ConsoleModule {
-        type Implementation = ModuleImpl<ConsoleOptions>;
-
-        fn implementation() -> &'static Self::Implementation {
-            &ModuleImpl {
-                declare: |decl| {
-                    decl.declare("default")?;
-                    Ok(())
-                },
-                evaluate: |ctx, exports, options| {
-                    println!("Options in eval? {:?}", options);
-                    exports.export("default", options.target.clone())?;
-                    Ok(())
-                },
-                name: "console",
-            }
-        }
-
-        fn options(self) -> ConsoleOptions {
-            self.options
-        }
-
-        fn globals(globals: &Object<'_>, options: &ConsoleOptions) -> Result<()> {
-            println!("Options in globals? {:?}", options);
-            Ok(())
-        }
-    }
-
-    #[tokio::test]
-    async fn test() {
-        let rt = AsyncRuntime::new().unwrap();
-
-        let mut loader = ModuleLoader::builder();
-        loader.add_module(ConsoleModule::new("console", true));
-
-        let (loader, resolver, initalizer) = loader.build();
-
-        // let loader = ModuleLoader::default().with_module(
-        //     "console",
-
-        //     .as_module(),
-        // );
-
-        rt.set_loader(resolver, loader).await;
-
-        let ctx = AsyncContext::full(&rt).await.unwrap();
-
-        async_with!(ctx => |ctx| {
-
-            if let Err(err) = initalizer.init(&ctx).catch(&ctx){
-                eprintln!("{:?}", err);
-            }
-
-            let mut opts = EvalOptions::default();
-            opts.global = false;
-
-            if let Err(err) = ctx.eval_with_options::<Value,_>(r#"
-
-            import console from "console";
-
-            "#, opts).catch(&ctx){
-                eprintln!("{:?}", err);
-            }
-
-
-        })
-        .await;
-    }
 }

src/loader/global.rs

@@ -2,6 +2,7 @@ use rquickjs::{Ctx, Result};
 
 use super::GlobalLoadFn;
 
+/// Global initializer that MUST be called before any user code is run.
 pub struct GlobalInitializer {
     globals: Vec<GlobalLoadFn>,
 }

src/loader/mod.rs

@@ -13,7 +13,8 @@ mod resolver;
 type GlobalLoadFn = Box<dyn for<'js> FnOnce(&Ctx<'js>, &Object<'js>) -> Result<()> + Send + Sync>;
 type ModuleLoadFn = for<'js> fn(Ctx<'js>, Vec<u8>) -> Result<Module<'js>>;
 
-/// Loader for Rust modules defined using [`crate::ModuleDefExt`].
+/// Rquickjs [`Loader`](rquickjs::loader::Loader) for Rust modules
+/// defined using [`ModuleDefExt`](crate::ModuleDefExt).
 ///
 /// See [`ModuleLoaderBuilder`] for usage.
 pub struct ModuleLoader {

src/loader/resolver.rs

@@ -5,6 +5,8 @@ use rquickjs::{
     Ctx, Result,
 };
 
+/// Rquickjs [`Resolver`](rquickjs::loader::Resolver) for modules
+/// defined using [`ModuleDefExt`](crate::ModuleDefExt).
 pub struct ModuleResolver {
     inner: BuiltinResolver,
 }