cc58dd1 | tide-jsx

git clone https://git.pyrossh.dev/tide-jsx

Tide + JSX

cc58dd1 — Gal Schlezinger 2019-09-21T08:30:36+03:00

initial implementation

Files changed (15) hide show

.gitignore +2 -0
Cargo.lock +61 -0
Cargo.toml +7 -0
render/Cargo.toml +10 -0
render/src/fragment.rs +28 -0
render/src/html.rs +28 -0
render/src/lib.rs +10 -0
render/src/renderable.rs +41 -0
render/src/simple_element.rs +41 -0
render/src/text_element.rs +13 -0
render_macros/Cargo.toml +15 -0
render_macros/src/element_attribute.rs +52 -0
render_macros/src/lib.rs +220 -0
render_tests/Cargo.toml +11 -0
render_tests/src/lib.rs +46 -0

.gitignore ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ target
2	+ */.rs.bk

Cargo.lock ADDED Viewed

@@ -0,0 +1,61 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "proc-macro2"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "quote"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "render"
+version = "0.1.0"
+dependencies = [
+ "render_macros 0.1.0",
+]
+[[package]]
+name = "render_macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "render_tests"
+version = "0.1.0"
+dependencies = [
+ "render 0.1.0",
+]
+[[package]]
+name = "syn"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro2 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+[metadata]
+"checksum proc-macro2 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "e98a83a9f9b331f54b924e68a66acb1bb35cb01fb0a23645139967abefb697e8"
+"checksum quote 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe"
+"checksum syn 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "66850e97125af79138385e9b88339cbcd037e3f28ceab8c5ad98e64f0f1f80bf"
+"checksum unicode-xid 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"

Cargo.toml ADDED Viewed

@@ -0,0 +1,7 @@
+[workspace]
+members = [
+    "render",
+    "render_macros",
+    "render_tests",
+]

render/Cargo.toml ADDED Viewed

@@ -0,0 +1,10 @@
+[package]
+name = "render"
+version = "0.1.0"
+authors = ["Gal Schlezinger <[email protected]>"]
+edition = "2018"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+render_macros = { path = "../render_macros" }

render/src/fragment.rs ADDED Viewed

@@ -0,0 +1,28 @@
+use crate::Renderable;
+/// A top-level root component to combine a same-level components
+/// in a RSX fashion
+///
+/// ```rust
+/// # #![feature(proc_macro_hygiene)]
+/// # use render::html::HTML5Doctype;
+/// # use render_macros::html;
+/// # use render::fragment::Fragment;
+/// let result = html! {
+///     <Fragment>
+///         <a />
+///         <b />
+///     </Fragment>
+/// };
+/// assert_eq!(result, "<a /><b />");
+/// ```
+#[derive(Debug)]
+pub struct Fragment<T: Renderable> {
+    pub children: T,
+}
+impl<T: Renderable> Renderable for Fragment<T> {
+    fn render(self) -> String {
+        self.children.render()
+    }
+}

render/src/html.rs ADDED Viewed

@@ -0,0 +1,28 @@
+use crate::Renderable;
+/// HTML 5 doctype declaration
+///
+/// ```rust
+/// # #![feature(proc_macro_hygiene)]
+/// # use render::html::HTML5Doctype;
+/// # use render::html;
+/// # use render::fragment::Fragment;
+/// # let result =
+/// html! {
+///     <Fragment>
+///         <HTML5Doctype />
+///         <html>
+///             <body />
+///         </html>
+///     </Fragment>
+/// };
+/// # assert_eq!(result, "<!DOCTYPE html><html><body /></html>");
+/// ```
+#[derive(Debug)]
+pub struct HTML5Doctype;
+impl Renderable for HTML5Doctype {
+    fn render(self) -> String {
+        "<!DOCTYPE html>".to_string()
+    }
+}

render/src/lib.rs ADDED Viewed

@@ -0,0 +1,10 @@
+pub mod fragment;
+pub mod html;
+mod renderable;
+mod simple_element;
+mod text_element;
+pub use fragment::Fragment;
+pub use renderable::Renderable;
+pub use render_macros::{html, rsx};
+pub use simple_element::SimpleElement;

render/src/renderable.rs ADDED Viewed

@@ -0,0 +1,41 @@
+/// A renderable component
+pub trait Renderable: core::fmt::Debug + Sized {
+    /// Render the component to the HTML representation.
+    ///
+    /// Mostly done using the `html!` macro to generate strings
+    /// by composing tags.
+    fn render(self) -> String;
+}
+impl Renderable for () {
+    fn render(self) -> String {
+        "".to_string()
+    }
+}
+impl<A: Renderable, B: Renderable> Renderable for (A, B) {
+    fn render(self) -> String {
+        format!("{}{}", self.0.render(), self.1.render())
+    }
+}
+impl<A: Renderable, B: Renderable, C: Renderable> Renderable for (A, B, C) {
+    fn render(self) -> String {
+        ((self.0, self.1), self.2).render()
+    }
+}
+impl<A: Renderable, B: Renderable, C: Renderable, D: Renderable> Renderable for (A, B, C, D) {
+    fn render(self) -> String {
+        ((self.0, self.1), (self.2, self.3)).render()
+    }
+}
+impl<T: Renderable> Renderable for Option<T> {
+    fn render(self) -> String {
+        match self {
+            None => "".to_string(),
+            Some(x) => x.render(),
+        }
+    }
+}

render/src/simple_element.rs ADDED Viewed

@@ -0,0 +1,41 @@
+use crate::Renderable;
+use std::collections::HashMap;
+/// Simple HTML element tag
+#[derive(Debug)]
+pub struct SimpleElement<'a, T: Renderable> {
+    /// the HTML tag name, like `html`, `head`, `body`, `link`...
+    pub tag_name: &'a str,
+    pub attributes: Option<HashMap<&'a str, &'a str>>,
+    pub contents: Option<T>,
+}
+fn attributes_to_string<Key: std::fmt::Display + std::hash::Hash, Value: std::fmt::Debug>(
+    opt: &Option<HashMap<Key, Value>>,
+) -> String {
+    match opt {
+        None => "".to_string(),
+        Some(map) => {
+            let s: String = map
+                .iter()
+                .map(|(key, value)| format!(" {}={:?}", key, value))
+                .collect();
+            s
+        }
+    }
+}
+impl<'a, T: Renderable> Renderable for SimpleElement<'a, T> {
+    fn render(self) -> String {
+        let attrs = attributes_to_string(&self.attributes);
+        match self.contents {
+            None => format!("<{}{} />", self.tag_name, attrs),
+            Some(renderable) => format!(
+                "<{tag_name}{attrs}>{contents}</{tag_name}>",
+                tag_name = self.tag_name,
+                attrs = attrs,
+                contents = renderable.render()
+            ),
+        }
+    }
+}

render/src/text_element.rs ADDED Viewed

@@ -0,0 +1,13 @@
+use crate::Renderable;
+impl Renderable for String {
+    fn render(self) -> String {
+        self
+    }
+}
+impl Renderable for &str {
+    fn render(self) -> String {
+        self.to_string()
+    }
+}

render_macros/Cargo.toml ADDED Viewed

@@ -0,0 +1,15 @@
+[package]
+name = "render_macros"
+version = "0.1.0"
+authors = ["Gal Schlezinger <[email protected]>"]
+edition = "2018"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+proc-macro = true
+[dependencies]
+syn = { version = "1.0", features = ["full"] }
+quote = "1.0"
+proc-macro2 = "1.0"

render_macros/src/element_attribute.rs ADDED Viewed

@@ -0,0 +1,52 @@
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+pub enum ElementAttribute {
+    Punned(syn::Ident),
+    WithValue(syn::Ident, syn::Block),
+}
+impl ElementAttribute {
+    pub fn ident(&self) -> &syn::Ident {
+        match self {
+            Self::Punned(ident) | Self::WithValue(ident, _) => ident,
+        }
+    }
+    pub fn value_tokens(&self) -> proc_macro2::TokenStream {
+        match self {
+            Self::WithValue(_, value) => quote!(#value),
+            Self::Punned(ident) => quote!(#ident),
+        }
+    }
+}
+impl PartialEq for ElementAttribute {
+    fn eq(&self, other: &Self) -> bool {
+        self.ident() == other.ident()
+    }
+}
+impl Eq for ElementAttribute {}
+impl std::hash::Hash for ElementAttribute {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        std::hash::Hash::hash(self.ident(), state)
+    }
+}
+impl Parse for ElementAttribute {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let name = input.parse::<syn::Ident>()?;
+        let not_punned = input.peek(syn::Token![=]);
+        if !not_punned {
+            return Ok(Self::Punned(name));
+        }
+        input.parse::<syn::Token![=]>()?;
+        let value = input.parse::<syn::Block>()?;
+        Ok(Self::WithValue(name, value))
+    }
+}

render_macros/src/lib.rs ADDED Viewed

@@ -0,0 +1,220 @@
+#![feature(proc_macro_diagnostic, proc_macro_hygiene)]
+// TODO: Extract a `Children` struct that can implement `Parse` and `ToTokens`:
+// - `Parse` will do the nasty things inside `Element`
+// - `ToTokens` will do the trick with the tuples
+extern crate proc_macro;
+mod element_attribute;
+use element_attribute::ElementAttribute;
+use proc_macro::TokenStream;
+use quote::{quote, ToTokens};
+use std::collections::HashSet;
+use syn::parse::{Parse, ParseStream, Result};
+use syn::parse_macro_input;
+struct Element {
+    name: syn::Ident,
+    attributes: HashSet<ElementAttribute>,
+    children: Vec<RenderableItem>,
+}
+enum RenderableItem {
+    Element(Element),
+    RawBlock(syn::Block),
+}
+impl ToTokens for RenderableItem {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        match self {
+            Self::Element(element) => element.to_tokens(tokens),
+            Self::RawBlock(block) => {
+                let ts = quote! { #block };
+                ts.to_tokens(tokens);
+            }
+        }
+    }
+}
+impl Parse for RenderableItem {
+    fn parse(input: ParseStream) -> Result<Self> {
+        match input.parse::<Element>() {
+            Ok(element) => Ok(Self::Element(element)),
+            Err(_) => {
+                let block = input.parse::<syn::Block>()?;
+                Ok(Self::RawBlock(block))
+            }
+        }
+    }
+}
+impl Parse for Element {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut attributes: HashSet<ElementAttribute> = HashSet::new();
+        let _starts_a_tag = input.parse::<syn::Token![<]>().is_ok();
+        let name = input.parse()?;
+        while input.peek(syn::Ident) {
+            if let Ok(attribute) = input.parse::<ElementAttribute>() {
+                if attributes.contains(&attribute) {
+                    let error_message = format!(
+                        "There is a previous definition of the {} attribute",
+                        attribute.ident()
+                    );
+                    attribute
+                        .ident()
+                        .span()
+                        .unwrap()
+                        .warning(error_message)
+                        .emit();
+                }
+                attributes.insert(attribute);
+            }
+        }
+        let can_have_contents = input.parse::<syn::Token![/]>().is_err();
+        input.parse::<syn::Token![>]>()?;
+        let mut children = vec![];
+        if can_have_contents {
+            while !input.peek(syn::Token![<]) || !input.peek2(syn::Token![/]) {
+                if let Ok(child) = input.parse::<RenderableItem>() {
+                    children.push(child);
+                }
+            }
+            // parse closing
+            input.parse::<syn::Token![<]>()?;
+            input.parse::<syn::Token![/]>()?;
+            let closing_name: syn::Ident = input.parse()?;
+            if closing_name != name {
+                let error_message = format!("Expected closing tag for: <{}>", &name);
+                closing_name.span().unwrap().error(error_message).emit();
+            }
+            input.parse::<syn::Token![>]>()?;
+        }
+        Ok(Element {
+            name,
+            attributes,
+            children,
+        })
+    }
+}
+impl Element {
+    pub fn is_custom_element(&self) -> bool {
+        let name = self.name.to_string();
+        let first_letter = name.get(0..1).unwrap();
+        first_letter.to_uppercase() == first_letter
+    }
+}
+impl ToTokens for Element {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Element { name, children, .. } = self;
+        let children_quotes: Vec<_> = children
+            .iter()
+            .map(|child| {
+                quote! { #child }
+            })
+            .collect();
+        let children_tuple = match children_quotes.len() {
+            0 => quote! { Option::<()>::None },
+            1 => quote! { Some(#(#children_quotes)*) },
+            _ => {
+                let mut iter = children_quotes.iter();
+                let first = iter.next().unwrap();
+                let second = iter.next().unwrap();
+                let tuple_of_tuples = iter.fold(
+                    quote!((#first, #second)),
+                    |renderable, current| quote!((#current, #renderable)),
+                );
+                quote! { Some(#tuple_of_tuples) }
+            }
+        };
+        let declaration = if self.is_custom_element() {
+            let mut attrs: Vec<_> = self
+                .attributes
+                .iter()
+                .map(|attribute| {
+                    let ident = attribute.ident();
+                    let value = attribute.value_tokens();
+                    quote! {
+                        #ident: #value
+                    }
+                })
+                .collect();
+            if children_quotes.len() > 0 {
+                attrs.push(quote! {
+                    children: #children_tuple
+                });
+            }
+            if attrs.len() == 0 {
+                quote! { #name }
+            } else {
+                quote! {
+                    #name {
+                        #(#attrs),*
+                    }
+                }
+            }
+        } else {
+            let attrs: Vec<_> = self
+                .attributes
+                .iter()
+                .map(|attribute| {
+                    let ident = attribute.ident();
+                    let value = attribute.value_tokens();
+                    quote! {
+                        hm.insert(stringify!(#ident), #value);
+                    }
+                })
+                .collect();
+            let attributes_value = if self.attributes.len() == 0 {
+                quote!(None)
+            } else {
+                quote! {{
+                    let mut hm = std::collections::HashMap::<&str, &str>::new();
+                    #(#attrs)*
+                    Some(hm)
+                }}
+            };
+            quote! {
+                ::render::SimpleElement {
+                    tag_name: stringify!(#name),
+                    attributes: #attributes_value,
+                    contents: #children_tuple,
+                }
+            }
+        };
+        declaration.to_tokens(tokens);
+    }
+}
+/// Render a component tree to an HTML string
+#[proc_macro]
+pub fn html(input: TokenStream) -> TokenStream {
+    let el = proc_macro2::TokenStream::from(rsx(input));
+    let result = quote! { ::render::Renderable::render(#el) };
+    TokenStream::from(result)
+}
+/// Generate a renderable component tree
+#[proc_macro]
+pub fn rsx(input: TokenStream) -> TokenStream {
+    let el = parse_macro_input!(input as Element);
+    let result = quote! { #el };
+    TokenStream::from(result)
+}

render_tests/Cargo.toml ADDED Viewed

@@ -0,0 +1,11 @@
+[package]
+name = "render_tests"
+version = "0.1.0"
+authors = ["Gal Schlezinger <[email protected]>"]
+edition = "2018"
+publish = false
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+render = { path = "../render" }

render_tests/src/lib.rs ADDED Viewed

@@ -0,0 +1,46 @@
+#![feature(proc_macro_hygiene)]
+use render::html::HTML5Doctype;
+use render::{html, rsx, Renderable, Fragment};
+#[derive(Debug)]
+struct Hello<'a, T: Renderable> {
+    world: &'a str,
+    yes: i32,
+    children: T,
+}
+impl<'a, T: Renderable> Renderable for Hello<'a, T> {
+    fn render(self) -> String {
+        html! {
+            <b class={"some_bem_class"}>
+                {format!("{}", self.world)}
+                <br />
+                {format!("A number: {}", self.yes)}
+                {self.children}
+            </b>
+        }
+    }
+}
+pub fn it_works() -> String {
+    let world = "hello";
+    let other_value = rsx! {
+        <em>{format!("hello world?")}</em>
+    };
+    let value = html! {
+        <Fragment>
+            <HTML5Doctype />
+            <Hello world yes={1 + 1}>
+                <div>{format!("HEY!")}</div>
+                {other_value}
+            </Hello>
+        </Fragment>
+    };
+    value
+}
+#[test]
+pub fn verify_works() {
+    println!("{}", it_works());
+}

tide-jsx v0.4.0

git clone https://git.pyrossh.dev/tide-jsx

Tide + JSX