feat: add extension attributes

vidhanio · vidhanio · commit e499a371d906 · 2023-07-28T23:54:44.000-04:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,4 +13,4 @@ resolver = "2"
     license = "MIT"
     readme = "README.md"
     repository = "https://github.com/vidhanio/html-node"
-    version = "0.1.16"
+    version = "0.1.17"
diff --git a/README.md b/README.md
@@ -6,7 +6,7 @@ A HTML to node macro powered by [rstml](https://github.com/rs-tml/rstml).
 
 - Text escaping
 - Pretty-printing
-- type-safe elements and attributes
+- T``ype-safe elements and attributes
   - completely optional, and can be mixed with untyped elements when needed!
 
 ## Example
diff --git a/html-node-core/src/typed/mod.rs b/html-node-core/src/typed/mod.rs
@@ -18,8 +18,7 @@ pub trait TypedElement: Default {
     /// Create an element from its attributes.
     fn from_attributes(
         attributes: Self::Attributes,
-        data_attributes: Vec<(String, Option<String>)>,
-        aria_attributes: Vec<(String, Option<String>)>,
+        other_attributes: Vec<(String, Option<String>)>,
     ) -> Self;
 
     /// Convert the typed element into an [`Element`].
@@ -57,7 +56,7 @@ macro_rules! typed_elements {
 macro_rules! typed_element {
     ($vis:vis $ElementName:ident $(($name:literal))? $([$AttributeName:ident])? $({ $($attribute:ident $(: $atype:ty)?),* $(,)? })?) => {
         $crate::typed_attributes!{
-            $vis $ElementName $([$vis $AttributeName])? $({
+            ($vis $ElementName) $([$vis $AttributeName])? $({
                 accesskey,
                 autocapitalize,
                 autofocus,
@@ -98,26 +97,23 @@ macro_rules! typed_element {
         #[allow(missing_docs)]
         $vis struct $ElementName {
             $vis attributes: <Self as $crate::typed::TypedElement>::Attributes,
-            $vis data_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
-            $vis aria_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
+            $vis other_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
         }
 
         impl $crate::typed::TypedElement for $ElementName {
             const NAME: &'static str = $crate::typed_element!(@NAME_STR $ElementName$(($name))?);
-            type Attributes = $crate::typed_attributes!(@NAME $ElementName $([$AttributeName])?);
+            type Attributes = $crate::typed_attributes!(@NAME ($ElementName) $([$AttributeName])?);
 
             fn from_attributes(
                 attributes: Self::Attributes,
-                data_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
-                aria_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
+                other_attributes: ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)>,
             ) -> Self {
-                Self { attributes, data_attributes, aria_attributes }
+                Self { attributes, other_attributes }
             }
 
             fn into_element(mut self, children: ::std::option::Option<::std::vec::Vec<$crate::Node>>) -> $crate::Element {
                 let mut attributes = $crate::typed::TypedAttributes::into_attributes(self.attributes);
-                attributes.append(&mut self.data_attributes);
-                attributes.append(&mut self.aria_attributes);
+                attributes.append(&mut self.other_attributes);
 
                 $crate::Element {
                     name: Self::NAME.into(),
@@ -139,13 +135,13 @@ macro_rules! typed_element {
 #[macro_export]
 macro_rules! typed_attributes {
     {
-        $($vise:vis $ElementName:ident)? $([$visa:vis $AttributeName:ident])? {
+        $(($vise:vis $ElementName:ident))? $([$visa:vis $AttributeName:ident])? {
             $($attribute:ident $(: $atype:ty)?),* $(,)?
         }
     } => {
-        $crate::typed_attributes!(@STRUCT $($vise $ElementName)? $([$visa $AttributeName])? { $($attribute $(: $atype)?),* });
+        $crate::typed_attributes!(@STRUCT $(($vise $ElementName))? $([$visa $AttributeName])? { $($attribute $(: $atype)?),* });
 
-        impl $crate::typed::TypedAttributes for $crate::typed_attributes!(@NAME $($ElementName)? $([$AttributeName])?) {
+        impl $crate::typed::TypedAttributes for $crate::typed_attributes!(@NAME $(($ElementName))? $([$AttributeName])?) {
             fn into_attributes(self) -> ::std::vec::Vec<(::std::string::String, ::std::option::Option<::std::string::String>)> {
                 [$((::std::stringify!($attribute), self.$attribute.map(|opt| opt.map(|a| ::std::string::ToString::to_string(&a))))),*]
                     .into_iter()
@@ -156,15 +152,15 @@ macro_rules! typed_attributes {
             }
         }
     };
-    ($($_vise:vis $_ElementName:ident)? $([$_visa:vis $_AttributeName:ident])?) => {};
-    (@NAME $ElementName:ident) => {
+    (($_vise:vis $_ElementName:ident) $([$_visa:vis $_AttributeName:ident])?) => {};
+    (@NAME ($ElementName:ident)) => {
         $crate::typed::paste!([< $ElementName:camel Attributes >])
     };
-    (@NAME $ElementName:ident [$AttributeName:ident]) => {
+    (@NAME $(($ElementName:ident))? [$AttributeName:ident]) => {
         $AttributeName
     };
     {
-        @STRUCT $vis:vis $ElementName:ident {
+        @STRUCT ($vis:vis $ElementName:ident) {
             $($attribute:ident $(:$atype:ty)?),* $(,)?
         }
     } => {
@@ -177,7 +173,7 @@ macro_rules! typed_attributes {
         }
     };
     {
-        @STRUCT $_vis:vis $ElementName:ident [$vis:vis $AttributeName:ident] {
+        @STRUCT $(($_vis:vis $ElementName:ident))? [$vis:vis $AttributeName:ident] {
             $($attribute:ident $(: $atype:ty)?),* $(,)?
         }
     } => {
diff --git a/html-node-macro/Cargo.toml b/html-node-macro/Cargo.toml
@@ -24,6 +24,7 @@ proc-macro2-diagnostics = { version = "0.10", default-features = false }
 quote = "1"
 rstml = { version = "0.11", default-features = false }
 syn = "2"
+syn_derive = { version = "0.1", optional = true }
 
 [features]
-typed = []
+typed = ["dep:syn_derive"]
diff --git a/html-node-macro/src/lib.rs b/html-node-macro/src/lib.rs
@@ -7,30 +7,98 @@
 
 mod node_handlers;
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 use node_handlers::{
     handle_block, handle_comment, handle_doctype, handle_element, handle_fragment, handle_raw_text,
     handle_text,
 };
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
+use proc_macro2::{Ident, TokenStream as TokenStream2};
 use proc_macro2_diagnostics::Diagnostic;
 use quote::quote;
 use rstml::{node::Node, Parser, ParserConfig};
+use syn::Type;
 
 #[proc_macro]
 pub fn html(tokens: TokenStream) -> TokenStream {
-    html_inner(tokens, false)
+    html_inner(tokens.into(), None)
 }
 
 #[cfg(feature = "typed")]
 #[proc_macro]
 pub fn typed_html(tokens: TokenStream) -> TokenStream {
-    html_inner(tokens, true)
+    use syn::{punctuated::Punctuated, token::Paren, Token};
+
+    #[derive(syn_derive::Parse)]
+    struct ColonAndType {
+        _colon_token: syn::Token![:],
+        ty: Type,
+    }
+
+    #[derive(syn_derive::Parse)]
+    enum MaybeColonAndType {
+        #[parse(peek = Token![:])]
+        ColonAndType(ColonAndType),
+        Nothing,
+    }
+
+    #[derive(syn_derive::Parse)]
+    struct Extension {
+        prefix: Ident,
+        colon_and_type: MaybeColonAndType,
+    }
+
+    #[derive(syn_derive::Parse)]
+    struct Extensions {
+        #[syn(parenthesized)]
+        #[allow(dead_code)]
+        paren_token: Paren,
+
+        #[syn(in = paren_token)]
+        #[parse(Punctuated::parse_terminated)]
+        extensions: Punctuated<Extension, syn::Token![,]>,
+    }
+
+    #[derive(syn_derive::Parse)]
+    enum MaybeExtensions {
+        #[parse(peek = Paren)]
+        Extensions(Extensions),
+        Nothing,
+    }
+
+    #[derive(syn_derive::Parse)]
+    struct TypedHtmlOptions {
+        extensions: MaybeExtensions,
+        tokens: TokenStream2,
+    }
+
+    let options = syn::parse_macro_input!(tokens as TypedHtmlOptions);
+
+    let mut extensions = match options.extensions {
+        MaybeExtensions::Extensions(extensions) => extensions
+            .extensions
+            .into_iter()
+            .map(|extension| match extension.colon_and_type {
+                MaybeColonAndType::ColonAndType(ColonAndType { ty, .. }) => {
+                    (extension.prefix, Some(ty))
+                }
+                MaybeColonAndType::Nothing => (extension.prefix, None),
+            })
+            .collect::<HashMap<_, _>>(),
+        MaybeExtensions::Nothing => HashMap::new(),
+    };
+
+    extensions.insert(Ident::new("data", proc_macro2::Span::call_site()), None);
+    extensions.insert(Ident::new("aria", proc_macro2::Span::call_site()), None);
+
+    html_inner(options.tokens, Some(&extensions))
 }
 
-fn html_inner(tokens: TokenStream, typed: bool) -> TokenStream {
+fn html_inner(
+    tokens: TokenStream2,
+    extensions: Option<&HashMap<Ident, Option<Type>>>,
+) -> TokenStream {
     // from: https://html.spec.whatwg.org/dev/syntax.html#void-elements
     let void_elements = [
         "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source",
@@ -50,7 +118,7 @@ fn html_inner(tokens: TokenStream, typed: bool) -> TokenStream {
     let parser = Parser::new(config);
     let (parsed_nodes, parsing_diagnostics) = parser.parse_recoverable(tokens).split_vec();
     let (tokenized_nodes, tokenization_diagnostics) =
-        tokenize_nodes(&void_elements, typed, &parsed_nodes);
+        tokenize_nodes(&void_elements, extensions, &parsed_nodes);
 
     let node = match &*tokenized_nodes {
         [node] => quote!(#node),
@@ -81,16 +149,16 @@ fn html_inner(tokens: TokenStream, typed: bool) -> TokenStream {
 
 fn tokenize_nodes(
     void_elements: &HashSet<&str>,
-    typed: bool,
+    extensions: Option<&HashMap<Ident, Option<Type>>>,
     nodes: &[Node],
 ) -> (Vec<TokenStream2>, Vec<Diagnostic>) {
     let (token_streams, diagnostics) = nodes
         .iter()
         .map(|node| match node {
             Node::Comment(comment) => (handle_comment(comment), vec![]),
             Node::Doctype(doctype) => (handle_doctype(doctype), vec![]),
-            Node::Fragment(fragment) => handle_fragment(void_elements, typed, fragment),
-            Node::Element(element) => handle_element(void_elements, typed, element),
+            Node::Fragment(fragment) => handle_fragment(void_elements, extensions, fragment),
+            Node::Element(element) => handle_element(void_elements, extensions, element),
             Node::Block(block) => (handle_block(block), vec![]),
             Node::Text(text) => (handle_text(text), vec![]),
             Node::RawText(text) => (handle_raw_text(text), vec![]),
diff --git a/html-node-macro/src/node_handlers/mod.rs b/html-node-macro/src/node_handlers/mod.rs
@@ -1,16 +1,16 @@
 #[cfg(feature = "typed")]
 mod typed;
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
-use proc_macro2::{Literal, TokenStream as TokenStream2};
+use proc_macro2::{Ident, Literal, TokenStream as TokenStream2};
 use proc_macro2_diagnostics::{Diagnostic, SpanDiagnosticExt};
 use quote::{quote, ToTokens};
 use rstml::node::{
     KeyedAttribute, NodeAttribute, NodeBlock, NodeComment, NodeDoctype, NodeElement, NodeFragment,
     NodeName, NodeText, RawText,
 };
-use syn::spanned::Spanned;
+use syn::{spanned::Spanned, Type};
 
 use crate::tokenize_nodes;
 
@@ -40,10 +40,11 @@ pub fn handle_doctype(doctype: &NodeDoctype) -> TokenStream2 {
 
 pub fn handle_fragment(
     void_elements: &HashSet<&str>,
-    typed: bool,
+    extensions: Option<&HashMap<Ident, Option<Type>>>,
     fragment: &NodeFragment,
 ) -> (TokenStream2, Vec<Diagnostic>) {
-    let (inner_nodes, inner_diagnostics) = tokenize_nodes(void_elements, typed, &fragment.children);
+    let (inner_nodes, inner_diagnostics) =
+        tokenize_nodes(void_elements, extensions, &fragment.children);
 
     let children = quote!(::std::vec![#(#inner_nodes),*]);
 
@@ -61,14 +62,13 @@ pub fn handle_fragment(
 
 pub fn handle_element(
     void_elements: &HashSet<&str>,
-    typed: bool,
+    extensions: Option<&HashMap<Ident, Option<Type>>>,
     element: &NodeElement,
 ) -> (TokenStream2, Vec<Diagnostic>) {
-    if typed {
-        typed::handle_element(void_elements, element)
-    } else {
-        handle_element_untyped(void_elements, element)
-    }
+    extensions.map_or_else(
+        || handle_element_untyped(void_elements, element),
+        |extensions| typed::handle_element(void_elements, extensions, element),
+    )
 }
 
 pub fn handle_element_untyped(
@@ -124,17 +124,17 @@ pub fn handle_element_untyped(
             }
         },
         void_elements,
-        false,
+        None,
         element,
     )
 }
 
 fn handle_element_inner<T>(
-    handle_block: fn(&NodeBlock) -> (T, Option<Diagnostic>),
-    handle_keyed: fn(&KeyedAttribute) -> (T, Option<Diagnostic>),
-    to_element: fn(&NodeElement, Vec<T>, TokenStream2) -> TokenStream2,
+    handle_block: impl Fn(&NodeBlock) -> (T, Option<Diagnostic>),
+    handle_keyed: impl Fn(&KeyedAttribute) -> (T, Option<Diagnostic>),
+    to_element: impl Fn(&NodeElement, Vec<T>, TokenStream2) -> TokenStream2,
     void_elements: &HashSet<&str>,
-    typed: bool,
+    extensions: Option<&HashMap<Ident, Option<Type>>>,
     element: &NodeElement,
 ) -> (TokenStream2, Vec<Diagnostic>) {
     let (attributes, attribute_diagnostics) = element
@@ -160,7 +160,7 @@ fn handle_element_inner<T>(
         (quote!(::std::option::Option::None), diagnostic)
     } else {
         let (inner_nodes, inner_diagnostics) =
-            tokenize_nodes(void_elements, typed, &element.children);
+            tokenize_nodes(void_elements, extensions, &element.children);
 
         (
             quote!(::std::option::Option::Some(::std::vec![#(#inner_nodes),*])),
@@ -224,11 +224,16 @@ fn node_name_to_literal(node_name: &NodeName) -> TokenStream2 {
 
 #[cfg(not(feature = "typed"))]
 mod typed {
-    use std::collections::HashSet;
+    use std::collections::{HashMap, HashSet};
 
     use rstml::node::NodeElement;
+    use syn::{Ident, Type};
 
-    pub fn handle_element(_void_elements: &HashSet<&str>, _element: &NodeElement) -> ! {
+    pub fn handle_element(
+        _void_elements: &HashSet<&str>,
+        _extensions: &HashMap<Ident, Option<Type>>,
+        _element: &NodeElement,
+    ) -> ! {
         unreachable!("`typed::handle_element` should be unreachable without the `typed` feature")
     }
 }
diff --git a/html-node-macro/src/node_handlers/typed.rs b/html-node-macro/src/node_handlers/typed.rs
diff --git a/html-node/src/lib.rs b/html-node/src/lib.rs
diff --git a/html-node/src/typed.rs b/html-node/src/typed.rs
