line-protocol-derive 0.1.0

pub(crate) mod line_protocol_struct;
pub(crate) mod line_protocol_tag_enum;

use proc_macro::TokenStream;
use syn::Data;
use syn::spanned::Spanned;
use syn::{DeriveInput, Error, parse_macro_input};

fn generate_line_protocol(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
    use crate::line_protocol_struct::parser::StructSettings;

    match input.data {
        Data::Struct(data) => Ok(StructSettings::new(&input.ident, &data, &input.attrs)?
            .generator()?
            .tokenstream()),
        Data::Enum(_) => Err(Error::new(
            input.span(),
            "#[derive(LineProtocol)] doesn't support enum types",
        )),
        Data::Union(_) => Err(Error::new(
            input.span(),
            "#[derive(LineProtocol)] doesn't support union types",
        )),
    }
}

fn generate_line_protocol_tag(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
    use crate::line_protocol_tag_enum::parser::EnumSettings;

    match input.data {
        Data::Struct(_) => Err(Error::new(
            input.span(),
            "#[derive(LineProtocolTag)] doesn't support struct types",
        )),
        Data::Enum(data) => Ok(EnumSettings::new(&input.ident, &data, &input.attrs)?
            .generator()
            .tokenstream()),
        Data::Union(_) => Err(Error::new(
            input.span(),
            "#[derive(LineProtocolTag)] doesn't support union types",
        )),
    }
}

#[proc_macro_derive(LineProtocol, attributes(line_protocol))]
pub fn line_protocol(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    generate_line_protocol(input)
        .unwrap_or_else(Error::into_compile_error)
        .into()
}

#[proc_macro_derive(LineProtocolTag, attributes(line_protocol))]
pub fn line_protocol_tag(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    generate_line_protocol_tag(input)
        .unwrap_or_else(Error::into_compile_error)
        .into()
}