Merge pull request #54 from koenichiwa/feature/add-documentation

Feature/add documentation

const_typed_builder_derive/src/generator/builder_generator.rs

@@ -92,7 +92,13 @@ impl<'a> BuilderGenerator<'a> {
 
         let vis = self.target_vis;
 
+        let documentation = format!(
+            "Builder for [`{}`] derived using the `const_typed_builder` crate",
+            self.target_name
+        );
+
         quote!(
+            #[doc = #documentation]
             #vis struct #builder_name #impl_generics #where_clause {
                 #data_field: #data_name #type_generics
             }
@@ -121,16 +127,22 @@ impl<'a> BuilderGenerator<'a> {
 
         let type_generics = self.generics_gen.const_generics_valued(false);
         let (impl_generics, _, where_clause) = self.generics_gen.target_generics().split_for_impl();
+        let documentation = format!(
+            "Creates a new [`{}`] without any fields initialized",
+            self.builder_name
+        );
 
         quote!(
             impl #impl_generics #builder_name #type_generics #where_clause{
+                #[doc = #documentation]
                 pub fn new() -> #builder_name #type_generics {
                     Self::default()
                 }
             }
 
             impl #impl_generics Default for #builder_name #type_generics #where_clause {
                 fn default() -> Self {
+                    #[doc = #documentation]
                     #builder_name {
                         #data_field: #data_name::default(),
                     }
@@ -144,6 +156,10 @@ impl<'a> BuilderGenerator<'a> {
         let builder_name = self.builder_name;
         let target_name = self.target_name;
         let data_field = self.data_field_ident();
+        let documentation = format!(
+            "Build an instance of [`{}`], consuming the [`{}`]",
+            self.target_name, self.builder_name
+        );
         let (impl_generics, target_type_generics, where_clause) =
             self.generics_gen.target_generics().split_for_impl();
 
@@ -159,7 +175,7 @@ impl<'a> BuilderGenerator<'a> {
 
                             quote!(
                                 impl #impl_generics #builder_name #type_generics #where_clause{
-
+                                    #[doc = #documentation]
                                     pub fn build(self) -> #target_name #target_type_generics {
                                         self.#data_field.into()
                                     }
@@ -194,6 +210,7 @@ impl<'a> BuilderGenerator<'a> {
                         #correctness_verifier
                         #correctness_helper_fns
 
+                        #[doc = #documentation]
                         pub fn build(self) -> #target_name #target_type_generics {
                             #correctness_check
                             self.#data_field.into()
@@ -223,8 +240,20 @@ impl<'a> BuilderGenerator<'a> {
                 let input_type = self.field_gen.builder_set_impl_input_type(field);
                 let input_value = self.field_gen.builder_set_impl_input_value(field);
 
+                let documentation = format!(r#"
+Setter for the [`{}::{field_name}`] field.
+
+# Arguments
+
+- `{field_name}`: field to be set
+
+# Returns
+
+`Self` with `{field_name}` initialized"#, self.target_name);
+
                 let tokens = quote!(
                     impl #const_idents_impl #builder_name #const_idents_type_input #where_clause {
+                        #[doc = #documentation]
                         pub fn #field_name (self, #input_type) -> #builder_name #const_idents_type_output {
                             let mut #data_field = self.#data_field;
                             #data_field.#field_name = #input_value;

const_typed_builder_derive/src/generator/data_generator.rs

@@ -67,6 +67,7 @@ impl<'a> DataGenerator<'a> {
 
         let tokens = quote!(
             impl #impl_generics From<#data_name #type_generics> for #struct_name #type_generics #where_clause {
+                #[doc(hidden)]
                 fn from(data: #data_name #type_generics) -> #struct_name #type_generics {
                     #struct_name {
                         #(#from_fields),*
@@ -75,6 +76,7 @@ impl<'a> DataGenerator<'a> {
             }
 
             impl #impl_generics Default for #data_name #type_generics #where_clause {
+                #[doc(hidden)]
                 fn default() -> Self {
                     #data_name {
                         #def_fields
@@ -94,6 +96,7 @@ impl<'a> DataGenerator<'a> {
             self.generics_gen.target_generics().split_for_impl();
 
         let tokens = quote!(
+            #[doc(hidden)]
             pub struct #data_name #impl_generics #where_clause{
                 #(#fields),*
             }

const_typed_builder_derive/src/generator/target_generator.rs

@@ -48,14 +48,16 @@ impl<'a> TargetGenerator<'a> {
         let target_name = self.target_name;
         let builder_name = self.builder_name;
         let const_generics = self.generics_gen.const_generics_valued(false);
-        let _builder_generics = self.generics_gen.builder_struct_generics();
+        // let _builder_generics = self.generics_gen.builder_struct_generics();
         let (impl_generics, type_generics, where_clause) =
             self.generics_gen.target_generics().split_for_impl();
 
+        let documentation = format!("Creates an instance of [`{}`]", self.builder_name);
         quote! {
             impl #impl_generics Builder for #target_name #type_generics #where_clause {
                 type BuilderImpl = #builder_name #const_generics;
 
+                #[doc = #documentation]
                 fn builder() -> Self::BuilderImpl  {
                     Self::BuilderImpl::new()
                 }