feat(baseline): display baseline by bcd key (#200)

* feat(baseline): display baseline by bcd key

* rename and fix by key status

Author: fiji-flo

.gitignore

@@ -12,3 +12,6 @@ tests/data/translated_content/files/*
 # Must be top level so these are included in npm publish.
 rari-npm/schema.json
 rari-npm/lib/rari-types.d.ts
+
+# inline deps
+/.deps

Cargo.lock

@@ -94,7 +94,7 @@ console = "0.15"
 sha2 = "0.10"
 dashmap = { version = "6", features = ["serde"] }
 serde_yaml_ng = "0.10"
-schemars = { version = "0.8", features = ["chrono"] }
+schemars = { version = "0.8", features = ["chrono", "url"] }
 pretty_yaml = "0.5"
 yaml_parser = "0.2"
 const_format = "0.2"

Cargo.toml

@@ -22,7 +22,5 @@ html-minifier = "5"
 ansi-to-html = "0.2"
 similar = "2"
 quick-xml = "0.37"
-sha2 = "0.10"
 clap = { version = "4", features = ["derive"] }
-dashmap = "6"
 lol_html = "2"

crates/diff-test/Cargo.toml

@@ -8,12 +8,10 @@ use std::io::{BufWriter, Write as _};
 use std::path::Path;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::Relaxed;
-use std::sync::{Arc, LazyLock};
+use std::sync::LazyLock;
 
 use anyhow::{anyhow, Error};
-use base64::prelude::{Engine as _, BASE64_STANDARD_NO_PAD};
 use clap::{Args, Parser, Subcommand};
-use dashmap::DashMap;
 use ignore::types::TypesBuilder;
 use ignore::WalkBuilder;
 use itertools::Itertools;
@@ -23,7 +21,6 @@ use prettydiff::{diff_lines, diff_words};
 use rayon::prelude::*;
 use regex::Regex;
 use serde_json::Value;
-use sha2::{Digest, Sha256};
 use xml::fmt_html;
 
 mod xml;
@@ -203,9 +200,6 @@ static WS_DIFF: LazyLock<Regex> =
 
 static EMPTY_P_DIFF: LazyLock<Regex> = LazyLock::new(|| Regex::new(r#"<p>[\n ]*</p>"#).unwrap());
 
-static DIFF_MAP: LazyLock<Arc<DashMap<String, String>>> =
-    LazyLock::new(|| Arc::new(DashMap::new()));
-
 /// Run html content through these handlers to clean up the html before minifying and diffing.
 fn pre_diff_element_massaging_handlers<'a>(
     _args: &BuildArgs,
@@ -353,15 +347,6 @@ fn full_diff(
                     rhs = fmt_html(&html_minifier::minify(rhs_t).unwrap());
                 }
                 if lhs != rhs {
-                    let mut diff_hash = Sha256::new();
-                    diff_hash.write_all(lhs.as_bytes()).unwrap();
-                    diff_hash.write_all(rhs.as_bytes()).unwrap();
-                    let diff_hash = BASE64_STANDARD_NO_PAD.encode(&diff_hash.finalize()[..]);
-                    if let Some(hash) = DIFF_MAP.get(&diff_hash) {
-                        diff.insert(key, format!("See {}", hash.as_str()));
-                        return;
-                    }
-                    DIFF_MAP.insert(diff_hash, "somewhere else".into());
                     diff.insert(
                         key,
                         ansi_to_html::convert(&if args.fast {

crates/diff-test/src/main.rs

@@ -19,9 +19,10 @@ use crate::error::Error;
 #[derive(Debug, Clone, Serialize, JsonSchema)]
 pub struct Baseline<'a> {
     #[serde(flatten)]
-    pub support: &'a SupportStatusWithByKey,
+    pub support: &'a SupportStatus,
     #[serde(skip_serializing_if = "std::ops::Not::not")]
     pub asterisk: bool,
+    pub feature: &'a FeatureData,
 }
 
 #[derive(Deserialize, Serialize, Clone, Debug)]
@@ -32,6 +33,7 @@ pub struct WebFeatures {
 
 #[derive(Deserialize, Serialize, Clone, Debug)]
 pub struct KeyStatus {
+    bcd_key_spaced: String,
     bcd_key: String,
     feature: String,
 }
@@ -46,11 +48,6 @@ fn spaced(bcd_key: &str) -> String {
     bcd_key.replace('.', " ")
 }
 
-#[inline]
-fn unspaced(bcd_key: &str) -> String {
-    bcd_key.replace(' ', ".")
-}
-
 impl WebFeatures {
     pub fn from_file(path: &Path) -> Result<Self, Error> {
         let json_str = read_to_string(path)?;
@@ -86,28 +83,29 @@ impl WebFeatures {
             .iter()
             .flat_map(|(feature, fd)| {
                 fd.compat_features.iter().map(|bcd_key| KeyStatus {
-                    bcd_key: spaced(bcd_key),
+                    bcd_key: bcd_key.clone(),
+                    bcd_key_spaced: spaced(bcd_key),
                     feature: feature.clone(),
                 })
             })
             .collect();
-        bcd_keys.sort_by(|a, b| a.bcd_key.cmp(&b.bcd_key));
-        bcd_keys.dedup_by(|a, b| a.bcd_key == b.bcd_key);
+        bcd_keys.sort_by(|a, b| a.bcd_key_spaced.cmp(&b.bcd_key_spaced));
+        bcd_keys.dedup_by(|a, b| a.bcd_key_spaced == b.bcd_key_spaced);
 
         let map = WebFeatures { features, bcd_keys };
         Ok(map)
     }
 
-    pub fn sub_keys(&self, bcd_key: &str) -> &[KeyStatus] {
-        let suffix = concat_strs!(bcd_key, " ");
+    pub fn sub_keys(&self, bcd_key_spaced: &str) -> &[KeyStatus] {
+        let suffix = concat_strs!(bcd_key_spaced, " ");
         if let Ok(start) = self
             .bcd_keys
-            .binary_search_by_key(&bcd_key, |ks| &ks.bcd_key)
+            .binary_search_by_key(&bcd_key_spaced, |ks| &ks.bcd_key_spaced)
         {
             if start < self.bcd_keys.len() {
                 if let Some(end) = self.bcd_keys[start + 1..]
                     .iter()
-                    .position(|ks| !ks.bcd_key.starts_with(&suffix))
+                    .position(|ks| !ks.bcd_key_spaced.starts_with(&suffix))
                 {
                     return &self.bcd_keys[start + 1..start + 1 + end];
                 }
@@ -118,154 +116,120 @@ impl WebFeatures {
 
     // Compute status according to:
     // https://github.com/mdn/yari/issues/11546#issuecomment-2531611136
-    pub fn feature_status(&self, bcd_key: &str) -> Option<Baseline> {
+    pub fn baseline_by_bcd_key(&self, bcd_key: &str) -> Option<Baseline> {
         let bcd_key_spaced = &spaced(bcd_key);
-        if let Some(status) = self.feature_status_internal(bcd_key_spaced) {
-            let sub_keys = self.sub_keys(bcd_key_spaced);
-            let sub_status = sub_keys
-                .iter()
-                .map(|sub_key| {
-                    self.feature_status_internal_with_feature_name(
-                        &sub_key.bcd_key,
-                        &sub_key.feature,
-                    )
-                    .and_then(|status| status.baseline)
-                })
-                .collect::<Vec<_>>();
-
-            if sub_status
-                .iter()
-                .all(|baseline| baseline == &status.baseline)
-            {
-                return Some(Baseline {
-                    support: status,
-                    asterisk: false,
-                });
-            }
-            match status.baseline {
-                Some(BaselineHighLow::False) => {
-                    let Support {
-                        chrome,
-                        chrome_android,
-                        firefox,
-                        firefox_android,
-                        safari,
-                        safari_ios,
-                        ..
-                    } = &status.support;
-                    if chrome == chrome_android
-                        && firefox == firefox_android
-                        && safari == safari_ios
-                    {
-                        return Some(Baseline {
-                            support: status,
-                            asterisk: false,
-                        });
-                    }
-                }
-                Some(BaselineHighLow::Low) => {
-                    if sub_status
+        if let Some(feature) = self.feature_data_by_key(bcd_key_spaced) {
+            if let Some(status) = feature.status.as_ref() {
+                if let Some(status_for_key) = status
+                    .by_compat_key
+                    .as_ref()
+                    .and_then(|by_key| by_key.get(bcd_key))
+                {
+                    let sub_keys = self.sub_keys(bcd_key_spaced);
+                    let sub_status = sub_keys
                         .iter()
-                        .all(|ss| matches!(ss, Some(BaselineHighLow::Low | BaselineHighLow::High)))
+                        .map(|sub_key| {
+                            self.feature_data_by_name(&sub_key.feature)
+                                .and_then(|feature| feature.status.as_ref())
+                                .and_then(|status| status.by_compat_key.as_ref())
+                                .and_then(|by_key| by_key.get(&sub_key.bcd_key))
+                                .and_then(|status_for_key| status_for_key.baseline)
+                        })
+                        .collect::<Vec<_>>();
+
+                    let asterisk = if sub_status
+                        .iter()
+                        .all(|baseline| baseline == &status.baseline)
                     {
-                        return Some(Baseline {
-                            support: status,
-                            asterisk: false,
-                        });
-                    }
+                        false
+                    } else {
+                        match status.baseline {
+                            Some(BaselineHighLow::False) => {
+                                let Support {
+                                    chrome,
+                                    chrome_android,
+                                    firefox,
+                                    firefox_android,
+                                    safari,
+                                    safari_ios,
+                                    ..
+                                } = &status.support;
+                                !(chrome == chrome_android
+                                    && firefox == firefox_android
+                                    && safari == safari_ios)
+                            }
+                            Some(BaselineHighLow::Low) => !sub_status.iter().all(|ss| {
+                                matches!(ss, Some(BaselineHighLow::Low | BaselineHighLow::High))
+                            }),
+                            _ => true,
+                        }
+                    };
+                    return Some(Baseline {
+                        support: status_for_key,
+                        asterisk,
+                        feature,
+                    });
                 }
-                _ => {}
             }
-            Some(Baseline {
-                support: status,
-                asterisk: true,
-            })
-        } else {
-            None
         }
+        None
     }
 
-    fn feature_status_internal(&self, bcd_key_spaced: &str) -> Option<&SupportStatusWithByKey> {
+    fn feature_data_by_key(&self, bcd_key_spaced: &str) -> Option<&FeatureData> {
         if let Ok(i) = self
             .bcd_keys
-            .binary_search_by(|ks| ks.bcd_key.as_str().cmp(bcd_key_spaced))
+            .binary_search_by(|ks| ks.bcd_key_spaced.as_str().cmp(bcd_key_spaced))
         {
             let feature_name = &self.bcd_keys[i].feature;
-            return self.feature_status_internal_with_feature_name(bcd_key_spaced, feature_name);
+            return self.feature_data_by_name(feature_name);
         }
         None
     }
 
-    fn feature_status_internal_with_feature_name(
-        &self,
-        bcd_key_spaced: &str,
-        feature_name: &str,
-    ) -> Option<&SupportStatusWithByKey> {
+    fn feature_data_by_name(&self, feature_name: &str) -> Option<&FeatureData> {
         if let Some(feature_data) = self.features.get(feature_name) {
             if feature_data.discouraged.is_some() {
                 return None;
             }
-            if let Some(ref status) = feature_data.status {
-                if let Some(by_key) = &status.by_compat_key {
-                    if let Some(key_status) = by_key.get(&unspaced(bcd_key_spaced)) {
-                        if key_status.baseline == status.baseline {
-                            return Some(status);
-                        }
-                    }
-                }
-            }
+            return Some(feature_data);
         }
         None
     }
 }
 
-#[derive(Deserialize, Serialize, Clone, Debug)]
+#[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 pub struct FeatureData {
     /** Specification */
-    #[serde(
-        deserialize_with = "t_or_vec",
-        default,
-        skip_serializing_if = "Vec::is_empty"
-    )]
+    #[serde(deserialize_with = "t_or_vec", default, skip_serializing)]
     pub spec: Vec<Url>,
     /** caniuse.com identifier */
-    #[serde(
-        deserialize_with = "t_or_vec",
-        default,
-        skip_serializing_if = "Vec::is_empty"
-    )]
+    #[serde(deserialize_with = "t_or_vec", default, skip_serializing)]
     pub caniuse: Vec<String>,
     /** Whether a feature is considered a "baseline" web platform feature and when it achieved that status */
     #[serde(skip_serializing_if = "Option::is_none")]
     pub status: Option<SupportStatusWithByKey>,
     /** Sources of support data for this feature */
-    #[serde(
-        deserialize_with = "t_or_vec",
-        default,
-        skip_serializing_if = "Vec::is_empty"
-    )]
+    #[serde(deserialize_with = "t_or_vec", default, skip_serializing)]
     pub compat_features: Vec<String>,
+    #[serde(skip_serializing)]
     pub description: String,
     pub description_html: String,
     #[serde(
         deserialize_with = "t_or_vec",
         default,
         skip_serializing_if = "Vec::is_empty"
     )]
+    #[serde(skip_serializing)]
     pub group: Vec<String>,
     pub name: String,
-    #[serde(
-        deserialize_with = "t_or_vec",
-        default,
-        skip_serializing_if = "Vec::is_empty"
-    )]
+    #[serde(deserialize_with = "t_or_vec", default, skip_serializing)]
     pub snapshot: Vec<String>,
     /** Whether developers are formally discouraged from using this feature */
     #[serde(skip_serializing_if = "Option::is_none")]
     pub discouraged: Option<Discouraged>,
 }
 
-#[derive(Deserialize, Serialize, Clone, Debug)]
+#[derive(Deserialize, Serialize, Clone, Debug, JsonSchema)]
 pub struct Discouraged {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     according_to: Vec<String>,

crates/rari-data/src/baseline.rs

@@ -39,7 +39,7 @@ static WEB_FEATURES: LazyLock<Option<WebFeatures>> = LazyLock::new(|| {
 pub(crate) fn get_baseline<'a>(browser_compat: &[String]) -> Option<Baseline<'a>> {
     if let Some(ref web_features) = *WEB_FEATURES {
         return match &browser_compat {
-            &[bcd_key] => web_features.feature_status(bcd_key.as_str()),
+            &[bcd_key] => web_features.baseline_by_bcd_key(bcd_key.as_str()),
             _ => None,
         };
     }