feat(derive): Add better string parsing support

Author: GeekMasher

geekorm-derive/src/attr.rs

@@ -51,9 +51,10 @@
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{
-    parse::{Parse, ParseStream},
+    parse::{discouraged::AnyDelimiter, Parse, ParseStream},
     punctuated::Punctuated,
     spanned::Spanned,
+    token::{Bracket, Comma},
     Attribute, Ident, LitBool, LitInt, LitStr, Token,
 };
 
@@ -70,6 +71,8 @@ pub(crate) struct GeekAttribute {
 pub(crate) enum GeekAttributeKeys {
     /// Rename the field for the table
     Rename,
+    /// Key
+    Key,
     /// Unique value
     Unique,
     /// New Constructor
@@ -82,6 +85,8 @@ pub(crate) enum GeekAttributeKeys {
     NotNull,
     /// Foreign Key
     ForeignKey,
+    /// Aliases
+    Aliases,
     /// Random value
     Rand,
     RandLength,
@@ -93,17 +98,21 @@ pub(crate) enum GeekAttributeKeys {
     /// Searchable
     Searchable,
     /// On Actions
+    OnValidate,
     OnUpdate,
     OnSave,
     /// Skip this field
     Skip,
+    /// Disable features
+    Disable,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub(crate) enum GeekAttributeValue {
     String(String),
     Int(i64),
     Bool(bool),
+    Vec(Vec<String>),
 }
 
 impl GeekAttribute {
@@ -240,7 +249,16 @@ impl GeekAttribute {
                     Ok(())
                 }
             }
-
+            Some(GeekAttributeKeys::Key) => {
+                if self.value.is_none() {
+                    Err(syn::Error::new(
+                        self.span.span(),
+                        "The `key` attribute requires a string or int value",
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
             _ => Ok(()),
         }
     }
@@ -253,7 +271,10 @@ impl Parse for GeekAttribute {
 
         let key: Option<GeekAttributeKeys> = match name_str.as_str() {
             "skip" => Some(GeekAttributeKeys::Skip),
+            "disable" => Some(GeekAttributeKeys::Disable),
             "rename" => Some(GeekAttributeKeys::Rename),
+            "key" | "name" => Some(GeekAttributeKeys::Key),
+            "aliases" => Some(GeekAttributeKeys::Aliases),
             // Primary Keys
             "primary_key" => Some(GeekAttributeKeys::PrimaryKey),
             "auto_increment" => Some(GeekAttributeKeys::AutoIncrement),
@@ -262,6 +283,7 @@ impl Parse for GeekAttribute {
             // Foreign Key
             "foreign_key" => Some(GeekAttributeKeys::ForeignKey),
             // Functions on action
+            "validate" | "on_validate" => Some(GeekAttributeKeys::OnValidate),
             "update" | "on_update" | "on_update_write" => Some(GeekAttributeKeys::OnUpdate),
             "save" | "on_save" | "on_save_write" => Some(GeekAttributeKeys::OnSave),
 

geekorm-derive/src/derive/column.rs

@@ -179,6 +179,12 @@ impl ColumnDerive {
                         // If the column is unique, then it should be searchable by default
                         self.mode = Some(ColumnMode::Searchable { enabled: true });
                     }
+                    GeekAttributeKeys::OnValidate => {
+                        if let Some(GeekAttributeValue::Bool(validate)) = &attr.value {
+                            self.save = Some(validate.to_string());
+                            self.update = Some(validate.to_string());
+                        }
+                    }
                     GeekAttributeKeys::OnUpdate => {
                         if let Some(GeekAttributeValue::String(value)) = &attr.value {
                             self.update = Some(value.to_string());
@@ -340,6 +346,11 @@ impl ColumnDerive {
                     GeekAttributeKeys::HashAlgorithm => {
                         // Skip
                     }
+                    GeekAttributeKeys::Key
+                    | GeekAttributeKeys::Disable
+                    | GeekAttributeKeys::Aliases => {
+                        // Skip (enum keys)
+                    }
                 }
             } else {
                 // TODO(geekmasher): Handle this better

geekorm-derive/src/lib.rs

@@ -74,6 +74,7 @@ pub fn depricated_table_derive(input: TokenStream) -> TokenStream {
 /// enum Role {
 ///     Admin,
 ///     Moderator,
+///     #[geekorm(key = "UserAccounts")]
 ///     User,
 ///     #[default]
 ///     Guest,
@@ -92,8 +93,13 @@ pub fn depricated_table_derive(input: TokenStream) -> TokenStream {
 /// # assert_eq!(geekmasher.role, Role::Admin);
 /// # assert_eq!(Value::from(geekmasher.role), Value::Text("Admin".to_string()));
 /// # assert_eq!(Role::from(Value::Text("Admin".to_string())), Role::Admin);
+/// # assert_eq!(Role::from(Value::Text("UserAccounts".to_string())), Role::User);
+///
+/// let role = Role::from("UserAccounts");
+/// # assert_eq!(role, Role::User);
+/// # assert_eq!(role.to_string(), String::from("UserAccounts"));
 /// ```
-#[proc_macro_derive(Data)]
+#[proc_macro_derive(Data, attributes(geekorm))]
 pub fn data_derive(input: TokenStream) -> TokenStream {
     let ast: DeriveInput = parse_macro_input!(input as DeriveInput);
 

geekorm-derive/src/parsers.rs

@@ -8,7 +8,7 @@ use syn::{
 #[cfg(feature = "rand")]
 use geekorm_core::utils::generate_random_string;
 use geekorm_core::{Columns, Table};
-use values::{generate_from_value, generate_serde};
+use values::{generate_from_value, generate_serde, generate_strings};
 
 mod helpers;
 mod tablebuilder;
@@ -74,12 +74,20 @@ pub(crate) fn derive_parser(ast: &DeriveInput) -> Result<TokenStream, syn::Error
 pub(crate) fn enum_parser(ast: &DeriveInput) -> Result<TokenStream, syn::Error> {
     let name = &ast.ident;
 
+    let attributes = GeekAttribute::parse_all(&ast.attrs)?;
+
     match &ast.data {
         Data::Enum(DataEnum { variants, .. }) => {
             let mut tokens = TokenStream::new();
 
             tokens.extend(generate_from_value(name, variants, &ast.generics)?);
             tokens.extend(generate_serde(name, variants, &ast.generics)?);
+            tokens.extend(generate_strings(
+                name,
+                variants,
+                &ast.generics,
+                &attributes,
+            )?);
 
             Ok(tokens)
         }

geekorm-derive/src/parsers/tablebuilder.rs

@@ -258,8 +258,6 @@ pub fn generate_backend(
             })?;
 
             auto_update.extend(quote! {
-                #[cfg(feature = "log")]
-                ::log::debug!("Auto updating field: '{}'", stringify!(#ident));
                 self.#ident = #auto;
             });
         }