Merge pull request #1850 from ngergs/kube-derive-cr-root-attr

feat: add #[kube(attr="...")] attribute helper to set attribute helper on the CR root type

Author: clux

examples/crd_derive.rs

@@ -21,6 +21,8 @@ use serde::{Deserialize, Serialize};
     status = "FooStatus",
     derive = "PartialEq",
     derive = "Default",
+    attr = "allow(deprecated)",
+    attr = "cfg_attr(docsrs,doc(cfg(feature = \"latest\")))",
     shortname = "f",
     scale(
         spec_replicas_path = ".spec.replicas",

kube-derive/src/custom_resource.rs

@@ -7,7 +7,7 @@ use darling::{
 use proc_macro2::{Ident, Literal, Span, TokenStream};
 use quote::{ToTokens, TokenStreamExt as _};
 use serde::Deserialize;
-use syn::{parse_quote, Data, DeriveInput, Expr, Path, Visibility};
+use syn::{parse_quote, Data, DeriveInput, Expr, Meta, Path, Visibility};
 
 /// Values we can parse from #[kube(attrs)]
 #[derive(Debug, FromDeriveInput)]
@@ -27,6 +27,8 @@ struct KubeAttrs {
     namespaced: bool,
     #[darling(multiple, rename = "derive")]
     derives: Vec<String>,
+    #[darling(multiple, rename = "attr")]
+    attributes: Vec<KubeRootMeta>,
     schema: Option<SchemaMode>,
     status: Option<Path>,
     #[darling(multiple, rename = "category")]
@@ -322,6 +324,44 @@ impl Scale {
     }
 }
 
+/// Attribute meta that should be added to the root of the custom resource.
+/// Wrapper around `Meta` to implement custom validation logic for `darling`.
+/// The validation rejects attributes for `derive`, `serde` and `schemars`.
+/// For `derive` there is `#[kube(derive=...)]` which does specialized handling
+/// and for `serde` and `schemars` allowing to set attributes could result in conflicts
+/// or unexpected behaviour with respect to other parts of the generated code.
+#[derive(Debug)]
+struct KubeRootMeta(Meta);
+
+impl ToTokens for KubeRootMeta {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.0.to_tokens(tokens);
+    }
+}
+
+impl FromMeta for KubeRootMeta {
+    fn from_string(value: &str) -> darling::Result<Self> {
+        /// Attributes that are not allowed to be set via `#[kube(attr=...)]`.
+        const NOT_ALLOWED_ATTRIBUTES: [&str; 3] = ["derive", "serde", "schemars"];
+
+        let meta = syn::parse_str::<Meta>(value)?;
+        if let Some(ident) = meta.path().get_ident() {
+            if NOT_ALLOWED_ATTRIBUTES.iter().any(|el| ident == el) {
+                if ident == "derive" {
+                    return Err(darling::Error::custom(
+                        r#"#[derive(CustomResource)] `kube(attr = "...")` does not support to set derives, you likely want to use `kube(derive = "...")`."#,
+                    ));
+                }
+                return Err(darling::Error::custom(format!(
+                    r#"#[derive(CustomResource)] `kube(attr = "...")` does not support to set the attributes {NOT_ALLOWED_ATTRIBUTES:?} as they might lead to unexpected behaviour.`"#,
+                )));
+            }
+        }
+
+        Ok(Self(meta))
+    }
+}
+
 pub(crate) fn derive(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
     let derive_input: DeriveInput = match syn::parse2(input) {
         Err(err) => return err.to_compile_error(),
@@ -351,6 +391,7 @@ pub(crate) fn derive(input: proc_macro2::TokenStream) -> proc_macro2::TokenStrea
         version,
         doc,
         namespaced,
+        attributes,
         derives,
         schema: schema_mode,
         status,
@@ -476,6 +517,7 @@ pub(crate) fn derive(input: proc_macro2::TokenStream) -> proc_macro2::TokenStrea
         #[automatically_derived]
         #[allow(missing_docs)]
         #[derive(#(#derive_paths),*)]
+        #(#[#attributes])*
         #[serde(rename_all = "camelCase")]
         #[serde(crate = #quoted_serde)]
         #schemars_attribute
@@ -902,6 +944,36 @@ mod tests {
         assert!(kube_attrs.namespaced);
     }
 
+    #[test]
+    // The error cases are handled in tests/test_ui together with validating that the error messages are helpful
+    fn test_parse_attribute_ok() {
+        let input = quote! {
+            #[derive(CustomResource, Serialize, Deserialize, Debug, PartialEq, Clone, JsonSchema)]
+            #[kube(group = "clux.dev", version = "v1", kind = "Foo", namespaced)]
+            #[kube(attr="hello")]
+            #[kube(attr="hello2")]
+            struct FooSpec { foo: String }
+        };
+        let input = syn::parse2(input).unwrap();
+        let kube_attrs = KubeAttrs::from_derive_input(&input).unwrap();
+        assert_eq!(kube_attrs.group, "clux.dev".to_string());
+        assert_eq!(kube_attrs.version, "v1".to_string());
+        assert_eq!(kube_attrs.kind, "Foo".to_string());
+        assert!(kube_attrs.namespaced);
+
+        let expected_attrs = ["hello", "hello2"];
+        assert_eq!(kube_attrs.attributes.len(), expected_attrs.len());
+        for (i, attr) in kube_attrs
+            .attributes
+            .into_iter()
+            .map(|el| el.to_token_stream().to_string())
+            .enumerate()
+        {
+            assert_eq!(attr, expected_attrs[i],);
+        }
+    }
+
+
     #[test]
     fn test_derive_crd() {
         let path = env::current_dir().unwrap().join("tests").join("crd_enum_test.rs");

kube-derive/src/lib.rs

@@ -113,6 +113,24 @@ mod resource;
 /// Adding `#[kube(derive = "PartialEq")]` is required if you want your generated
 /// top level type to be able to `#[derive(PartialEq)]`
 ///
+/// ## `#[kube(attr = "attribute")]`
+/// Adding `#[kube(attr = "attribute")]` is required if you want your generated
+/// top level type to have the `#[attribute]` type level attribute added.
+/// The attributes will be added after the `#[derive(...)]` attribute of the root type.
+/// The added attributes can either attribute macros or derive macro helper attributes.
+///
+/// Does not allow to set the `derive`, `serde` or `schemars` derive helper attributes.
+/// To add `derive`s the correct way to set it is `#[kube(derive = "Trait")]`.
+/// Setting derive helper attributes for `serde` and `schemars` is not supported as
+/// it might yield unexpected behaviour when interacting with the other generated code.
+///
+/// ```ignore
+/// #[kube(
+///     attr="allow(deprecated)",
+///     attr="cfg_attr(docsrs,doc(cfg(feature = \"latest\")))",
+/// )]
+/// ```
+///
 /// ## `#[kube(schema = "mode")]`
 /// Defines whether the `JsonSchema` of the top level generated type should be used when generating a `CustomResourceDefinition`.
 ///

kube-derive/tests/ui/attr_derive_not_allowed.rs

@@ -0,0 +1,12 @@
+#![allow(missing_docs)]
+
+use kube_derive::CustomResource;
+
+#[derive(CustomResource)]
+#[kube(group = "clux.dev", version = "v1", kind = "FooEnum")]
+#[kube(attr = "derive(Serialize)")]
+struct FooSpec {
+    int: u32,
+}
+
+fn main() {}

kube-derive/tests/ui/attr_derive_not_allowed.stderr

@@ -0,0 +1,5 @@
+error: #[derive(CustomResource)] `kube(attr = "...")` does not support to set derives, you likely want to use `kube(derive = "...")`.
+ --> tests/ui/attr_derive_not_allowed.rs:7:15
+  |
+7 | #[kube(attr = "derive(Serialize)")]
+  |               ^^^^^^^^^^^^^^^^^^^

kube-derive/tests/ui/attr_serde_not_allowed.rs

@@ -0,0 +1,12 @@
+#![allow(missing_docs)]
+
+use kube_derive::CustomResource;
+
+#[derive(CustomResource)]
+#[kube(group = "clux.dev", version = "v1", kind = "FooEnum")]
+#[kube(attr = "serde(rename_all=\"snake_case\")")]
+struct FooSpec {
+    int: u32,
+}
+
+fn main() {}

kube-derive/tests/ui/attr_serde_not_allowed.stderr

@@ -0,0 +1,5 @@
+error: #[derive(CustomResource)] `kube(attr = "...")` does not support to set the attributes ["derive", "serde", "schemars"] as they might lead to unexpected behaviour.`
+ --> tests/ui/attr_serde_not_allowed.rs:7:15
+  |
+7 | #[kube(attr = "serde(rename_all=\"snake_case\")")]
+  |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^