use heck::{ToLowerCamelCase as _, ToShoutySnakeCase as _};
use quote::{format_ident, quote};
use syn::ext::IdentExt as _;
use crate::{enumeration::IntegerWidth, model::DatabaseKind};
mod remote;
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum BitWidth {
U8,
U16,
U32,
}
impl BitWidth {
pub const ALL: [Self; 3] = [Self::U8, Self::U16, Self::U32];
pub const fn as_str(self) -> &'static str {
match self {
Self::U8 => "u8",
Self::U16 => "u16",
Self::U32 => "u32",
}
}
pub fn named(word: &str) -> Option<Self> {
Self::ALL.into_iter().find(|width| width.as_str() == word)
}
pub const fn count(self) -> u32 {
match self {
Self::U8 => 8,
Self::U16 => 16,
Self::U32 => 32,
}
}
pub const fn ceiling(self) -> u128 {
(1u128 << self.count()) - 1
}
pub const fn carried(self) -> IntegerWidth {
match self {
Self::U8 => IntegerWidth::U8,
Self::U16 => IntegerWidth::U16,
Self::U32 => IntegerWidth::U32,
}
}
pub const fn stored(self, database: DatabaseKind) -> IntegerWidth {
self.carried().wire(database)
}
}
#[derive(Debug, Clone)]
pub struct FlagBit {
pub ident: syn::Ident,
pub rename: Option<String>,
pub upstream: Option<syn::Ident>,
pub value: u128,
pub attrs: Vec<syn::Attribute>,
}
impl FlagBit {
pub fn word(&self) -> String {
self
.rename
.clone()
.unwrap_or_else(|| self.ident.unraw().to_string().to_shouty_snake_case())
}
pub fn field(&self) -> String {
self.word().to_lower_camel_case()
}
pub fn constant(&self) -> syn::Ident {
format_ident!("{}", self.word())
}
pub fn upstream(&self) -> syn::Ident {
self.upstream.clone().unwrap_or_else(|| self.constant())
}
}
#[derive(Debug, Clone)]
pub struct FlagsModel {
pub krate: syn::Path,
pub vis: syn::Visibility,
pub name: syn::Ident,
pub width: BitWidth,
pub bits: Vec<FlagBit>,
pub attrs: Vec<syn::Attribute>,
pub remote: Option<syn::Path>,
pub wire_name: Option<String>,
}
impl FlagsModel {
#[must_use]
pub fn sdl_name(&self) -> String {
self
.wire_name
.clone()
.unwrap_or_else(|| self.name.unraw().to_string())
}
#[must_use]
pub fn emit(&self) -> proc_macro2::TokenStream {
let declaration = self.declaration();
let vocabulary = self.vocabulary();
let reading = self.reading();
let width = self.width_row();
let read = self.read_row();
let storage = DatabaseKind::ALL
.into_iter()
.map(|database| self.storage_rows(database));
let wire = self.wire_seats();
let mirror = self.remote.as_ref().map(|path| self.mirror(path));
quote! {
#declaration
const _: () = {
#vocabulary
#reading
#width
#read
#(#storage)*
};
#wire
#mirror
}
}
fn declaration(&self) -> proc_macro2::TokenStream {
let krate = &self.krate;
let vis = &self.vis;
let name = &self.name;
let attrs = &self.attrs;
let primitive = format_ident!("{}", self.width.as_str());
let bits = self.bits.iter().map(|bit| {
let attrs = &bit.attrs;
let constant = bit.constant();
let value = syn::LitInt::new(
&format!("0x{:x}{}", bit.value, self.width.as_str()),
proc_macro2::Span::call_site(),
);
quote! {
#(#attrs)*
const #constant = #value;
}
});
quote! {
#krate::__private::bitflags::bitflags! {
#(#attrs)*
#vis struct #name: ::core::primitive::#primitive {
#(#bits)*
}
}
}
}
fn vocabulary(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let trait_path = self.framework(&["flags"], "FlagsValue");
let sdl = self.sdl_name();
let fields = self.bits.iter().map(FlagBit::field);
quote! {
#[automatically_derived]
impl #trait_path for #name {
const GRAPHQL_NAME: &'static ::core::primitive::str = #sdl;
const FIELDS: &'static [&'static ::core::primitive::str] = &[#(#fields),*];
}
}
}
fn reading(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let filter_marker = self.framework(&["marker"], "FlagsFilterMarker");
let filter = self.framework(&["graphql"], "FlagsFilter");
let default_marker = self.framework(&["marker"], "DefaultMarker");
let default_vec_marker = self.framework(&["marker"], "DefaultVecMarker");
let list_marker = self.framework(&["marker"], "ListMarker");
let marker = self.framework(&["marker"], "FlagsMarker");
let cursor_value = self.framework(&["cursor"], "CursorValue");
let primitive = format_ident!("{}", self.width.as_str());
let bytes = (self.width.count() / 8) as usize;
quote! {
#[automatically_derived]
impl #filter_marker for #name {
type Filter = #filter<#name>;
}
#[automatically_derived]
impl #default_marker for #name {
type Marker = #marker<#name>;
}
#[automatically_derived]
impl #default_vec_marker for #name {
type Marker = #list_marker<::std::vec::Vec<#name>, #marker<#name>>;
}
#[automatically_derived]
impl #cursor_value for #name {
fn write_cursor(&self, out: &mut ::std::vec::Vec<::core::primitive::u8>) {
out.extend_from_slice(&::core::primitive::#primitive::to_be_bytes(
#name::bits(self),
));
}
fn read_cursor(bytes: &[::core::primitive::u8]) -> ::core::option::Option<Self> {
match <[::core::primitive::u8; #bytes] as ::core::convert::TryFrom<&[
::core::primitive::u8
]>>::try_from(bytes) {
::core::result::Result::Ok(fixed) => {
#name::from_bits(::core::primitive::#primitive::from_be_bytes(fixed))
}
::core::result::Result::Err(_) => ::core::option::Option::None,
}
}
}
}
}
fn width_row(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let column_kind = self.framework(&["column"], "ColumnKind");
let column_eq = self.framework(&["column"], "ColumnEq");
quote! {
#[automatically_derived]
impl #column_kind for #name {}
#[automatically_derived]
impl #column_eq for #name {
#[inline]
fn column_eq(&self, __ingraph_other: &Self) -> ::core::primitive::bool {
::core::cmp::PartialEq::eq(self, __ingraph_other)
}
}
}
}
fn read_row(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let gate = self.framework(&["gate"], "if_sqlx");
let assemble = self.framework(&["column"], "Assemble");
let plain_column = self.framework(&["column"], "plain_column");
let path = self.framework(&["comparison"], "Path");
let row_trait = self.framework(&["sqlx"], "Row");
let decode = self.framework(&["sqlx"], "Decode");
let sqlx_type = self.framework(&["sqlx"], "Type");
let column_index = self.framework(&["sqlx"], "ColumnIndex");
let result = self.framework(&["sqlx"], "Result");
let row = crate::emit::parameter("ROW");
quote! {
#gate! {
#[automatically_derived]
impl<'__ingraph, #row> #assemble<'__ingraph, #row> for #name
where
#row: #row_trait,
#name: #decode<'__ingraph, <#row as #row_trait>::Database>
+ #sqlx_type<<#row as #row_trait>::Database>,
for<'__ingraph_name> &'__ingraph_name ::core::primitive::str: #column_index<#row>,
{
#[inline]
fn assemble(
__row: &'__ingraph #row,
__ingraph_under: ::core::option::Option<&#path<'_>>,
) -> #result<Self> {
#plain_column(__row, __ingraph_under)
}
}
}
}
}
fn framework(&self, module: &[&str], name: &str) -> proc_macro2::TokenStream {
let krate = &self.krate;
let module = module.iter().map(|segment| format_ident!("{segment}"));
let name = format_ident!("{name}");
quote!(#krate::__private #(:: #module)* :: #name)
}
fn storage_rows(&self, database: DatabaseKind) -> proc_macro2::TokenStream {
if !database.is_sql() {
return quote!();
}
let name = &self.name;
let gate = self.framework(&["gate"], &database.gate().to_string());
let backend = self.backend(database);
let carrier = self.framework(&["comparison", "sql"], "Carrier");
let query_builder = self.framework(&["sqlx"], "QueryBuilder");
let sqlx_type = self.framework(&["sqlx"], "Type");
let encode = self.framework(&["sqlx"], "Encode");
let decode = self.framework(&["sqlx"], "Decode");
let database_trait = self.framework(&["sqlx"], "Database");
let is_null = self.framework(&["sqlx", "encode"], "IsNull");
let error = self.framework(&["sqlx", "error"], "BoxDynError");
let declared = format_ident!("{}", self.width.as_str());
let stored = format_ident!("{}", self.width.stored(database).as_str());
let too_wide =
format!("{name}: the stored number does not fit the width this declaration is declared at");
let undeclared = format!("{name}: the stored bits name a flag this declaration never declared");
let stored_as = self.framework(&["column"], "StoredAs");
quote! {
#gate! {
#[automatically_derived]
impl #stored_as<#backend> for #name {
const WORDS: &'static [&'static ::core::primitive::str] =
<::core::primitive::#stored as #stored_as<#backend>>::WORDS;
}
#[automatically_derived]
impl #sqlx_type<#backend> for #name {
fn type_info() -> <#backend as #database_trait>::TypeInfo {
<::core::primitive::#stored as #sqlx_type<#backend>>::type_info()
}
fn compatible(ty: &<#backend as #database_trait>::TypeInfo) -> ::core::primitive::bool {
<::core::primitive::#stored as #sqlx_type<#backend>>::compatible(ty)
}
}
#[automatically_derived]
impl<'__ingraph> #encode<'__ingraph, #backend> for #name {
fn encode_by_ref(
&self,
buf: &mut <#backend as #database_trait>::ArgumentBuffer,
) -> ::core::result::Result<#is_null, #error> {
<::core::primitive::#stored as #encode<'__ingraph, #backend>>::encode(
#name::bits(self) as ::core::primitive::#stored,
buf,
)
}
}
#[automatically_derived]
impl<'__ingraph> #decode<'__ingraph, #backend> for #name {
fn decode(
value: <#backend as #database_trait>::ValueRef<'__ingraph>,
) -> ::core::result::Result<Self, #error> {
let stored =
<::core::primitive::#stored as #decode<'__ingraph, #backend>>::decode(value)?;
let bits = match <::core::primitive::#declared as ::core::convert::TryFrom<
::core::primitive::#stored
>>::try_from(stored) {
::core::result::Result::Ok(bits) => bits,
::core::result::Result::Err(_) => {
return ::core::result::Result::Err(#error::from(#too_wide));
}
};
match #name::from_bits(bits) {
::core::option::Option::Some(value) => ::core::result::Result::Ok(value),
::core::option::Option::None => {
::core::result::Result::Err(#error::from(#undeclared))
}
}
}
}
#[automatically_derived]
impl #carrier<#backend> for #name {
fn push_bind(&self, qb: &mut #query_builder<#backend>) {
qb.push_bind(#name::bits(self) as ::core::primitive::#stored);
}
}
}
}
}
fn backend(&self, database: DatabaseKind) -> proc_macro2::TokenStream {
match database {
DatabaseKind::Sqlite => self.framework(&["sqlx"], "Sqlite"),
DatabaseKind::Postgres => self.framework(&["sqlx"], "Postgres"),
DatabaseKind::Mysql => self.framework(&["sqlx"], "MySql"),
DatabaseKind::Mongo => self.framework(&["comparison", "mongo"], "Mongo"),
}
}
fn wire_seats(&self) -> proc_macro2::TokenStream {
let name = &self.name;
let gate = self.framework(&["gate"], "if_async_graphql");
let output = self.framework(&["graphql"], "ToGraphqlOutput");
let input = self.framework(&["graphql"], "ToGraphqlInput");
let view = self.framework(&["graphql"], "FlagsView");
let operand = self.framework(&["graphql"], "FlagsInput");
quote! {
const _: () = {
#gate! {
#[automatically_derived]
impl #output for #name {
type Output<'__ingraph> = #view<Self>;
#[inline]
fn to_graphql_output(__ingraph_value: &Self) -> #view<Self> {
#view::new(*__ingraph_value)
}
}
#[automatically_derived]
impl #input for #name {
type Input = #operand<Self>;
type Error = ::core::convert::Infallible;
#[inline]
fn cross(
__ingraph_value: #operand<Self>,
) -> ::core::result::Result<Self, ::core::convert::Infallible> {
::core::result::Result::Ok(#operand::into_inner(__ingraph_value))
}
#[inline]
fn carry(__ingraph_value: &Self) -> #operand<Self> {
#operand::new(*__ingraph_value)
}
}
}
};
}
}
}