Using builder for component instantiation

crates/hypertext-macros/src/derive.rs

@@ -1,6 +1,6 @@
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
-use syn::{DeriveInput, Error, spanned::Spanned};
+use syn::{Data, DeriveInput, Error, spanned::Spanned};
 
 use crate::{
     AttributeValue, Config, Document, Many, Maud, Rsx, Semantics,
@@ -132,3 +132,67 @@ fn renderable_attribute(input: &DeriveInput) -> syn::Result<Option<TokenStream>>
 
     Ok(Some(output))
 }
+
+#[allow(clippy::needless_pass_by_value)]
+pub fn default_builder(input: DeriveInput) -> syn::Result<TokenStream> {
+    let Data::Struct(data_struct) = &input.data else {
+        return Err(Error::new(
+            input.span(),
+            "#[derive(DefaultBuilder)] may only be used on structs",
+        ));
+    };
+
+    let struct_name = &input.ident;
+    let vis = &input.vis;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let mut methods = Vec::new();
+    for field in &data_struct.fields {
+        if let Some(name) = &field.ident {
+            let ty = &field.ty;
+
+            let is_skipped = field
+                .attrs
+                .iter()
+                .find(|attr| attr.path().is_ident("builder"))
+                .map_or(Ok(false), |builder_attr| {
+                    builder_attr
+                        .parse_nested_meta(|meta| {
+                            if meta.path.is_ident("skip") {
+                                return Ok(());
+                            }
+
+                            Err(meta.error("unexpected param for `#[builder(...)]`"))
+                        })
+                        .map(|()| true)
+                })?;
+
+            if !is_skipped {
+                methods.push(quote! {
+                    #[must_use]
+                    #vis fn #name(mut self, #name: #ty) -> Self {
+                        self.#name = #name;
+                        self
+                    }
+                });
+            }
+        }
+    }
+
+    let output = quote! {
+        #[automatically_derived]
+        impl #impl_generics #struct_name #ty_generics #where_clause {
+            #vis fn builder() -> Self {
+                <Self as ::core::default::Default>::default()
+            }
+
+            #vis fn build(self) -> Self {
+                self
+            }
+
+            #(#methods)*
+        }
+    };
+
+    Ok(output)
+}

crates/hypertext-macros/src/html/component.rs

@@ -1,9 +1,8 @@
 use proc_macro2::TokenStream;
-use quote::{ToTokens, quote, quote_spanned};
+use quote::{ToTokens, quote};
 use syn::{
     Ident, Lit, Token,
     parse::{Parse, ParseStream},
-    spanned::Spanned,
     token::{Brace, Paren},
 };
 
@@ -13,18 +12,17 @@ use crate::{AttributeValue, html::Node};
 pub struct Component<S: Syntax> {
     pub name: Ident,
     pub attrs: Vec<ComponentAttribute>,
-    pub dotdot: Option<Token![..]>,
     pub body: ElementBody<S>,
 }
 
 impl<S: Syntax> Generate for Component<S> {
     type Context = Node<S>;
 
     fn generate(&self, g: &mut Generator) {
-        let fields = self.attrs.iter().map(|attr| {
+        let props = self.attrs.iter().map(|attr| {
             let name = &attr.name;
             attr.value_expr()
-                .map_or_else(|| quote!(#name,), |value| quote!(#name: #value,))
+                .map_or_else(|| quote!(.#name(#name)), |value| quote!(.#name(#value)))
         });
 
         let children = match &self.body {
@@ -45,26 +43,19 @@ impl<S: Syntax> Generate for Component<S> {
                 let children_ident = Ident::new("children", self.name.span());
 
                 quote!(
-                    #children_ident: #lazy,
+                    .#children_ident(#lazy)
                 )
             }
             ElementBody::Void => quote!(),
         };
 
         let name = &self.name;
 
-        let default = self
-            .dotdot
-            .as_ref()
-            .map(|dotdot| quote_spanned!(dotdot.span()=> ..::core::default::Default::default()))
-            .unwrap_or_default();
-
         let init = quote! {
-            #name {
-                #(#fields)*
+            #name::builder()
+                #(#props)*
                 #children
-                #default
-            }
+                .build()
         };
 
         g.push_expr::<Self::Context>(Paren::default(), &init);

crates/hypertext-macros/src/html/syntaxes/maud.rs

@@ -131,7 +131,6 @@ impl Parse for Component<Maud> {
 
                 attrs
             },
-            dotdot: input.parse()?,
             body: input.parse()?,
         })
     }

crates/hypertext-macros/src/html/syntaxes/rsx.rs

@@ -32,16 +32,13 @@ impl Node<Rsx> {
             attrs.push(input.parse()?);
         }
 
-        let dotdot = input.parse()?;
-
         let solidus = input.parse::<Option<Token![/]>>()?;
         input.parse::<Token![>]>()?;
 
         if solidus.is_some() {
             Ok(Self::Component(Component {
                 name,
                 attrs,
-                dotdot,
                 body: ElementBody::Void,
             }))
         } else {
@@ -54,7 +51,6 @@ impl Node<Rsx> {
                         Self::Component(Component {
                             name,
                             attrs,
-                            dotdot,
                             body: ElementBody::Void,
                         }),
                     );
@@ -77,7 +73,6 @@ impl Node<Rsx> {
                     Self::Component(Component {
                         name,
                         attrs,
-                        dotdot,
                         body: ElementBody::Void,
                     }),
                 );
@@ -89,7 +84,6 @@ impl Node<Rsx> {
             Ok(Self::Component(Component {
                 name,
                 attrs,
-                dotdot,
                 body: ElementBody::Normal {
                     children: Many(children),
                     closing_name: Some(parse_quote!(#closing_name)),

crates/hypertext-macros/src/lib.rs

@@ -76,3 +76,10 @@ pub fn renderable(attr: TokenStream, item: TokenStream) -> TokenStream {
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }
+
+#[proc_macro_derive(DefaultBuilder, attributes(builder))]
+pub fn derive_default_builder(input: TokenStream) -> TokenStream {
+    derive::default_builder(parse_macro_input!(input))
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}