Check names in ReqList::contains_request

Signed-off-by: Ryan Bottriell <rbottriell@ilm.com>

Author: rydrman

crates/spk-schema/src/requirements_list.rs

@@ -3,6 +3,7 @@
 // https://github.com/imageworks/spk
 
 use std::collections::HashSet;
+use std::fmt::Write;
 
 use serde::{Deserialize, Serialize};
 use spk_schema_foundation::version::Compatibility;
@@ -81,16 +82,26 @@ impl RequirementsList {
     pub fn contains_request(&self, theirs: &Request) -> Compatibility {
         for ours in self.iter() {
             match (ours, theirs) {
-                (Request::Pkg(ours), Request::Pkg(theirs)) => {
+                (Request::Pkg(ours), Request::Pkg(theirs)) if ours.pkg.name == theirs.pkg.name => {
                     return ours.contains(theirs);
                 }
-                (Request::Var(ours), Request::Var(theirs)) => {
+                (Request::Var(ours), Request::Var(theirs))
+                    // a var request satisfy another if they have the same opt name or
+                    // if our request is package-less and has the same base name, eg:
+                    // name/value     [contains] name/value
+                    // pkg.name/value [contains] pkg.name/value
+                    // name/value     [contains] pkg.name/value
+                    if ours.var == theirs.var || ours.var.as_str() == theirs.var.base_name() =>
+                {
                     return ours.contains(theirs);
                 }
-                _ => continue,
+                _ => {
+                    tracing::trace!("skip {ours}, not {theirs}");
+                    continue;
+                }
             }
         }
-        Compatibility::incompatible("No request exists for this")
+        Compatibility::incompatible(format!("No request exists for {}", theirs.name()))
     }
 
     /// Render all requests with a package pin using the given resolved packages.
@@ -136,7 +147,7 @@ impl RequirementsList {
                             ));
                         }
                         Some(opt) => {
-                            let rendered = request.render_pin(opt)?;
+                            let rendered = request.render_pin(opt.as_str())?;
                             let _ = std::mem::replace(request, rendered);
                         }
                     }
@@ -167,6 +178,20 @@ impl RequirementsList {
     }
 }
 
+impl std::fmt::Display for RequirementsList {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_char('[')?;
+        let mut entries = self.0.iter().peekable();
+        while let Some(i) = entries.next() {
+            i.fmt(f)?;
+            if entries.peek().is_some() {
+                f.write_str(", ")?;
+            }
+        }
+        f.write_char(']')
+    }
+}
+
 impl IntoIterator for RequirementsList {
     type Item = Request;
     type IntoIter = std::vec::IntoIter<Request>;
@@ -199,12 +224,11 @@ impl<'de> Deserialize<'de> for RequirementsList {
                 let mut requirement_names = HashSet::with_capacity(size_hint);
                 while let Some(request) = seq.next_element::<Request>()? {
                     let name = request.name();
-                    if requirement_names.contains(name) {
+                    if !requirement_names.insert(name.to_owned()) {
                         return Err(serde::de::Error::custom(format!(
                             "found multiple install requirements for '{name}'"
                         )));
                     }
-                    requirement_names.insert(name.to_owned());
                     requirements.push(request);
                 }
                 Ok(RequirementsList(requirements))

crates/spk-schema/src/requirements_list_test.rs

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 // https://github.com/imageworks/spk
 use rstest::rstest;
+use serde_json::json;
+use spk_schema_foundation::fixtures::*;
+use spk_schema_foundation::version::Compatibility;
+use spk_schema_ident::Request;
 
 use super::RequirementsList;
 
@@ -12,3 +16,28 @@ fn test_deserialize_no_duplicates() {
     serde_yaml::from_str::<RequirementsList>("[{pkg: python}, {pkg: python}]")
         .expect_err("should fail to deserialize with the same package twice");
 }
+
+#[rstest]
+#[case(
+    json!([
+        {"pkg": "pkg-a"},
+        {"pkg": "pkg-b"},
+    ]),
+    json!({"pkg": "pkg-a"})
+)]
+#[should_panic]
+#[case(
+    json!([
+        {"pkg": "pkg-a"},
+        {"pkg": "pkg-b"},
+    ]),
+    json!({"pkg": "pkg-c"})
+)]
+fn test_contains_request(#[case] requests: serde_json::Value, #[case] contains: serde_json::Value) {
+    init_logging();
+
+    let reqs: RequirementsList = serde_json::from_value(requests).unwrap();
+    let contains: Request = serde_json::from_value(contains).unwrap();
+    tracing::debug!("is {contains} contained within this? {reqs}");
+    assert_eq!(reqs.contains_request(&contains), Compatibility::Compatible);
+}