add strike tag support

src/app/browser/window/tab/item/page/content/text/markdown/tags.rs

@@ -3,6 +3,7 @@ mod header;
 mod list;
 mod quote;
 mod reference;
+mod strike;
 mod title;
 mod underline;
 
@@ -18,6 +19,7 @@ use gtk::{
 use header::Header;
 use list::List;
 use quote::Quote;
+use strike::Strike;
 use title::Title;
 use underline::Underline;
 
@@ -28,6 +30,7 @@ pub struct Tags {
     pub header: Header,
     pub list: TextTag,
     pub quote: Quote,
+    pub strike: Strike,
     pub title: TextTag,
     pub underline: Underline,
 }
@@ -57,6 +60,7 @@ impl Tags {
             header: Header::new(),
             list,
             quote: Quote::new(),
+            strike: Strike::new(),
             title,
             underline: Underline::new(),
         }
@@ -74,6 +78,7 @@ impl Tags {
         self.quote.render(buffer);
 
         self.bold.render(buffer);
+        self.strike.render(buffer);
         self.underline.render(buffer);
 
         reference::render_images_links(&buffer, base, &link_color, links);
@@ -81,8 +86,9 @@ impl Tags {
         reference::render_links(&buffer, base, &link_color, links);
 
         title.map(|mut s| {
-            s = reference::strip_tags(&s);
             s = bold::strip_tags(&s);
+            s = reference::strip_tags(&s);
+            s = strike::strip_tags(&s);
             s = underline::strip_tags(&s);
             s // @TODO other tags
         })

src/app/browser/window/tab/item/page/content/text/markdown/tags/strike.rs

@@ -0,0 +1,91 @@
+use gtk::{
+    TextBuffer, TextTag,
+    WrapMode::Word,
+    prelude::{TextBufferExt, TextBufferExtManual},
+};
+use regex::Regex;
+
+const REGEX_STRIKE: &str = r"~~(?P<text>.+?)~~";
+
+pub struct Strike(TextTag);
+
+impl Strike {
+    pub fn new() -> Self {
+        Self(
+            TextTag::builder()
+                .strikethrough(true)
+                .wrap_mode(Word)
+                .build(),
+        )
+    }
+
+    /// Apply ~~strike~~ `Tag` to given `TextBuffer`
+    pub fn render(&self, buffer: &TextBuffer) {
+        assert!(buffer.tag_table().add(&self.0));
+
+        let (start, end) = buffer.bounds();
+        let full_content = buffer.text(&start, &end, true).to_string();
+
+        let matches: Vec<_> = Regex::new(REGEX_STRIKE)
+            .unwrap()
+            .captures_iter(&full_content)
+            .collect();
+
+        for cap in matches.into_iter().rev() {
+            let full_match = cap.get(0).unwrap();
+
+            let start_char_offset = full_content[..full_match.start()].chars().count() as i32;
+            let end_char_offset = full_content[..full_match.end()].chars().count() as i32;
+
+            let mut start_iter = buffer.iter_at_offset(start_char_offset);
+            let mut end_iter = buffer.iter_at_offset(end_char_offset);
+
+            buffer.delete(&mut start_iter, &mut end_iter);
+            buffer.insert_with_tags(&mut start_iter, &cap["text"], &[&self.0])
+        }
+    }
+}
+
+pub fn strip_tags(value: &str) -> String {
+    let mut result = String::from(value);
+    for cap in Regex::new(REGEX_STRIKE)
+        .unwrap()
+        .captures_iter(&value)
+        .into_iter()
+    {
+        if let Some(m) = cap.get(0) {
+            result = result.replace(m.as_str(), &cap["text"]);
+        }
+    }
+    result
+}
+
+#[test]
+fn test_strip_tags() {
+    const VALUE: &str = r"Some ~~strike 1~~ and ~~strike 2~~ with ![img](https://link.com)";
+    let mut result = String::from(VALUE);
+    for cap in Regex::new(REGEX_STRIKE)
+        .unwrap()
+        .captures_iter(VALUE)
+        .into_iter()
+    {
+        if let Some(m) = cap.get(0) {
+            result = result.replace(m.as_str(), &cap["text"]);
+        }
+    }
+    assert_eq!(
+        result,
+        "Some strike 1 and strike 2 with ![img](https://link.com)"
+    )
+}
+
+#[test]
+fn test_regex() {
+    let cap: Vec<_> = Regex::new(REGEX_STRIKE)
+        .unwrap()
+        .captures_iter(r"Some ~~strike 1~~ and ~~strike 2~~ with ![img](https://link.com)")
+        .collect();
+
+    assert_eq!(&cap.get(0).unwrap()["text"], "strike 1");
+    assert_eq!(&cap.get(1).unwrap()["text"], "strike 2");
+}