use crate::{
generate::{util, VariantField},
parse::{self, OriginField, OriginStruct},
};
use proc_macro2::TokenStream;
use quote::{ToTokens, format_ident, quote};
use std::rc::Rc;
use syn::{Ident, parse_quote, Type};
#[derive(Debug, Copy, Clone)]
pub struct OverrideVariant;
#[cfg_attr(feature = "syn-debug", derive(Debug))]
#[derive(Clone)]
pub struct OverrideStruct {
ident: Ident,
ty: Type,
fields: Vec<OverrideField>,
origin: Rc<OriginStruct>,
phantom_fields: Vec<Rc<OriginField>>,
}
impl OverrideStruct {
pub fn new(origin: Rc<OriginStruct>) -> Self {
let with_phantoms = origin.use_phantom_fields();
let mut fields = Vec::new();
let mut phantom_fields = Vec::new();
for field in &origin.fields {
if !field.attrs.skip_override_field() {
fields.push(OverrideField::new(field.clone()));
} else if with_phantoms {
phantom_fields.push(field.clone());
}
}
let ident = Self::generate_ident(&origin.ident, origin.suffix);
let ty = util::build_type(&ident, &origin.generics);
Self {
ident,
ty,
fields,
origin,
phantom_fields,
}
}
pub fn ident(&self) -> &Ident {
&self.ident
}
pub fn ty(&self) -> &Type {
&self.ty
}
pub fn has_required_fields(&self) -> bool {
self.fields.iter().any(OverrideField::is_required)
}
#[allow(dead_code)] pub fn has_optional_fields(&self) -> bool {
self.fields.iter().any(OverrideField::is_optional)
}
fn generate_ident(origin_ident: &Ident, suffix: &'static str) -> Ident {
let ident_str = origin_ident.to_string();
assert!(ident_str.ends_with(suffix));
let suf_index = ident_str.rfind(suffix).unwrap();
let prefix = &ident_str[..suf_index];
format_ident!("{prefix}Override{suffix}")
}
#[cfg(not(feature = "serde"))]
fn struct_docs(&self) -> String {
let origin_ident = &self.origin.ident;
format!(
"Provides support for configuring [`{origin_ident}`] at run-time.
**Note**: `serde` support is disabled. This struct must be manually initialized. It is provided to allow for retained override/unset support")
}
#[cfg(feature = "serde")]
fn struct_docs(&self) -> String {
let origin_ident = &self.origin.ident;
let ident = &self.ident;
let origin_has_opt_fields = self.origin.has_optional_fields();
let mut support = Vec::new();
support.push("This struct can be used to:".to_string());
support.push(format!("- *Set* [`{origin_ident}`] fields"));
support.push(format!("- *Override* assignments made using [`{origin_ident}Builder`]"));
if origin_has_opt_fields {
support.push("- *Revert* field assignments back to library-defined defaults".to_string());
}
let support = support.join("\n");
let overview = format!(
"Provides support for configuring [`{origin_ident}`] at run-time.
A common method of rust app configuration is deserializing a config file or env vars into a *'Config'* struct at run-time.
`{ident}` is provided for just this case.
{support}"
);
let mut default_attr = String::new();
if !self.has_required_fields() {
default_attr.push_str("#[serde(default)]\n ");
}
let example = format!(
"```rust,ignore
#[derive(Debug, Clone, Deserialize)]
pub struct Conf {{
api: ApiConf,
// ..
{default_attr}_: {ident},
}}
```"
);
let mut fields = Vec::new();
let mut unset_fields = Vec::new();
if origin_has_opt_fields {
unset_fields.push(format!(
"For each of [`{origin_ident}`]'s optional fields, there is an additional `{{}}_unset` field.
If set to `true`, the associated field will have it's value reverted to the library default.\n"
));
}
for field in &self.fields {
let mut suffix = String::new();
if field.is_required() {
suffix.push_str(" // mandatory");
}
let field_ident = field.ident();
let ty = field.flat_ty().to_token_stream().to_string().replace(' ', "");
fields.push(format!("- `{field_ident}: {ty}{suffix}`"));
if let Some(unset_ident) = field.origin.unset_ident() {
unset_fields.push(format!("- `{unset_ident}: bool`"));
}
}
if self.has_optional_fields() {
if self.has_required_fields() {
fields.push("\n**Note**: Each override field is optional unless explicitly stated otherwise.".to_string());
} else {
fields.push("\n**Note**: All override fields are optional.".to_string());
}
}
if !unset_fields.is_empty() {
fields.push("\n## Unset fields\n".to_string());
let unset_aliases = parse::UNSET_ALIASES.iter().map(|s| format!("`{s}`")).collect::<Vec<_>>().join(", ");
unset_fields.push(format!("\n**Note**: The following unset aliases are also supported: {unset_aliases}"));
}
fields = fields.into_iter().chain(unset_fields).collect();
let fields = fields.join("\n");
format!(
"{overview}
# Example
{example}
# Fields
{fields}"
)
}
}
impl OverrideStruct {
fn derive_tokens(&self) -> TokenStream {
#[cfg(not(feature = "serde"))]
let base = quote! { #[derive(Debug, Clone)] };
#[cfg(feature = "serde")]
let base = quote! { #[derive(Debug, Clone, ::serde::Deserialize)] };
let custom = self.origin.attrs.has_override_derives().then(|| {
let derives = &self.origin.attrs.override_derives;
quote!(#[derive(#(#derives),*)])
});
quote! {
#base
#custom
}
}
fn attr_tokens(&self) -> Option<TokenStream> {
self.origin.attrs.has_override_attrs().then(|| {
let attrs = &self.origin.attrs.override_attrs;
quote!(#(#[#attrs])*)
})
}
fn phantom_fields_tokens(&self) -> TokenStream {
let mut out = TokenStream::new();
for field in &self.phantom_fields {
let ident = field.phantom_ident();
let ty = &field.ty;
#[cfg(feature = "serde")]
out.extend(quote!(#[serde(default)]));
out.extend(quote! {
#ident: ::std::marker::PhantomData<#ty>,
});
}
out
}
fn struct_tokens(&self) -> TokenStream {
let docs = util::doc_lines_split(self.struct_docs(), false);
let derives = self.derive_tokens();
let attrs = self.attr_tokens();
let struct_ident = &self.ident;
let fields: Vec<_> = self.fields
.iter()
.map(ToTokens::into_token_stream)
.collect();
let phantom_fields = self.phantom_fields_tokens();
let generics = &self.origin.generics;
let where_clause = &generics.where_clause;
quote! {
#docs
#derives
#attrs
pub struct #struct_ident #generics
#where_clause
{
#(#fields)*
#phantom_fields
}
}
}
fn getter_fns_tokens(&self) -> TokenStream {
self.fields
.iter()
.map(OverrideField::getter_tokens)
.collect()
}
fn impl_tokens(&self) -> TokenStream {
let ident = &self.ident;
let getters = self.getter_fns_tokens();
let (
impl_generics,
ty_generics,
where_clause,
) = self.origin.generics.split_for_impl();
quote! {
#[automatically_derived]
impl #impl_generics #ident #ty_generics #where_clause {
#getters
}
}
}
fn default_impl_tokens(&self) -> TokenStream {
assert!(!self.has_required_fields());
let struct_ident = &self.ident;
let mut fields = TokenStream::new();
for field in &self.fields {
let ident = field.ident();
fields.extend(quote!(#ident: None,));
if let Some(unset_ident) = field.origin.unset_ident() {
fields.extend(quote!(#unset_ident: false,));
}
}
let mut phantoms = TokenStream::new();
for field in &self.phantom_fields {
let ident = field.phantom_ident();
phantoms.extend(quote!(#ident: ::std::marker::PhantomData,));
}
let (
impl_generics,
ty_generics,
where_clause,
) = self.origin.generics.split_for_impl();
quote! {
#[automatically_derived]
#[allow(clippy::redundant_field_names)]
impl #impl_generics Default for #struct_ident #ty_generics #where_clause {
fn default() -> Self {
Self {
#fields
#phantoms
}
}
}
}
}
}
impl ToTokens for OverrideStruct {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
tokens.extend(self.struct_tokens());
tokens.extend(self.impl_tokens());
if !self.has_required_fields() {
tokens.extend(self.default_impl_tokens());
}
}
}
pub type OverrideField = VariantField<OverrideVariant>;
impl OverrideField {
pub fn is_required(&self) -> bool {
self.attrs().override_required
}
#[allow(dead_code)] pub fn is_optional(&self) -> bool {
!self.attrs().override_required
}
fn attr_tokens(&self) -> Option<TokenStream> {
self.origin.has_override_attrs().then(|| {
let attrs = &self.origin.override_attrs;
quote!(#(#[#attrs])*)
})
}
pub fn flat_ty(&self) -> Type {
match self.attrs().override_from {
Some(ref ty) => Type::Path(ty.clone()),
None => self.origin.flat_ty.clone(),
}
}
pub fn ty(&self) -> Type {
let mut ty = self.flat_ty();
if !self.attrs().override_required {
ty = parse_quote!(Option<#ty>);
}
ty
}
fn getter_ret_ty(&self) -> Type {
if self.attrs().copy && self.attrs().override_from.is_none() {
if self.attrs().override_required {
return self.origin.flat_ty.clone();
}
let inner = &self.origin.flat_ty;
return parse_quote!(Option<#inner>);
}
let ty = self.ty();
if let Some(inner_ty) = parse::util::unwrap_option(&ty) {
if parse::util::is_string(inner_ty) {
parse_quote!(Option<&str>)
} else {
parse_quote!(Option<&#inner_ty>)
}
} else {
if parse::util::is_string(&ty) {
parse_quote!(&str)
} else {
parse_quote!(&#ty)
}
}
}
fn getter_ret_expr(&self) -> TokenStream {
let ident = self.ident();
let inner = quote!(self.#ident);
if self.attrs().copy && self.attrs().override_from.is_none() {
return inner;
}
let ty = self.ty();
if let Some(inner_ty) = parse::util::unwrap_option(&ty) {
if parse::util::is_string(inner_ty) {
quote!(#inner.as_ref().map(|s| s.as_str()))
} else {
quote!(#inner.as_ref())
}
} else {
if parse::util::is_string(&ty) {
quote!(#inner.as_str())
} else {
quote!(&#inner)
}
}
}
pub(super) fn getter_tokens(&self) -> TokenStream {
let ident = self.ident();
let docs = self.docs();
let ty = self.getter_ret_ty();
let ret = self.getter_ret_expr();
let unset_getter = self.unset_getter_tokens();
quote! {
#docs
#[must_use]
pub fn #ident(&self) -> #ty {
#ret
}
#unset_getter
}
}
pub(super) fn unset_getter_tokens(&self) -> Option<TokenStream> {
self.origin.unset_ident().map(|unset_ident| {
let ident = self.ident();
let docs_txt = format!("Returns true if the `{ident}` unset field has been explicitly set to true");
let docs = util::doc_line(docs_txt, true);
quote! {
#docs
#[must_use]
pub fn #unset_ident(&self) -> bool {
self.#unset_ident
}
}
})
}
}
impl ToTokens for OverrideField {
fn to_tokens(&self, tokens: &mut TokenStream) {
let ident = self.ident();
let ty = self.ty();
#[cfg(feature = "serde")]
let vis = quote!(pub(crate));
#[cfg(not(feature = "serde"))]
let vis = quote!(pub);
let field_docs = self.docs();
let attrs = self.attr_tokens();
let field = quote! {
#field_docs
#attrs
#vis #ident: #ty,
};
tokens.extend(field);
if let Some(unset_ident) = self.origin.unset_ident() {
#[cfg(feature = "serde")]
{
let aliases = self.origin.unset_aliases();
tokens.extend(quote! {
#[serde(default, #(alias=#aliases),*)]
});
}
tokens.extend(quote! {
#vis #unset_ident: bool,
});
}
}
}