tide-jsx

GIT_CONFIG_PARAMETERS="'http.version=HTTP/1.1'" git clone https://git.pyrossh.dev/tide-jsx/.git tide-jsx
Discussions: https://groups.google.com/g/rust-embed-devs

Tide + JSX

509577f5 — Peter John

new stuff

Files changed (7) hide show

examples/basic.rs +19 -2
impl/src/lib.rs +43 -0
impl/src/route.rs +38 -0
impl/src/tags.rs +0 -2
src/lib.rs +34 -1
tests/lib.rs +163 -1
tests/ui/fail/unexpected-attribute.stderr +2 -2

examples/basic.rs CHANGED Viewed

@@ -2,13 +2,14 @@ use tide::http::mime;
 use tide::utils::After;
 use tide::{log, Request, Response};
 use tide_jsx::html::HTML5Doctype;
-use tide_jsx::{component, rsx, view};
+use tide_jsx::{component, get, post, routes, rsx, view};
 #[component]
 fn Heading<'title>(title: &'title str) {
     rsx! { <h1 class={"title"}>{title}</h1> }
 }
+#[get("/")]
 async fn index(_req: Request<()>) -> tide::Result {
     view! {
       <>
@@ -25,6 +26,22 @@ async fn index(_req: Request<()>) -> tide::Result {
     }
 }
+#[post("/submit")]
+async fn submit(mut req: Request<()>) -> tide::Result {
+    let body = req.body_string().await?;
+    view! {
+      <>
+       <HTML5Doctype />
+       <html>
+         <body>
+           <h1>{"Submitted"}</h1>
+           <p>{format!("Received: {}", body)}</p>
+         </body>
+       </html>
+      </>
+    }
+}
 #[async_std::main]
 async fn main() -> tide::Result<()> {
     log::start();
@@ -39,7 +56,7 @@ async fn main() -> tide::Result<()> {
         }
         Ok(res)
     }));
-    app.at("/").get(index);
+    routes!(app, [index, submit]);
     app.listen("127.0.0.1:5000").await?;
     Ok(())
 }

impl/src/lib.rs CHANGED Viewed

@@ -6,6 +6,7 @@ mod element;
 mod element_attribute;
 mod element_attributes;
 mod function_component;
+mod route;
 mod tags;
 use element::Element;
@@ -50,3 +51,45 @@ pub fn component(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let f = parse_macro_input!(item as syn::ItemFn);
     function_component::create_function_component(f)
 }
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn get(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("get", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn post(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("post", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn put(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("put", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn delete(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("delete", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn patch(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("patch", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn head(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("head", attr, item)
+}
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn options(attr: TokenStream, item: TokenStream) -> TokenStream {
+    route::create_route("options", attr, item)
+}

impl/src/route.rs ADDED Viewed

@@ -0,0 +1,38 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::LitStr;
+pub fn create_route(method: &str, attr: TokenStream, item: TokenStream) -> TokenStream {
+    let path = match syn::parse::<LitStr>(attr) {
+        Ok(lit) => lit,
+        Err(err) => return TokenStream::from(err.to_compile_error()),
+    };
+    let f = match syn::parse::<syn::ItemFn>(item) {
+        Ok(f) => f,
+        Err(err) => return TokenStream::from(err.to_compile_error()),
+    };
+    let fn_name = &f.sig.ident;
+    let vis = &f.vis;
+    let block = &f.block;
+    let inputs = &f.sig.inputs;
+    let output = &f.sig.output;
+    let attrs = &f.attrs;
+    let asyncness = &f.sig.asyncness;
+    let method_str = method;
+    TokenStream::from(quote! {
+        #[allow(non_camel_case_types)]
+        #vis struct #fn_name;
+        impl #fn_name {
+            pub const PATH: &'static str = #path;
+            pub const METHOD: &'static str = #method_str;
+            #(#attrs)*
+            #vis #asyncness fn handler(#inputs) #output
+                #block
+        }
+    })
+}

impl/src/tags.rs CHANGED Viewed

@@ -8,7 +8,6 @@ pub struct OpenTag {
     pub name: syn::Path,
     pub attributes: ElementAttributes,
     pub self_closing: bool,
-    pub is_custom_element: bool,
 }
 fn name_or_fragment(maybe_name: Result<syn::Path>) -> syn::Path {
@@ -40,7 +39,6 @@ impl Parse for OpenTag {
             name,
             attributes,
             self_closing,
-            is_custom_element,
         })
     }
 }

src/lib.rs CHANGED Viewed

@@ -10,4 +10,37 @@ pub use self::render::Render;
 pub use fragment::Fragment;
 pub use simple_element::SimpleElement;
 pub use text_element::Raw;
-pub use tide_jsx_impl::{component, html, rsx, view};
+pub use tide_jsx_impl::{component, delete, get, head, html, options, patch, post, put, rsx, view};
+#[macro_export]
+macro_rules! routes {
+    ($app:expr, [$($route:ident),* $(,)?]) => {{
+        $(
+            $crate::__register_route!($app, $route);
+        )*
+    }};
+}
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __register_route {
+    ($app:expr, $route:ident) => {
+        if $route::METHOD == "get" {
+            $app.at($route::PATH).get($route::handler);
+        } else if $route::METHOD == "post" {
+            $app.at($route::PATH).post($route::handler);
+        } else if $route::METHOD == "put" {
+            $app.at($route::PATH).put($route::handler);
+        } else if $route::METHOD == "delete" {
+            $app.at($route::PATH).delete($route::handler);
+        } else if $route::METHOD == "patch" {
+            $app.at($route::PATH).patch($route::handler);
+        } else if $route::METHOD == "head" {
+            $app.at($route::PATH).head($route::handler);
+        } else if $route::METHOD == "options" {
+            $app.at($route::PATH).options($route::handler);
+        } else {
+            panic!("Unsupported HTTP method: {}", $route::METHOD);
+        }
+    };
+}

tests/lib.rs CHANGED Viewed

@@ -253,7 +253,9 @@ mod other {
 }
 mod integration {
+    use crate::{component, rsx, view};
-    use crate::view;
+    use tide::Request;
+    use tide_jsx::{delete, get, patch, post, put, routes};
     use tide_testing::TideTestingExt;
     #[async_std::test]
@@ -277,4 +279,164 @@ mod integration {
         );
         Ok(())
     }
+    #[get("/")]
+    async fn index(_req: Request<()>) -> tide::Result {
+        view! { <h1>{"Home"}</h1> }
+    }
+    #[get("/about")]
+    async fn about(_req: Request<()>) -> tide::Result {
+        view! { <h1>{"About"}</h1> }
+    }
+    #[post("/submit")]
+    async fn submit(mut req: Request<()>) -> tide::Result {
+        let body = req.body_string().await?;
+        view! { <p>{format!("Received: {}", body)}</p> }
+    }
+    #[put("/update")]
+    async fn update(_req: Request<()>) -> tide::Result {
+        view! { <p>{"Updated"}</p> }
+    }
+    #[patch("/patch")]
+    async fn patch_it(_req: Request<()>) -> tide::Result {
+        view! { <p>{"Patched"}</p> }
+    }
+    #[delete("/remove")]
+    async fn remove(_req: Request<()>) -> tide::Result {
+        view! { <p>{"Deleted"}</p> }
+    }
+    #[async_std::test]
+    async fn test_get_route_macro() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [index]);
+        let res = app.get("/").recv_string().await?;
+        assert_eq!(res, "<h1>Home</h1>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_multiple_get_routes() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [index, about]);
+        assert_eq!(app.get("/").recv_string().await?, "<h1>Home</h1>");
+        assert_eq!(app.get("/about").recv_string().await?, "<h1>About</h1>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_post_route_macro() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [submit]);
+        let res = app.post("/submit").body_string("hello".into()).recv_string().await?;
+        assert_eq!(res, "<p>Received: hello</p>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_put_route_macro() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [update]);
+        let mut res = app.put("/update").await?;
+        assert_eq!(res.body_string().await?, "<p>Updated</p>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_patch_route_macro() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [patch_it]);
+        let mut res = app.patch("/patch").await?;
+        assert_eq!(res.body_string().await?, "<p>Patched</p>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_delete_route_macro() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [remove]);
+        let mut res = app.delete("/remove").await?;
+        assert_eq!(res.body_string().await?, "<p>Deleted</p>");
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_all_methods_together() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [index, about, submit, update, patch_it, remove]);
+        assert_eq!(app.get("/").recv_string().await?, "<h1>Home</h1>");
+        assert_eq!(app.get("/about").recv_string().await?, "<h1>About</h1>");
+        assert_eq!(
+            app.post("/submit").body_string("data".into()).recv_string().await?,
+            "<p>Received: data</p>"
+        );
+        let mut put_res = app.put("/update").await?;
+        assert_eq!(put_res.body_string().await?, "<p>Updated</p>");
+        let mut patch_res = app.patch("/patch").await?;
+        assert_eq!(patch_res.body_string().await?, "<p>Patched</p>");
+        let mut del_res = app.delete("/remove").await?;
+        assert_eq!(del_res.body_string().await?, "<p>Deleted</p>");
+        Ok(())
+    }
+    #[component]
+    fn Greeting<'name>(name: &'name str) {
+        rsx! { <h1>{format!("Hello, {}!", name)}</h1> }
+    }
+    #[get("/greet")]
+    async fn greet(_req: Request<()>) -> tide::Result {
+        view! { <Greeting name={"World"} /> }
+    }
+    #[async_std::test]
+    async fn test_route_with_component() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [greet]);
+        assert_eq!(
+            app.get("/greet").recv_string().await?,
+            "<h1>Hello, World!</h1>"
+        );
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_route_returns_html_content_type() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [index]);
+        let res = app.get("/").await?;
+        assert_eq!(
+            res.header("content-type").unwrap().as_str(),
+            tide::http::mime::HTML.to_string()
+        );
+        Ok(())
+    }
+    #[async_std::test]
+    async fn test_wrong_method_returns_not_found() -> tide::Result<()> {
+        let mut app = tide::new();
+        routes!(app, [index]);
+        let res = app.post("/").await?;
+        assert_eq!(res.status(), tide::http::StatusCode::MethodNotAllowed);
+        Ok(())
+    }
 }

tests/ui/fail/unexpected-attribute.stderr CHANGED Viewed

@@ -1,7 +1,7 @@
 error[E0560]: struct `Heading<'_>` has no field named `t`
- --> $DIR/unexpected-attribute.rs:9:22
+ --> tests/ui/fail/unexpected-attribute.rs:9:22
   |
 9 |     html! { <Heading t={"Hello world!"} /> };
   |                      ^ `Heading<'_>` does not have this field
   |
-  = note: available fields are: `title`
+  = note: all struct fields are already assigned

~repos /tide-jsx

GIT_CONFIG_PARAMETERS="'http.version=HTTP/1.1'" git clone https://git.pyrossh.dev/tide-jsx/.git tide-jsx Discussions: https://groups.google.com/g/rust-embed-devs

Tide + JSX

GIT_CONFIG_PARAMETERS="'http.version=HTTP/1.1'" git clone https://git.pyrossh.dev/tide-jsx/.git tide-jsx
Discussions: https://groups.google.com/g/rust-embed-devs