Start to implement handling embedded packages

A handful of tests now pass but `todo!`s remain. One test was modified
to be less picky about how the build is populated when the solve
includes an embedded package. The new solver populates the embedded
package parent info instead of leaving it as "Unknown".

Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spk-solve/src/cdcl_solver/spk_provider.rs

@@ -3,7 +3,7 @@
 // https://github.com/spkenv/spk
 
 use std::cell::{Cell, RefCell};
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeSet, HashMap, HashSet};
 use std::sync::Arc;
 
 use resolvo::utils::Pool;
@@ -22,9 +22,20 @@ use resolvo::{
     VersionSetUnionId,
 };
 use spk_schema::foundation::pkg_name;
-use spk_schema::ident::{LocatedBuildIdent, PinnableValue, PkgRequest, Satisfy, VarRequest};
+use spk_schema::ident::{
+    LocatedBuildIdent,
+    PinnableValue,
+    PkgRequest,
+    RangeIdent,
+    RequestedBy,
+    Satisfy,
+    VarRequest,
+};
+use spk_schema::ident_build::{Build, EmbeddedSource, EmbeddedSourcePackage};
 use spk_schema::ident_component::Component;
 use spk_schema::name::{OptNameBuf, PkgNameBuf};
+use spk_schema::prelude::{HasVersion, Named};
+use spk_schema::version_range::{DoubleEqualsVersion, VersionFilter};
 use spk_schema::{Opt, Package, Request, VersionIdent};
 use spk_storage::RepositoryHandle;
 
@@ -456,6 +467,19 @@ impl DependencyProvider for SpkProvider {
                     let located_build_ident =
                         LocatedBuildIdent::new(repo.name().to_owned(), build.clone());
                     if let SyntheticComponent::Actual(pkg_name_component) = &pkg_name.component {
+                        if let Build::Embedded(EmbeddedSource::Package(parent)) = build.build() {
+                            // Embedded packages don't have components, but
+                            // their parent has a component.
+                            if parent.components.contains(pkg_name_component) {
+                                located_builds.push(LocatedBuildIdentWithComponent {
+                                    ident: located_build_ident,
+                                    component: SyntheticComponent::Actual(
+                                        pkg_name_component.clone(),
+                                    ),
+                                });
+                            }
+                            continue;
+                        }
                         let components =
                             repo.list_build_components(&build).await.unwrap_or_default();
                         for component in components.into_iter().chain(
@@ -692,6 +716,67 @@ impl DependencyProvider for SpkProvider {
                             .extend(self.pkg_requirements(&component_spec.requirements));
                     }
                 }
+                // Also add dependencies on any packages embedded in this
+                // component.
+                // XXX: This ignores the detail of embeds inside components for
+                // now.
+                for embedded in package.embedded().iter() {
+                    let dep_name = self.pool.intern_package_name(PkgNameBufWithComponent {
+                        name: embedded.name().to_owned(),
+                        component: located_build_ident_with_component.component.clone(),
+                    });
+                    known_deps.requirements.push(
+                        self.pool
+                            .intern_version_set(
+                                dep_name,
+                                RequestVS::SpkRequest(Request::Pkg(PkgRequest::new(
+                                    RangeIdent {
+                                        repository_name: Some(
+                                            located_build_ident_with_component
+                                                .ident
+                                                .repository_name()
+                                                .to_owned(),
+                                        ),
+                                        name: embedded.name().to_owned(),
+                                        components: Default::default(),
+                                        version: VersionFilter::single(
+                                            DoubleEqualsVersion::version_range(
+                                                embedded.version().clone(),
+                                            ),
+                                        ),
+                                        // This needs to match the build of
+                                        // the stub for get_candidates to like
+                                        // it.
+                                        build: Some(Build::Embedded(EmbeddedSource::Package(
+                                            Box::new(EmbeddedSourcePackage {
+                                                ident: package.ident().into(),
+                                                // XXX: Hard coded to Run for
+                                                // now.
+                                                components: BTreeSet::from_iter([Component::Run]),
+                                            }),
+                                        ))),
+                                    },
+                                    RequestedBy::Embedded(
+                                        located_build_ident_with_component.ident.target().clone(),
+                                    ),
+                                ))),
+                            )
+                            .into(),
+                    );
+                    // Any install requirements of components inside embedded
+                    // packages with the same name as this component also
+                    // become dependencies.
+                    for embedded_component_requirement in embedded
+                        .components()
+                        .iter()
+                        .filter(|embedded_component| {
+                            embedded_component.name == located_build_ident_with_component.component
+                        })
+                        .flat_map(|embedded_component| embedded_component.requirements.iter())
+                    {
+                        todo!("{embedded_component_requirement:?}");
+                    }
+                }
                 for option in package.get_build_options() {
                     let Opt::Var(var_opt) = option else {
                         continue;

crates/spk-solve/src/solver_test.rs

@@ -67,6 +67,16 @@ macro_rules! assert_resolved {
         assert_eq!(pkg.spec.ident().build(), &$build, $message);
     }};
 
+    ($solution:ident, $pkg:literal, build =~ $build:pat) => {
+        assert_resolved!($solution, $pkg, build =~ $build, "wrong package build was resolved")
+    };
+    ($solution:ident, $pkg:literal, build =~ $build:pat, $message:literal) => {{
+        let pkg = $solution
+            .get($pkg)
+            .expect("expected package to be in solution");
+        assert!(matches!(pkg.spec.ident().build(), $build), $message);
+    }};
+
     ($solution:ident, $pkg:literal, components = [$($component:literal),+ $(,)?]) => {{
         let mut resolved = std::collections::HashSet::<String>::new();
         let pkg = $solution
@@ -510,8 +520,6 @@ async fn test_solver_dependency_already_satisfied(#[case] mut solver: SolverImpl
 
 #[rstest]
 #[case::og(og_solver())]
-// Remove #[should_panic] once cdcl handles this case
-#[should_panic]
 #[case::cdcl(cdcl_solver())]
 #[tokio::test]
 async fn test_solver_dependency_already_satisfied_conflicting_components(
@@ -1279,8 +1287,6 @@ async fn test_solver_build_from_source_deprecated_and_impossible_initial_checks(
 
 #[rstest]
 #[case::og(og_solver())]
-// Remove #[should_panic] once cdcl handles this case
-#[should_panic]
 #[case::cdcl(cdcl_solver())]
 #[tokio::test]
 async fn test_solver_embedded_package_adds_request(#[case] mut solver: SolverImpl) {
@@ -1301,18 +1307,21 @@ async fn test_solver_embedded_package_adds_request(#[case] mut solver: SolverImp
     solver.add_repository(Arc::new(repo));
     solver.add_request(request!("maya"));
 
-    let solution = run_and_print_resolve_for_tests(&mut solver).await.unwrap();
+    let solution = run_and_print_resolve_for_tests(&mut solver)
+        .await
+        .tap_err(|e| eprintln!("{e}"))
+        .unwrap();
 
     assert_resolved!(
         solution,
         "qt",
-        build = Build::Embedded(EmbeddedSource::Unknown)
+        build =~ Build::Embedded(_)
     );
     assert_resolved!(solution, "qt", "5.12.6");
     assert_resolved!(
         solution,
         "qt",
-        build = Build::Embedded(EmbeddedSource::Unknown)
+        build =~ Build::Embedded(_)
     );
 }
 
@@ -1358,8 +1367,6 @@ async fn test_solver_embedded_package_solvable(#[case] mut solver: SolverImpl) {
 
 #[rstest]
 #[case::og(og_solver())]
-// Remove #[should_panic] once cdcl handles this case
-#[should_panic]
 #[case::cdcl(cdcl_solver())]
 #[tokio::test]
 async fn test_solver_embedded_package_unsolvable(#[case] mut solver: SolverImpl) {
@@ -1739,7 +1746,6 @@ async fn test_solver_some_versions_conflicting_requests(#[case] mut solver: Solv
 
 #[rstest]
 #[case::og(og_solver())]
-#[should_panic]
 #[case::cdcl(cdcl_solver())]
 #[tokio::test]
 async fn test_solver_embedded_request_invalidates(#[case] mut solver: SolverImpl) {
@@ -2629,8 +2635,6 @@ async fn test_solver_component_embedded_multiple_versions(
 
 #[rstest]
 #[case::og(og_solver())]
-// Remove #[should_panic] once cdcl handles this case
-#[should_panic]
 #[case::cdcl(cdcl_solver())]
 #[tokio::test]
 async fn test_solver_component_embedded_incompatible_requests(#[case] mut solver: SolverImpl) {