| use std::collections::{BTreeMap, BTreeSet}; |
| use std::fmt::Debug; |
| |
| use serde::ser::{SerializeMap, Serializer}; |
| use serde::Serialize; |
| use serde_starlark::{FunctionCall, MULTILINE}; |
| |
| use crate::select::{Select, SelectableScalar}; |
| use crate::utils::starlark::{ |
| looks_like_bazel_configuration_label, NoMatchingPlatformTriples, WithOriginalConfigurations, |
| }; |
| |
| #[derive(Debug, PartialEq, Eq)] |
| pub(crate) struct SelectScalar<T> |
| where |
| T: SelectableScalar, |
| { |
| common: Option<T>, |
| selects: BTreeMap<String, WithOriginalConfigurations<T>>, |
| // Elements from the `Select` whose configuration did not get mapped to any |
| // new configuration. They could be ignored, but are preserved here to |
| // generate comments that help the user understand what happened. |
| unmapped: BTreeMap<String, T>, |
| } |
| |
| impl<T> SelectScalar<T> |
| where |
| T: SelectableScalar, |
| { |
| /// Re-keys the provided Select by the given configuration mapping. |
| /// This mapping maps from configurations in the input Select to sets of |
| /// configurations in the output SelectScalar. |
| pub(crate) fn new(select: Select<T>, platforms: &BTreeMap<String, BTreeSet<String>>) -> Self { |
| let (common, selects) = select.into_parts(); |
| |
| // Map new configuration -> WithOriginalConfigurations(value, old configurations). |
| let mut remapped: BTreeMap<String, WithOriginalConfigurations<T>> = BTreeMap::new(); |
| // Map unknown configuration -> value. |
| let mut unmapped: BTreeMap<String, T> = BTreeMap::new(); |
| |
| for (original_configuration, value) in selects { |
| match platforms.get(&original_configuration) { |
| Some(configurations) => { |
| for configuration in configurations { |
| remapped |
| .entry(configuration.clone()) |
| .or_insert_with(|| WithOriginalConfigurations { |
| value: value.clone(), |
| original_configurations: BTreeSet::new(), |
| }) |
| .original_configurations |
| .insert(original_configuration.clone()); |
| } |
| } |
| None => { |
| if looks_like_bazel_configuration_label(&original_configuration) { |
| remapped |
| .entry(original_configuration.clone()) |
| .or_insert_with(|| WithOriginalConfigurations { |
| value: value.clone(), |
| original_configurations: BTreeSet::new(), |
| }) |
| .original_configurations |
| .insert(original_configuration.clone()); |
| } else { |
| unmapped.insert(original_configuration.clone(), value); |
| } |
| } |
| } |
| } |
| |
| Self { |
| common, |
| selects: remapped, |
| unmapped, |
| } |
| } |
| |
| /// Determine whether or not the select should be serialized |
| pub(crate) fn is_empty(&self) -> bool { |
| self.common.is_none() && self.selects.is_empty() && self.unmapped.is_empty() |
| } |
| } |
| |
| impl<T> Serialize for SelectScalar<T> |
| where |
| T: SelectableScalar, |
| { |
| fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
| where |
| S: Serializer, |
| { |
| // If there are no platform-specific entries, we output just an ordinary |
| // value. |
| // |
| // If there are platform-specific ones, we use the following. |
| // |
| // select({ |
| // "configuration": "plat-value", # cfg(whatever), |
| // "//conditions:default": "common-value", |
| // }) |
| // |
| // If there are unmapped entries, we include them like this: |
| // |
| // selects.with_unmapped({ |
| // "configuration": "plat-value", # cfg(whatever), |
| // "//conditions:default": "common-value", |
| // selects.NO_MATCHING_PLATFORM_TRIPLES: { |
| // "cfg(obscure)": [ |
| // "unmapped-value", |
| // ], |
| // }, |
| // }) |
| |
| if self.common.is_some() && self.selects.is_empty() && self.unmapped.is_empty() { |
| return self.common.as_ref().unwrap().serialize(serializer); |
| } |
| |
| struct SelectInner<'a, T>(&'a SelectScalar<T>) |
| where |
| T: SelectableScalar; |
| |
| impl<'a, T> Serialize for SelectInner<'a, T> |
| where |
| T: SelectableScalar, |
| { |
| fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
| where |
| S: Serializer, |
| { |
| let mut map = serializer.serialize_map(Some(MULTILINE))?; |
| for (configuration, value) in self.0.selects.iter() { |
| map.serialize_entry(configuration, value)?; |
| } |
| if let Some(common) = self.0.common.as_ref() { |
| map.serialize_entry("//conditions:default", common)?; |
| } |
| if !self.0.unmapped.is_empty() { |
| struct SelectUnmapped<'a, T>(&'a BTreeMap<String, T>) |
| where |
| T: SelectableScalar; |
| |
| impl<'a, T> Serialize for SelectUnmapped<'a, T> |
| where |
| T: SelectableScalar, |
| { |
| fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> |
| where |
| S: Serializer, |
| { |
| let mut map = serializer.serialize_map(Some(MULTILINE))?; |
| for (cfg, value) in self.0.iter() { |
| map.serialize_entry(cfg, value)?; |
| } |
| map.end() |
| } |
| } |
| |
| map.serialize_entry( |
| &NoMatchingPlatformTriples, |
| &SelectUnmapped(&self.0.unmapped), |
| )?; |
| } |
| map.end() |
| } |
| } |
| |
| let function = if self.unmapped.is_empty() { |
| "select" |
| } else { |
| "selects.with_unmapped" |
| }; |
| |
| FunctionCall::new(function, [SelectInner(self)]).serialize(serializer) |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use super::*; |
| |
| use indoc::indoc; |
| |
| #[test] |
| fn empty_select_value() { |
| let select_value: SelectScalar<String> = |
| SelectScalar::new(Default::default(), &Default::default()); |
| |
| let expected_starlark = indoc! {r#" |
| select({}) |
| "#}; |
| |
| assert_eq!( |
| select_value.serialize(serde_starlark::Serializer).unwrap(), |
| expected_starlark, |
| ); |
| } |
| |
| #[test] |
| fn no_platform_specific_select_value() { |
| let mut select: Select<String> = Select::default(); |
| select.insert("Hello".to_owned(), None); |
| |
| let select_value = SelectScalar::new(select, &Default::default()); |
| |
| let expected_starlark = indoc! {r#" |
| "Hello" |
| "#}; |
| |
| assert_eq!( |
| select_value.serialize(serde_starlark::Serializer).unwrap(), |
| expected_starlark, |
| ); |
| } |
| |
| #[test] |
| fn only_platform_specific_select_value() { |
| let mut select: Select<String> = Select::default(); |
| select.insert("Hello".to_owned(), Some("platform".to_owned())); |
| |
| let platforms = BTreeMap::from([( |
| "platform".to_owned(), |
| BTreeSet::from(["platform".to_owned()]), |
| )]); |
| |
| let select_value = SelectScalar::new(select, &platforms); |
| |
| let expected_starlark = indoc! {r#" |
| select({ |
| "platform": "Hello", # platform |
| }) |
| "#}; |
| |
| assert_eq!( |
| select_value.serialize(serde_starlark::Serializer).unwrap(), |
| expected_starlark, |
| ); |
| } |
| |
| #[test] |
| fn mixed_select_value() { |
| let mut select: Select<String> = Select::default(); |
| select.insert("Hello".to_owned(), Some("platform".to_owned())); |
| select.insert("Goodbye".to_owned(), None); |
| |
| let platforms = BTreeMap::from([( |
| "platform".to_owned(), |
| BTreeSet::from(["platform".to_owned()]), |
| )]); |
| |
| let select_value = SelectScalar::new(select, &platforms); |
| |
| let expected_starlark = indoc! {r#" |
| select({ |
| "platform": "Hello", # platform |
| "//conditions:default": "Goodbye", |
| }) |
| "#}; |
| |
| assert_eq!( |
| select_value.serialize(serde_starlark::Serializer).unwrap(), |
| expected_starlark, |
| ); |
| } |
| |
| #[test] |
| fn remap_select_value_configurations() { |
| let mut select: Select<String> = Select::default(); |
| select.insert("a".to_owned(), Some("cfg(macos)".to_owned())); |
| select.insert("a".to_owned(), Some("cfg(x86_64)".to_owned())); |
| select.insert("e".to_owned(), Some("cfg(pdp11)".to_owned())); |
| select.insert("f".to_owned(), Some("@platforms//os:magic".to_owned())); |
| select.insert("g".to_owned(), Some("//another:platform".to_owned())); |
| |
| let platforms = BTreeMap::from([ |
| ( |
| "cfg(macos)".to_owned(), |
| BTreeSet::from(["x86_64-macos".to_owned(), "aarch64-macos".to_owned()]), |
| ), |
| ( |
| "cfg(x86_64)".to_owned(), |
| BTreeSet::from(["x86_64-linux".to_owned(), "x86_64-macos".to_owned()]), |
| ), |
| ]); |
| |
| let select_value = SelectScalar::new(select, &platforms); |
| |
| let expected = SelectScalar { |
| common: None, |
| selects: BTreeMap::from([ |
| ( |
| "x86_64-macos".to_owned(), |
| WithOriginalConfigurations { |
| value: "a".to_owned(), |
| original_configurations: BTreeSet::from([ |
| "cfg(macos)".to_owned(), |
| "cfg(x86_64)".to_owned(), |
| ]), |
| }, |
| ), |
| ( |
| "aarch64-macos".to_owned(), |
| WithOriginalConfigurations { |
| value: "a".to_owned(), |
| original_configurations: BTreeSet::from(["cfg(macos)".to_owned()]), |
| }, |
| ), |
| ( |
| "x86_64-linux".to_owned(), |
| WithOriginalConfigurations { |
| value: "a".to_owned(), |
| original_configurations: BTreeSet::from(["cfg(x86_64)".to_owned()]), |
| }, |
| ), |
| ( |
| "@platforms//os:magic".to_owned(), |
| WithOriginalConfigurations { |
| value: "f".to_owned(), |
| original_configurations: BTreeSet::from( |
| ["@platforms//os:magic".to_owned()], |
| ), |
| }, |
| ), |
| ( |
| "//another:platform".to_owned(), |
| WithOriginalConfigurations { |
| value: "g".to_owned(), |
| original_configurations: BTreeSet::from(["//another:platform".to_owned()]), |
| }, |
| ), |
| ]), |
| unmapped: BTreeMap::from([("cfg(pdp11)".to_owned(), "e".to_owned())]), |
| }; |
| |
| assert_eq!(select_value, expected); |
| |
| let expected_starlark = indoc! {r#" |
| selects.with_unmapped({ |
| "//another:platform": "g", # //another:platform |
| "@platforms//os:magic": "f", # @platforms//os:magic |
| "aarch64-macos": "a", # cfg(macos) |
| "x86_64-linux": "a", # cfg(x86_64) |
| "x86_64-macos": "a", # cfg(macos), cfg(x86_64) |
| selects.NO_MATCHING_PLATFORM_TRIPLES: { |
| "cfg(pdp11)": "e", |
| }, |
| }) |
| "#}; |
| |
| assert_eq!( |
| select_value.serialize(serde_starlark::Serializer).unwrap(), |
| expected_starlark, |
| ); |
| } |
| } |
