Drop support for v1.11, v1.12, v1.13, v1.14, v1.15

Public clouds no longer support them.

.github/workflows/ci.yaml

@@ -13,11 +13,6 @@ jobs:
 
       matrix:
         version:
-        - '1.11'
-        - '1.12'
-        - '1.13'
-        - '1.14'
-        - '1.15'
         - '1.16'
         - '1.17'
         - '1.18'

Cargo.toml

@@ -52,11 +52,6 @@ default = ["api"]
 api = ["http", "percent-encoding", "url"] # Enables API operation functions and response types. If disabled, only the resource types will be exported.
 
 # Each feature corresponds to a supported version of Kubernetes
-v1_11 = []
-v1_12 = []
-v1_13 = []
-v1_14 = []
-v1_15 = []
 v1_16 = []
 v1_17 = []
 v1_18 = []

build.rs

@@ -1,4 +1,4 @@
-const MIN: usize = 11;
+const MIN: usize = 16;
 const MAX: usize = 23;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {

k8s-openapi-codegen-common/src/lib.rs

@@ -627,20 +627,6 @@ pub fn run(
 		},
 
 		swagger20::SchemaKind::Ty(swagger20::Type::WatchEvent(raw_extension_ref_path)) => {
-			let has_bookmark_event_type = {
-				let watch_optional_schema =
-					definitions.get(&swagger20::DefinitionPath("io.k8s.WatchOptional".to_owned()))
-					.ok_or("could not find io.k8s.WatchOptional")?;
-				let watch_optional_properties =
-					if let swagger20::SchemaKind::Ty(swagger20::Type::WatchOptional(properties)) = &watch_optional_schema.kind {
-						properties
-					}
-					else {
-						return Err("io.k8s.WatchOptional has unexpected schema kind".into());
-					};
-				watch_optional_properties.contains_key(&swagger20::PropertyName("allowWatchBookmarks".to_owned()))
-			};
-
 			let error_status_rust_type = get_rust_type(
 				&swagger20::SchemaKind::Ref(swagger20::RefPath {
 					path: "io.k8s.apimachinery.pkg.apis.meta.v1.Status".to_owned(),
@@ -657,7 +643,6 @@ pub fn run(
 			templates::watch_event::generate(
 				&mut out,
 				type_name,
-				has_bookmark_event_type,
 				&error_status_rust_type,
 				&error_other_rust_type,
 				map_namespace,

k8s-openapi-codegen-common/src/templates/watch_event.rs

@@ -1,91 +1,20 @@
 pub(crate) fn generate(
 	mut writer: impl std::io::Write,
 	type_name: &str,
-	has_bookmark_event_type: bool,
 	error_status_rust_type: &str,
 	error_other_rust_type: &str,
 	map_namespace: &impl crate::MapNamespace,
 ) -> Result<(), crate::Error> {
 	let local = crate::map_namespace_local_to_string(map_namespace)?;
 
-	let (
-		bookmark_def,
-		bookmark_event_type,
-		bookmark_type_match_arm,
-		bookmark_type_value,
-		bookmark_value_match_arm,
-		bookmark_serialize,
-	) =
-		if has_bookmark_event_type {
-			(
-				"Bookmark { resource_version: String },\n    ",
-				"Bookmark,\n            ",
-				"\"BOOKMARK\" => WatchEventType::Bookmark,\n                            ",
-				"\"BOOKMARK\", ",
-				{
-					use std::fmt::Write;
-
-					let mut result = String::new();
-					writeln!(result, "                    WatchEventType::Bookmark => {{")?;
-					writeln!(result, "                        let value_object = {}serde_value::ValueDeserializer::new(value_object);", local)?;
-					writeln!(result, "                        let value: BookmarkObject<'static> = {}serde::Deserialize::deserialize(value_object)?;", local)?;
-					writeln!(result, "                        {type_name}::Bookmark {{", type_name = type_name)?;
-					writeln!(result, "                            resource_version: value.metadata.resource_version.into_owned(),")?;
-					writeln!(result, "                        }}")?;
-					writeln!(result, "                    }},")?;
-					result
-				},
-				{
-					use std::fmt::Write;
-
-					let mut result = String::new();
-					writeln!(result, "{type_name}::Bookmark {{ resource_version }} => {{", type_name = type_name)?;
-					writeln!(result, r#"                {}serde::ser::SerializeStruct::serialize_field(&mut state, "type", "BOOKMARK")?;"#, local)?;
-					writeln!(result, "                let object = BookmarkObject {{")?;
-					writeln!(result, "                    metadata: BookmarkObjectMeta {{")?;
-					writeln!(result, "                        resource_version: std::borrow::Cow::Borrowed(&**resource_version),")?;
-					writeln!(result, "                    }},")?;
-					writeln!(result, "                }};")?;
-					writeln!(result, r#"                {}serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;"#, local)?;
-					writeln!(result, "            }},")?;
-					write!(result, "            ")?;
-					result
-				},
-			)
-		}
-		else {
-			(
-				"",
-				"",
-				"",
-				"",
-				String::new(),
-				String::new(),
-			)
-		};
-
 	writeln!(
 		writer,
 		include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/watch_event.rs")),
 		local = local,
 		type_name = type_name,
-		bookmark_def = bookmark_def,
 		error_status_rust_type = error_status_rust_type,
 		error_other_rust_type = error_other_rust_type,
-		bookmark_event_type = bookmark_event_type,
-		bookmark_type_match_arm = bookmark_type_match_arm,
-		bookmark_type_value = bookmark_type_value,
-		bookmark_value_match_arm = bookmark_value_match_arm,
-		bookmark_serialize = bookmark_serialize,
 	)?;
 
-	if has_bookmark_event_type {
-		writeln!(
-			writer,
-			include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/watch_event_bookmark_object.rs")),
-			local = local,
-		)?;
-	}
-
 	Ok(())
 }

k8s-openapi-codegen-common/templates/watch_event.rs

@@ -2,7 +2,8 @@ enum {type_name}<T> {{
     Added(T),
     Deleted(T),
     Modified(T),
-    {bookmark_def}ErrorStatus({error_status_rust_type}),
+    Bookmark {{ resource_version: String }},
+    ErrorStatus({error_status_rust_type}),
     ErrorOther({error_other_rust_type}),
 }}
 
@@ -43,7 +44,8 @@ impl<'de, T> {local}serde::Deserialize<'de> for {type_name}<T> where T: {local}s
             Added,
             Deleted,
             Modified,
-            {bookmark_event_type}Error,
+            Bookmark,
+            Error,
         }}
 
         impl<'de> {local}serde::Deserialize<'de> for WatchEventType {{
@@ -62,10 +64,11 @@ impl<'de, T> {local}serde::Deserialize<'de> for {type_name}<T> where T: {local}s
                             "ADDED" => WatchEventType::Added,
                             "DELETED" => WatchEventType::Deleted,
                             "MODIFIED" => WatchEventType::Modified,
-                            {bookmark_type_match_arm}"ERROR" => WatchEventType::Error,
+                            "BOOKMARK" => WatchEventType::Bookmark,
+                            "ERROR" => WatchEventType::Error,
                             _ => return Err({local}serde::de::Error::unknown_variant(
                                 v,
-                                &["ADDED", "DELETED", "MODIFIED", {bookmark_type_value}"ERROR"],
+                                &["ADDED", "DELETED", "MODIFIED", "BOOKMARK", "ERROR"],
                             )),
                         }})
                     }}
@@ -112,7 +115,13 @@ impl<'de, T> {local}serde::Deserialize<'de> for {type_name}<T> where T: {local}s
                         let value_object = {local}serde_value::ValueDeserializer::new(value_object);
                         {type_name}::Modified({local}serde::Deserialize::deserialize(value_object)?)
                     }},
-{bookmark_value_match_arm}
+                    WatchEventType::Bookmark => {{
+                        let value_object = {local}serde_value::ValueDeserializer::new(value_object);
+                        let value: BookmarkObject<'static> = {local}serde::Deserialize::deserialize(value_object)?;
+                        {type_name}::Bookmark {{
+                            resource_version: value.metadata.resource_version.into_owned(),
+                        }}
+                    }},
                     WatchEventType::Error => {{
                         let is_status =
                             if let {local}serde_value::Value::Map(map) = &value_object {{
@@ -163,7 +172,16 @@ impl<T> {local}serde::Serialize for {type_name}<T> where T: {local}serde::Serial
                 {local}serde::ser::SerializeStruct::serialize_field(&mut state, "type", "MODIFIED")?;
                 {local}serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
             }},
-            {bookmark_serialize}{type_name}::ErrorStatus(object) => {{
+            {type_name}::Bookmark {{ resource_version }} => {{
+                {local}serde::ser::SerializeStruct::serialize_field(&mut state, "type", "BOOKMARK")?;
+                let object = BookmarkObject {{
+                    metadata: BookmarkObjectMeta {{
+                        resource_version: std::borrow::Cow::Borrowed(&**resource_version),
+                    }},
+                }};
+                {local}serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
+            }},
+            {type_name}::ErrorStatus(object) => {{
                 {local}serde::ser::SerializeStruct::serialize_field(&mut state, "type", "ERROR")?;
                 {local}serde::ser::SerializeStruct::serialize_field(&mut state, "object", &object)?;
             }},
@@ -174,4 +192,168 @@ impl<T> {local}serde::Serialize for {type_name}<T> where T: {local}serde::Serial
         }}
         {local}serde::ser::SerializeStruct::end(state)
     }}
-}}
+}}
+
+#[derive(Debug, PartialEq)]
+struct BookmarkObject<'a> {{
+    metadata: BookmarkObjectMeta<'a>,
+}}
+
+#[derive(Debug, PartialEq)]
+struct BookmarkObjectMeta<'a> {{
+    resource_version: std::borrow::Cow<'a, str>,
+}}
+
+impl<'de> {local}serde::Deserialize<'de> for BookmarkObject<'static> {{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: {local}serde::Deserializer<'de> {{
+        #[allow(non_camel_case_types)]
+        enum Field {{
+            Key_metadata,
+            Other,
+        }}
+
+        impl<'de> {local}serde::Deserialize<'de> for Field {{
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: {local}serde::Deserializer<'de> {{
+                struct Visitor;
+
+                impl<'de> {local}serde::de::Visitor<'de> for Visitor {{
+                    type Value = Field;
+
+                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{
+                        f.write_str("field identifier")
+                    }}
+
+                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: {local}serde::de::Error {{
+                        Ok(match v {{
+                            "metadata" => Field::Key_metadata,
+                            _ => Field::Other,
+                        }})
+                    }}
+                }}
+
+                deserializer.deserialize_identifier(Visitor)
+            }}
+        }}
+
+        struct Visitor;
+
+        impl<'de> {local}serde::de::Visitor<'de> for Visitor {{
+            type Value = BookmarkObject<'static>;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{
+                f.write_str("BookmarkObject")
+            }}
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: {local}serde::de::MapAccess<'de> {{
+                let mut value_metadata: Option<BookmarkObjectMeta<'static>> = None;
+
+                while let Some(key) = {local}serde::de::MapAccess::next_key::<Field>(&mut map)? {{
+                    match key {{
+                        Field::Key_metadata => value_metadata = {local}serde::de::MapAccess::next_value(&mut map)?,
+                        Field::Other => {{ let _: {local}serde::de::IgnoredAny = {local}serde::de::MapAccess::next_value(&mut map)?; }},
+                    }}
+                }}
+
+                Ok(BookmarkObject {{
+                    metadata: value_metadata.ok_or_else(|| {local}serde::de::Error::missing_field("metadata"))?,
+                }})
+            }}
+        }}
+
+        deserializer.deserialize_struct(
+            "BookmarkObject",
+            &[
+                "metadata",
+            ],
+            Visitor,
+        )
+    }}
+}}
+
+impl<'de> {local}serde::Deserialize<'de> for BookmarkObjectMeta<'static> {{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: {local}serde::Deserializer<'de> {{
+        #[allow(non_camel_case_types)]
+        enum Field {{
+            Key_resource_version,
+            Other,
+        }}
+
+        impl<'de> {local}serde::Deserialize<'de> for Field {{
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: {local}serde::Deserializer<'de> {{
+                struct Visitor;
+
+                impl<'de> {local}serde::de::Visitor<'de> for Visitor {{
+                    type Value = Field;
+
+                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{
+                        f.write_str("field identifier")
+                    }}
+
+                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: {local}serde::de::Error {{
+                        Ok(match v {{
+                            "resourceVersion" => Field::Key_resource_version,
+                            _ => Field::Other,
+                        }})
+                    }}
+                }}
+
+                deserializer.deserialize_identifier(Visitor)
+            }}
+        }}
+
+        struct Visitor;
+
+        impl<'de> {local}serde::de::Visitor<'de> for Visitor {{
+            type Value = BookmarkObjectMeta<'static>;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{
+                f.write_str("ObjectMeta")
+            }}
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: {local}serde::de::MapAccess<'de> {{
+                let mut value_resource_version: Option<String> = None;
+
+                while let Some(key) = {local}serde::de::MapAccess::next_key::<Field>(&mut map)? {{
+                    match key {{
+                        Field::Key_resource_version => value_resource_version = {local}serde::de::MapAccess::next_value(&mut map)?,
+                        Field::Other => {{ let _: {local}serde::de::IgnoredAny = {local}serde::de::MapAccess::next_value(&mut map)?; }},
+                    }}
+                }}
+
+                Ok(BookmarkObjectMeta {{
+                    resource_version: std::borrow::Cow::Owned(value_resource_version.ok_or_else(|| {local}serde::de::Error::missing_field("resourceVersion"))?),
+                }})
+            }}
+        }}
+
+        deserializer.deserialize_struct(
+            "ObjectMeta",
+            &[
+                "resourceVersion",
+            ],
+            Visitor,
+        )
+    }}
+}}
+
+impl<'a> {local}serde::Serialize for BookmarkObject<'a> {{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: {local}serde::Serializer {{
+        let mut state = serializer.serialize_struct(
+            "BookmarkObject",
+            1,
+        )?;
+        {local}serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
+        {local}serde::ser::SerializeStruct::end(state)
+    }}
+}}
+
+impl<'a> {local}serde::Serialize for BookmarkObjectMeta<'a> {{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: {local}serde::Serializer {{
+        let mut state = serializer.serialize_struct(
+            "ObjectMeta",
+            1,
+        )?;
+        {local}serde::ser::SerializeStruct::serialize_field(&mut state, "resourceVersion", &self.resource_version)?;
+        {local}serde::ser::SerializeStruct::end(state)
+    }}
+}}