reorganize input format: make constructors lazy, parse members on get

src/client/connection/response/input/default.rs

@@ -0,0 +1,61 @@
+pub mod error;
+pub use error::Error;
+
+const CODE: &[u8] = b"10";
+
+/// Hold header `String` for [10](https://geminiprotocol.net/docs/protocol-specification.gmi#status-10) status code
+/// * this response type does not contain body data
+/// * the header member is closed to require valid construction
+pub struct Default(String);
+
+impl Default {
+    // Constructors
+
+    /// Parse `Self` from buffer contains header bytes
+    pub fn from_utf8(buffer: &[u8]) -> Result<Self, Error> {
+        if !buffer.starts_with(CODE) {
+            return Err(Error::Code);
+        }
+        Ok(Self(
+            std::str::from_utf8(
+                crate::client::connection::response::header_bytes(buffer).map_err(Error::Header)?,
+            )
+            .map_err(Error::Utf8Error)?
+            .to_string(),
+        ))
+    }
+
+    // Getters
+
+    /// Get optional message for `Self`
+    /// * return `None` if the message is empty
+    pub fn message(&self) -> Option<&str> {
+        self.0.get(2..).map(|s| s.trim()).filter(|x| !x.is_empty())
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+}
+
+#[test]
+fn test() {
+    // ok
+    let default = Default::from_utf8("10 Default\r\n".as_bytes()).unwrap();
+    assert_eq!(default.message(), Some("Default"));
+    assert_eq!(default.as_str(), "10 Default\r\n");
+
+    let default = Default::from_utf8("10\r\n".as_bytes()).unwrap();
+    assert_eq!(default.message(), None);
+    assert_eq!(default.as_str(), "10\r\n");
+
+    // err
+    assert!(Default::from_utf8("12 Fail\r\n".as_bytes()).is_err());
+    assert!(Default::from_utf8("22 Fail\r\n".as_bytes()).is_err());
+    assert!(Default::from_utf8("Fail\r\n".as_bytes()).is_err());
+    assert!(Default::from_utf8("Fail".as_bytes()).is_err());
+}

src/client/connection/response/input/default/error.rs

@@ -0,0 +1,24 @@
+use std::fmt::{Display, Formatter, Result};
+
+#[derive(Debug)]
+pub enum Error {
+    Code,
+    Header(crate::client::connection::response::HeaderBytesError),
+    Utf8Error(std::str::Utf8Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        match self {
+            Self::Code => {
+                write!(f, "Unexpected status code")
+            }
+            Self::Header(e) => {
+                write!(f, "Header error: {e}")
+            }
+            Self::Utf8Error(e) => {
+                write!(f, "UTF-8 decode error: {e}")
+            }
+        }
+    }
+}

src/client/connection/response/input/error.rs

@@ -1,23 +1,40 @@
-use std::{
-    fmt::{Display, Formatter, Result},
-    str::Utf8Error,
-};
+use std::fmt::{Display, Formatter, Result};
 
 #[derive(Debug)]
 pub enum Error {
+    Default(super::default::Error),
+    FirstByte(u8),
     Protocol,
-    Utf8Error(Utf8Error),
+    SecondByte(u8),
+    Sensitive(super::sensitive::Error),
+    UndefinedFirstByte,
+    UndefinedSecondByte,
 }
 
 impl Display for Error {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match self {
-            Self::Utf8Error(e) => {
-                write!(f, "UTF-8 error: {e}")
+            Self::Default(e) => {
+                write!(f, "Default parse error: {e}")
+            }
+            Self::FirstByte(b) => {
+                write!(f, "Unexpected first byte: {b}")
             }
             Self::Protocol => {
                 write!(f, "Protocol error")
             }
+            Self::SecondByte(b) => {
+                write!(f, "Unexpected second byte: {b}")
+            }
+            Self::Sensitive(e) => {
+                write!(f, "Sensitive parse error: {e}")
+            }
+            Self::UndefinedFirstByte => {
+                write!(f, "Undefined first byte")
+            }
+            Self::UndefinedSecondByte => {
+                write!(f, "Undefined second byte")
+            }
         }
     }
 }

src/client/connection/response/input/sensitive.rs

@@ -0,0 +1,61 @@
+pub mod error;
+pub use error::Error;
+
+const CODE: &[u8] = b"11";
+
+/// Hold header `String` for [11](https://geminiprotocol.net/docs/protocol-specification.gmi#status-11-sensitive-input) status code
+/// * this response type does not contain body data
+/// * the header member is closed to require valid construction
+pub struct Sensitive(String);
+
+impl Sensitive {
+    // Constructors
+
+    /// Parse `Self` from buffer contains header bytes
+    pub fn from_utf8(buffer: &[u8]) -> Result<Self, Error> {
+        if !buffer.starts_with(CODE) {
+            return Err(Error::Code);
+        }
+        Ok(Self(
+            std::str::from_utf8(
+                crate::client::connection::response::header_bytes(buffer).map_err(Error::Header)?,
+            )
+            .map_err(Error::Utf8Error)?
+            .to_string(),
+        ))
+    }
+
+    // Getters
+
+    /// Get optional message for `Self`
+    /// * return `None` if the message is empty
+    pub fn message(&self) -> Option<&str> {
+        self.0.get(2..).map(|s| s.trim()).filter(|x| !x.is_empty())
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+}
+
+#[test]
+fn test() {
+    // ok
+    let sensitive = Sensitive::from_utf8("11 Sensitive\r\n".as_bytes()).unwrap();
+    assert_eq!(sensitive.message(), Some("Sensitive"));
+    assert_eq!(sensitive.as_str(), "11 Sensitive\r\n");
+
+    let sensitive = Sensitive::from_utf8("11\r\n".as_bytes()).unwrap();
+    assert_eq!(sensitive.message(), None);
+    assert_eq!(sensitive.as_str(), "11\r\n");
+
+    // err
+    assert!(Sensitive::from_utf8("12 Fail\r\n".as_bytes()).is_err());
+    assert!(Sensitive::from_utf8("22 Fail\r\n".as_bytes()).is_err());
+    assert!(Sensitive::from_utf8("Fail\r\n".as_bytes()).is_err());
+    assert!(Sensitive::from_utf8("Fail".as_bytes()).is_err());
+}

src/client/connection/response/input/sensitive/error.rs

@@ -0,0 +1,24 @@
+use std::fmt::{Display, Formatter, Result};
+
+#[derive(Debug)]
+pub enum Error {
+    Code,
+    Header(crate::client::connection::response::HeaderBytesError),
+    Utf8Error(std::str::Utf8Error),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter) -> Result {
+        match self {
+            Self::Code => {
+                write!(f, "Unexpected status code")
+            }
+            Self::Header(e) => {
+                write!(f, "Header error: {e}")
+            }
+            Self::Utf8Error(e) => {
+                write!(f, "UTF-8 decode error: {e}")
+            }
+        }
+    }
+}