stackable_versioned_macros__snapshots__pass@scale.rs.snap

---
source: crates/stackable-versioned-macros/src/lib.rs
expression: formatted
input_file: crates/stackable-versioned-macros/tests/inputs/pass/scale.rs
---
#[automatically_derived]
pub(crate) mod v1alpha1 {
    use super::*;
    #[derive(
        Clone,
        Debug,
        serde::Deserialize,
        serde::Serialize,
        schemars::JsonSchema,
        kube::CustomResource,
    )]
    #[kube(
        group = "stackable.tech",
        version = "v1alpha1",
        kind = "Foo",
        scale(
            spec_replicas_path = ".spec.replicas",
            status_replicas_path = ".status.replicas",
            label_selector_path = ".status.selector"
        )
    )]
    pub struct FooSpec {
        pub bar: usize,
        pub baz: bool,
    }
}
#[automatically_derived]
#[derive(::core::fmt::Debug)]
pub(crate) enum Foo {
    V1Alpha1(v1alpha1::Foo),
}
#[automatically_derived]
impl Foo {
    /// Generates a merged CRD containing all versions and marking `stored_apiversion` as stored.
    pub fn merged_crd(
        stored_apiversion: FooVersion,
    ) -> ::std::result::Result<
        ::k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition,
        ::kube::core::crd::MergeError,
    > {
        ::kube::core::crd::merge_crds(
            vec![< v1alpha1::Foo as ::kube::core::CustomResourceExt > ::crd()],
            stored_apiversion.as_version_str(),
        )
    }
    ///Tries to convert a list of objects of kind [`Foo`] to the desired API version
    ///specified in the [`ConversionReview`][cr].
    ///
    ///The returned [`ConversionReview`][cr] either indicates a success or a failure, which
    ///is handed back to the Kubernetes API server.
    ///
    ///[cr]: ::kube::core::conversion::ConversionReview
    pub fn try_convert(
        review: ::kube::core::conversion::ConversionReview,
    ) -> ::kube::core::conversion::ConversionReview {
        let request = match ::kube::core::conversion::ConversionRequest::from_review(
            review,
        ) {
            ::std::result::Result::Ok(request) => request,
            ::std::result::Result::Err(err) => {
                return ::kube::core::conversion::ConversionResponse::invalid(::kube::core::Status {
                        status: Some(::kube::core::response::StatusSummary::Failure),
                        message: err.to_string(),
                        metadata: None,
                        reason: err.to_string(),
                        details: None,
                        code: 400,
                    })
                    .into_review();
            }
        };
        let response = match Self::convert_objects(
            request.objects,
            &request.desired_api_version,
        ) {
            ::std::result::Result::Ok(converted_objects) => {
                ::kube::core::conversion::ConversionResponse {
                    result: ::kube::core::Status::success(),
                    types: request.types,
                    uid: request.uid,
                    converted_objects,
                }
            }
            ::std::result::Result::Err(err) => {
                let code = err.http_status_code();
                let message = err.join_errors();
                ::kube::core::conversion::ConversionResponse {
                    result: ::kube::core::Status {
                        status: Some(::kube::core::response::StatusSummary::Failure),
                        message: message.clone(),
                        metadata: None,
                        reason: message,
                        details: None,
                        code,
                    },
                    types: request.types,
                    uid: request.uid,
                    converted_objects: vec![],
                }
            }
        };
        response.into_review()
    }
    fn convert_objects(
        objects: ::std::vec::Vec<::serde_json::Value>,
        desired_api_version: &str,
    ) -> ::std::result::Result<
        ::std::vec::Vec<::serde_json::Value>,
        ::stackable_versioned::ConvertObjectError,
    > {
        let desired_api_version = FooVersion::from_api_version(desired_api_version)
            .map_err(|source| ::stackable_versioned::ConvertObjectError::ParseDesiredApiVersion {
                source,
            })?;
        let mut converted_objects = ::std::vec::Vec::with_capacity(objects.len());
        for object in objects {
            let current_object = Self::from_json_object(object.clone())
                .map_err(|source| ::stackable_versioned::ConvertObjectError::Parse {
                    source,
                })?;
            match (current_object, desired_api_version) {
                _ => converted_objects.push(object),
            }
        }
        ::std::result::Result::Ok(converted_objects)
    }
    fn from_json_object(
        object_value: ::serde_json::Value,
    ) -> ::std::result::Result<Self, ::stackable_versioned::ParseObjectError> {
        let kind = object_value
            .get("kind")
            .ok_or_else(|| ::stackable_versioned::ParseObjectError::FieldNotPresent {
                field: "kind".to_owned(),
            })?
            .as_str()
            .ok_or_else(|| ::stackable_versioned::ParseObjectError::FieldNotStr {
                field: "kind".to_owned(),
            })?;
        if kind != "Foo" {
            return Err(::stackable_versioned::ParseObjectError::UnexpectedKind {
                kind: kind.to_owned(),
                expected: "Foo".to_owned(),
            });
        }
        let api_version = object_value
            .get("apiVersion")
            .ok_or_else(|| ::stackable_versioned::ParseObjectError::FieldNotPresent {
                field: "apiVersion".to_owned(),
            })?
            .as_str()
            .ok_or_else(|| ::stackable_versioned::ParseObjectError::FieldNotStr {
                field: "apiVersion".to_owned(),
            })?;
        let object = match api_version {
            "stackable.tech/v1alpha1" => {
                let object = ::serde_json::from_value(object_value)
                    .map_err(|source| ::stackable_versioned::ParseObjectError::Deserialize {
                        source,
                    })?;
                Self::V1Alpha1(object)
            }
            unknown_api_version => {
                return ::std::result::Result::Err(::stackable_versioned::ParseObjectError::UnknownApiVersion {
                    api_version: unknown_api_version.to_owned(),
                });
            }
        };
        ::std::result::Result::Ok(object)
    }
    fn into_json_value(
        self,
    ) -> ::std::result::Result<::serde_json::Value, ::serde_json::Error> {
        match self {
            Self::V1Alpha1(__sv_foo) => Ok(::serde_json::to_value(__sv_foo)?),
        }
    }
}
#[automatically_derived]
#[derive(::core::marker::Copy, ::core::clone::Clone, ::core::fmt::Debug)]
pub(crate) enum FooVersion {
    V1Alpha1,
}
#[automatically_derived]
impl ::core::fmt::Display for FooVersion {
    fn fmt(
        &self,
        f: &mut ::core::fmt::Formatter<'_>,
    ) -> ::std::result::Result<(), ::std::fmt::Error> {
        f.write_str(self.as_version_str())
    }
}
#[automatically_derived]
impl FooVersion {
    pub fn as_version_str(&self) -> &str {
        match self {
            FooVersion::V1Alpha1 => "v1alpha1",
        }
    }
    pub fn as_api_version_str(&self) -> &str {
        match self {
            FooVersion::V1Alpha1 => "stackable.tech/v1alpha1",
        }
    }
    pub fn from_api_version(
        api_version: &str,
    ) -> Result<Self, ::stackable_versioned::UnknownDesiredApiVersionError> {
        match api_version {
            "stackable.tech/v1alpha1" => Ok(FooVersion::V1Alpha1),
            _ => {
                Err(::stackable_versioned::UnknownDesiredApiVersionError {
                    api_version: api_version.to_owned(),
                })
            }
        }
    }
}