Mark default features with a *

Fixes rust-lang#2531 by marking every (transitive) default feature with a `*`.
The features list is already sorted according to depth-first `"default"` order first, and according to the number of sub-features.

I changed that so the secondary sort order is alphabetic, as that might make more sense than sorting by number of sub-features.

Author: Swatinem

src/web/features.rs

@@ -16,10 +16,20 @@ use std::collections::{HashMap, VecDeque};
 
 const DEFAULT_NAME: &str = "default";
 
+#[derive(Debug, Clone, Serialize)]
+struct DocsFeature {
+    name: String,
+    subfeatures: Vec<String>,
+    is_default: bool,
+}
+
+type AllFeatures = HashMap<String, DocsFeature>;
+
 #[derive(Debug, Clone, Serialize)]
 struct FeaturesPage {
     metadata: MetaData,
-    features: Option<Vec<Feature>>,
+    all_features: AllFeatures,
+    sorted_features: Option<Vec<String>>,
     default_len: usize,
     canonical_url: CanonicalUrl,
     is_latest_url: bool,
@@ -66,18 +76,21 @@ pub(crate) async fn build_features_handler(
     .await?
     .ok_or_else(|| anyhow!("missing release"))?;
 
-    let mut features = None;
+    let mut all_features = HashMap::new();
+    let mut sorted_features = None;
     let mut default_len = 0;
 
     if let Some(raw_features) = row.features {
         let result = order_features_and_count_default_len(raw_features);
-        features = Some(result.0);
-        default_len = result.1;
+        all_features = result.0;
+        sorted_features = Some(result.1);
+        default_len = result.2;
     }
 
     Ok(FeaturesPage {
         metadata,
-        features,
+        all_features,
+        sorted_features,
         default_len,
         is_latest_url: req_version.is_latest(),
         canonical_url: CanonicalUrl::from_path(format!("/crate/{}/latest/features", &name)),
@@ -86,40 +99,64 @@ pub(crate) async fn build_features_handler(
     .into_response())
 }
 
-fn order_features_and_count_default_len(raw: Vec<Feature>) -> (Vec<Feature>, usize) {
-    let mut feature_map = get_feature_map(raw);
-    let mut features = get_tree_structure_from_default(&mut feature_map);
-    let mut remaining = Vec::from_iter(feature_map.into_values());
-    remaining.sort_by_key(|feature| feature.subfeatures.len());
+fn order_features_and_count_default_len(raw: Vec<Feature>) -> (AllFeatures, Vec<String>, usize) {
+    let mut all_features = get_all_features(raw);
+    let sorted_features = get_sorted_features(&mut all_features);
 
-    let default_len = features.len();
+    let default_len = all_features.values().filter(|f| f.is_default).count();
 
-    features.extend(remaining.into_iter().rev());
-    (features, default_len)
+    (all_features, sorted_features, default_len)
 }
 
-fn get_tree_structure_from_default(feature_map: &mut HashMap<String, Feature>) -> Vec<Feature> {
-    let mut features = Vec::new();
-    let mut queue: VecDeque<String> = VecDeque::new();
-
-    queue.push_back(DEFAULT_NAME.into());
-    while !queue.is_empty() {
-        let name = queue.pop_front().unwrap();
-        if let Some(feature) = feature_map.remove(&name) {
+/// This flags all features as being reachable from `"default"`,
+/// and returns them as a sorted list.
+///
+/// The sorting order depends on depth-first traversal of the default features,
+/// and alphabetically otherwise.
+fn get_sorted_features(all_features: &mut AllFeatures) -> Vec<String> {
+    let mut sorted_features = Vec::new();
+    let mut working_features: HashMap<&str, &mut DocsFeature> = all_features
+        .iter_mut()
+        .map(|(k, v)| (k.as_str(), v))
+        .collect();
+
+    // this does a depth-first traversal starting at the special `"default"` feature
+    let mut queue: VecDeque<&str> = VecDeque::new();
+    queue.push_back(DEFAULT_NAME);
+
+    while let Some(name) = queue.pop_front() {
+        if let Some(feature) = working_features.remove(name) {
             feature
                 .subfeatures
                 .iter()
-                .for_each(|sub| queue.push_back(sub.clone()));
-            features.push(feature);
+                .for_each(|sub| queue.push_back(sub.as_str()));
+            feature.is_default = true;
+            sorted_features.push(feature.name.clone());
         }
     }
-    features
+
+    // the rest of the features not reachable from `"default"` are sorted alphabetically
+    let mut remaining = Vec::from_iter(working_features.into_values());
+    remaining.sort_by(|f1, f2| f2.name.cmp(&f1.name));
+    sorted_features.extend(remaining.into_iter().map(|f| f.name.clone()).rev());
+
+    sorted_features
 }
 
-fn get_feature_map(raw: Vec<Feature>) -> HashMap<String, Feature> {
+/// Parses the raw [`Feature`] into a map of the more structured [`DocsFeature`].
+fn get_all_features(raw: Vec<Feature>) -> AllFeatures {
     raw.into_iter()
         .filter(|feature| !feature.is_private())
-        .map(|feature| (feature.name.clone(), feature))
+        .map(|feature| {
+            (
+                feature.name.clone(),
+                DocsFeature {
+                    name: feature.name,
+                    subfeatures: feature.subfeatures,
+                    is_default: false,
+                },
+            )
+        })
         .collect()
 }
 
@@ -135,11 +172,11 @@ mod tests {
         let feature2 = Feature::new("feature2".into(), Vec::new());
 
         let raw = vec![private1.clone(), feature2.clone()];
-        let feature_map = get_feature_map(raw);
+        let all_features = get_all_features(raw);
 
-        assert_eq!(feature_map.len(), 1);
-        assert!(feature_map.contains_key(&feature2.name));
-        assert!(!feature_map.contains_key(&private1.name));
+        assert_eq!(all_features.len(), 1);
+        assert!(all_features.contains_key(&feature2.name));
+        assert!(!all_features.contains_key(&private1.name));
     }
 
     #[test]
@@ -160,17 +197,23 @@ mod tests {
             feature2.clone(),
             feature1.clone(),
         ];
-        let mut feature_map = get_feature_map(raw);
-        let default_tree = get_tree_structure_from_default(&mut feature_map);
-
-        assert_eq!(feature_map.len(), 1);
-        assert_eq!(default_tree.len(), 4);
-        assert!(feature_map.contains_key(&non_default.name));
-        assert!(!feature_map.contains_key(&default.name));
-        assert_eq!(default_tree[0], default);
-        assert_eq!(default_tree[1], feature1);
-        assert_eq!(default_tree[2], feature2);
-        assert_eq!(default_tree[3], feature3);
+        let mut all_features = get_all_features(raw);
+        let sorted_features = get_sorted_features(&mut all_features);
+
+        assert_eq!(all_features.len(), 5);
+
+        assert_eq!(
+            sorted_features,
+            vec![
+                "default".to_string(),
+                "feature1".into(),
+                "feature2".into(),
+                "feature3".into(),
+                "non-default".into()
+            ]
+        );
+        assert!(all_features["feature3"].is_default);
+        assert!(!all_features["non-default"].is_default);
     }
 
     #[test]
@@ -183,14 +226,16 @@ mod tests {
         let feature3 = Feature::new("feature3".into(), Vec::new());
 
         let raw = vec![feature3.clone(), feature2.clone(), feature1.clone()];
-        let mut feature_map = get_feature_map(raw);
-        let default_tree = get_tree_structure_from_default(&mut feature_map);
-
-        assert_eq!(feature_map.len(), 3);
-        assert_eq!(default_tree.len(), 0);
-        assert!(feature_map.contains_key(&feature1.name));
-        assert!(feature_map.contains_key(&feature2.name));
-        assert!(feature_map.contains_key(&feature3.name));
+        let mut all_features = get_all_features(raw);
+        let sorted_features = get_sorted_features(&mut all_features);
+
+        assert_eq!(
+            sorted_features,
+            vec!["feature1".to_string(), "feature2".into(), "feature3".into()]
+        );
+        assert!(!all_features["feature1"].is_default);
+        assert!(!all_features["feature2"].is_default);
+        assert!(!all_features["feature3"].is_default);
     }
 
     #[test]
@@ -199,14 +244,15 @@ mod tests {
         let non_default = Feature::new("non-default".into(), Vec::new());
 
         let raw = vec![default.clone(), non_default.clone()];
-        let mut feature_map = get_feature_map(raw);
-        let default_tree = get_tree_structure_from_default(&mut feature_map);
-
-        assert_eq!(feature_map.len(), 1);
-        assert_eq!(default_tree.len(), 1);
-        assert!(feature_map.contains_key(&non_default.name));
-        assert!(!feature_map.contains_key(&default.name));
-        assert_eq!(default_tree[0], default);
+        let mut all_features = get_all_features(raw);
+        let sorted_features = get_sorted_features(&mut all_features);
+
+        assert_eq!(
+            sorted_features,
+            vec!["default".to_string(), "non-default".into()]
+        );
+        assert!(all_features["default"].is_default);
+        assert!(!all_features["non-default"].is_default);
     }
 
     #[test]
@@ -219,13 +265,14 @@ mod tests {
         let feature3 = Feature::new("feature3".into(), Vec::new());
 
         let raw = vec![feature3.clone(), feature2.clone(), feature1.clone()];
-        let (features, default_len) = order_features_and_count_default_len(raw);
+        let (_all_features, sorted_features, default_len) =
+            order_features_and_count_default_len(raw);
 
-        assert_eq!(features.len(), 3);
+        assert_eq!(
+            sorted_features,
+            vec!["feature1".to_string(), "feature2".into(), "feature3".into()]
+        );
         assert_eq!(default_len, 0);
-        assert_eq!(features[0], feature1);
-        assert_eq!(features[1], feature2);
-        assert_eq!(features[2], feature3);
     }
 
     #[test]
@@ -234,12 +281,14 @@ mod tests {
         let non_default = Feature::new("non-default".into(), Vec::new());
 
         let raw = vec![default.clone(), non_default.clone()];
-        let (features, default_len) = order_features_and_count_default_len(raw);
+        let (_all_features, sorted_features, default_len) =
+            order_features_and_count_default_len(raw);
 
-        assert_eq!(features.len(), 2);
+        assert_eq!(
+            sorted_features,
+            vec!["default".to_string(), "non-default".into()]
+        );
         assert_eq!(default_len, 1);
-        assert_eq!(features[0], default);
-        assert_eq!(features[1], non_default);
     }
 
     #[test]

templates/crate/features.html

@@ -34,15 +34,16 @@
                 <div class="pure-menu package-menu">
                     <ul class="pure-menu-list">
                         <li class="pure-menu-heading">Feature flags</li>
-                        {%- if features -%}
-                            {%- for feature in features -%}
+                        {%- if sorted_features -%}
+                            {%- for name in sorted_features -%}
+                                {%- set feature = all_features | get(key=name) -%}
                                 <li class="pure-menu-item">
-                                    <a href="#{{ feature.name }}" class="pure-menu-link text-center">
-                                        {{ feature.name }}
+                                    <a href="#{{ name }}" class="pure-menu-link text-center">
+                                        {{ name }} {%- if feature.is_default -%}*{%- endif -%}
                                     </a>
                                 </li>
                             {%- endfor -%}
-                        {%- elif features is iterable -%}
+                        {%- elif sorted_features is iterable -%}
                             <li class="pure-menu-item">
                                 <span class="documented-info">This release does not have any feature flags.</span>
                             </li>
@@ -68,23 +69,25 @@ <h1>{{ metadata.name }}</h1>
                     <a href="/crate/{{ metadata.name }}/{{ metadata.req_version }}/source/Cargo.toml.orig">Cargo.toml</a>
                     in case the author documented the features in them.
                 </div>
-                {%- if features -%}
-                    <p>This version has <b>{{ features | length }}</b> feature flags, <b data-id="default-feature-len">{{ default_len }}</b> of them enabled by <b>default</b>.</p>
-                    {%- for feature in features -%}
-                        <h3 id="{{ feature.name }}">{{ feature.name }}</h3>
+                {%- if sorted_features -%}
+                    <p>This version has <b>{{ sorted_features | length }}</b> feature flags, <b data-id="default-feature-len">{{ default_len }}</b> of them enabled by <b>default</b>.</p>
+                    {%- for name in sorted_features -%}
+                        {%- set feature = all_features | get(key=name) -%}
+                        <h3 id="{{ name }}">{{ name }} {%- if feature.is_default -%}*{%- endif -%}</h3>
                         <ul class="pure-menu-list">
                             {%- if feature.subfeatures -%}
-                                {%- for subfeature in feature.subfeatures -%}
+                                {%- for name in feature.subfeatures -%}
+                                    {%- set feature = all_features | get(key=name, default=false) -%}
                                     <li class="pure-menu-item">
-                                        <span>{{ subfeature }}</span>
+                                        <span>{{ name }} {%- if feature and feature.is_default -%}*{%- endif -%}</span>
                                     </li>
                                 {%- endfor -%}
                             {%- else -%}
                                 <p>This feature flag does not enable additional features.</p>
                             {%- endif -%}
                         </ul>
                     {%- endfor -%}
-                {%- elif features is iterable  -%}
+                {%- elif sorted_features is iterable -%}
                     <p data-id="empty-features">This release does not have any feature flags.</p>
                 {%- else -%}
                 <p data-id="null-features">