feat: Add stackable-versioned and k8s-version crates for CRD versioning

Cargo.toml

@@ -16,6 +16,7 @@ chrono = { version = "0.4.37", default-features = false }
 clap = { version = "4.5.4", features = ["derive", "cargo", "env"] }
 const_format = "0.2.32"
 const-oid = "0.9.6"
+convert_case = "0.6.0"
 darling = "0.20.8"
 delegate = "0.12.0"
 derivative = "2.2.0"

crates/stackable-versioned/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "stackable-versioned"
+version = "0.1.0"
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+convert_case.workspace = true
+darling.workspace = true
+proc-macro2.workspace = true
+syn.workspace = true
+quote.workspace = true

crates/stackable-versioned/src/attrs/container.rs

@@ -0,0 +1,68 @@
+use darling::{
+    util::{Flag, SpannedValue},
+    Error, FromDeriveInput, FromMeta,
+};
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(
+    attributes(versioned),
+    supports(struct_named),
+    forward_attrs(allow, doc, cfg, serde),
+    and_then = ContainerAttributes::validate
+)]
+pub(crate) struct ContainerAttributes {
+    #[darling(multiple)]
+    pub(crate) version: SpannedValue<Vec<VersionAttributes>>,
+}
+
+impl ContainerAttributes {
+    fn validate(mut self) -> darling::Result<Self> {
+        if self.version.is_empty() {
+            return Err(Error::custom(
+                "attribute `#[versioned()]` must contain at least one `version`",
+            )
+            .with_span(&self.version.span()));
+        }
+
+        for version in &mut *self.version {
+            if version.name.is_empty() {
+                return Err(Error::custom("field `name` of `version` must not be empty")
+                    .with_span(&version.name.span()));
+            }
+
+            if !version
+                .name
+                .chars()
+                .all(|c| c.is_ascii_alphanumeric() || c == '.' || c == '-')
+            {
+                return Err(Error::custom(
+                    "field `name` of `version` must only contain alphanumeric ASCII characters (a-z, A-Z, 0-9, '.', '-')",
+                )
+                .with_span(&version.name.span()));
+            }
+
+            // TODO (@Techassi): Use Diagnostics API when stablizized to throw
+            // a warning when the input mismatches the generated module name.
+            // See https://github.com/rust-lang/rust/issues/54140
+            let module_name = version.name.to_lowercase();
+            if module_name != *version.name {
+                println!("the generated module name differs from the provided version name which might cause confusion around what the code seems to suggest")
+            }
+            version.module_name = module_name
+        }
+
+        Ok(self)
+    }
+}
+
+#[derive(Debug, FromMeta)]
+pub struct VersionAttributes {
+    pub(crate) name: SpannedValue<String>,
+
+    pub(crate) deprecated: Flag,
+
+    #[darling(skip)]
+    pub(crate) module_name: String,
+    // #[darling(default = default_visibility)]
+    // pub(crate) visibility: Visibility,
+}

crates/stackable-versioned/src/attrs/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod container;

crates/stackable-versioned/src/gen/mod.rs

@@ -0,0 +1,45 @@
+use darling::FromDeriveInput;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{spanned::Spanned, Data, DataEnum, DataStruct, DeriveInput, Error, Ident, Result};
+
+use crate::attrs::container::ContainerAttributes;
+
+pub(crate) mod version;
+
+pub(crate) fn expand(input: DeriveInput) -> Result<TokenStream> {
+    // Extract container attributes
+    let attributes = ContainerAttributes::from_derive_input(&input)?;
+
+    // Validate container shape
+    let expanded = match input.data {
+        Data::Struct(data) => expand_struct(input.ident, data, attributes)?,
+        Data::Enum(data) => expand_enum(input.ident, data, attributes)?,
+        Data::Union(_) => {
+            return Err(Error::new(
+                input.span(),
+                "derive macro `Versioned` only supports structs and enums",
+            ))
+        }
+    };
+
+    Ok(quote! {
+        #expanded
+    })
+}
+
+pub(crate) fn expand_struct(
+    ident: Ident,
+    data: DataStruct,
+    attributes: ContainerAttributes,
+) -> Result<TokenStream> {
+    Ok(quote!())
+}
+
+pub(crate) fn expand_enum(
+    ident: Ident,
+    data: DataEnum,
+    attributes: ContainerAttributes,
+) -> Result<TokenStream> {
+    Ok(quote!())
+}

crates/stackable-versioned/src/gen/version.rs

@@ -0,0 +1,12 @@
+use syn::{Field, Ident};
+
+pub(crate) struct Version {
+    struct_ident: Ident,
+    version: String,
+
+    deprecated: Vec<Field>,
+    renamed: Vec<Field>,
+    added: Vec<Field>,
+
+    fields: Vec<Field>,
+}

crates/stackable-versioned/src/lib.rs

@@ -0,0 +1,14 @@
+use proc_macro::TokenStream;
+use syn::{DeriveInput, Error};
+
+mod attrs;
+mod gen;
+
+#[proc_macro_derive(Versioned, attributes(versioned))]
+pub fn versioned_macro_derive(input: TokenStream) -> TokenStream {
+    let input = syn::parse_macro_input!(input as DeriveInput);
+
+    gen::expand(input)
+        .unwrap_or_else(Error::into_compile_error)
+        .into()
+}

crates/stackable-versioned/tests/basic.rs

@@ -0,0 +1,10 @@
+use stackable_versioned::Versioned;
+
+#[test]
+fn basic() {
+    #[derive(Versioned)]
+    #[versioned(version(name = "1.2.3", deprecated))]
+    struct Foo {
+        bar: usize,
+    }
+}