Remove unused code in EmbeddedRecipeSpec

As seen from coverage tests.

Signed-off-by: J Robert Ray <jrray@jrray.org>

Author: jrray

crates/spk-schema/src/v0/embedded_recipe_spec.rs

@@ -2,19 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/spkenv/spk
 
-use std::borrow::Cow;
-use std::str::FromStr;
-
 use serde::{Deserialize, Serialize};
 use spk_schema_foundation::IsDefault;
 use spk_schema_foundation::ident::{AsVersionIdent, VersionIdent};
-use spk_schema_foundation::version::{IncompatibleReason, VarOptionProblem};
 
 use super::TestSpec;
 use crate::foundation::name::PkgName;
 use crate::foundation::spec_ops::prelude::*;
-use crate::foundation::version::{Compat, Compatibility, Version};
-use crate::ident::{Satisfy, VarRequest, is_false};
+use crate::foundation::version::{Compat, Version};
+use crate::ident::is_false;
 use crate::metadata::Meta;
 use crate::v0::{EmbeddedBuildSpec, EmbeddedInstallSpec, EmbeddedPackageSpec};
 use crate::{
@@ -23,7 +19,6 @@ use crate::{
     Deprecate,
     DeprecateMut,
     EnvOp,
-    Opt,
     Result,
     RuntimeEnvironment,
     SourceSpec,
@@ -54,26 +49,6 @@ pub struct EmbeddedRecipeSpec {
     pub install: EmbeddedInstallSpec,
 }
 
-impl EmbeddedRecipeSpec {
-    /// Create an empty spec for the identified package
-    pub fn new(ident: VersionIdent) -> Self {
-        Self {
-            pkg: ident,
-            meta: Meta::default(),
-            compat: Compat::default(),
-            deprecated: bool::default(),
-            sources: Vec::new(),
-            build: EmbeddedBuildSpec::default(),
-            tests: Vec::new(),
-            install: EmbeddedInstallSpec::default(),
-        }
-    }
-
-    pub fn build_options(&self) -> Cow<'_, [Opt]> {
-        Cow::Borrowed(self.build.options.as_slice())
-    }
-}
-
 impl AsVersionIdent for EmbeddedRecipeSpec {
     fn as_version_ident(&self) -> &VersionIdent {
         self.pkg.as_version_ident()
@@ -128,95 +103,6 @@ impl Versioned for EmbeddedRecipeSpec {
     }
 }
 
-impl Satisfy<VarRequest> for EmbeddedRecipeSpec
-where
-    Self: Named,
-{
-    fn check_satisfies_request(&self, var_request: &VarRequest) -> Compatibility {
-        let opt_required = var_request.var.namespace() == Some(self.name());
-        let mut opt: Option<&Opt> = None;
-        let request_name = &var_request.var;
-        for o in self.build.options.iter() {
-            if request_name == o.full_name() {
-                opt = Some(o);
-                break;
-            }
-            if request_name == &o.full_name().with_namespace(self.name()) {
-                opt = Some(o);
-                break;
-            }
-        }
-
-        match opt {
-            None => {
-                if opt_required {
-                    return Compatibility::Incompatible(IncompatibleReason::VarOptionMissing(
-                        var_request.var.clone(),
-                    ));
-                }
-                Compatibility::Compatible
-            }
-            Some(Opt::Pkg(opt)) => opt.validate(var_request.value.as_pinned()),
-            Some(Opt::Var(opt)) => {
-                let request_value = var_request.value.as_pinned();
-                let exact = opt.get_value(request_value);
-                if exact.as_deref() == request_value {
-                    return Compatibility::Compatible;
-                }
-
-                // For values that aren't exact matches, if the option specifies
-                // a compat rule, try treating the values as version numbers
-                // and see if they satisfy the rule.
-                if let Some(compat) = &opt.compat {
-                    let base_version = exact.clone();
-                    let Ok(base_version) = Version::from_str(&base_version.unwrap_or_default())
-                    else {
-                        return Compatibility::Incompatible(IncompatibleReason::VarOptionMismatch(
-                            VarOptionProblem::IncompatibleBuildOptionInvalidVersion {
-                                var_request: var_request.var.clone(),
-                                base: exact.unwrap_or_default(),
-                                request_value: request_value.unwrap_or_default().to_string(),
-                            },
-                        ));
-                    };
-
-                    let Ok(request_version) = Version::from_str(request_value.unwrap_or_default())
-                    else {
-                        return Compatibility::Incompatible(IncompatibleReason::VarOptionMismatch(
-                            VarOptionProblem::IncompatibleBuildOptionInvalidVersion {
-                                var_request: var_request.var.clone(),
-                                base: exact.unwrap_or_default(),
-                                request_value: request_value.unwrap_or_default().to_string(),
-                            },
-                        ));
-                    };
-
-                    let result = compat.is_binary_compatible(&base_version, &request_version);
-                    if let Compatibility::Incompatible(incompatible) = result {
-                        return Compatibility::Incompatible(IncompatibleReason::VarOptionMismatch(
-                            VarOptionProblem::IncompatibleBuildOptionWithContext {
-                                var_request: var_request.var.clone(),
-                                exact: exact.unwrap_or_else(|| "None".to_string()),
-                                request_value: request_value.unwrap_or_default().to_string(),
-                                context: Box::new(incompatible),
-                            },
-                        ));
-                    }
-                    return result;
-                }
-
-                Compatibility::Incompatible(IncompatibleReason::VarOptionMismatch(
-                    VarOptionProblem::IncompatibleBuildOption {
-                        var_request: var_request.var.clone(),
-                        exact: exact.unwrap_or_else(|| "None".to_string()),
-                        request_value: request_value.unwrap_or_default().to_string(),
-                    },
-                ))
-            }
-        }
-    }
-}
-
 impl From<EmbeddedPackageSpec> for EmbeddedRecipeSpec {
     fn from(pkg_spec: EmbeddedPackageSpec) -> Self {
         Self {