Handle basic build from source cases

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

Author: jrray

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

@@ -6,12 +6,12 @@ mod pkg_request_version_set;
 mod spk_provider;
 
 use std::borrow::Cow;
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::sync::Arc;
 
 use pkg_request_version_set::{SpkSolvable, SyntheticComponent};
 use spk_provider::SpkProvider;
-use spk_schema::ident::{InclusionPolicy, PinPolicy, PkgRequest, RangeIdent};
+use spk_schema::ident::{InclusionPolicy, LocatedBuildIdent, PinPolicy, PkgRequest, RangeIdent};
 use spk_schema::ident_component::Component;
 use spk_schema::prelude::{HasVersion, Named, Versioned};
 use spk_schema::version_range::VersionFilter;
@@ -31,17 +31,25 @@ mod cdcl_solver_tests;
 pub struct Solver {
     repos: Vec<Arc<RepositoryHandle>>,
     requests: Vec<Request>,
+    binary_only: bool,
     _validators: Cow<'static, [Validators]>,
+    build_from_source_trail: HashSet<LocatedBuildIdent>,
 }
 
 impl Solver {
     pub fn new(repos: Vec<Arc<RepositoryHandle>>, validators: Cow<'static, [Validators]>) -> Self {
         Self {
             repos,
             requests: Vec::new(),
+            binary_only: true,
             _validators: validators,
+            build_from_source_trail: HashSet::new(),
         }
     }
+
+    pub(crate) fn set_build_from_source_trail(&mut self, trail: HashSet<LocatedBuildIdent>) {
+        self.build_from_source_trail = trail;
+    }
 }
 
 impl AbstractSolver for Solver {
@@ -62,16 +70,22 @@ impl AbstractSolver for Solver {
         self._validators = Cow::from(default_validators());
     }
 
-    fn set_binary_only(&mut self, _binary_only: bool) {
-        // TODO
+    fn set_binary_only(&mut self, binary_only: bool) {
+        self.binary_only = binary_only;
     }
 
     async fn solve(&mut self) -> Result<Solution> {
         let repos = self.repos.clone();
         let requests = self.requests.clone();
+        let binary_only = self.binary_only;
+        let build_from_source_trail = self.build_from_source_trail.clone();
         // Use a blocking thread so resolvo can call `block_on` on the runtime.
         let solvables = tokio::task::spawn_blocking(move || {
-            let mut provider = Some(SpkProvider::new(repos.clone()));
+            let mut provider = Some(SpkProvider::new(
+                repos.clone(),
+                binary_only,
+                build_from_source_trail,
+            ));
             let (solver, solved) = loop {
                 let mut this_iter_provider = provider.take().expect("provider is always Some");
                 let pkg_requirements = this_iter_provider.pkg_requirements(&requests);
@@ -216,17 +230,25 @@ impl AbstractSolver for Solver {
                 located_build_ident_with_component.ident.name().to_owned(),
                 next_index,
             );
-            solution_adds.push((
-                pkg_request,
-                package,
-                PackageSource::Repository {
-                    repo: Arc::clone(&repo),
-                    // XXX: Why is this needed?
-                    components: repo
-                        .read_components(located_build_ident_with_component.ident.target())
-                        .await?,
-                },
-            ));
+            solution_adds.push((pkg_request, package, {
+                if located_build_ident_with_component.requires_build_from_source {
+                    PackageSource::BuildFromSource {
+                        recipe: repo
+                            .read_recipe(
+                                &located_build_ident_with_component.ident.to_version_ident(),
+                            )
+                            .await?,
+                    }
+                } else {
+                    PackageSource::Repository {
+                        repo: Arc::clone(&repo),
+                        // XXX: Why is this needed?
+                        components: repo
+                            .read_components(located_build_ident_with_component.ident.target())
+                            .await?,
+                    }
+                }
+            }));
         }
         let mut solution = Solution::new(solution_options);
         for (pkg_request, package, source) in solution_adds {

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

@@ -104,10 +104,28 @@ impl SyntheticComponent {
     }
 }
 
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+// The `requires_build_from_source` field is ignored for hashing and equality
+// purposes.
+#[derive(Clone, Debug)]
 pub(crate) struct LocatedBuildIdentWithComponent {
     pub(crate) ident: LocatedBuildIdent,
     pub(crate) component: SyntheticComponent,
+    pub(crate) requires_build_from_source: bool,
+}
+
+impl std::hash::Hash for LocatedBuildIdentWithComponent {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ident.hash(state);
+        self.component.hash(state);
+    }
+}
+
+impl Eq for LocatedBuildIdentWithComponent {}
+
+impl PartialEq for LocatedBuildIdentWithComponent {
+    fn eq(&self, other: &Self) -> bool {
+        self.ident == other.ident && self.component == other.component
+    }
 }
 
 impl LocatedBuildIdentWithComponent {