make mime type optional

src/client/response/meta.rs

@@ -23,7 +23,7 @@ pub const MAX_LEN: usize = 0x400; // 1024
 
 pub struct Meta {
     data: Data,
-    mime: Mime,
+    mime: Option<Mime>,
     status: Status,
     // @TODO
     // charset: Charset,
@@ -129,7 +129,7 @@ impl Meta {
         &self.data
     }
 
-    pub fn mime(&self) -> &Mime {
+    pub fn mime(&self) -> &Option<Mime> {
         &self.mime
     }
 }

src/client/response/meta/mime.rs

@@ -24,7 +24,7 @@ pub enum Mime {
 } // @TODO
 
 impl Mime {
-    pub fn from_utf8(buffer: &[u8]) -> Result<Self, Error> {
+    pub fn from_utf8(buffer: &[u8]) -> Result<Option<Self>, Error> {
         let len = buffer.len();
         match buffer.get(..if len > MAX_LEN { MAX_LEN } else { len }) {
             Some(value) => match GString::from_utf8(value.into()) {
@@ -53,47 +53,53 @@ impl Mime {
         } // @TODO extension to lowercase
     }
 
-    pub fn from_string(value: &str) -> Result<Self, Error> {
+    pub fn from_string(value: &str) -> Result<Option<Self>, Error> {
         // Text
         if value.contains("text/gemini") {
-            return Ok(Self::TextGemini);
+            return Ok(Some(Self::TextGemini));
         }
 
         if value.contains("text/plain") {
-            return Ok(Self::TextPlain);
+            return Ok(Some(Self::TextPlain));
         }
 
         // Image
         if value.contains("image/gif") {
-            return Ok(Self::ImageGif);
+            return Ok(Some(Self::ImageGif));
         }
 
         if value.contains("image/jpeg") {
-            return Ok(Self::ImageJpeg);
+            return Ok(Some(Self::ImageJpeg));
         }
 
         if value.contains("image/webp") {
-            return Ok(Self::ImageWebp);
+            return Ok(Some(Self::ImageWebp));
         }
 
         if value.contains("image/png") {
-            return Ok(Self::ImagePng);
+            return Ok(Some(Self::ImagePng));
         }
 
         // Audio
         if value.contains("audio/flac") {
-            return Ok(Self::AudioFlac);
+            return Ok(Some(Self::AudioFlac));
         }
 
         if value.contains("audio/mpeg") {
-            return Ok(Self::AudioMpeg);
+            return Ok(Some(Self::AudioMpeg));
         }
 
         if value.contains("audio/ogg") {
-            return Ok(Self::AudioOgg);
+            return Ok(Some(Self::AudioOgg));
         }
 
-        Err(Error::Undefined)
+        // Some type exist, but not defined yet
+        if value.contains("/") {
+            return Err(Error::Undefined);
+        }
+
+        // Done
+        Ok(None) // may be empty (for some status codes)
     }
 
     pub fn from_uri(uri: &Uri) -> Result<Self, Error> {