parse: Move field parsing into separate method

Author: robin-nitrokey

src/parse.rs

@@ -1,4 +1,5 @@
 use proc_macro2::Span;
+use quote::ToTokens;
 use syn::meta::ParseNestedMeta;
 use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::{Data, DeriveInput, Fields, Generics, Ident, LitInt, LitStr, Token};
@@ -92,6 +93,37 @@ impl Parse for Input {
     }
 }
 
+fn parse_field<T: ToTokens + Copy>(span: T, i: usize, field: &syn::Field) -> Result<Field> {
+    let ident = field
+        .ident
+        .as_ref()
+        .ok_or_else(|| Error::new_spanned(span, "Tuple structs are not supported"))?;
+    let mut skip_serializing_if = None;
+    for attr in &field.attrs {
+        if attr.path().is_ident("serde") {
+            attr.parse_nested_meta(|meta| {
+                if meta.path.is_ident("skip_serializing_if") {
+                    let litstr: LitStr = meta.value()?.parse()?;
+                    let tokens = syn::parse_str(&litstr.value())?;
+                    if skip_serializing_if.is_some() {
+                        return Err(meta.error("Multiple attributes for skip_serializing_if"));
+                    }
+                    skip_serializing_if = Some(syn::parse2(tokens)?);
+                    Ok(())
+                } else {
+                    Err(meta.error("Unkown field attribute"))
+                }
+            })?;
+        }
+    }
+    Ok(Field {
+        label: ident.to_string(),
+        member: syn::Member::Named(ident.clone()),
+        index: i,
+        skip_serializing_if,
+    })
+}
+
 fn fields_from_ast(
     attrs: &StructAttrs,
     fields: &syn::punctuated::Punctuated<syn::Field, Token![,]>,
@@ -107,46 +139,6 @@ fn fields_from_ast(
     fields
         .iter()
         .enumerate()
-        .map(|(i, field)| {
-            Ok(Field {
-                // these are https://docs.rs/syn/2.0.28/syn/struct.Field.html
-                label: match &field.ident {
-                    Some(ident) => ident.to_string(),
-                    None => {
-                        return Err(Error::new_spanned(fields, "Tuple struct are not supported"));
-                    }
-                },
-                member: match &field.ident {
-                    Some(ident) => syn::Member::Named(ident.clone()),
-                    None => {
-                        return Err(Error::new_spanned(fields, "Tuple struct are not supported"));
-                    }
-                },
-                index: i,
-                // TODO: make this... more concise? handle errors? the thing with the spans?
-                skip_serializing_if: {
-                    let mut skip_serializing_if = None;
-                    for attr in &field.attrs {
-                        if attr.path().is_ident("serde") {
-                            attr.parse_nested_meta(|meta| {
-                                if meta.path.is_ident("skip_serializing_if") {
-                                    let litstr: LitStr = meta.value()?.parse()?;
-                                    let tokens = syn::parse_str(&litstr.value())?;
-                                    if skip_serializing_if.is_some() {
-                                        return Err(meta
-                                            .error("Multiple attributes for skip_serializing_if"));
-                                    }
-                                    skip_serializing_if = Some(syn::parse2(tokens)?);
-                                    Ok(())
-                                } else {
-                                    Err(meta.error("Unkown field attribute"))
-                                }
-                            })?;
-                        }
-                    }
-                    skip_serializing_if
-                },
-            })
-        })
+        .map(|(i, field)| parse_field(fields, i, field))
         .collect()
 }