Add ResourceInherit derive macro

Allows to generate Resource trait implementation for types which proxy
another type internally.

ConfigMaps and Secrets can be strictly typed on the client side. While
using DeserializeGuard, resources can be listed and watched, skipping
invalid resources.

Signed-off-by: Danil-Grigorev <danil.grigorev@suse.com>

kube-derive/src/lib.rs

@@ -4,6 +4,7 @@ extern crate proc_macro;
 #[macro_use] extern crate quote;
 
 mod custom_resource;
+mod resource_inherit;
 
 /// A custom derive for kubernetes custom resource definitions.
 ///
@@ -308,3 +309,52 @@ mod custom_resource;
 pub fn derive_custom_resource(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     custom_resource::derive(proc_macro2::TokenStream::from(input)).into()
 }
+
+/// A custom derive for inheriting Resource impl for the type.
+///
+/// This will generate a [`kube::Resource`] trait implementation, which inherits the specified
+/// resources trait implementation.
+///
+/// Such implementation allows to add strict typing to some typical resources like `Secret` or `ConfigMap`,
+/// in cases when implementing CRD is not desirable or it does not fit the use-case.
+///
+/// This object can be used with [`kube::Api`].
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use kube::api::ObjectMeta;
+/// use k8s_openapi::api::core::v1::ConfigMap;
+/// use kube_derive::ResourceInherit;
+/// use kube::Client;
+/// use kube::Api;
+/// use serde::Deserialize;
+///
+/// #[derive(ResourceInherit, Clone, Debug, Deserialize)]
+/// #[inherit(
+///     resource = "ConfigMap",
+///     namespaced,
+/// )]
+/// struct FooMap {
+///     metadata: ObjectMeta,
+///     data: Option<FooMapSpec>,
+/// }
+///
+/// #[derive(Clone, Debug, Deserialize)]
+/// struct FooMapSpec {
+///     field: String,
+/// }
+///
+/// let client: Client = todo!();
+/// let api: Api<FooMap> = Api::default_namespaced(client);
+/// let config_map = api.get("with-field");
+/// ```
+///
+/// The example above will generate:
+/// ```
+/// // impl kube::Resource for FooMap { .. }
+/// ```
+#[proc_macro_derive(ResourceInherit, attributes(inherit))]
+pub fn derive_resource_inherit(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    resource_inherit::derive(proc_macro2::TokenStream::from(input)).into()
+}

kube-derive/src/resource_inherit.rs

@@ -0,0 +1,141 @@
+// Generated by darling macros, out of our control
+#![allow(clippy::manual_unwrap_or_default)]
+
+use darling::{FromDeriveInput, FromMeta};
+use syn::{parse_quote, Data, DeriveInput, Path};
+
+/// Values we can parse from #[kube(attrs)]
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(inherit))]
+struct InheritAttrs {
+    resource: syn::Path,
+    #[darling(default)]
+    namespaced: bool,
+    #[darling(default)]
+    crates: Crates,
+}
+
+#[derive(Debug, FromMeta)]
+struct Crates {
+    #[darling(default = "Self::default_kube_core")]
+    kube_core: Path,
+    #[darling(default = "Self::default_k8s_openapi")]
+    k8s_openapi: Path,
+}
+
+// Default is required when the subattribute isn't mentioned at all
+// Delegate to darling rather than deriving, so that we can piggyback off the `#[darling(default)]` clauses
+impl Default for Crates {
+    fn default() -> Self {
+        Self::from_list(&[]).unwrap()
+    }
+}
+
+impl Crates {
+    fn default_kube_core() -> Path {
+        parse_quote! { ::kube::core } // by default must work well with people using facade crate
+    }
+
+    fn default_k8s_openapi() -> Path {
+        parse_quote! { ::k8s_openapi }
+    }
+}
+
+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(),
+        Ok(di) => di,
+    };
+    // Limit derive to structs
+    match derive_input.data {
+        Data::Struct(_) | Data::Enum(_) => {}
+        _ => {
+            return syn::Error::new_spanned(&derive_input.ident, r#"Unions can not #[derive(Resource)]"#)
+                .to_compile_error()
+        }
+    }
+    let kube_attrs = match InheritAttrs::from_derive_input(&derive_input) {
+        Err(err) => return err.write_errors(),
+        Ok(attrs) => attrs,
+    };
+
+    let InheritAttrs {
+        resource,
+        namespaced,
+        crates: Crates {
+            kube_core,
+            k8s_openapi,
+            ..
+        },
+        ..
+    } = kube_attrs;
+
+    let rootident = derive_input.ident;
+
+    let scope_quote = if namespaced {
+        quote! { #kube_core::NamespaceResourceScope }
+    } else {
+        quote! { #kube_core::ClusterResourceScope }
+    };
+
+    // let inherit = quote! { #inherit };
+    let inherit_resource = quote! {
+        impl #kube_core::Resource for #rootident {
+            type DynamicType = ();
+            type Scope = #scope_quote;
+
+            fn group(_: &()) -> std::borrow::Cow<'_, str> {
+                #resource::group(&Default::default()).into_owned().into()
+            }
+
+            fn kind(_: &()) -> std::borrow::Cow<'_, str> {
+                #resource::kind(&Default::default()).into_owned().into()
+            }
+
+            fn version(_: &()) -> std::borrow::Cow<'_, str> {
+                #resource::version(&Default::default()).into_owned().into()
+            }
+
+            fn api_version(_: &()) -> std::borrow::Cow<'_, str> {
+                #resource::api_version(&Default::default()).into_owned().into()
+            }
+
+            fn plural(_: &()) -> std::borrow::Cow<'_, str> {
+                #resource::plural(&Default::default()).into_owned().into()
+            }
+
+            fn meta(&self) -> &#k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
+                &self.metadata
+            }
+
+            fn meta_mut(&mut self) -> &mut #k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta {
+                &mut self.metadata
+            }
+        }
+    };
+
+    // Concat output
+    quote! {
+        #inherit_resource
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{env, fs};
+
+    use super::*;
+
+    #[test]
+    fn test_parse_inherit() {
+        let input = quote! {
+            #[derive(ResourceInherit)]
+            #[inherit(resource = "ConfigMap", namespaced)]
+            struct Foo { metadata: ObjectMeta }
+        };
+
+        let input = syn::parse2(input).unwrap();
+        let inherit_attrs = InheritAttrs::from_derive_input(&input).unwrap();
+        assert!(inherit_attrs.namespaced);
+    }
+}

kube-derive/tests/resource_inherit.rs

@@ -0,0 +1,55 @@
+use k8s_openapi::{
+    api::core::v1::{ConfigMap, Secret},
+    ByteString,
+};
+use kube::api::ObjectMeta;
+use kube_derive::ResourceInherit;
+
+#[derive(ResourceInherit, Default)]
+#[inherit(resource = "ConfigMap", namespaced)]
+struct TypedMap {
+    metadata: ObjectMeta,
+    data: Option<TypedData>,
+}
+
+#[derive(Default)]
+struct TypedData {
+    field: String,
+}
+
+#[derive(ResourceInherit, Default)]
+#[inherit(resource = "Secret", namespaced)]
+struct TypedSecret {
+    metadata: ObjectMeta,
+    data: Option<TypedSecretData>,
+}
+
+#[derive(Default)]
+struct TypedSecretData {
+    field: ByteString,
+}
+
+#[cfg(test)]
+mod tests {
+    use kube::Resource;
+
+    use crate::{TypedMap, TypedSecret};
+
+    #[test]
+    fn test_parse_config_map_default() {
+        TypedMap::default();
+        assert_eq!(TypedMap::kind(&()), "ConfigMap");
+        assert_eq!(TypedMap::api_version(&()), "v1");
+        assert_eq!(TypedMap::group(&()), "");
+        assert_eq!(TypedMap::plural(&()), "configmaps");
+    }
+
+    #[test]
+    fn test_parse_secret_default() {
+        TypedSecret::default();
+        assert_eq!(TypedSecret::kind(&()), "Secret");
+        assert_eq!(TypedSecret::api_version(&()), "v1");
+        assert_eq!(TypedSecret::group(&()), "");
+        assert_eq!(TypedSecret::plural(&()), "secrets");
+    }
+}