chore: introduction to abuse of structfields

Author: orzklv

.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Cargo CI
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+jobs:
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+
+      - name: Install stable toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+
+      - run: cargo publish --token ${CRATES_TOKEN}
+        env:
+          CRATES_TOKEN: ${{ secrets.CRATES_TOKEN }}

Cargo.lock

@@ -1,20 +1,24 @@
 [package]
-name = "template"
+name = "maydon"
 version = "0.1.0"
 edition = "2021"
-homepage = "https://github.com/xinux-org/templates"
-repository = "https://github.com/xinux-org/templates"
-description = "Just a Rust template via nix flakes"
+homepage = "https://github.com/rust-lang-uz/maydon"
+repository = "https://github.com/rust-lang-uz/maydon"
+description = "Generating enumation for fields of a struct"
+authors = ["Sokhibjon Orzikulov <orzklv.uz>"]
+keywords = ["fields", "enum"]
+license = "MIT OR Apache-2.0"
+
+[lib]
+proc-macro = true
 
 # Dependencies that will included with final binary
 [dependencies]
+syn = { version = "2.0", features = ["derive", "full"] }
+quote = "1.0"
+proc-macro2 = "1.0"
+convert_case = "0.7.1"
 
 # Development dependencies which aren't used in release binary
 [dev-dependencies]
-
-# Optimize release binary as much as possible
-[profile.release]
-strip = true
-opt-level = "z"
-lto = true
-codegen-units = 1
+# trybuild = "1.0.103"

Cargo.toml

@@ -0,0 +1,59 @@
+#![allow(clippy::useless_conversion)]
+
+use convert_case::{Case, Casing};
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Expr, Lit, Meta};
+
+#[proc_macro_derive(Maydon, attributes(name))]
+pub fn field_enum_derive(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    // Default enum name
+    let mut enum_name = syn::Ident::new("Field", proc_macro2::Span::call_site());
+
+    // Parse attributes to extract custom enum name
+    for attr in input.attrs.iter() {
+        if attr.path().is_ident("name") {
+            if let Ok(Meta::NameValue(name_value)) = attr.meta.clone().try_into() {
+                // Extract value from Meta::NameValue
+                if let Expr::Lit(expr_lit) = name_value.value {
+                    if let Lit::Str(lit_str) = expr_lit.lit {
+                        enum_name =
+                            syn::Ident::new(&lit_str.value(), proc_macro2::Span::call_site());
+                    }
+                }
+            }
+        }
+    }
+
+    // Extract fields from the struct
+    let fields = if let syn::Data::Struct(data_struct) = &input.data {
+        &data_struct.fields
+    } else {
+        panic!("FieldEnum can only be derived for structs");
+    };
+
+    let field_variants = fields.iter().map(|field| {
+        let field_name = &field.ident;
+        let variant_name = syn::Ident::new(
+            &field_name
+                .as_ref()
+                .unwrap()
+                .to_string()
+                .to_case(Case::Pascal),
+            proc_macro2::Span::call_site(),
+        );
+        quote! { #variant_name }
+    });
+
+    let expanded = quote! {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        pub enum #enum_name {
+            #(#field_variants,)*
+            Unknown,
+        }
+    };
+
+    TokenStream::from(expanded)
+}

src/lib.rs

@@ -0,0 +1,18 @@
+use maydon::Maydon;
+
+#[derive(Maydon)]
+pub struct Config {
+    pub url: String,
+    pub port: u16,
+    pub database_url: String,
+    pub threads: u16,
+}
+
+// The macro should generate:
+fn main() {
+    let _ = Field::Url;
+    let _ = Field::Port;
+    let _ = Field::DatabaseUrl;
+    let _ = Field::Threads;
+    let _ = Field::Unknown;
+}

src/main.rs

@@ -0,0 +1,15 @@
+use maydon::Maydon;
+
+#[derive(Maydon)]
+#[name = "ConfigField"]
+pub struct Config {
+    pub url: String,
+    pub port: u16,
+}
+
+// The macro should generate:
+fn main() {
+    let _ = ConfigField::Url;
+    let _ = ConfigField::Port;
+    let _ = ConfigField::Unknown;
+}

tests/basic.rs

@@ -0,0 +1,11 @@
+use maydon::Maydon;
+
+#[derive(Maydon)]
+enum InvalidEnum {
+    // ❌ Macros should only be used on structs
+    A,
+    B,
+    C,
+}
+
+fn main() {}