Add CheckCfg/ExpectedValues to cargo-platform

Author: Urgau

crates/cargo-platform/src/check_cfg.rs

@@ -0,0 +1,71 @@
+//! check-cfg
+
+use std::collections::{HashMap, HashSet};
+
+/// Check Config (aka `--print=check-cfg` representation)
+#[derive(Debug, Default, Clone)]
+pub struct CheckCfg {
+    /// Is `--check-cfg` activated
+    pub exhaustive: bool,
+    /// List of expected cfgs
+    pub expecteds: HashMap<String, ExpectedValues>,
+}
+
+/// List of expected check-cfg values
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ExpectedValues {
+    /// List of expected values
+    Some(HashSet<Option<String>>),
+    /// All values expected
+    Any,
+}
+
+impl CheckCfg {
+    /// Process an output line
+    pub fn process_line(&mut self, line: &str) {
+        if line == "any()=any()" || line == "any()" {
+            self.exhaustive = false;
+            return;
+        }
+
+        let mut value: HashSet<Option<String>> = HashSet::default();
+        let mut value_any_specified = false;
+        let name: String;
+
+        if let Some((n, val)) = line.split_once('=') {
+            name = n.to_string();
+
+            if val == "any()" {
+                value_any_specified = true;
+            } else if val.is_empty() {
+                // no value to add
+                // strip "" around the value, e.g. "linux" -> linux
+            } else if let Some(val) = val.strip_prefix('"').map(|v| v.strip_suffix('"')).flatten() {
+                value.insert(Some(val.to_string()));
+            } else {
+                // missing quotes and non-empty, ignore
+                return;
+            }
+        } else {
+            name = line.to_string();
+            value.insert(None);
+        }
+
+        self.expecteds
+            .entry(name)
+            .and_modify(|v| match v {
+                ExpectedValues::Some(v) if !value_any_specified => {
+                    v.extend(value.clone());
+                }
+                ExpectedValues::Some(_) => *v = ExpectedValues::Any,
+                ExpectedValues::Any => {}
+            })
+            .or_insert_with(|| {
+                if value_any_specified {
+                    ExpectedValues::Any
+                } else {
+                    ExpectedValues::Some(value)
+                }
+            });
+    }
+}

crates/cargo-platform/src/lib.rs

@@ -12,9 +12,11 @@ use std::fmt;
 use std::str::FromStr;
 
 mod cfg;
+mod check_cfg;
 mod error;
 
 pub use cfg::{Cfg, CfgExpr};
+pub use check_cfg::{CheckCfg, ExpectedValues};
 pub use error::{ParseError, ParseErrorKind};
 
 /// Platform definition.

crates/cargo-platform/tests/test_check_cfg.rs

@@ -0,0 +1,79 @@
+use cargo_platform::{CheckCfg, ExpectedValues};
+use std::collections::HashSet;
+
+#[test]
+fn check_cfg_none() {
+    let mut check_cfg = CheckCfg::default();
+
+    check_cfg.process_line("cfg_a");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_a").unwrap(),
+        ExpectedValues::Some(HashSet::from([None]))
+    );
+}
+
+#[test]
+fn check_cfg_empty() {
+    let mut check_cfg = CheckCfg::default();
+
+    check_cfg.process_line("cfg_b=");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_b").unwrap(),
+        ExpectedValues::Some(HashSet::from([]))
+    );
+}
+
+#[test]
+fn check_cfg_any() {
+    let mut check_cfg = CheckCfg::default();
+
+    check_cfg.process_line("cfg_c=any()");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_c").unwrap(),
+        ExpectedValues::Any
+    );
+
+    check_cfg.process_line("cfg_c");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_c").unwrap(),
+        ExpectedValues::Any
+    );
+}
+
+#[test]
+fn check_cfg_value() {
+    let mut check_cfg = CheckCfg::default();
+
+    check_cfg.process_line("cfg_d=\"test\"");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_d").unwrap(),
+        ExpectedValues::Some(HashSet::from([Some("test".to_string())]))
+    );
+
+    check_cfg.process_line("cfg_d=\"tmp\"");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_d").unwrap(),
+        ExpectedValues::Some(HashSet::from([
+            Some("test".to_string()),
+            Some("tmp".to_string())
+        ]))
+    );
+}
+
+#[test]
+fn check_cfg_weird() {
+    let mut check_cfg = CheckCfg::default();
+
+    check_cfg.process_line("cfg_e=\"double_quote\"\"");
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_e").unwrap(),
+        ExpectedValues::Some(HashSet::from([Some("double_quote\"".to_string())]))
+    );
+
+    check_cfg.process_line("cfg_e=any()"); // this shouldn't be possible but better handle this
+                                           // correctly anyway
+    assert_eq!(
+        *check_cfg.expecteds.get("cfg_e").unwrap(),
+        ExpectedValues::Any
+    );
+}