virto-network · olanod · Nov 26, 2020 · Nov 26, 2020 · olanod · Nov 26, 2020
diff --git a/examples/hello-plugin/src/functions.rs b/examples/hello-plugin/src/functions.rs
@@ -0,0 +1,9 @@
+//! Simple macro example for functions
+
+use valor::*;
+
+#[vlugin]
+fn hello_plugin(_req: Request) -> Response {
+    "Hello Plugin!".into()
+}
+
diff --git a/examples/hello-plugin/src/lib.rs b/examples/hello-plugin/src/lib.rs
@@ -1,6 +1,2 @@
-use valor::*;
-
-#[vlugin]
-fn hello_plugin(_req: Request) -> Response {
-    "Hello Plugin!".into()
-}
+pub mod functions;
+pub mod structures;
diff --git a/examples/hello-plugin/src/structures.rs b/examples/hello-plugin/src/structures.rs
@@ -0,0 +1,14 @@
+//! Simple macro example for structures
+
+use valor::*;
+
+#[vlugin]
+#[derive(Default)]
+struct MyHandler;
+
+impl RequestHandler for MyHandler {
+    fn handle_request(&self, _: Request) -> HandlerResponse {
+        unimplemented!()
+    }
+}
+
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,7 +1,10 @@
+//! Valor
+
 use http_types::Body;
 pub use http_types::{Method, Request, Response, StatusCode, Url};
 use registry::PluginRegistry;
 use serde::{Deserialize, Serialize};
+use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -24,6 +27,7 @@ type Result = std::result::Result<Response, Response>;
 pub struct Handler(Arc<PluginRegistry>);
 
 impl Handler {
+    /// Creates a new `Handler` instance
     pub fn new(loader: Arc<impl Loader>) -> Self {
         let registry = PluginRegistry::new();
         let (plugin, handler) = registry.clone().as_handler(loader);
@@ -60,7 +64,18 @@ impl Clone for Handler {
     }
 }
 
+impl fmt::Debug for Handler
+where
+    for<'a> dyn RequestHandler + 'a: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Handler").field(&self.0).finish()
+    }
+}
+
+/// Loader
 pub trait Loader: Send + Sync + 'static {
+    /// Loads the given `plugin`
     fn load(&self, plugin: &Plugin) -> std::result::Result<Box<dyn RequestHandler>, ()>;
 }
 
@@ -71,9 +86,12 @@ pub(crate) fn res(status: StatusCode, msg: impl Into<Body>) -> Response {
     res
 }
 
+/// Handler response
 pub type HandlerResponse = Pin<Box<dyn Future<Output = Response> + Send>>;
 
+/// Request handler
 pub trait RequestHandler: Send + Sync {
+    /// Handles the request
     fn handle_request(&self, request: Request) -> HandlerResponse;
 }
 
@@ -86,13 +104,31 @@ where
     }
 }
 
+/// Plugin
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum Plugin {
-    BuiltIn { name: String },
+    /// Built in
+    BuiltIn {
+        /// Name
+        name: String,
+    },
+    /// Dummy
     Dummy,
-    Native { name: String, path: Option<String> },
-    WebWorker { name: String, url: Url },
+    /// Native
+    Native {
+        /// Name
+        name: String,
+        /// Path
+        path: Option<String>,
+    },
+    /// Web worker
+    WebWorker {
+        /// Name
+        name: String,
+        /// Url
+        url: Url,
+    },
 }
 
 impl Plugin {

diff --git a/src/registry.rs b/src/registry.rs
@@ -2,6 +2,7 @@ use crate::{res, HandlerResponse, Loader, Method, Plugin, Request, RequestHandle
 use path_tree::PathTree;
 use serde_json as json;
 use std::collections::HashMap;
+use std::fmt;
 use std::iter::Iterator;
 use std::sync::{Arc, Mutex};
 
@@ -82,3 +83,15 @@ impl PluginRegistry {
         )
     }
 }
+
+impl fmt::Debug for PluginRegistry
+where
+    for<'a> dyn RequestHandler + 'a: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PluginRegistry")
+            .field("plugins", &self.plugins)
+            .field("routes", &self.routes)
+            .finish()
+    }
+}
diff --git a/valor-native/src/loader.rs b/valor-native/src/loader.rs
@@ -12,7 +12,7 @@ impl Loader for DynLoader {
                 let lib = Library::new(path).map_err(|_| ())?;
 
                 debug!("loading native plugin {}", path);
-                let get_request_handler: Symbol<fn() -> _> =
+                let get_request_handler: Symbol<'_, fn() -> _> =
                     unsafe { lib.get(b"get_request_handler") }.map_err(|_| ())?;
                 debug!("symbol {:?}", plugin);
 

diff --git a/valor-native/src/main.rs b/valor-native/src/main.rs
@@ -1,3 +1,5 @@
+//! Valor vlupin
+
 use kv_log_macro::{error, info};
 use loader::DynLoader;
 use std::sync::Arc;

diff --git a/valor-vlugin/Cargo.toml b/valor-vlugin/Cargo.toml
@@ -13,4 +13,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0.24"
 quote = "1.0.7"
-syn = { version = "1.0.48", features = ["full"] }
+syn = { version = "1.0.48", features = ["full", "parsing"] }
diff --git a/valor-vlugin/README.md b/valor-vlugin/README.md
@@ -1,2 +1,3 @@
 # Vlugin
+
 "pluging" was taken so now we have Vlugins!. This helper crate is a procedural macro that annotates a function to be the entry point of a plugin that handles requests.
diff --git a/valor-vlugin/src/lib.rs b/valor-vlugin/src/lib.rs
@@ -1,33 +1,59 @@
+//! Valor vlugin
+
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse_macro_input, Ident, ItemFn};
+use syn::{Error, ItemFn, ItemStruct};
 
+/// vlugin
 #[proc_macro_attribute]
-pub fn vlugin(_attr: TokenStream, input: TokenStream) -> TokenStream {
-    let func = parse_macro_input!(input as ItemFn);
-    let name = func.sig.ident.clone();
+pub fn vlugin(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let ts2: proc_macro2::TokenStream = item.into();
 
-    let handler = sync_req_handler(name);
+    if let Ok(rslt) = syn::parse2::<ItemFn>(ts2.clone()) {
+        return handle_item_fn(rslt).into();
+    }
+
+    if let Ok(rslt) = syn::parse2::<ItemStruct>(ts2) {
+        return handle_item_struct(rslt).into();
+    }
+
+    Error::new(
+        proc_macro2::Span::mixed_site(),
+        "Only functions and structures that implement `RequestHandler` are currently supported",
+    )
+    .to_compile_error()
+    .into()
+}
+
+fn handle_item_fn(item: ItemFn) -> TokenStream2 {
+    let name = item.sig.ident.clone();
 
     let plugin_def = quote! {
+        /// Handler
         #[no_mangle]
         pub extern "Rust" fn get_request_handler() -> Box<dyn valor::RequestHandler> {
-            sync_req_handler()
+            Box::new(|req| Box::pin(async { #name(req) }) as valor::HandlerResponse)
         }
 
-        #handler
-
-        #func
+        #item
     };
+
     plugin_def.into()
 }
 
-fn sync_req_handler(handler: Ident) -> TokenStream2 {
-    quote! {
-        #[inline]
-        fn sync_req_handler() -> Box<dyn valor::RequestHandler> {
-            Box::new(|req| Box::pin(async { #handler(req) }) as valor::HandlerResponse)
+fn handle_item_struct(item: ItemStruct) -> TokenStream2 {
+    let name = &item.ident;
+
+    let plugin_def = quote! {
+        /// Handler
+        #[no_mangle]
+        pub extern "Rust" fn get_request_handler() -> Box<dyn valor::RequestHandler> {
+            Box::new(#name::default())
         }
-    }
+
+        #item
+    };
+
+    plugin_def.into()
 }
diff --git a/valor-web/src/lib.rs b/valor-web/src/lib.rs
@@ -1,5 +1,7 @@
+//! Valor web
+
 #[global_allocator]
-static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+static ALLOC: wee_alloc::WeeAlloc<'_> = wee_alloc::WeeAlloc::INIT;
 
 use js_sys::{Array, ArrayBuffer, Object, Reflect, Uint8Array};
 use std::rc::Rc;
@@ -39,6 +41,7 @@ impl From<JsRequest> for Request {
     }
 }
 
+/// Run
 #[wasm_bindgen(start)]
 pub async fn run() -> Result<(), JsValue> {
     init_log();
@@ -87,7 +90,7 @@ fn load_service_worker(url: &str) -> Result<(), JsValue> {
 struct Loader;
 
 impl valor::Loader for Loader {
-    fn load(&self, plugin: &Plugin) -> std::result::Result<Box<dyn RequestHandler>, ()> {
+    fn load(&self, plugin: &Plugin) -> Result<Box<dyn RequestHandler>, ()> {
         match plugin {
             Plugin::WebWorker { .. } => todo!(),
             _ => unreachable!(),