Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ggemtext"
-version = "0.7.0"
+version = "0.3.1"
-edition = "2024"
+edition = "2021"
 license = "MIT"
 readme = "README.md"
 description = "Glib-oriented Gemtext API"
@@ -17,5 +17,5 @@ repository = "https://github.com/YGGverse/ggemtext"
 
 [dependencies.glib]
 package = "glib"
-version = "0.21.0"
+version = "0.20.4"
 features = ["v2_66"]

README.md

@@ -20,6 +20,20 @@ cargo add ggemtext
 
 Line parser, useful for [TextTag](https://docs.gtk.org/gtk4/class.TextTag.html) operations in [TextBuffer](https://docs.gtk.org/gtk4/class.TextBuffer.html) context.
 
+**Connect dependencies**
+
+``` rust
+use ggemtext::line::{
+    code::{Inline, Multiline},
+    header::{Header, Level},
+    link::Link,
+    list::List,
+    quote::Quote,
+};
+```
+
+**Prepare document**
+
 Iterate Gemtext lines to continue with [Line](#Line) API:
 
 ``` rust
@@ -30,108 +44,89 @@ for line in gemtext.lines() {
 
 #### Code
 
-``` rust
+##### Inline
-use ggemtext::line::Code;
-match Code::begin_from("```alt") {
-    Some(mut code) => {
-        assert!(code.continue_from("line 1").is_ok());
-        assert!(code.continue_from("line 2").is_ok());
-        assert!(code.continue_from("```").is_ok()); // complete
 
-        assert!(code.is_completed);
+``` rust
-        assert_eq!(code.alt, Some("alt".into()));
+match Inline::from("```inline```") {
-        assert_eq!(code.value.len(), 12 + 2); // +NL
+    Some(inline) => assert_eq!(inline.value, "inline"),
+    None => assert!(false),
+};
+```
+
+##### Multiline
+
+``` rust
+match Multiline::begin_from("```alt") {
+    Some(mut multiline) => {
+        assert!(Multiline::continue_from(&mut multiline, "line 1").is_ok());
+        assert!(Multiline::continue_from(&mut multiline, "line 2").is_ok());
+        assert!(Multiline::continue_from(&mut multiline, "```").is_ok()); // complete
+
+        assert!(multiline.completed);
+        assert_eq!(multiline.alt, Some("alt".into()));
+        assert_eq!(multiline.buffer.len(), 3);
     }
-    None => unreachable!(),
+    None => assert!(false),
-}
+};
 ```
 
 #### Header
 
-**Struct**
-
 ``` rust
-use ggemtext::line::{Header, header::Level};
+match Header::from("# H1") {
-match Header::parse("# H1") {
     Some(h1) => {
-        assert_eq!(h1.level as u8, Level::H1 as u8);
+        assert_eq!(h1.level as i8, Level::H1 as i8);
         assert_eq!(h1.value, "H1");
     }
-    None => unreachable!(),
+    None => assert!(false),
-} // H1, H2, H3
+}; // H1, H2, H3
-```
-
-**Trait**
-
-``` rust
-use ggemtext::line::header::{Gemtext, Level};
-assert_eq!("# H1".as_value(), Some("H1"));
-assert_eq!("H1".to_source(&Level::H1), "# H1");
-// H1, H2, H3
 ```
 
 #### Link
 
 ``` rust
-use ggemtext::line::Link;
+match Link::from(
+    "=> gemini://geminiprotocol.net 1965-01-19 Gemini",
+    None, // absolute path given, base not wanted
+    Some(&glib::TimeZone::local()),
+) {
+    Some(link) => {
+        // Alt
+        assert_eq!(link.alt, Some("Gemini".into()));
 
-const SOURCE: &str = "=> gemini://geminiprotocol.net 1965-01-19 Gemini";
+        // Date
+        match link.timestamp {
+            Some(timestamp) => {
+                assert_eq!(timestamp.year(), 1965);
+                assert_eq!(timestamp.month(), 1);
+                assert_eq!(timestamp.day_of_month(), 19);
+            }
+            None => assert!(false),
+        }
 
-let link = Link::parse(SOURCE).unwrap();
+        // URI
-
+        assert_eq!(link.uri.to_string(), "gemini://geminiprotocol.net");
-assert_eq!(link.alt, Some("1965-01-19 Gemini".to_string()));
+    }
-assert_eq!(link.url, "gemini://geminiprotocol.net");
+    None => assert!(false),
-
+};
-let uri = link.uri(None).unwrap();
-assert_eq!(uri.scheme(), "gemini");
-assert_eq!(uri.host().unwrap(), "geminiprotocol.net");
-
-let time = link.time(Some(&glib::TimeZone::local())).unwrap();
-assert_eq!(time.year(), 1965);
-assert_eq!(time.month(), 1);
-assert_eq!(time.day_of_month(), 19);
-
-assert_eq!(link.to_source(), SOURCE);
 ```
 
 #### List
 
-**Struct**
-
 ``` rust
-use ggemtext::line::List;
+match List::from("* Item") {
-match List::parse("* Item") {
     Some(list) => assert_eq!(list.value, "Item"),
-    None => unreachable!(),
+    None => assert!(false),
-}
+};
-```
-
-**Trait**
-
-``` rust
-use ggemtext::line::list::Gemtext;
-assert_eq!("* Item".as_value(), Some("Item"))
-assert_eq!("Item".to_source(), "* Item")
 ```
 
 #### Quote
 
-**Struct**
-
 ``` rust
-use ggemtext::line::Quote;
+match Quote::from("> Quote") {
-match Quote::parse("> Quote") {
     Some(quote) => assert_eq!(quote.value, "Quote"),
-    None => unreachable!(),
+    None => assert!(false),
-}
+};
-```
-
-**Trait**
-
-``` rust
-use ggemtext::line::quote::Gemtext;
-assert_eq!("> Quote".as_value(), Some("Quote"))
-assert_eq!("Quote".to_source(), "> Quote")
 ```
 
 ## Integrations

src/line.rs

@@ -3,9 +3,3 @@ pub mod header;
 pub mod link;
 pub mod list;
 pub mod quote;
-
-pub use code::Code;
-pub use header::Header;
-pub use link::Link;
-pub use list::List;
-pub use quote::Quote;

src/line/code.rs

@@ -1,90 +1,5 @@
-pub mod error;
+pub mod inline;
-pub use error::Error;
+pub mod multiline;
 
-pub const TAG: &str = "```";
+pub use inline::Inline;
-pub const NEW_LINE: char = '\n';
+pub use multiline::Multiline;
-
-/// Multi-line [preformatted](https://geminiprotocol.net/docs/gemtext-specification.gmi#in-pre-formatted-mode) entity holder
-pub struct Code {
-    pub alt: Option<String>,
-    pub value: String,
-    pub is_completed: bool,
-}
-
-impl Code {
-    // Constructors
-
-    /// Search in line string for tag open,
-    /// return Self constructed on success or None
-    pub fn begin_from(line: &str) -> Option<Self> {
-        if line.starts_with(TAG) {
-            let alt = line.trim_start_matches(TAG).trim();
-
-            return Some(Self {
-                alt: match alt.is_empty() {
-                    true => None,
-                    false => Some(alt.to_string()),
-                },
-                value: String::new(),
-                is_completed: false,
-            });
-        }
-        None
-    }
-
-    /// Continue preformatted buffer from line string,
-    /// set `completed` as True on close tag found
-    pub fn continue_from(&mut self, line: &str) -> Result<(), Error> {
-        // Make sure buffer not completed yet
-        if self.is_completed {
-            return Err(Error::Completed);
-        }
-
-        // Append to value, trim close tag on exists
-        self.value.push_str(line.trim_end_matches(TAG));
-
-        // Line contain close tag
-        if line.ends_with(TAG) {
-            self.is_completed = true;
-        } else {
-            self.value.push(NEW_LINE);
-        }
-
-        Ok(())
-    }
-
-    // Converters
-
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) format
-    pub fn to_source(&self) -> String {
-        format!(
-            "{TAG}{}{NEW_LINE}{}{TAG}",
-            match &self.alt {
-                Some(alt) => format!(" {}", alt.trim()),
-                None => String::new(),
-            },
-            self.value
-        )
-    }
-}
-
-#[test]
-fn test() {
-    match Code::begin_from("```alt") {
-        Some(mut code) => {
-            assert!(code.continue_from("line 1").is_ok());
-            assert!(code.continue_from("line 2").is_ok());
-            assert!(code.continue_from("```").is_ok()); // complete
-
-            assert!(code.is_completed);
-            assert_eq!(code.alt, Some("alt".into()));
-            assert_eq!(code.value.len(), 12 + 2); // +NL
-
-            assert_eq!(
-                code.to_source(),
-                format!("{TAG} alt{NEW_LINE}line 1{NEW_LINE}line 2{NEW_LINE}{TAG}")
-            )
-        }
-        None => unreachable!(),
-    }
-}

src/line/code/inline.rs

@@ -0,0 +1,26 @@
+use glib::{Regex, RegexCompileFlags, RegexMatchFlags};
+
+/// Inline [preformatted](https://geminiprotocol.net/docs/gemtext-specification.gmi#in-pre-formatted-mode) entity holder
+pub struct Inline {
+    pub value: String,
+}
+
+impl Inline {
+    // Constructors
+
+    /// Parse `Self` from line string
+    pub fn from(line: &str) -> Option<Self> {
+        // Parse line
+        let regex = Regex::split_simple(
+            r"^`{3}([^`]+)`{3}$",
+            line,
+            RegexCompileFlags::DEFAULT,
+            RegexMatchFlags::DEFAULT,
+        );
+
+        // Extract formatted value
+        Some(Self {
+            value: regex.get(1)?.trim().to_string(),
+        })
+    }
+}

src/line/code/multiline.rs

@@ -0,0 +1,58 @@
+pub mod error;
+pub use error::Error;
+
+// Shared defaults
+
+pub const NEW_LINE: char = '\n';
+pub const TAG: &str = "```";
+
+/// Multi-line [preformatted](https://geminiprotocol.net/docs/gemtext-specification.gmi#in-pre-formatted-mode) entity holder
+pub struct Multiline {
+    pub alt: Option<String>,
+    pub value: String,
+    pub completed: bool,
+}
+
+impl Multiline {
+    // Constructors
+
+    /// Search in line string for tag open,
+    /// return Self constructed on success or None
+    pub fn begin_from(line: &str) -> Option<Self> {
+        if line.starts_with(TAG) {
+            let alt = line.trim_start_matches(TAG).trim();
+
+            return Some(Self {
+                alt: match alt.is_empty() {
+                    true => None,
+                    false => Some(alt.to_string()),
+                },
+                value: String::new(),
+                completed: false,
+            });
+        }
+
+        None
+    }
+
+    /// Continue preformatted buffer from line string,
+    /// set `completed` as True on close tag found
+    pub fn continue_from(&mut self, line: &str) -> Result<(), Error> {
+        // Make sure buffer not completed yet
+        if self.completed {
+            return Err(Error::Completed);
+        }
+
+        // Append to value, trim close tag on exists
+        self.value.push_str(line.trim_end_matches(TAG));
+
+        // Line contain close tag
+        if line.ends_with(TAG) {
+            self.completed = true;
+        } else {
+            self.value.push(NEW_LINE);
+        }
+
+        Ok(())
+    }
+}

src/line/header.rs

@@ -1,76 +1,40 @@
-pub mod gemtext;
+use glib::{Regex, RegexCompileFlags, RegexMatchFlags};
-pub mod level;
 
-pub use gemtext::Gemtext;
+/// [Header](https://geminiprotocol.net/docs/gemtext-specification.gmi#heading-lines) type holder
-pub use level::Level;
+pub enum Level {
+    H1,
+    H2,
+    H3,
+}
 
 /// [Header](https://geminiprotocol.net/docs/gemtext-specification.gmi#heading-lines) entity holder
 pub struct Header {
-    pub level: Level,
     pub value: String,
+    pub level: Level,
 }
 
 impl Header {
     // Constructors
 
     /// Parse `Self` from line string
-    pub fn parse(line: &str) -> Option<Self> {
+    pub fn from(line: &str) -> Option<Self> {
-        if let Some(value) = line.as_h1_value() {
+        // Parse line
-            return Some(Self {
+        let regex = Regex::split_simple(
-                level: Level::H1,
+            r"^(#{1,3})\s*(.+)$",
-                value: value.to_string(),
+            line,
-            });
+            RegexCompileFlags::DEFAULT,
-        }
+            RegexMatchFlags::DEFAULT,
-        if let Some(value) = line.as_h2_value() {
+        );
-            return Some(Self {
-                level: Level::H2,
-                value: value.to_string(),
-            });
-        }
-        if let Some(value) = line.as_h3_value() {
-            return Some(Self {
-                level: Level::H3,
-                value: value.to_string(),
-            });
-        }
-        None
-    }
 
-    // Converters
+        // Result
-
+        Some(Self {
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
+            level: match regex.get(1)?.len() {
-    pub fn to_source(&self) -> String {
+                1 => Level::H1,
-        self.value.to_source(&self.level)
+                2 => Level::H2,
+                3 => Level::H3,
+                _ => return None,
+            },
+            value: regex.get(2)?.trim().to_string(),
+        })
     }
 }
-
-#[test]
-fn test() {
-    fn test(source: &str, value: &str, level: Level) {
-        fn f(s: &str) -> String {
-            s.chars().filter(|&c| c != ' ').collect()
-        }
-        let header = Header::parse(source).unwrap();
-        assert_eq!(header.value, value);
-        assert_eq!(header.level.as_tag(), level.as_tag());
-        assert_eq!(f(&header.to_source()), f(source));
-    }
-    // h1
-    test("# H1", "H1", Level::H1);
-    test("# H1 ", "H1", Level::H1);
-    test("#H1", "H1", Level::H1);
-    test("#H1 ", "H1", Level::H1);
-    // h2
-    test("## H2", "H2", Level::H2);
-    test("## H2 ", "H2", Level::H2);
-    test("##H2", "H2", Level::H2);
-    test("##H2 ", "H2", Level::H2);
-    // h3
-    test("### H3", "H3", Level::H3);
-    test("### H3 ", "H3", Level::H3);
-    test("###H3", "H3", Level::H3);
-    test("###H3 ", "H3", Level::H3);
-    // other
-    assert!(Header::parse("H").is_none());
-    assert!(Header::parse("#### H").is_none())
-}

src/line/header/gemtext.rs

@@ -1,98 +0,0 @@
-use super::Level;
-
-pub trait Gemtext {
-    /// Get [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) value for `Self`
-    fn as_value(&self) -> Option<&str>;
-    /// Get parsed H1 header value for `Self`
-    fn as_h1_value(&self) -> Option<&str>;
-    /// Get parsed H2 header value `Self`
-    fn as_h2_value(&self) -> Option<&str>;
-    /// Get parsed H3 header value `Self`
-    fn as_h3_value(&self) -> Option<&str>;
-    /// Get parsed header value `Self` match `Level`
-    fn as_value_match_level(&self, level: Level) -> Option<&str>;
-    /// Convert `Self` to `Level`
-    fn to_level(&self) -> Option<Level>;
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    fn to_source(&self, level: &Level) -> String;
-}
-
-impl Gemtext for str {
-    fn as_value(&self) -> Option<&str> {
-        if let Some(value) = self.as_h1_value() {
-            return Some(value);
-        }
-        if let Some(value) = self.as_h2_value() {
-            return Some(value);
-        }
-        if let Some(value) = self.as_h3_value() {
-            return Some(value);
-        }
-        None
-    }
-    fn as_h1_value(&self) -> Option<&str> {
-        self.as_value_match_level(Level::H1)
-    }
-    fn as_h2_value(&self) -> Option<&str> {
-        self.as_value_match_level(Level::H2)
-    }
-    fn as_h3_value(&self) -> Option<&str> {
-        self.as_value_match_level(Level::H3)
-    }
-    fn as_value_match_level(&self, level: Level) -> Option<&str> {
-        self.strip_prefix(level.as_tag())
-            .map(|postfix| postfix.trim())
-            .filter(|value| !value.starts_with(Level::H1.as_tag()))
-    }
-    fn to_level(&self) -> Option<Level> {
-        if self.as_h1_value().is_some() {
-            return Some(Level::H1);
-        }
-        if self.as_h2_value().is_some() {
-            return Some(Level::H2);
-        }
-        if self.as_h3_value().is_some() {
-            return Some(Level::H3);
-        }
-        None
-    }
-    fn to_source(&self, level: &Level) -> String {
-        format!("{} {}", level.as_tag(), self.trim())
-    }
-}
-
-#[test]
-fn test() {
-    const VALUE: &str = "H";
-    let mut value: Option<&str> = Some(VALUE);
-    for t in ["#", "##", "###", "####"] {
-        if t.len() > 3 {
-            value = None;
-        }
-        assert_eq!(format!("{t}{VALUE}").as_value(), value);
-        assert_eq!(format!("{t}{VALUE} ").as_value(), value);
-        assert_eq!(format!("{t} {VALUE}").as_value(), value);
-        assert_eq!(format!("{t} {VALUE} ").as_value(), value);
-    }
-
-    fn to_source(l: &Level) {
-        assert_eq!(VALUE.to_source(l), format!("{} {VALUE}", l.as_tag()));
-    }
-    to_source(&Level::H1);
-    to_source(&Level::H2);
-    to_source(&Level::H3);
-
-    fn to_level(l: &Level) {
-        fn assert(s: String, l: &str) {
-            assert_eq!(s.to_level().unwrap().as_tag(), l);
-        }
-        let t = l.as_tag();
-        assert(format!("{t} {VALUE}"), t);
-        assert(format!("{t} {VALUE} "), t);
-        assert(format!("{t}{VALUE} "), t);
-        assert(format!("{t} {VALUE} "), t);
-    }
-    to_level(&Level::H1);
-    to_level(&Level::H2);
-    to_level(&Level::H3);
-}

src/line/header/level.rs

@@ -1,16 +0,0 @@
-/// [Header](https://geminiprotocol.net/docs/gemtext-specification.gmi#heading-lines) type holder
-pub enum Level {
-    H1,
-    H2,
-    H3,
-}
-
-impl Level {
-    pub fn as_tag(&self) -> &str {
-        match self {
-            Level::H1 => "#",
-            Level::H2 => "##",
-            Level::H3 => "###",
-        }
-    }
-}

src/line/link.rs

@@ -1,119 +1,101 @@
-use glib::{DateTime, TimeZone, Uri, UriFlags};
+use glib::{DateTime, Regex, RegexCompileFlags, RegexMatchFlags, TimeZone, Uri, UriFlags};
-const S: char = ' ';
-
-pub const TAG: &str = "=>";
 
 /// [Link](https://geminiprotocol.net/docs/gemtext-specification.gmi#link-lines) entity holder
 pub struct Link {
-    /// For performance reasons, hold Gemtext date and alternative together as the optional String
+    pub alt: Option<String>,         // [optional] alternative link description
-    /// * to extract valid [DateTime](https://docs.gtk.org/glib/struct.DateTime.html) use `time` implementation method
+    pub is_external: Option<bool>,   // [optional] external link indication, on base option provided
-    pub alt: Option<String>,
+    pub timestamp: Option<DateTime>, // [optional] valid link DateTime object
-    /// For performance reasons, hold URL as the raw String
+    pub uri: Uri,                    // [required] valid link URI object
-    /// * to extract valid [Uri](https://docs.gtk.org/glib/struct.Uri.html) use `uri` implementation method
-    pub url: String,
 }
 
 impl Link {
     // Constructors
 
     /// Parse `Self` from line string
-    pub fn parse(line: &str) -> Option<Self> {
+    pub fn from(line: &str, base: Option<&Uri>, timezone: Option<&TimeZone>) -> Option<Self> {
-        let l = line.strip_prefix(TAG)?.trim();
+        // Define initial values
-        let u = l.find(S).map_or(l, |i| &l[..i]);
+        let mut alt = None;
-        if u.is_empty() {
+        let mut timestamp = None;
-            return None;
+        let mut is_external = None;
+
+        // Begin line parse
+        let regex = Regex::split_simple(
+            r"^=>\s*([^\s]+)\s*(\d{4}-\d{2}-\d{2})?\s*(.+)?$",
+            line,
+            RegexCompileFlags::DEFAULT,
+            RegexMatchFlags::DEFAULT,
+        );
+
+        // Detect address required to continue
+        let mut unresolved_address = regex.get(1)?.to_string();
+
+        // Seems that [Uri resolver](https://docs.gtk.org/glib/type_func.Uri.resolve_relative.html)
+        // does not support [protocol-relative URI](https://datatracker.ietf.org/doc/html/rfc3986#section-4.2)
+        // resolve manually
+        if unresolved_address.starts_with("//:") {
+            let scheme = match base {
+                Some(base) => base.scheme(),
+                None => return None,
+            };
+            unresolved_address = unresolved_address.replace("//:", &format!("{scheme}://"));
         }
+
+        // Convert address to the valid URI
+        let uri = match base {
+            // Base conversion requested
+            Some(base_uri) => {
+                // Convert relative address to absolute
+                match Uri::resolve_relative(
+                    Some(&base_uri.to_str()),
+                    unresolved_address.as_str(),
+                    UriFlags::NONE,
+                ) {
+                    Ok(resolved_str) => {
+                        // Try convert string to the valid URI
+                        match Uri::parse(&resolved_str, UriFlags::NONE) {
+                            Ok(resolved_uri) => {
+                                // Change external status
+                                is_external = Some(resolved_uri.scheme() != base_uri.scheme());
+
+                                // Result
+                                resolved_uri
+                            }
+                            Err(_) => return None,
+                        }
+                    }
+                    Err(_) => return None,
+                }
+            }
+            // Base resolve not requested
+            None => {
+                // Try convert address to valid URI
+                match Uri::parse(&unresolved_address, UriFlags::NONE) {
+                    Ok(unresolved_uri) => unresolved_uri,
+                    Err(_) => return None,
+                }
+            }
+        };
+
+        // Timestamp
+        if let Some(date) = regex.get(2) {
+            timestamp = match DateTime::from_iso8601(&format!("{date}T00:00:00"), timezone) {
+                Ok(value) => Some(value),
+                Err(_) => None,
+            }
+        }
+
+        // Alt
+        if let Some(value) = regex.get(3) {
+            if !value.is_empty() {
+                alt = Some(value.to_string())
+            }
+        };
+
         Some(Self {
-            alt: l
+            alt,
-                .get(u.len()..)
+            is_external,
-                .map(|a| a.trim())
+            timestamp,
-                .filter(|a| !a.is_empty())
+            uri,
-                .map(|a| a.to_string()),
-            url: u.to_string(),
         })
     }
-
-    // Converters
-
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    pub fn to_source(&self) -> String {
-        let mut s = String::with_capacity(
-            TAG.len() + self.url.len() + self.alt.as_ref().map_or(0, |a| a.len()) + 2,
-        );
-        s.push_str(TAG);
-        s.push(S);
-        s.push_str(self.url.trim());
-        if let Some(ref alt) = self.alt {
-            s.push(S);
-            s.push_str(alt.trim());
-        }
-        s
-    }
-
-    // Getters
-
-    /// Get valid [DateTime](https://docs.gtk.org/glib/struct.DateTime.html) for `Self`
-    pub fn time(&self, timezone: Option<&TimeZone>) -> Option<DateTime> {
-        let a = self.alt.as_ref()?;
-        let t = &a[..a.find(S).unwrap_or(a.len())];
-        DateTime::from_iso8601(&format!("{t}T00:00:00"), timezone).ok()
-    }
-
-    /// Get valid [Uri](https://docs.gtk.org/glib/struct.Uri.html) for `Self`
-    pub fn uri(&self, base: Option<&Uri>) -> Option<Uri> {
-        // Relative scheme patch
-        // https://datatracker.ietf.org/doc/html/rfc3986#section-4.2
-        let unresolved_address = match self.url.strip_prefix("//") {
-            Some(p) => {
-                let b = base?;
-                let s = p.trim_start_matches(":");
-                &format!(
-                    "{}://{}",
-                    b.scheme(),
-                    if s.is_empty() {
-                        format!("{}/", b.host()?)
-                    } else {
-                        s.into()
-                    }
-                )
-            }
-            None => &self.url,
-        };
-        // Convert address to the valid URI,
-        // resolve to absolute URL format if the target is relative
-        match base {
-            Some(base_uri) => match Uri::resolve_relative(
-                Some(&base_uri.to_str()),
-                unresolved_address,
-                UriFlags::NONE,
-            ) {
-                Ok(resolved_str) => Uri::parse(&resolved_str, UriFlags::NONE).ok(),
-                Err(_) => None,
-            },
-            None => Uri::parse(unresolved_address, UriFlags::NONE).ok(),
-        }
-    }
-}
-
-#[test]
-fn test() {
-    use crate::line::Link;
-
-    const SOURCE: &str = "=> gemini://geminiprotocol.net 1965-01-19 Gemini";
-
-    let link = Link::parse(SOURCE).unwrap();
-
-    assert_eq!(link.alt, Some("1965-01-19 Gemini".to_string()));
-    assert_eq!(link.url, "gemini://geminiprotocol.net");
-
-    let uri = link.uri(None).unwrap();
-    assert_eq!(uri.scheme(), "gemini");
-    assert_eq!(uri.host().unwrap(), "geminiprotocol.net");
-
-    let time = link.time(Some(&glib::TimeZone::local())).unwrap();
-    assert_eq!(time.year(), 1965);
-    assert_eq!(time.month(), 1);
-    assert_eq!(time.day_of_month(), 19);
-
-    assert_eq!(link.to_source(), SOURCE);
 }

src/line/list.rs

@@ -1,8 +1,4 @@
-pub mod gemtext;
+use glib::{Regex, RegexCompileFlags, RegexMatchFlags};
-pub use gemtext::Gemtext;
-
-/// [List item](https://geminiprotocol.net/docs/gemtext-specification.gmi#list-items) tag
-pub const TAG: char = '*';
 
 /// [List](https://geminiprotocol.net/docs/gemtext-specification.gmi#list-items) entity holder
 pub struct List {
@@ -12,27 +8,19 @@ pub struct List {
 impl List {
     // Constructors
 
-    /// Parse `Self` from [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
+    /// Parse `Self` from line string
-    pub fn parse(line: &str) -> Option<Self> {
+    pub fn from(line: &str) -> Option<Self> {
+        // Parse line
+        let regex = Regex::split_simple(
+            r"^\*\s*(.*)$",
+            line,
+            RegexCompileFlags::DEFAULT,
+            RegexMatchFlags::DEFAULT,
+        );
+
+        // Extract formatted value
         Some(Self {
-            value: line.as_value()?.to_string(),
+            value: regex.get(1)?.trim().to_string(),
         })
     }
-
-    // Converters
-
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    pub fn to_source(&self) -> String {
-        self.value.to_source()
-    }
-}
-
-#[test]
-fn test() {
-    const SOURCE: &str = "* Item";
-    const VALUE: &str = "Item";
-
-    let list = List::parse(SOURCE).unwrap();
-    assert_eq!(list.value, VALUE);
-    assert_eq!(list.to_source(), SOURCE);
 }

src/line/list/gemtext.rs

@@ -1,26 +0,0 @@
-use super::TAG;
-
-pub trait Gemtext {
-    /// Get [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) value for `Self`
-    fn as_value(&self) -> Option<&str>;
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    fn to_source(&self) -> String;
-}
-
-impl Gemtext for str {
-    fn as_value(&self) -> Option<&str> {
-        self.strip_prefix(TAG).map(|s| s.trim())
-    }
-    fn to_source(&self) -> String {
-        format!("{TAG} {}", self.trim())
-    }
-}
-
-#[test]
-fn test() {
-    const SOURCE: &str = "* Item";
-    const VALUE: &str = "Item";
-
-    assert_eq!(SOURCE.as_value(), Some(VALUE));
-    assert_eq!(VALUE.to_source(), SOURCE)
-}

src/line/quote.rs

@@ -1,8 +1,4 @@
-pub mod gemtext;
+use glib::{Regex, RegexCompileFlags, RegexMatchFlags};
-pub use gemtext::Gemtext;
-
-/// [Quote item](https://geminiprotocol.net/docs/gemtext-specification.gmi#quote-lines) tag
-pub const TAG: char = '>';
 
 /// [Quote](https://geminiprotocol.net/docs/gemtext-specification.gmi#quote-lines) entity holder
 pub struct Quote {
@@ -12,28 +8,19 @@ pub struct Quote {
 impl Quote {
     // Constructors
 
-    /// Parse `Self` from [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
+    /// Parse `Self` from line string
-    pub fn parse(line: &str) -> Option<Self> {
+    pub fn from(line: &str) -> Option<Self> {
+        // Parse line
+        let regex = Regex::split_simple(
+            r"^>\s*(.*)$",
+            line,
+            RegexCompileFlags::DEFAULT,
+            RegexMatchFlags::DEFAULT,
+        );
+
+        // Extract formatted value
         Some(Self {
-            value: line.as_value()?.to_string(),
+            value: regex.get(1)?.trim().to_string(),
         })
     }
-
-    // Converters
-
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    pub fn to_source(&self) -> String {
-        self.value.to_source()
-    }
-}
-
-#[test]
-fn test() {
-    const SOURCE: &str = "> Quote";
-    const VALUE: &str = "Quote";
-
-    let quote = Quote::parse(SOURCE).unwrap();
-
-    assert_eq!(quote.value, VALUE);
-    assert_eq!(quote.to_source(), SOURCE);
 }

src/line/quote/gemtext.rs

@@ -1,26 +0,0 @@
-use super::TAG;
-
-pub trait Gemtext {
-    /// Get [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) value for `Self`
-    fn as_value(&self) -> Option<&str>;
-    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
-    fn to_source(&self) -> String;
-}
-
-impl Gemtext for str {
-    fn as_value(&self) -> Option<&str> {
-        self.strip_prefix(TAG).map(|s| s.trim())
-    }
-    fn to_source(&self) -> String {
-        format!("{TAG} {}", self.trim())
-    }
-}
-
-#[test]
-fn test() {
-    const SOURCE: &str = "> Quote";
-    const VALUE: &str = "Quote";
-
-    assert_eq!(SOURCE.as_value(), Some(VALUE));
-    assert_eq!(VALUE.to_source(), SOURCE)
-}

tests/integration.gmi

@@ -8,13 +8,12 @@
 => gemini://geminiprotocol.net 1965-01-19 Gemini
 => /docs/gemtext.gmi 1965-01-19 Gemini
 => //:geminiprotocol.net
-=> //geminiprotocol.net
-=> //geminiprotocol.net/path
-=> //
 
 * Listing item 1
 * Listing item 2
 
+```inline code```
+
 ``` alt text
 multi
     preformatted line

tests/integration.rs

@@ -1,6 +1,9 @@
 use ggemtext::line::{
-    Code, Link, List, Quote,
+    code::{Inline, Multiline},
     header::{Header, Level},
+    link::Link,
+    list::List,
+    quote::Quote,
 };
 
 use glib::{TimeZone, Uri, UriFlags};
@@ -11,69 +14,85 @@ fn gemtext() {
     match fs::read_to_string("tests/integration.gmi") {
         Ok(gemtext) => {
             // Init tags collection
-            let mut code: Vec<Code> = Vec::new();
+            let mut code_inline: Vec<Inline> = Vec::new();
-            let mut headers: Vec<Header> = Vec::new();
+            let mut code_multiline: Vec<Multiline> = Vec::new();
-            let mut links: Vec<Link> = Vec::new();
+            let mut header: Vec<Header> = Vec::new();
+            let mut link: Vec<Link> = Vec::new();
             let mut list: Vec<List> = Vec::new();
             let mut quote: Vec<Quote> = Vec::new();
 
             // Define preformatted buffer
-            let mut code_buffer: Option<Code> = None;
+            let mut code_multiline_buffer: Option<Multiline> = None;
 
             // Define base URI as integration.gmi contain one relative link
-            let base = Uri::parse("gemini://geminiprotocol.net", UriFlags::NONE).unwrap();
+            let base = match Uri::parse("gemini://geminiprotocol.net", UriFlags::NONE) {
+                Ok(uri) => Some(uri),
+                Err(_) => None,
+            };
 
             // Define timezone as integration.gmi contain one links with date
-            let timezone = TimeZone::local();
+            let timezone = Some(TimeZone::local());
 
             // Parse document by line
             for line in gemtext.lines() {
-                match code_buffer {
+                // Inline code
+                if let Some(result) = Inline::from(line) {
+                    code_inline.push(result);
+                    continue;
+                }
+
+                // Multiline code
+                match code_multiline_buffer {
                     None => {
-                        if let Some(code) = Code::begin_from(line) {
+                        if let Some(code) = Multiline::begin_from(line) {
-                            code_buffer = Some(code);
+                            code_multiline_buffer = Some(code);
                             continue;
                         }
                     }
-                    Some(ref mut c) => {
+                    Some(ref mut result) => {
-                        assert!(c.continue_from(line).is_ok());
+                        assert!(Multiline::continue_from(result, line).is_ok());
-                        if c.is_completed {
+                        if result.completed {
-                            code.push(code_buffer.take().unwrap());
+                            code_multiline.push(code_multiline_buffer.take().unwrap());
-                            code_buffer = None;
+                            code_multiline_buffer = None;
                         }
                         continue;
                     }
                 };
 
                 // Header
-                if let Some(result) = Header::parse(line) {
+                if let Some(result) = Header::from(line) {
-                    headers.push(result);
+                    header.push(result);
                     continue;
                 }
 
                 // Link
-                if let Some(result) = Link::parse(line) {
+                if let Some(result) = Link::from(line, base.as_ref(), timezone.as_ref()) {
-                    links.push(result);
+                    link.push(result);
                     continue;
                 }
 
                 // List
-                if let Some(result) = List::parse(line) {
+                if let Some(result) = List::from(line) {
                     list.push(result);
                     continue;
                 }
 
                 // Quote
-                if let Some(result) = Quote::parse(line) {
+                if let Some(result) = Quote::from(line) {
                     quote.push(result);
                     continue;
                 }
             }
 
-            // Validate code
+            // Validate inline code
-            assert_eq!(code.len(), 2);
+            assert_eq!(code_inline.len(), 1);
+            assert_eq!(code_inline.first().unwrap().value, "inline code");
+
+            // Validate multiline code
+            assert_eq!(code_multiline.len(), 2);
+
             {
-                let item = code.first().unwrap();
+                let item = code_multiline.first().unwrap();
                 assert_eq!(item.alt.clone().unwrap(), "alt text");
 
                 assert_eq!(item.value.lines().count(), 2);
@@ -84,7 +103,7 @@ fn gemtext() {
             } // #1
 
             {
-                let item = code.get(1).unwrap();
+                let item = code_multiline.get(1).unwrap();
                 assert_eq!(item.alt.clone(), None);
 
                 assert_eq!(item.value.lines().count(), 2);
@@ -95,143 +114,105 @@ fn gemtext() {
             } // #2
 
             // Validate headers
-            assert_eq!(headers.len(), 3);
+            assert_eq!(header.len(), 3);
 
-            fn to_u8(level: &Level) -> u8 {
+            fn to_i8(level: &Level) -> i8 {
                 match level {
                     Level::H1 => 1,
                     Level::H2 => 2,
                     Level::H3 => 3,
                 }
             } // comparison helper
-            let mut header = headers.iter();
-            {
-                let item = header.next().unwrap();
 
-                assert_eq!(to_u8(&item.level), to_u8(&Level::H1));
+            {
+                let item = header.first().unwrap();
+
+                assert_eq!(to_i8(&item.level), to_i8(&Level::H1));
                 assert_eq!(item.value, "H1");
             } // #1
-            {
-                let item = header.next().unwrap();
 
-                assert_eq!(to_u8(&item.level), to_u8(&Level::H2));
+            {
+                let item = header.get(1).unwrap();
+
+                assert_eq!(to_i8(&item.level), to_i8(&Level::H2));
                 assert_eq!(item.value, "H2");
             } // #2
-            {
-                let item = header.next().unwrap();
 
-                assert_eq!(to_u8(&item.level), to_u8(&Level::H3));
+            {
+                let item = header.get(2).unwrap();
+
+                assert_eq!(to_i8(&item.level), to_i8(&Level::H3));
                 assert_eq!(item.value, "H3");
             } // #3
 
             // Validate links
-            assert_eq!(links.len(), 9);
+            assert_eq!(link.len(), 6);
-            let mut link = links.iter();
+
             {
-                let item = link.next().unwrap();
+                let item = link.first().unwrap();
 
                 assert_eq!(item.alt, None);
-                assert_eq!(item.time(Some(&timezone)), None);
+                assert_eq!(item.timestamp, None);
-                assert_eq!(
+                assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
-                    item.uri(Some(&base)).unwrap().to_str(),
-                    "gemini://geminiprotocol.net"
-                );
             } // #1
+
             {
-                let item = link.next().unwrap();
+                let item = link.get(1).unwrap();
 
-                assert_eq!(
+                assert_eq!(item.alt, None);
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net"
-                );
 
-                let time = item.time(Some(&timezone)).unwrap();
+                let timestamp = item.timestamp.clone().unwrap();
-                assert_eq!(time.year(), 1965);
+                assert_eq!(timestamp.year(), 1965);
-                assert_eq!(time.month(), 1);
+                assert_eq!(timestamp.month(), 1);
-                assert_eq!(time.day_of_month(), 19);
+                assert_eq!(timestamp.day_of_month(), 19);
 
-                assert_eq!(item.alt, Some("1965-01-19".to_string()));
+                assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
             } // #2
+
             {
-                let item = link.next().unwrap();
+                let item = link.get(2).unwrap();
 
                 assert_eq!(item.alt.clone().unwrap(), "Gemini");
-                assert_eq!(item.time(Some(&timezone)), None);
+                assert_eq!(item.timestamp, None);
-                assert_eq!(
+                assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net"
-                );
             } // #3
+
             {
-                let item = link.next().unwrap();
+                let item = link.get(3).unwrap();
 
-                assert_eq!(item.alt, Some("1965-01-19 Gemini".to_string()));
+                assert_eq!(item.alt.clone().unwrap(), "Gemini");
 
-                let time = item.time(Some(&timezone)).unwrap();
+                let timestamp = item.timestamp.clone().unwrap();
-                assert_eq!(time.year(), 1965);
+                assert_eq!(timestamp.year(), 1965);
-                assert_eq!(time.month(), 1);
+                assert_eq!(timestamp.month(), 1);
-                assert_eq!(time.day_of_month(), 19);
+                assert_eq!(timestamp.day_of_month(), 19);
 
-                assert_eq!(
+                assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net"
-                );
             } // #4
+
             {
-                let item = link.next().unwrap();
+                let item = link.get(4).unwrap();
 
-                assert_eq!(item.alt, Some("1965-01-19 Gemini".to_string()));
+                assert_eq!(item.alt.clone().unwrap(), "Gemini");
 
-                let time = item.time(Some(&timezone)).unwrap();
+                let timestamp = item.timestamp.clone().unwrap();
-                assert_eq!(time.year(), 1965);
+                assert_eq!(timestamp.year(), 1965);
-                assert_eq!(time.month(), 1);
+                assert_eq!(timestamp.month(), 1);
-                assert_eq!(time.day_of_month(), 19);
+                assert_eq!(timestamp.day_of_month(), 19);
 
                 assert_eq!(
-                    item.uri(Some(&base)).unwrap().to_string(),
+                    item.uri.to_str(),
                     "gemini://geminiprotocol.net/docs/gemtext.gmi"
                 );
             } // #5
+
             {
-                let item = link.next().unwrap();
+                let item = link.get(5).unwrap();
 
                 assert_eq!(item.alt, None);
-                assert_eq!(item.time(Some(&timezone)), None);
+                assert_eq!(item.timestamp, None);
-                assert_eq!(
+                assert_eq!(item.uri.to_str(), "gemini://geminiprotocol.net");
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net"
-                );
             } // #6
-            {
-                let item = link.next().unwrap();
-
-                assert_eq!(item.alt, None);
-                assert_eq!(item.time(Some(&timezone)), None);
-                assert_eq!(
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net"
-                );
-            } // #7
-            {
-                let item = link.next().unwrap();
-
-                assert_eq!(item.alt, None);
-                assert_eq!(item.time(Some(&timezone)), None);
-                assert_eq!(
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net/path"
-                );
-            } // #8
-            {
-                let item = link.next().unwrap();
-
-                assert_eq!(item.alt, None);
-                assert_eq!(item.time(Some(&timezone)), None);
-                assert_eq!(
-                    item.uri(Some(&base)).unwrap().to_string(),
-                    "gemini://geminiprotocol.net/"
-                );
-            } // #9
 
             // Validate lists
             assert_eq!(list.len(), 2);