tide-jsx

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

Tide + JSX

6534ef8a — Gal Schlezinger

Refactor proc macro to multiple structs (#1)

Files changed (6) hide show

render_macros/src/child.rs +32 -0
render_macros/src/children.rs +63 -0
render_macros/src/element.rs +63 -0
render_macros/src/element_attributes.rs +127 -0
render_macros/src/lib.rs +7 -196
render_macros/src/tags.rs +47 -0

render_macros/src/child.rs ADDED Viewed

@@ -0,0 +1,32 @@
+use crate::element::Element;
+use quote::{quote, ToTokens};
+use syn::parse::{Parse, ParseStream, Result};
+pub enum Child {
+    Element(Element),
+    RawBlock(syn::Block),
+}
+impl ToTokens for Child {
+    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 Child {
+    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))
+            }
+        }
+    }
+}

render_macros/src/children.rs ADDED Viewed

@@ -0,0 +1,63 @@
+use crate::child::Child;
+use quote::{quote, ToTokens};
+use syn::parse::{Parse, ParseStream, Result};
+#[derive(Default)]
+pub struct Children {
+    pub nodes: Vec<Child>,
+}
+impl Children {
+    pub fn new(nodes: Vec<Child>) -> Self {
+        Children { nodes }
+    }
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+    pub fn as_option_of_tuples_tokens(&self) -> proc_macro2::TokenStream {
+        let children_quotes: Vec<_> = self
+            .nodes
+            .iter()
+            .map(|child| {
+                quote! { #child }
+            })
+            .collect();
+        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) }
+            }
+        }
+    }
+}
+impl Parse for Children {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut nodes = vec![];
+        while !input.peek(syn::Token![<]) || !input.peek2(syn::Token![/]) {
+            if let Ok(child) = input.parse::<Child>() {
+                nodes.push(child);
+            }
+        }
+        Ok(Self::new(nodes))
+    }
+}
+impl ToTokens for Children {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        self.as_option_of_tuples_tokens().to_tokens(tokens);
+    }
+}

render_macros/src/element.rs ADDED Viewed

@@ -0,0 +1,63 @@
+use crate::children::Children;
+use crate::element_attributes::ElementAttributes;
+use crate::tags::{ClosingTag, OpenTag};
+use quote::{quote, ToTokens};
+use syn::parse::{Parse, ParseStream, Result};
+pub struct Element {
+    name: syn::Ident,
+    attributes: ElementAttributes,
+    children: Children,
+}
+impl Parse for Element {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let open_tag = input.parse::<OpenTag>()?;
+        let children = if open_tag.self_closing {
+            Children::default()
+        } else {
+            let children = input.parse::<Children>()?;
+            let closing_tag = input.parse::<ClosingTag>()?;
+            closing_tag.validate(&open_tag);
+            children
+        };
+        Ok(Element {
+            name: open_tag.name,
+            attributes: open_tag.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 name = &self.name;
+        let declaration = if self.is_custom_element() {
+            let attrs = self.attributes.for_custom_element(&self.children);
+            quote! { #name #attrs }
+        } else {
+            let attrs = self.attributes.for_simple_element();
+            let children_tuple = self.children.as_option_of_tuples_tokens();
+            quote! {
+                ::render::SimpleElement {
+                    tag_name: stringify!(#name),
+                    attributes: #attrs,
+                    contents: #children_tuple,
+                }
+            }
+        };
+        declaration.to_tokens(tokens);
+    }
+}

render_macros/src/element_attributes.rs ADDED Viewed

@@ -0,0 +1,127 @@
+use crate::children::Children;
+use crate::element_attribute::ElementAttribute;
+use quote::{quote, ToTokens};
+use std::collections::HashSet;
+use syn::parse::{Parse, ParseStream, Result};
+pub type Attributes = HashSet<ElementAttribute>;
+pub struct ElementAttributes {
+    pub attributes: Attributes,
+}
+impl ElementAttributes {
+    pub fn new(attributes: Attributes) -> Self {
+        Self { attributes }
+    }
+    pub fn for_custom_element<'c>(
+        &self,
+        children: &'c Children,
+    ) -> CustomElementAttributes<'_, 'c> {
+        CustomElementAttributes {
+            attributes: &self.attributes,
+            children,
+        }
+    }
+    pub fn for_simple_element(&self) -> SimpleElementAttributes<'_> {
+        SimpleElementAttributes {
+            attributes: &self.attributes,
+        }
+    }
+}
+impl Parse for ElementAttributes {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut attributes: HashSet<ElementAttribute> = HashSet::new();
+        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);
+            }
+        }
+        Ok(ElementAttributes::new(attributes))
+    }
+}
+pub struct CustomElementAttributes<'a, 'c> {
+    attributes: &'a Attributes,
+    children: &'c Children,
+}
+impl<'a, 'c> ToTokens for CustomElementAttributes<'a, 'c> {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let mut attrs: Vec<_> = self
+            .attributes
+            .iter()
+            .map(|attribute| {
+                let ident = attribute.ident();
+                let value = attribute.value_tokens();
+                quote! {
+                    #ident: #value
+                }
+            })
+            .collect();
+        if self.children.len() > 0 {
+            let children_tuple = self.children.as_option_of_tuples_tokens();
+            attrs.push(quote! {
+                children: #children_tuple
+            });
+        }
+        let quoted = if attrs.len() == 0 {
+            quote!()
+        } else {
+            quote!({ #(#attrs),* })
+        };
+        quoted.to_tokens(tokens);
+    }
+}
+pub struct SimpleElementAttributes<'a> {
+    attributes: &'a Attributes,
+}
+impl<'a> ToTokens for SimpleElementAttributes<'a> {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        if self.attributes.is_empty() {
+            quote!(None).to_tokens(tokens);
+        } 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 hashmap_declaration = quote! {{
+                let mut hm = std::collections::HashMap::<&str, &str>::new();
+                #(#attrs)*
+                Some(hm)
+            }};
+            hashmap_declaration.to_tokens(tokens);
+        }
+    }
+}

render_macros/src/lib.rs CHANGED Viewed

@@ -1,208 +1,19 @@
 #![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 child;
+mod children;
+mod element;
 mod element_attribute;
+mod element_attributes;
+mod tags;
-use element_attribute::ElementAttribute;
+use element::Element;
 use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
+use quote::quote;
-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 {

render_macros/src/tags.rs ADDED Viewed

@@ -0,0 +1,47 @@
+use crate::element_attributes::ElementAttributes;
+use syn::parse::{Parse, ParseStream, Result};
+pub struct OpenTag {
+    pub name: syn::Ident,
+    pub attributes: ElementAttributes,
+    pub self_closing: bool,
+}
+impl Parse for OpenTag {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let _starts_a_tag = input.parse::<syn::Token![<]>().is_ok();
+        let name = input.parse()?;
+        let attributes = input.parse::<ElementAttributes>()?;
+        let self_closing = input.parse::<syn::Token![/]>().is_ok();
+        input.parse::<syn::Token![>]>()?;
+        Ok(Self {
+            name,
+            attributes,
+            self_closing,
+        })
+    }
+}
+pub struct ClosingTag {
+    name: syn::Ident,
+}
+impl ClosingTag {
+    pub fn validate(&self, open_tag: &OpenTag) {
+        if self.name != open_tag.name {
+            let error_message = format!("Expected closing tag for: <{}>", &open_tag.name);
+            self.name.span().unwrap().error(error_message).emit();
+        }
+    }
+}
+impl Parse for ClosingTag {
+    fn parse(input: ParseStream) -> Result<Self> {
+        input.parse::<syn::Token![<]>()?;
+        input.parse::<syn::Token![/]>()?;
+        let name = input.parse::<syn::Ident>()?;
+        input.parse::<syn::Token![>]>()?;
+        Ok(Self { name })
+    }
+}

~repos /tide-jsx

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

Tide + JSX