markdown_it_ruby 0.1.1

data/ext/markdown_it_ruby/src/extensions/link_with_target.rs

@@ -0,0 +1,473 @@
+use markdown_it::parser::core::CoreRule;
+use markdown_it::plugins::cmark::inline::{autolink::Autolink, link::Link};
+use markdown_it::plugins::extra::linkify::Linkified;
+use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
+
+use crate::driver::{InternalDomain, MarkdonwItOptions};
+
+#[derive(Debug)]
+pub struct LinkWithTarget {
+    pub url: String,
+    pub title: Option<String>,
+    pub target: Option<String>,
+    pub rel: Option<String>,
+}
+
+impl NodeValue for LinkWithTarget {
+    fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
+        let mut attrs = node.attrs.clone();
+        attrs.push(("href", self.url.clone()));
+
+        if let Some(target) = self.target.as_ref() {
+            attrs.push(("target", target.to_string()));
+        }
+        if let Some(rel) = self.rel.as_ref() {
+            attrs.push(("rel", rel.to_string()));
+        }
+
+        if let Some(title) = &self.title {
+            attrs.push(("title", title.clone()));
+        }
+
+        fmt.open("a", &attrs);
+        fmt.contents(&node.children);
+        fmt.close("a");
+    }
+}
+
+impl LinkWithTarget {
+    pub fn new(
+        url: String,
+        title: Option<String>,
+        internal_domain_name: Option<InternalDomain>,
+    ) -> Self {
+        // for internal links only
+        if let Some(internal_domain_name) = internal_domain_name {
+            if internal_domain_name.matches(&url) {
+                return LinkWithTarget {
+                    url,
+                    title,
+                    target: None,
+                    rel: None,
+                };
+            }
+        }
+
+        // open external links in a new tab
+        LinkWithTarget {
+            url,
+            title,
+            target: Some("_blank".to_string()),
+            rel: Some("noopener noreferrer".to_string()),
+        }
+    }
+}
+
+struct LinkTargetRule;
+
+impl CoreRule for LinkTargetRule {
+    // a custom function that will be invoked once per document.
+    fn run(root: &mut Node, md: &MarkdownIt) {
+        let options = md.ext.get::<MarkdonwItOptions>();
+        let internal_domain = match options {
+            None => None,
+            Some(options) => options.internal_domain(),
+        };
+
+        // walk through AST recursively
+        root.walk_mut(|node, _| {
+            if let Some(link) = node.cast::<Link>() {
+                let link_with_target = LinkWithTarget::new(
+                    link.url.clone(),
+                    link.title.clone(),
+                    internal_domain.clone(),
+                );
+                node.replace::<LinkWithTarget>(link_with_target);
+            } else if let Some(autolink) = node.cast::<Autolink>() {
+                let link_with_target =
+                    LinkWithTarget::new(autolink.url.clone(), None, internal_domain.clone());
+                node.replace::<LinkWithTarget>(link_with_target);
+            } else if let Some(linkified) = node.cast::<Linkified>() {
+                let link_with_target =
+                    LinkWithTarget::new(linkified.url.clone(), None, internal_domain.clone());
+                node.replace::<LinkWithTarget>(link_with_target);
+            }
+        });
+    }
+}
+
+pub fn add(md: &mut MarkdownIt) {
+    md.add_rule::<LinkTargetRule>();
+}
+
+#[test]
+fn test_link_with_target() {
+    use std::collections::HashMap;
+
+    let mut md = MarkdownIt::new();
+
+    markdown_it::plugins::cmark::add(&mut md);
+    markdown_it::plugins::extra::add(&mut md);
+    add(&mut md);
+
+    {
+        // without options
+        {
+            // for non-autolink (custom links)
+            {
+                // with scheme part
+                {
+                    // with base_url that has scheme part
+                    let src = "[some title](https://kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://kyoto.dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with base_url with http scheme
+                    let src = "[some title](http://kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"http://kyoto.dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with subdomain of base_url
+                    let src = "[some title](https://fuji.kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://fuji.kyoto.dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with 'parent' domain of base_url
+                    // this should be treated as external link
+                    let src = "[some title](https://dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                        );
+                }
+                {
+                    // with different domain
+                    let src = "[some title](https://nara.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://nara.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                        );
+                }
+            }
+            {
+                // without sheme part
+                {
+                    // domain part is the same as base_url
+                    let src = "[some title](kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"kyoto.dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // domain part is different from base_url
+                    // NOTE: for simplicity, any url without scheme part is treated as "internal" link
+                    let src = "[some title](dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n");
+                }
+                {
+                    // without domain part
+                    let src = "[some title](foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n");
+                }
+                {
+                    // with filename
+                    let src = "[some title](foo.jpg)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"foo.jpg\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n");
+                }
+            }
+        }
+        {
+            // for autolink urls
+            {
+                // with base_url
+                let src = "<https://kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // with child domain of base_url
+                let src = "<https://pontocho.kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://pontocho.kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">pontocho.kyoto.dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with parent domain of base_url
+                let src = "<https://dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with base_url, with http scheme
+                let src = "<http://kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"http://kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // external links
+                let src = "<https://nara.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(html, "<p><a href=\"https://nara.jp\" target=\"_blank\" rel=\"noopener noreferrer\">nara.jp</a></p>\n");
+            }
+        }
+        {
+            // for linkified urls
+            {
+                // with base_url
+                let src = "https://kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // with child domain of base_url
+                let src = "https://pontocho.kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://pontocho.kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">pontocho.kyoto.dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with parent domain of base_url
+                let src = "https://dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with base_url, with http scheme
+                let src = "http://kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"http://kyoto.dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // external links
+                let src = "https://nara.jp";
+                let html = md.parse(src).render();
+                assert_eq!(html, "<p><a href=\"https://nara.jp\" target=\"_blank\" rel=\"noopener noreferrer\">nara.jp</a></p>\n");
+            }
+        }
+    }
+
+    {
+        // with options
+        let base_url = "https://kyoto.dosue.jp".to_string();
+        let options = MarkdonwItOptions::new(HashMap::from([(
+            "internal_domain_name".to_string(),
+            base_url.to_string(),
+        )]));
+        options.add(&mut md);
+
+        {
+            // for non-autolink (custom links)
+            {
+                // with scheme part
+                {
+                    // with base_url that has scheme part
+                    let src = "[some title](https://kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://kyoto.dosue.jp/foo/bar\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with base_url with http scheme
+                    let src = "[some title](http://kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"http://kyoto.dosue.jp/foo/bar\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with subdomain of base_url
+                    let src = "[some title](https://fuji.kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://fuji.kyoto.dosue.jp/foo/bar\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // with 'parent' domain of base_url
+                    // this should be treated as external link
+                    let src = "[some title](https://dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://dosue.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                        );
+                }
+                {
+                    // with different domain
+                    let src = "[some title](https://nara.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"https://nara.jp/foo/bar\" target=\"_blank\" rel=\"noopener noreferrer\">some title</a></p>\n"
+                        );
+                }
+            }
+            {
+                // without sheme part
+                {
+                    // domain part is the same as base_url
+                    let src = "[some title](kyoto.dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(
+                        html,
+                        "<p><a href=\"kyoto.dosue.jp/foo/bar\">some title</a></p>\n"
+                    );
+                }
+                {
+                    // domain part is different from base_url
+                    // NOTE: for simplicity, any url without scheme part is treated as "internal" link
+                    let src = "[some title](dosue.jp/foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"dosue.jp/foo/bar\">some title</a></p>\n");
+                }
+                {
+                    // without domain part
+                    let src = "[some title](foo/bar)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"foo/bar\">some title</a></p>\n");
+                }
+                {
+                    // with filename
+                    let src = "[some title](foo.jpg)";
+                    let html = md.parse(src).render();
+                    assert_eq!(html, "<p><a href=\"foo.jpg\">some title</a></p>\n");
+                }
+            }
+        }
+        {
+            // for autolink urls
+            {
+                // with base_url
+                let src = "<https://kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://kyoto.dosue.jp\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // with child domain of base_url
+                let src = "<https://pontocho.kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://pontocho.kyoto.dosue.jp\">pontocho.kyoto.dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with parent domain of base_url
+                let src = "<https://dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with base_url, with http scheme
+                let src = "<http://kyoto.dosue.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"http://kyoto.dosue.jp\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // external links
+                let src = "<https://nara.jp>";
+                let html = md.parse(src).render();
+                assert_eq!(html, "<p><a href=\"https://nara.jp\" target=\"_blank\" rel=\"noopener noreferrer\">nara.jp</a></p>\n");
+            }
+        }
+        {
+            // for linkified urls
+            {
+                // with base_url
+                let src = "https://kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://kyoto.dosue.jp\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // with child domain of base_url
+                let src = "https://pontocho.kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://pontocho.kyoto.dosue.jp\">pontocho.kyoto.dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with parent domain of base_url
+                let src = "https://dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"https://dosue.jp\" target=\"_blank\" rel=\"noopener noreferrer\">dosue.jp</a></p>\n"
+                    );
+            }
+            {
+                // with base_url, with http scheme
+                let src = "http://kyoto.dosue.jp";
+                let html = md.parse(src).render();
+                assert_eq!(
+                    html,
+                    "<p><a href=\"http://kyoto.dosue.jp\">kyoto.dosue.jp</a></p>\n"
+                );
+            }
+            {
+                // external links
+                let src = "https://nara.jp";
+                let html = md.parse(src).render();
+                assert_eq!(html, "<p><a href=\"https://nara.jp\" target=\"_blank\" rel=\"noopener noreferrer\">nara.jp</a></p>\n");
+            }
+        }
+    }
+}

data/ext/markdown_it_ruby/src/extensions/table_decoration.rs

@@ -0,0 +1,88 @@
+use crate::driver::MarkdonwItOptions;
+use markdown_it::parser::core::CoreRule;
+use markdown_it::plugins::extra::tables::Table;
+use markdown_it::{MarkdownIt, Node, NodeValue, Renderer};
+
+#[derive(Debug)]
+pub struct TableDecoration {
+    pub table: Table,
+    pub class_name: String,
+}
+
+impl NodeValue for TableDecoration {
+    fn render(&self, node: &Node, fmt: &mut dyn Renderer) {
+        let class_name = self.class_name.clone();
+        let div_attrs = vec![("class", class_name)];
+        fmt.open("div", &div_attrs);
+        fmt.cr();
+        self.table.render(node, fmt);
+        fmt.cr();
+        fmt.close("div");
+    }
+}
+
+struct TableDecorationRule;
+
+impl CoreRule for TableDecorationRule {
+    // a custom function that will be invoked once per document.
+    fn run(root: &mut Node, md: &MarkdownIt) {
+        let options = md.ext.get::<MarkdonwItOptions>();
+        let table_class_name = match options {
+            Some(options) => options.get_option_or_default("table_class_name", "table"),
+            None => "table".to_string(),
+        };
+        root.walk_mut(|node, _| {
+            if let Some(table) = node.cast::<Table>() {
+                node.replace(TableDecoration {
+                    table: Table {
+                        alignments: table.alignments.clone(),
+                    },
+                    class_name: table_class_name.clone(),
+                })
+            }
+        });
+    }
+}
+
+pub fn add(md: &mut MarkdownIt) {
+    md.add_rule::<TableDecorationRule>();
+}
+
+#[test]
+fn test_table_decoration() {
+    use std::collections::HashMap;
+
+    let mut md = MarkdownIt::new();
+
+    markdown_it::plugins::cmark::add(&mut md);
+    markdown_it::plugins::extra::add(&mut md);
+    add(&mut md);
+
+    {
+        // without options
+        let src = "| 左寄せタイトル | センタリング | 右寄せタイトル |\n |:------------|:------------:|-----------:|\n | column | column | column |\n";
+        let html = md.parse(src).render();
+
+        assert_eq!(
+            html,
+            "<div class=\"table\">\n<table>\n<thead>\n<tr>\n<th style=\"text-align:left\">左寄せタイトル</th>\n<th style=\"text-align:center\">センタリング</th>\n<th style=\"text-align:right\">右寄せタイトル</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:left\">column</td>\n<td style=\"text-align:center\">column</td>\n<td style=\"text-align:right\">column</td>\n</tr>\n</tbody>\n</table>\n</div>"
+        )
+    }
+
+    {
+        // with options
+        let options = MarkdonwItOptions::new(HashMap::from([(
+            "table_class_name".to_string(),
+            "custom-table-class-name".to_string(),
+        )]));
+        options.add(&mut md);
+
+        let src = "| 左寄せタイトル | センタリング | 右寄せタイトル |\n |:------------|:------------:|-----------:|\n | column | column | column |\n";
+        let html = md.parse(src).render();
+
+        assert_eq!(
+            html,
+            "<div class=\"custom-table-class-name\">\n<table>\n<thead>\n<tr>\n<th style=\"text-align:left\">左寄せタイトル</th>\n<th style=\"text-align:center\">センタリング</th>\n<th style=\"text-align:right\">右寄せタイトル</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align:left\">column</td>\n<td style=\"text-align:center\">column</td>\n<td style=\"text-align:right\">column</td>\n</tr>\n</tbody>\n</table>\n</div>"
+        )
+    }
+}

data/ext/markdown_it_ruby/src/extensions.rs

@@ -0,0 +1,18 @@
+pub(super) mod heading_level_modification;
+pub(super) mod link_with_target;
+pub(super) mod table_decoration;
+
+use crate::driver::MarkdonwItOptions;
+use markdown_it::MarkdownIt;
+
+pub(super) fn add(md: &mut MarkdownIt, option: &MarkdonwItOptions) {
+    if option.is_enabled("heading_level_offset", true) {
+        heading_level_modification::add(md);
+    }
+    if option.is_enabled("internal_domain_name", true) {
+        link_with_target::add(md);
+    }
+    if option.is_enabled("table_class_name", true) {
+        table_decoration::add(md);
+    }
+}

data/ext/markdown_it_ruby/src/lib.rs

@@ -0,0 +1,35 @@
+mod driver;
+mod extensions;
+use magnus::{define_module, function, prelude::*, Error};
+use std::collections::HashMap;
+
+// macro for regex
+//
+// usage:
+//
+// use crate::regex;
+// let domain_regex = regex!(r"^[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+/");
+// if domain_regex.is_match(url) { ...
+#[macro_export]
+macro_rules! regex {
+    ($re:literal $(,)?) => {{
+        static RE: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
+        RE.get_or_init(|| regex::Regex::new($re).unwrap())
+    }};
+}
+
+use driver::MarkdownDriver;
+
+fn convert(contents: String, options: HashMap<String, String>) -> String {
+    let handler = MarkdownDriver::new(options);
+    handler.parse(contents);
+    handler.render()
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("MarkdownIt")?;
+    module.define_singleton_method("__convert", function!(convert, 2))?;
+
+    Ok(())
+}

data/lib/markdown_it_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MarkdownIt
+  VERSION = "0.1.1"
+end

data/lib/markdown_it_ruby.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "markdown_it_ruby/version"
+require_relative "markdown_it_ruby/markdown_it_ruby"
+
+module MarkdownIt
+  class Error < StandardError; end
+
+  def self.convert(input, **options)
+    options.transform_keys!(&:to_s)
+    options.transform_values!(&:to_s)
+
+    __convert(input, **options)
+  end
+end

data/sig/markdown_it_ruby.rbs

@@ -0,0 +1,4 @@
+module MarkdownIt
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end