feat(transpiler): allow metadata to be created from actual types.

Author: Christoph Bühler

src/KubeOps.Abstractions/Entities/EntityMetadata.cs

@@ -17,10 +17,12 @@ public record EntityMetadata(string Kind, string Version, string? Group = null,
     /// <summary>
     /// Name of the singular entity.
     /// </summary>
-    public string SingularName => Kind.ToLower();
+    public string SingularName => Kind.ToLowerInvariant();
 
     /// <summary>
     /// Name of the plural entity.
     /// </summary>
-    public string PluralName => Plural ?? $"{Kind.ToLower()}s";
+    public string PluralName => (Plural ?? $"{Kind}s").ToLowerInvariant();
+
+    public string GroupWithVersion => $"{Group ?? string.Empty}/{Version}".TrimStart('/');
 }

src/KubeOps.Transpiler/Entities.cs

@@ -13,13 +13,15 @@ namespace KubeOps.Transpiler;
 public static class Entities
 {
     /// <summary>
-    /// Create a metadata / scope tuple out of a given entity type.
+    /// Create a metadata / scope tuple out of a given entity type via externally loaded assembly.
     /// </summary>
     /// <param name="context">The context that loaded the types.</param>
     /// <param name="entityType">The type to convert.</param>
     /// <returns>A tuple that contains <see cref="EntityMetadata"/> and a scope.</returns>
     /// <exception cref="ArgumentException">Thrown when the type contains no <see cref="KubernetesEntityAttribute"/>.</exception>
-    public static (EntityMetadata Metadata, string Scope) ToEntityMetadata(this MetadataLoadContext context, Type entityType)
+    public static (EntityMetadata Metadata, string Scope) ToEntityMetadata(
+        this MetadataLoadContext context,
+        Type entityType)
         => (context.GetContextType(entityType).GetCustomAttributeData<KubernetesEntityAttribute>(),
                 context.GetContextType(entityType).GetCustomAttributeData<EntityScopeAttribute>()) switch
         {
@@ -29,15 +31,45 @@ public static (EntityMetadata Metadata, string Scope) ToEntityMetadata(this Meta
                         attr.GetCustomAttributeNamedArg<string>(context, nameof(KubernetesEntityAttribute.Kind)),
                         entityType.Name),
                     Defaulted(
-                        attr.GetCustomAttributeNamedArg<string>(context, nameof(KubernetesEntityAttribute.ApiVersion)),
+                        attr.GetCustomAttributeNamedArg<string>(
+                            context,
+                            nameof(KubernetesEntityAttribute.ApiVersion)),
                         "v1"),
                     attr.GetCustomAttributeNamedArg<string>(context, nameof(KubernetesEntityAttribute.Group)),
                     attr.GetCustomAttributeNamedArg<string>(context, nameof(KubernetesEntityAttribute.PluralName))),
                 scope switch
                 {
-                    null => Enum.GetName(EntityScope.Namespaced) ?? "namespaced",
+                    null => Enum.GetName(EntityScope.Namespaced) ?? "Namespaced",
                     _ => Enum.GetName(
-                        scope.GetCustomAttributeCtorArg<EntityScope>(context, 0)) ?? "namespaced",
+                        scope.GetCustomAttributeCtorArg<EntityScope>(context, 0)) ?? "Namespaced",
+                }),
+        };
+
+    /// <summary>
+    /// Create a metadata / scope tuple out of a given entity type via reflection in the same loaded assembly.
+    /// </summary>
+    /// <param name="entityType">The type to convert.</param>
+    /// <returns>A tuple that contains <see cref="EntityMetadata"/> and a scope.</returns>
+    /// <exception cref="ArgumentException">Thrown when the type contains no <see cref="KubernetesEntityAttribute"/>.</exception>
+    public static (EntityMetadata Metadata, string Scope) ToEntityMetadata(Type entityType)
+        => (entityType.GetCustomAttributeData<KubernetesEntityAttribute>(),
+                entityType.GetCustomAttributeData<EntityScopeAttribute>()) switch
+        {
+            (null, _) => throw new ArgumentException("The given type is not a valid Kubernetes entity."),
+            ({ } attr, var scope) => (new(
+                    Defaulted(
+                        attr.GetCustomAttributeNamedArg<string>(nameof(KubernetesEntityAttribute.Kind)),
+                        entityType.Name),
+                    Defaulted(
+                        attr.GetCustomAttributeNamedArg<string>(nameof(KubernetesEntityAttribute.ApiVersion)),
+                        "v1"),
+                    attr.GetCustomAttributeNamedArg<string>(nameof(KubernetesEntityAttribute.Group)),
+                    attr.GetCustomAttributeNamedArg<string>(nameof(KubernetesEntityAttribute.PluralName))),
+                scope switch
+                {
+                    null => Enum.GetName(EntityScope.Namespaced) ?? "Namespaced",
+                    _ => Enum.GetName(
+                        scope.GetCustomAttributeCtorArg<EntityScope>(0)) ?? "Namespaced",
                 }),
         };
 

src/KubeOps.Transpiler/Utilities.cs

@@ -61,6 +61,23 @@ public static T?
             ? (T)attr.NamedArguments.FirstOrDefault(a => a.MemberName == name).TypedValue.Value!
             : default;
 
+    /// <summary>
+    /// Load a specific named argument from a custom attribute.
+    /// Without the metadata load context, this method is only usable for types in the same loaded assembly.
+    /// Named arguments are in the property-notation:
+    /// <c>[KubernetesEntity(Kind = "foobar")]</c>.
+    /// </summary>
+    /// <param name="attr">The attribute in question.</param>
+    /// <param name="name">The name of the argument.</param>
+    /// <typeparam name="T">What target type the argument has.</typeparam>
+    /// <returns>The argument value if found.</returns>
+    /// <exception cref="InvalidCastException">Thrown if the data did not match the target type.</exception>
+    public static T?
+        GetCustomAttributeNamedArg<T>(this CustomAttributeData attr, string name) =>
+        attr.NamedArguments.FirstOrDefault(a => a.MemberName == name).TypedValue.ArgumentType == typeof(T)
+            ? (T)attr.NamedArguments.FirstOrDefault(a => a.MemberName == name).TypedValue.Value!
+            : default;
+
     /// <summary>
     /// Load a specific named argument array from a custom attribute.
     /// Named arguments are in the property-notation:
@@ -94,6 +111,23 @@ ReadOnlyCollection<CustomAttributeTypedArgument> value
             ? (T)attr.ConstructorArguments[index].Value!
             : default;
 
+    /// <summary>
+    /// Load a specific constructor argument from a custom attribute.
+    /// Without the metadata load context, this method is only usable for types in the same loaded assembly.
+    /// Constructor arguments are in the "new" format:
+    /// <c>[KubernetesEntity("foobar")]</c>.
+    /// </summary>
+    /// <param name="attr">The attribute in question.</param>
+    /// <param name="index">Index of the value in the constructor notation.</param>
+    /// <typeparam name="T">What target type the argument has.</typeparam>
+    /// <returns>The argument value if found.</returns>
+    /// <exception cref="InvalidCastException">Thrown if the data did not match the target type.</exception>
+    public static T? GetCustomAttributeCtorArg<T>(this CustomAttributeData attr, int index) =>
+        attr.ConstructorArguments.Count >= index + 1 &&
+        attr.ConstructorArguments[index].ArgumentType == typeof(T)
+            ? (T)attr.ConstructorArguments[index].Value!
+            : default;
+
     /// <summary>
     /// Load a specific constructor argument array from a custom attribute.
     /// Constructor arguments are in the "new" format: