use mime::Mime for mime types / content types

Author: syphar

src/db/file.rs

@@ -8,7 +8,10 @@
 //! However, postgres is still available for testing and backwards compatibility.
 
 use crate::error::Result;
-use crate::storage::{AsyncStorage, CompressionAlgorithm};
+use crate::{
+    db::mimes,
+    storage::{AsyncStorage, CompressionAlgorithm},
+};
 use mime::Mime;
 use serde_json::Value;
 use std::ffi::OsStr;
@@ -25,28 +28,30 @@ pub struct FileEntry {
 
 impl FileEntry {
     pub(crate) fn mime(&self) -> Mime {
-        detect_mime(&self.path).parse().unwrap()
+        detect_mime(&self.path)
     }
 }
 
-pub(crate) fn detect_mime(file_path: impl AsRef<Path>) -> &'static str {
+pub(crate) fn detect_mime(file_path: impl AsRef<Path>) -> Mime {
     let mime = mime_guess::from_path(file_path.as_ref())
-        .first_raw()
-        .unwrap_or("text/plain");
-    match mime {
+        .first()
+        .unwrap_or(mime::TEXT_PLAIN);
+
+    match mime.as_ref() {
         "text/plain" | "text/troff" | "text/x-markdown" | "text/x-rust" | "text/x-toml" => {
             match file_path.as_ref().extension().and_then(OsStr::to_str) {
-                Some("md") => "text/markdown",
-                Some("rs") => "text/rust",
-                Some("markdown") => "text/markdown",
-                Some("css") => "text/css",
-                Some("toml") => "text/toml",
-                Some("js") => "application/javascript",
-                Some("json") => "application/json",
+                Some("md") => mimes::TEXT_MARKDOWN.clone(),
+                Some("rs") => mimes::TEXT_RUST.clone(),
+                Some("markdown") => mimes::TEXT_MARKDOWN.clone(),
+                Some("css") => mime::TEXT_CSS,
+                Some("toml") => mimes::TEXT_TOML.clone(),
+                Some("js") => mime::TEXT_JAVASCRIPT,
+                Some("json") => mime::APPLICATION_JSON,
                 _ => mime,
             }
         }
-        "image/svg" => "image/svg+xml",
+        "image/svg" => mime::IMAGE_SVG,
+
         _ => mime,
     }
 }

src/db/mimes.rs

@@ -0,0 +1,13 @@
+use mime::Mime;
+use once_cell::sync::Lazy;
+
+macro_rules! mime {
+    ($id:ident, $mime:expr) => {
+        pub(crate) static $id: Lazy<Mime> = Lazy::new(|| $mime.parse().unwrap());
+    };
+}
+
+mime!(APPLICATION_ZIP, "application/zip");
+mime!(TEXT_MARKDOWN, "text/markdown");
+mime!(TEXT_RUST, "text/rust");
+mime!(TEXT_TOML, "text/toml");

src/db/mod.rs

@@ -19,6 +19,7 @@ mod add_package;
 pub mod blacklist;
 pub mod delete;
 pub(crate) mod file;
+pub(crate) mod mimes;
 mod overrides;
 mod pool;
 pub(crate) mod types;

src/storage/database.rs

@@ -136,7 +136,10 @@ impl DatabaseBackend {
         });
         Ok(Blob {
             path: result.path,
-            mime: result.mime,
+            mime: result
+                .mime
+                .parse()
+                .unwrap_or(mime::APPLICATION_OCTET_STREAM),
             date_updated: result.date_updated,
             content: result.content.unwrap_or_default(),
             compression,
@@ -154,7 +157,7 @@ impl DatabaseBackend {
                  ON CONFLICT (path) DO UPDATE
                     SET mime = EXCLUDED.mime, content = EXCLUDED.content, compression = EXCLUDED.compression",
                 &blob.path,
-                &blob.mime,
+                &blob.mime.to_string(),
                 &blob.content,
                 compression,
             )

src/storage/mod.rs

@@ -9,7 +9,7 @@ use self::s3::S3Backend;
 use crate::{
     db::{
         file::{detect_mime, FileEntry},
-        Pool,
+        mimes, Pool,
     },
     error::Result,
     utils::spawn_blocking,
@@ -19,6 +19,7 @@ use anyhow::anyhow;
 use chrono::{DateTime, Utc};
 use fn_error_context::context;
 use futures_util::stream::BoxStream;
+use mime::Mime;
 use path_slash::PathExt;
 use std::iter;
 use std::{
@@ -41,7 +42,7 @@ pub(crate) struct PathNotFoundError;
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub(crate) struct Blob {
     pub(crate) path: String,
-    pub(crate) mime: String,
+    pub(crate) mime: Mime,
     pub(crate) date_updated: DateTime<Utc>,
     pub(crate) content: Vec<u8>,
     pub(crate) compression: Option<CompressionAlgorithm>,
@@ -378,7 +379,7 @@ impl AsyncStorage {
 
         Ok(Blob {
             path: format!("{archive_path}/{path}"),
-            mime: detect_mime(path).into(),
+            mime: detect_mime(path),
             date_updated: blob.date_updated,
             content: blob.content,
             compression: None,
@@ -460,14 +461,14 @@ impl AsyncStorage {
         self.store_inner(vec![
             Blob {
                 path: archive_path.to_string(),
-                mime: "application/zip".to_owned(),
+                mime: mimes::APPLICATION_ZIP.clone(),
                 content: zip_content,
                 compression: None,
                 date_updated: Utc::now(),
             },
             Blob {
                 path: remote_index_path,
-                mime: "application/octet-stream".to_owned(),
+                mime: mime::APPLICATION_OCTET_STREAM,
                 content: compressed_index_content,
                 compression: Some(alg),
                 date_updated: Utc::now(),
@@ -512,7 +513,7 @@ impl AsyncStorage {
                         path: file_path,
                         size: file_size,
                     };
-                    let mime = file_info.mime().to_string();
+                    let mime = file_info.mime();
                     file_paths.push(file_info);
 
                     blobs.push(Blob {
@@ -877,7 +878,7 @@ mod backend_tests {
         assert!(!storage.exists("path/to/file.txt").unwrap());
         let blob = Blob {
             path: "path/to/file.txt".into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             content: "Hello world!".into(),
             compression: None,
@@ -893,7 +894,7 @@ mod backend_tests {
 
         storage.store_blobs(vec![Blob {
             path: path.into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             compression: None,
             content: b"test content\n".to_vec(),
@@ -920,7 +921,7 @@ mod backend_tests {
         let path: &str = "foo/bar.txt";
         let blob = Blob {
             path: path.into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             compression: None,
             content: b"test content\n".to_vec(),
@@ -955,7 +956,7 @@ mod backend_tests {
     fn test_get_range(storage: &Storage) -> Result<()> {
         let blob = Blob {
             path: "foo/bar.txt".into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             compression: None,
             content: b"test content\n".to_vec(),
@@ -995,7 +996,7 @@ mod backend_tests {
                 .iter()
                 .map(|&filename| Blob {
                     path: filename.into(),
-                    mime: "text/plain".into(),
+                    mime: mime::TEXT_PLAIN,
                     date_updated: Utc::now(),
                     compression: None,
                     content: b"test content\n".to_vec(),
@@ -1036,14 +1037,14 @@ mod backend_tests {
 
         let small_blob = Blob {
             path: "small-blob.bin".into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             content: vec![0; MAX_SIZE],
             compression: None,
         };
         let big_blob = Blob {
             path: "big-blob.bin".into(),
-            mime: "text/plain".into(),
+            mime: mime::TEXT_PLAIN,
             date_updated: Utc::now(),
             content: vec![0; MAX_SIZE * 2],
             compression: None,
@@ -1078,7 +1079,7 @@ mod backend_tests {
             .iter()
             .map(|&path| Blob {
                 path: path.into(),
-                mime: "text/plain".into(),
+                mime: mime::TEXT_PLAIN,
                 date_updated: Utc::now(),
                 compression: None,
                 content: b"Hello world!\n".to_vec(),
@@ -1221,7 +1222,7 @@ mod backend_tests {
             .map(|i| {
                 let content = format!("const IDX: usize = {i};").as_bytes().to_vec();
                 Blob {
-                    mime: "text/rust".into(),
+                    mime: mimes::TEXT_RUST.clone(),
                     content,
                     path: format!("{i}.rs"),
                     date_updated: now,
@@ -1286,7 +1287,7 @@ mod backend_tests {
                     path: (*path).to_string(),
                     content: b"foo\n".to_vec(),
                     compression: None,
-                    mime: "text/plain".into(),
+                    mime: mime::TEXT_PLAIN,
                     date_updated: Utc::now(),
                 })
                 .collect(),

src/storage/s3.rs

@@ -214,7 +214,12 @@ impl S3Backend {
 
         Ok(Blob {
             path: path.into(),
-            mime: res.content_type.unwrap(),
+            mime: res
+                .content_type
+                .as_ref()
+                .unwrap()
+                .parse()
+                .unwrap_or(mime::APPLICATION_OCTET_STREAM),
             date_updated,
             content: content.into_inner(),
             compression,
@@ -232,7 +237,7 @@ impl S3Backend {
                         .bucket(&self.bucket)
                         .key(&blob.path)
                         .body(blob.content.clone().into())
-                        .content_type(&blob.mime)
+                        .content_type(blob.mime.to_string())
                         .set_content_encoding(blob.compression.map(|alg| alg.to_string()))
                         .send()
                         .map_ok(|_| {

src/web/file.rs

@@ -15,7 +15,6 @@ use axum::{
     },
     response::{IntoResponse, Response as AxumResponse},
 };
-use mime::Mime;
 
 #[derive(Debug)]
 pub(crate) struct File(pub(crate) Blob);
@@ -39,16 +38,10 @@ impl File {
 
 impl IntoResponse for File {
     fn into_response(self) -> AxumResponse {
-        let content_type: Mime = self
-            .0
-            .mime
-            .parse::<Mime>()
-            .unwrap_or(mime::APPLICATION_OCTET_STREAM);
-
         (
             StatusCode::OK,
             [
-                (CONTENT_TYPE, content_type.as_ref()),
+                (CONTENT_TYPE, self.0.mime.as_ref()),
                 (
                     LAST_MODIFIED,
                     &self.0.date_updated.format("%a, %d %b %Y %T %Z").to_string(),

src/web/source.rs

@@ -17,6 +17,7 @@ use crate::{
 use anyhow::{Context as _, Result};
 use axum::{response::IntoResponse, Extension};
 use axum_extra::headers::HeaderMapExt;
+use mime::Mime;
 use rinja::Template;
 use semver::Version;
 use serde::Deserialize;
@@ -26,18 +27,16 @@ use tracing::instrument;
 /// A source file's name and mime type
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
 struct File {
-    /// The name of the file
     name: String,
-    /// The mime type of the file
     mime: String,
 }
 
 impl File {
-    fn from_path_and_mime(path: &str, mime: &str) -> File {
+    fn from_path_and_mime(path: &str, mime: &Mime) -> File {
         let (name, mime) = if let Some((dir, _)) = path.split_once('/') {
             (dir, "dir")
         } else {
-            (path, mime)
+            (path, mime.as_ref())
         };
 
         Self {
@@ -106,7 +105,11 @@ impl FileList {
 
             for file in files {
                 if let Some(file) = file.as_array() {
-                    let mime = file[0].as_str().unwrap();
+                    let mime: Mime = file[0]
+                        .as_str()
+                        .unwrap()
+                        .parse()
+                        .unwrap_or(mime::APPLICATION_OCTET_STREAM);
                     let path = file[1].as_str().unwrap();
 
                     // skip .cargo-ok generated by cargo
@@ -116,7 +119,7 @@ impl FileList {
 
                     // look only files for req_path
                     if let Some(path) = path.strip_prefix(folder) {
-                        let file = File::from_path_and_mime(path, mime);
+                        let file = File::from_path_and_mime(path, &mime);
 
                         // avoid adding duplicates, a directory may occur more than once
                         if !file_list.contains(&file) {
@@ -278,7 +281,7 @@ pub(crate) async fn source_browser_handler(
     ));
 
     let (file, file_content) = if let Some(blob) = blob {
-        let is_text = blob.mime.starts_with("text") || blob.mime == "application/json";
+        let is_text = blob.mime.type_() == mime::TEXT || blob.mime == mime::APPLICATION_JSON;
         // serve the file with DatabaseFileHandler if file isn't text and not empty
         if !is_text && !blob.is_empty() {
             let mut response = DbFile(blob).into_response();