licenses: Simplify validate_license_expr() API

The main purpose of this wrapper fn is to apply our custom `ParseMode`. The conversion to an `AppError` should be done in the route handler code though.

Author: Turbo87

src/controllers/krate/publish.rs

@@ -17,7 +17,7 @@ use crate::models::{
     VersionAction,
 };
 
-use crate::licenses::validate_license_expr;
+use crate::licenses::parse_license_expr;
 use crate::middleware::log_request::RequestLogExt;
 use crate::models::token::EndpointScope;
 use crate::rate_limiter::LimitedAction;
@@ -34,6 +34,10 @@ const MISSING_RIGHTS_ERROR_MESSAGE: &str = "this crate exists but you don't seem
      to accept an invitation to be an owner before \
      publishing.";
 
+const LICENSE_ERROR: &str = "unknown or invalid license expression; \
+    see http://opensource.org/licenses for options, \
+    and http://spdx.org/licenses/ for their identifiers";
+
 /// Handles the `PUT /crates/new` route.
 /// Used by `cargo publish` to publish a new crate or to publish a new version of an
 /// existing crate.
@@ -138,7 +142,7 @@ pub async fn publish(app: AppState, req: BytesRequest) -> AppResult<Json<GoodCra
         }
 
         if let Some(ref license) = license {
-            validate_license_expr(license)?;
+            parse_license_expr(license).map_err(|_| cargo_err(LICENSE_ERROR))?;
         } else if license_file.is_some() {
             // If no license is given, but a license file is given, flag this
             // crate as having a nonstandard license. Note that we don't

src/licenses.rs

@@ -1,4 +1,4 @@
-use crate::util::errors::{cargo_err, AppResult};
+use spdx::{Expression, ParseError};
 
 const PARSE_MODE: spdx::ParseMode = spdx::ParseMode {
     allow_lower_case_operators: false,
@@ -7,28 +7,23 @@ const PARSE_MODE: spdx::ParseMode = spdx::ParseMode {
     allow_postfix_plus_on_gpl: true,
 };
 
-pub fn validate_license_expr(s: &str) -> AppResult<()> {
-    spdx::Expression::parse_mode(s, PARSE_MODE).map_err(|_| {
-        cargo_err("unknown or invalid license expression; see http://opensource.org/licenses for options, and http://spdx.org/licenses/ for their identifiers")
-    })?;
-
-    Ok(())
+pub fn parse_license_expr(s: &str) -> Result<Expression, ParseError> {
+    Expression::parse_mode(s, PARSE_MODE)
 }
 
 #[cfg(test)]
 mod tests {
-    use super::validate_license_expr;
+    use super::parse_license_expr;
 
     #[test]
     fn licenses() {
-        assert_ok!(validate_license_expr("MIT"));
-        assert_ok!(validate_license_expr("MIT OR Apache-2.0"));
-        assert_ok!(validate_license_expr("MIT/Apache-2.0"));
-        assert_ok!(validate_license_expr("MIT AND Apache-2.0"));
-        assert_ok!(validate_license_expr("MIT OR (Apache-2.0 AND MIT)"));
-        assert_ok!(validate_license_expr("GPL-3.0+"));
+        assert_ok!(parse_license_expr("MIT"));
+        assert_ok!(parse_license_expr("MIT OR Apache-2.0"));
+        assert_ok!(parse_license_expr("MIT/Apache-2.0"));
+        assert_ok!(parse_license_expr("MIT AND Apache-2.0"));
+        assert_ok!(parse_license_expr("MIT OR (Apache-2.0 AND MIT)"));
+        assert_ok!(parse_license_expr("GPL-3.0+"));
 
-        let error = assert_err!(validate_license_expr("apache 2.0")).to_string();
-        assert!(error.starts_with("unknown or invalid license expression; see http"));
+        assert_err!(parse_license_expr("apache 2.0"));
     }
 }