config_plus_macro/

lib.rs

//! 通过`#[derive(Deserialize, Configuration)`] 为结构体（必须实现[Deserialize]特征）生成一个`config`方法，
//! 调用该方法可以读取配置文件中的属性

use darling::{FromDeriveInput, FromMeta};
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use std::fmt::{Display, Formatter};
use syn::{parse_macro_input, DeriveInput};

/// 为结构体生成一个`config`方法，调用该方法可以读取配置文件中的属性
///
/// # Example
/// `application.yml`文件的内容为
/// ```
/// "
/// push:
///   file:
///     enable: 1
///     appId:  4ULDFh55cx9uM
///     appKey: MPRaknd2Q49hgE1
///     masterSecret: esEDaOfvvi5aD
///     packageName:  www.baidu.com
/// "
/// ```
/// rust代码
/// ```
/// r#"
/// use config_macro::Configuration;
/// use serde::Deserialize;
///
/// #[derive(Debug, Deserialize, Configuration)]
/// #[properties(prefix = "push.file", file = "application.yml")]
/// #[serde(rename_all(deserialize = "camelCase"))]
/// struct PushFile {
///     enable: u8,
///     app_id: String,
///     app_key: String,
///     master_secret: String,
///     package_name: String,
/// }
///
/// let config = PushFile::config();
/// "#
/// ```
/// `#[properties]`可以配置的属性
/// - prefix： 读取配置文件的前缀
/// - file: 配置文件的路径（可以配置多个file属性）
/// - environment: 是否从环境变量中读取，默认为true
#[proc_macro_derive(Configuration, attributes(properties))]
pub fn derive_helper_attr(input: TokenStream) -> TokenStream {
    let input: DeriveInput = parse_macro_input!(input);

    // parse the input to the ValidationData struct defined above
    let configuration = ConfigurationData::from_derive_input(&input).unwrap();
    expand(configuration).into()
}

fn expand(configuration: ConfigurationData) -> TokenStream2 {
    let ident = configuration.ident;
    // let generics = configuration.generics;
    let prefix = configuration.prefix;
    let files = configuration.file;
    let environment = configuration.environment;
    let https = configuration.http;

    // let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
    let file_sources = file_source(files);
    let environment_source = environment_source(environment);
    let http_sources = http_source(https);
    let get_result = process_prefix(prefix, &ident);
    quote! {
        // impl #impl_generics #ident #ty_generics #where_clause {
        impl #ident {
            pub fn config()  -> &'static Self {
                static CONFIG: ::std::sync::LazyLock<#ident>  = ::std::sync::LazyLock::new(|| {
                    ::config::Config::builder()
                        #(#file_sources)* 
                        #environment_source
                        #(#http_sources)* 
                        .build()
                        .unwrap()
                        #get_result
                });
                &CONFIG
            }
        }
    }
}

/// 添加文件源
fn file_source(files: Vec<String>) -> Vec<TokenStream2> {
    let mut ts = vec![];

    for file in files {
        ts.push(quote! {
            .add_source(
                ::config::File::with_name(#file)
            )
        })
    }
    ts
}

/// 添加环境源
fn environment_source(environment: bool) -> TokenStream2 {
    let mut ts = quote! {};

    if environment {
        ts.extend(quote! {
            .add_source(
                ::config::Environment::with_prefix("")
                        .separator(".")
                        .prefix_separator("")
                        .list_separator(",")
            )
        })
    }
    ts
}

/// 添加http源
fn http_source(https: Vec<HttpData>) -> Vec<TokenStream2> {
    let mut ts = vec![];
    
    for http in https {
        let url = http.url;
        let format = http.format.to_string();
        let method = http.method.to_string();
        ts.push(quote! {
            .add_source(
                ::config_plus::Http::with(#url, #format, #method)
            )
        })
    }
    ts
}

/// 处理前缀
fn process_prefix(prefix: String, ident: &syn::Ident) -> TokenStream2 {
    let mut ts = quote! {};

    if prefix.is_empty() {
        return quote! {
            .try_deserialize()
            .unwrap()
        };
    }
    let split = prefix.split(".");

    // 元素个数
    let count = split.clone().count();
    for (index, str) in split.enumerate() {
        if count == 1 {
            ts.extend(quote! {
                .get::<#ident>(#str)
                .unwrap()
            });
            return ts;
        }

        if index == 0 {
            ts.extend(quote! {
                .get_table(#str)
                .unwrap()
            })
        } else if count == index + 1 {
            ts.extend(quote! {
                .get(#str)
                .ok_or_else(|| ::config::ConfigError::NotFound(#str.into()))
                .unwrap()
                .clone()
                .try_deserialize()
                .unwrap()
            })
        } else {
            ts.extend(quote! {
                .get(#str)
                .ok_or_else(|| ::config::ConfigError::NotFound(#str.into()))
                .unwrap()
                .into_table()
                .unwrap()
            })
        }
    }
    ts
}

#[derive(Debug, FromDeriveInput)]
#[darling(attributes(properties), supports(struct_named))]
struct ConfigurationData {
    /// 结构体名
    ident: syn::Ident,
    // /// 泛型参数
    // generics: syn::Generics,

    /// 配置前缀
    #[darling(default)]
    prefix: String,

    /// 配置文件路径
    #[darling(multiple, default)]
    file: Vec<String>,

    /// 配置http
    #[darling(multiple, default)]
    http: Vec<HttpData>,

    /// 是否从环境变量中读取，默认为true
    #[darling(default = env_default)]
    environment: bool,
}

#[derive(Debug, FromMeta)]
struct HttpData{
    url: String,
    #[darling(default)]
    method: Method,
    format: Format,
}

#[derive(Debug, FromMeta)]
enum Method {
    Get,
    Post,
}

impl Default for Method {
    fn default() -> Self {
        Method::Get
    }
}

impl Display for Method{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Method::Get =>  write!(f, "get"),
            Method::Post =>  write!(f, "post"),
        }
    }
}

#[derive(Debug, FromMeta)]
enum Format {
    /// TOML (parsed with toml)
    Toml,

    /// JSON (parsed with `serde_json`)
    Json,

    /// YAML (parsed with `yaml_rust2`)
    Yaml,

    /// YAML (parsed with `yaml_rust2`)
    Yml,

    /// INI (parsed with `rust_ini`)
    Ini,

    /// RON (parsed with ron)
    Ron,

    /// JSON5 (parsed with json5)
    Json5,
}


impl Display for Format{
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Format::Toml =>  write!(f, "toml"),
            Format::Json =>  write!(f, "json"),
            Format::Yaml =>  write!(f, "yaml"),
            Format::Yml =>  write!(f, "yaml"),
            Format::Ini =>  write!(f, "ini"),
            Format::Ron =>  write!(f, "ron"),
            Format::Json5 =>  write!(f, "json5"),
        }
    }
}

fn env_default() -> bool {
    true
}