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

685384d0 — Peter John

HEAD -> master

Revert "new stuff"

Files changed (7) hide show

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

examples/basic.rs CHANGED Viewed

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

impl/src/lib.rs CHANGED Viewed

@@ -6,7 +6,6 @@ mod element;
 mod element_attribute;
 mod element_attributes;
 mod function_component;
-mod route;
 mod tags;
 use element::Element;
@@ -51,45 +50,3 @@ 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 DELETED Viewed

@@ -1,38 +0,0 @@
-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,6 +8,7 @@ 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 {
@@ -39,6 +40,7 @@ impl Parse for OpenTag {
             name,
             attributes,
             self_closing,
+            is_custom_element,
         })
     }
 }

src/lib.rs CHANGED Viewed

@@ -10,37 +10,4 @@ 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, delete, get, head, html, options, patch, post, put, rsx, view};
+pub use tide_jsx_impl::{component, html, 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,9 +253,7 @@ mod other {
 }
 mod integration {
-    use crate::{component, rsx, view};
-    use tide::Request;
+    use crate::view;
-    use tide_jsx::{delete, get, patch, post, put, routes};
     use tide_testing::TideTestingExt;
     #[async_std::test]
@@ -279,164 +277,4 @@ 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`
- --> tests/ui/fail/unexpected-attribute.rs:9:22
+ --> $DIR/unexpected-attribute.rs:9:22
   |
 9 |     html! { <Heading t={"Hello world!"} /> };
   |                      ^ `Heading<'_>` does not have this field
   |
-  = note: all struct fields are already assigned
+  = note: available fields are: `title`

~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

HEAD -> master

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