publish: Read features metadata from embedded Cargo.toml file

src/controllers/krate/publish.rs

@@ -185,16 +185,27 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
             return Err(cargo_err("expected at most 5 categories per crate"));
         }
 
+        let features = tarball_info.manifest.features.unwrap_or_default();
+        for (key, values) in features.iter() {
+            if !Crate::valid_feature_name(key) {
+                return Err(cargo_err(&format!(
+                    "\"{key}\" is an invalid feature name (feature names must contain only letters, numbers, '-', '+', or '_')"
+                )));
+            }
+
+            for value in values.iter() {
+                if !Crate::valid_feature(value) {
+                    return Err(cargo_err(&format!("\"{value}\" is an invalid feature name")));
+                }
+            }
+        }
+
+
         // Create a transaction on the database, if there are no errors,
         // commit the transactions to record a new or updated crate.
         conn.transaction(|conn| {
             let name = metadata.name;
             let vers = &*metadata.vers;
-            let features = metadata
-                .features
-                .into_iter()
-                .map(|(k, v)| (k.0, v.into_iter().map(|v| v.0).collect()))
-                .collect();
             let keywords = keywords.iter().map(|s| s.as_str()).collect::<Vec<_>>();
             let categories = categories.iter().map(|s| s.as_str()).collect::<Vec<_>>();
 

src/tests/builders/publish.rs

@@ -1,5 +1,5 @@
 use bytes::{BufMut, Bytes, BytesMut};
-use cargo_manifest::{DependencyDetail, DepsSet, FeatureSet, MaybeInherited};
+use cargo_manifest::{DependencyDetail, DepsSet, MaybeInherited};
 use crates_io::models::DependencyKind;
 use crates_io::views::krate_publish as u;
 use std::collections::BTreeMap;
@@ -24,7 +24,7 @@ pub struct PublishBuilder {
     manifest: Manifest,
     readme: Option<String>,
     version: semver::Version,
-    features: BTreeMap<u::EncodableFeatureName, Vec<u::EncodableFeature>>,
+    features: BTreeMap<String, Vec<String>>,
 }
 
 enum Manifest {
@@ -112,12 +112,8 @@ impl PublishBuilder {
 
     // Adds a feature.
     pub fn feature(mut self, name: &str, values: &[&str]) -> Self {
-        let values = values
-            .iter()
-            .map(|s| u::EncodableFeature(s.to_string()))
-            .collect();
-        self.features
-            .insert(u::EncodableFeatureName(name.to_string()), values);
+        let values = values.iter().map(ToString::to_string).collect();
+        self.features.insert(name.to_string(), values);
         self
     }
 
@@ -140,7 +136,6 @@ impl PublishBuilder {
         let metadata = u::PublishMetadata {
             name: u::EncodableCrateName(self.krate_name.clone()),
             vers: u::EncodableCrateVersion(self.version.clone()),
-            features: self.features.clone(),
             deps: self.deps.clone(),
             readme: self.readme,
             readme_file: None,
@@ -180,7 +175,7 @@ impl PublishBuilder {
                     build_dependencies: build_deps.none_or_filled(),
                     dependencies: deps.none_or_filled(),
                     dev_dependencies: dev_deps.none_or_filled(),
-                    features: convert_features(self.features).none_or_filled(),
+                    features: self.features.none_or_filled(),
                     ..Default::default()
                 };
 
@@ -277,15 +272,6 @@ fn is_simple_dependency(dep: &u::EncodableCrateDependency) -> bool {
         && dep.registry.is_none()
 }
 
-fn convert_features(
-    encoded: BTreeMap<u::EncodableFeatureName, Vec<u::EncodableFeature>>,
-) -> FeatureSet {
-    encoded
-        .into_iter()
-        .map(|(key, value)| (key.0, value.into_iter().map(|f| f.0).collect()))
-        .collect()
-}
-
 trait NoneOrFilled: Sized {
     fn none_or_filled(self) -> Option<Self>;
 }

src/tests/krate/publish/snapshots/all__krate__publish__features__invalid_feature.snap

@@ -5,7 +5,7 @@ expression: response.into_json()
 {
   "errors": [
     {
-      "detail": "invalid upload request: invalid value: string \"!bar\", expected a valid feature name at line 1 column 65"
+      "detail": "\"!bar\" is an invalid feature name"
     }
   ]
 }

src/tests/krate/publish/snapshots/all__krate__publish__features__invalid_feature_name.snap

@@ -5,7 +5,7 @@ expression: response.into_json()
 {
   "errors": [
     {
-      "detail": "invalid upload request: invalid value: string \"~foo\", expected a valid feature name containing only letters, numbers, '-', '+', or '_' at line 1 column 57"
+      "detail": "\"~foo\" is an invalid feature name (feature names must contain only letters, numbers, '-', '+', or '_')"
     }
   ]
 }

src/views/krate_publish.rs

@@ -2,7 +2,6 @@
 //! and manages the serialising and deserializing of this information
 //! to and from structs. The serializing is only utilised in
 //! integration tests.
-use std::collections::BTreeMap;
 
 use diesel::pg::Pg;
 use diesel::serialize::{self, Output, ToSql};
@@ -19,7 +18,6 @@ pub struct PublishMetadata {
     pub name: EncodableCrateName,
     pub vers: EncodableCrateVersion,
     pub deps: Vec<EncodableCrateDependency>,
-    pub features: BTreeMap<EncodableFeatureName, Vec<EncodableFeature>>,
     pub readme: Option<String>,
     pub readme_file: Option<String>,
 }
@@ -84,23 +82,6 @@ impl<'de> Deserialize<'de> for EncodableDependencyName {
     }
 }
 
-#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Clone, Debug, Deref)]
-pub struct EncodableFeatureName(pub String);
-
-impl<'de> Deserialize<'de> for EncodableFeatureName {
-    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
-        let s = String::deserialize(d)?;
-        if !Crate::valid_feature_name(&s) {
-            let value = de::Unexpected::Str(&s);
-            let expected = "a valid feature name containing only letters, \
-                            numbers, '-', '+', or '_'";
-            Err(de::Error::invalid_value(value, &expected))
-        } else {
-            Ok(EncodableFeatureName(s))
-        }
-    }
-}
-
 #[derive(Serialize, Clone, Debug, Deref)]
 pub struct EncodableFeature(pub String);