Add menu item called Feature flags

Feature flags should show all available features
for current crate version with default being first
is specified.

Author: almusil

Cargo.lock

@@ -53,6 +53,7 @@ lol_html = "0.2"
 font-awesome-as-a-crate = { path = "crates/font-awesome-as-a-crate" }
 dashmap = "3.11.10"
 string_cache = "0.8.0"
+postgres-types = { version = "0.1.3", features = ["derive"] }
 
 # Async
 tokio = { version = "0.2.22", features = ["rt-threaded"] }

Cargo.toml

@@ -5,6 +5,7 @@ use std::{
 };
 
 use crate::{
+    db::types::Feature,
     docbuilder::{BuildResult, DocCoverage},
     error::Result,
     index::api::{CrateData, CrateOwner, ReleaseData},
@@ -42,6 +43,7 @@ pub(crate) fn add_package_into_database(
     let dependencies = convert_dependencies(metadata_pkg);
     let rustdoc = get_rustdoc(metadata_pkg, source_dir).unwrap_or(None);
     let readme = get_readme(metadata_pkg, source_dir).unwrap_or(None);
+    let features = get_features(metadata_pkg);
     let is_library = metadata_pkg.is_library();
 
     let rows = conn.query(
@@ -52,12 +54,12 @@ pub(crate) fn add_package_into_database(
             homepage_url, description, description_long, readme,
             authors, keywords, have_examples, downloads, files,
             doc_targets, is_library, doc_rustc_version,
-            documentation_url, default_target
+            documentation_url, default_target, features
          )
          VALUES (
             $1,  $2,  $3,  $4,  $5,  $6,  $7,  $8,  $9,
             $10, $11, $12, $13, $14, $15, $16, $17, $18,
-            $19, $20, $21, $22, $23, $24, $25
+            $19, $20, $21, $22, $23, $24, $25, $26
          )
          ON CONFLICT (crate_id, version) DO UPDATE
             SET release_time = $3,
@@ -82,7 +84,8 @@ pub(crate) fn add_package_into_database(
                 is_library = $22,
                 doc_rustc_version = $23,
                 documentation_url = $24,
-                default_target = $25
+                default_target = $25,
+                features = $26
          RETURNING id",
         &[
             &crate_id,
@@ -110,6 +113,7 @@ pub(crate) fn add_package_into_database(
             &res.rustc_version,
             &metadata_pkg.documentation,
             &default_target,
+            &features,
         ],
     )?;
 
@@ -213,6 +217,35 @@ fn convert_dependencies(pkg: &MetadataPackage) -> Vec<(String, String, String)>
         .collect()
 }
 
+/// Reads features and converts them to Vec<Feature> with default being first
+fn get_features(pkg: &MetadataPackage) -> Vec<Feature> {
+    let mut features = Vec::with_capacity(pkg.features.len());
+    if let Some(subfeatures) = pkg.features.get("default") {
+        features.push(Feature::new("default".into(), subfeatures.clone()));
+    };
+    features.extend(
+        pkg.features
+            .iter()
+            .filter(|(name, _)| !name.eq(&"default"))
+            .map(|(name, subfeatures)| Feature::new(name.clone(), subfeatures.clone())),
+    );
+    features.extend(get_optional_features(pkg));
+    features
+}
+
+fn get_optional_features(pkg: &MetadataPackage) -> Vec<Feature> {
+    pkg.dependencies
+        .iter()
+        .filter(|dep| dep.optional)
+        .filter(|dep| {
+            pkg.features
+                .values()
+                .any(|features| features.iter().any(|sub| sub.eq(&dep.name)))
+        })
+        .map(|dep| Feature::new(dep.name.clone(), Vec::new()))
+        .collect()
+}
+
 /// Reads readme if there is any read defined in Cargo.toml of a Package
 fn get_readme(pkg: &MetadataPackage, source_dir: &Path) -> Result<Option<String>> {
     let readme_path = source_dir.join(pkg.readme.as_deref().unwrap_or("README.md"));

src/db/add_package.rs

@@ -457,7 +457,24 @@ pub fn migrate(version: Option<Version>, conn: &mut Client) -> CratesfyiResult<(
                 DROP COLUMN total_items_needing_examples,
                 DROP COLUMN items_with_examples;
             "
-        )
+        ),
+        migration!(
+            context,
+            // version
+            19,
+            // description
+            "Add features that are available for given release",
+            // upgrade query
+            "
+                CREATE TYPE feature AS (name TEXT, subfeatures TEXT[]);
+                ALTER TABLE releases ADD COLUMN features feature[];
+            ",
+            // downgrade query
+            "
+                ALTER TABLE releases DROP COLUMN features;
+                DROP TYPE feature;                         
+            "
+        ),
     ];
 
     for migration in migrations {

src/db/migrate.rs

@@ -15,3 +15,4 @@ mod delete;
 pub(crate) mod file;
 mod migrate;
 mod pool;
+pub(crate) mod types;

src/db/mod.rs

@@ -0,0 +1,26 @@
+use failure::_core::fmt::Formatter;
+use postgres_types::{FromSql, ToSql};
+use serde::Serialize;
+
+#[derive(Debug, Clone, PartialEq, Serialize, FromSql, ToSql)]
+#[postgres(name = "feature")]
+pub struct Feature {
+    name: String,
+    subfeatures: Vec<String>,
+}
+
+impl Feature {
+    pub fn new(name: String, subfeatures: Vec<String>) -> Self {
+        Feature { name, subfeatures }
+    }
+
+    pub fn is_private(&self) -> bool {
+        self.name.starts_with('_')
+    }
+}
+
+impl std::fmt::Display for Feature {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{} = {:?}", self.name, self.subfeatures)
+    }
+}

src/db/types.rs

@@ -5,6 +5,7 @@ use crate::storage::Storage;
 use crate::utils::{Dependency, MetadataPackage, Target};
 use chrono::{DateTime, Utc};
 use failure::Error;
+use std::collections::HashMap;
 use std::sync::Arc;
 
 #[must_use = "FakeRelease does nothing until you call .create()"]
@@ -48,11 +49,21 @@ impl<'a> FakeRelease<'a> {
                     name: "fake-dependency".into(),
                     req: "^1.0.0".into(),
                     kind: None,
+                    optional: false,
                 }],
                 targets: vec![Target::dummy_lib("fake_package".into(), None)],
                 readme: None,
                 keywords: vec!["fake".into(), "package".into()],
                 authors: vec!["Fake Person <[email protected]>".into()],
+                features: [
+                    ("default".into(), vec!["feature1".into(), "feature3".into()]),
+                    ("feature1".into(), Vec::new()),
+                    ("feature2".into(), vec!["feature1".into()]),
+                    ("feature3".into(), Vec::new()),
+                ]
+                .iter()
+                .cloned()
+                .collect::<HashMap<String, Vec<String>>>(),
             },
             build_result: BuildResult {
                 rustc_version: "rustc 2.0.0-nightly (000000000 1970-01-01)".into(),
@@ -199,6 +210,11 @@ impl<'a> FakeRelease<'a> {
         self
     }
 
+    pub(crate) fn features(mut self, features: HashMap<String, Vec<String>>) -> Self {
+        self.package.features = features;
+        self
+    }
+
     /// Returns the release_id
     pub(crate) fn create(self) -> Result<i32, Error> {
         use std::fs;

src/test/fakes.rs

@@ -77,6 +77,7 @@ pub(crate) struct Package {
     pub(crate) readme: Option<String>,
     pub(crate) keywords: Vec<String>,
     pub(crate) authors: Vec<String>,
+    pub(crate) features: HashMap<String, Vec<String>>,
 }
 
 impl Package {
@@ -131,6 +132,7 @@ pub(crate) struct Dependency {
     pub(crate) name: String,
     pub(crate) req: String,
     pub(crate) kind: Option<String>,
+    pub(crate) optional: bool,
 }
 
 #[derive(Deserialize, Serialize)]

src/utils/cargo_metadata.rs

@@ -1,5 +1,5 @@
 use super::{match_version, redirect_base, render_markdown, MatchSemver, MetaData};
-use crate::{db::Pool, impl_webpage, web::page::WebPage};
+use crate::{db::types::Feature, db::Pool, impl_webpage, web::page::WebPage};
 use chrono::{DateTime, NaiveDateTime, Utc};
 use iron::prelude::*;
 use iron::Url;
@@ -45,6 +45,7 @@ pub struct CrateDetails {
     documented_items: Option<f32>,
     total_items_needing_examples: Option<f32>,
     items_with_examples: Option<f32>,
+    features: Option<Vec<String>>,
     /// Database id for this crate
     pub(crate) crate_id: i32,
     /// Database id for this release
@@ -103,6 +104,7 @@ impl CrateDetails {
                 releases.license,
                 releases.documentation_url,
                 releases.default_target,
+                releases.features,
                 doc_coverage.total_items,
                 doc_coverage.documented_items,
                 doc_coverage.total_items_needing_examples,
@@ -187,6 +189,7 @@ impl CrateDetails {
             total_items: total_items.map(|v| v as f32),
             total_items_needing_examples: total_items_needing_examples.map(|v| v as f32),
             items_with_examples: items_with_examples.map(|v| v as f32),
+            features: get_features(krate.get("features")),
             crate_id,
             release_id,
         };
@@ -278,6 +281,15 @@ fn map_to_release(conn: &mut Client, crate_id: i32, version: semver::Version) ->
     }
 }
 
+fn get_features(features: Option<Vec<Feature>>) -> Option<Vec<String>> {
+    features.map(|vec| {
+        vec.iter()
+            .filter(|feature| !feature.is_private())
+            .map(|feature| format!("{}", feature))
+            .collect()
+    })
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize)]
 struct CrateDetailsPage {
     details: CrateDetails,
@@ -325,6 +337,7 @@ mod tests {
     use crate::test::{wrapper, TestDatabase};
     use failure::Error;
     use kuchiki::traits::TendrilSink;
+    use std::collections::HashMap;
 
     fn assert_last_successful_build_equals(
         db: &TestDatabase,
@@ -741,4 +754,42 @@ mod tests {
             Ok(())
         });
     }
+
+    #[test]
+    fn feature_flags_is_hidden_when_empty() {
+        wrapper(|env| {
+            env.fake_release()
+                .name("binary")
+                .version("0.1.0")
+                .binary(true)
+                .features(HashMap::new())
+                .create()?;
+
+            let page = kuchiki::parse_html()
+                .one(env.frontend().get("/crate/binary/0.1.0").send()?.text()?);
+            assert!(page.select_first(r#"a[aria-label="Feature"]"#).is_err());
+            Ok(())
+        });
+    }
+
+    #[test]
+    fn feature_private_feature_flags_are_hidden() {
+        wrapper(|env| {
+            let features = [("_private".into(), Vec::new())]
+                .iter()
+                .cloned()
+                .collect::<HashMap<String, Vec<String>>>();
+            env.fake_release()
+                .name("binary")
+                .version("0.1.0")
+                .binary(true)
+                .features(features)
+                .create()?;
+
+            let page = kuchiki::parse_html()
+                .one(env.frontend().get("/crate/binary/0.1.0").send()?.text()?);
+            assert!(page.select_first(r#"a[aria-label="Feature"]"#).is_err());
+            Ok(())
+        });
+    }
 }

src/web/crate_details.rs

@@ -226,7 +226,26 @@
                 </li>
             {%- endfor -%}
         </ul>
-    </li>
+    </li>{#
+    Display the features available in current build
+    #}
+    {% if krate.features %}
+        <li class="pure-menu-item pure-menu-has-children">
+            <a href="#" class="pure-menu-link" aria-label="Features">
+                {{ "flag" | fas }}
+                <span class="title">Feature flags</span>
+            </a>
+
+            {# Build the dropdown list showing available features #}
+            <ul class="pure-menu-children">
+                {%- for feature in krate.features -%}
+                    <li class="pure-menu-item">
+                        <span class="pure-menu-link">{{ feature }}</span>
+                    </li>
+                {%- endfor -%}
+            </ul>
+        </li>
+    {%- endif -%}
 </ul>
 
 {%- include "header/topbar_end.html" -%}