commonmarker 0.23.10 → 1.0.0

data/Cargo.toml

@@ -0,0 +1,6 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions depedencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["ext/commonmarker"]

data/README.md

@@ -1,11 +1,13 @@
-# CommonMarker
+# Commonmarker
 
-![Build Status](https://github.com/gjtorikian/commonmarker/workflows/CI/badge.svg) [![Gem Version](https://badge.fury.io/rb/commonmarker.svg)](http://badge.fury.io/rb/commonmarker)
+> **Note**
+> This README refers to the behavior in the new 1.0.0.pre gem.
 
-Ruby wrapper for [libcmark-gfm](https://github.com/github/cmark),
-GitHub's fork of the reference parser for CommonMark. It passes all of the C tests, and is therefore spec-complete. It also includes extensions to the CommonMark spec as documented in the [GitHub Flavored Markdown spec](http://github.github.com/gfm/), such as support for tables, strikethroughs, and autolinking.
+Ruby wrapper for Rust's [comrak](https://github.com/kivikakk/comrak) crate.
 
-For more information on available extensions, see [the documentation below](#extensions).
+It passes all of the CommonMark test suite, and is therefore spec-complete. It also includes extensions to the CommonMark spec as documented in the [GitHub Flavored Markdown spec](http://github.github.com/gfm/), such as support for tables, strikethroughs, and autolinking.
+
+For more information on available extensions, see [the documentation below](#extension-options).
 
 ## Installation
 
@@ -25,234 +27,168 @@ Or install it yourself as:
 
 ### Converting to HTML
 
-Call `render_html` on a string to convert it to HTML:
-
-``` ruby
-require 'commonmarker'
-CommonMarker.render_html('Hi *there*', :DEFAULT)
-# <p>Hi <em>there</em></p>\n
-```
-
-The second argument is optional--[see below](#options) for more information.
-
-### Generating a document
+Call `to_html` on a string to convert it to HTML:
 
-You can also parse a string to receive a `Document` node. You can then print that node to HTML, iterate over the children, and other fun node stuff. For example:
-
-``` ruby
+```ruby
 require 'commonmarker'
-
-doc = CommonMarker.render_doc('*Hello* world', :DEFAULT)
-puts(doc.to_html) # <p>Hi <em>there</em></p>\n
-
-doc.walk do |node|
-  puts node.type # [:document, :paragraph, :text, :emph, :text]
-end
+Commonmarker.to_html('"Hi *there*"', options: {
+    parse: { smart: true }
+})
+# <p>“Hi <em>there</em>”</p>\n
 ```
 
 The second argument is optional--[see below](#options) for more information.
 
-#### Example: walking the AST
-
-You can use `walk` or `each` to iterate over nodes:
-
-- `walk` will iterate on a node and recursively iterate on a node's children.
-- `each` will iterate on a node and its children, but no further.
+## Options and plugins
 
-``` ruby
-require 'commonmarker'
-
-# parse the files specified on the command line
-doc = CommonMarker.render_doc("# The site\n\n [GitHub](https://www.github.com)")
+### Options
 
-# Walk tree and print out URLs for links
-doc.walk do |node|
-  if node.type == :link
-    printf("URL = %s\n", node.url)
-  end
-end
-
-# Capitalize all regular text in headers
-doc.walk do |node|
-  if node.type == :header
-    node.each do |subnode|
-      if subnode.type == :text
-        subnode.string_content = subnode.string_content.upcase
-      end
-    end
-  end
-end
-
-# Transform links to regular text
-doc.walk do |node|
-  if node.type == :link
-    node.insert_before(node.first_child)
-    node.delete
-  end
-end
-```
-
-### Creating a custom renderer
-
-You can also derive a class from CommonMarker's `HtmlRenderer` class. This produces slower output, but is far more customizable. For example:
-
-``` ruby
-class MyHtmlRenderer < CommonMarker::HtmlRenderer
-  def initialize
-    super
-    @headerid = 1
-  end
-
-  def header(node)
-    block do
-      out("<h", node.header_level, " id=\"", @headerid, "\">",
-               :children, "</h", node.header_level, ">")
-      @headerid += 1
-    end
-  end
-end
+Commonmarker accepts the same parse, render, and extensions options that comrak does, as a hash dictionary with symbol keys:
 
-myrenderer = MyHtmlRenderer.new
-puts myrenderer.render(doc)
-
-# Print any warnings to STDERR
-renderer.warnings.each do |w|
-  STDERR.write("#{w}\n")
-end
+```ruby
+Commonmarker.to_html('"Hi *there*"', options:{
+  parse: { smart: true },
+  render: { hardbreaks: false}
+})
 ```
 
-## Options
-
-CommonMarker accepts the same options that CMark does, as symbols. Note that there is a distinction in CMark for "parse" options and "render" options, which are represented in the tables below.
+Note that there is a distinction in comrak for "parse" options and "render" options, which are represented in the tables below.
 
 ### Parse options
 
-| Name                          | Description
-| ----------------------------- | -----------
-| `:DEFAULT`                    | The default parsing system.
-| `:SOURCEPOS`                  | Include source position in nodes
-| `:UNSAFE`                     | Allow raw/custom HTML and unsafe links.
-| `:VALIDATE_UTF8`              | Replace illegal sequences with the replacement character `U+FFFD`.
-| `:SMART`                      | Use smart punctuation (curly quotes, etc.).
-| `:LIBERAL_HTML_TAG`           | Support liberal parsing of inline HTML tags.
-| `:FOOTNOTES`                  | Parse footnotes.
-| `:STRIKETHROUGH_DOUBLE_TILDE` | Parse strikethroughs by double tildes (compatibility with [redcarpet](https://github.com/vmg/redcarpet))
+| Name                  | Description                                                                          | Default |
+| --------------------- | ------------------------------------------------------------------------------------ | ------- |
+| `smart`               | Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation. | `false` |
+| `default_info_string` | The default info string for fenced code blocks.                                      | `""`    |
 
 ### Render options
 
-| Name                             | Description                                                     |
-| ------------------               | -----------                                                     |
-| `:DEFAULT`                       | The default rendering system.                                   |
-| `:SOURCEPOS`                     | Include source position in rendered HTML.                       |
-| `:HARDBREAKS`                    | Treat `\n` as hardbreaks (by adding `<br/>`).                   |
-| `:UNSAFE`                        | Allow raw/custom HTML and unsafe links.                         |
-| `:NOBREAKS`                      | Translate `\n` in the source to a single whitespace.            |
-| `:VALIDATE_UTF8`                 | Replace illegal sequences with the replacement character `U+FFFD`. |
-| `:SMART`                         | Use smart punctuation (curly quotes, etc.).                     |
-| `:GITHUB_PRE_LANG`               | Use GitHub-style `<pre lang>` for fenced code blocks.           |
-| `:LIBERAL_HTML_TAG`              | Support liberal parsing of inline HTML tags.                    |
-| `:FOOTNOTES`                     | Render footnotes.                                               |
-| `:STRIKETHROUGH_DOUBLE_TILDE`    | Parse strikethroughs by double tildes (compatibility with [redcarpet](https://github.com/vmg/redcarpet)) |
-| `:TABLE_PREFER_STYLE_ATTRIBUTES` | Use `style` insted of `align` for table cells.                  |
-| `:FULL_INFO_STRING`              | Include full info strings of code blocks in separate attribute. |
-
-### Passing options
-
-To apply a single option, pass it in as a symbol argument:
-
-``` ruby
-CommonMarker.render_doc("\"Hello,\" said the spider.", :SMART)
-# <p>“Hello,” said the spider.</p>\n
-```
+| Name              | Description                                                                                            | Default |
+| ----------------- | ------------------------------------------------------------------------------------------------------ | ------- |
+| `hardbreaks`      | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks. | `true`  |
+| `github_pre_lang` | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                         | `true`  |
+| `width`           | The wrap column when outputting CommonMark.                                                            | `80`    |
+| `unsafe`          | Allow rendering of raw HTML and potentially dangerous links.                                           | `false` |
+| `escape`          | Escape raw HTML instead of clobbering it.                                                              | `false` |
 
-To have multiple options applied, pass in an array of symbols:
+As well, there are several extensions which you can toggle in the same manner:
 
-``` ruby
-CommonMarker.render_html("\"'Shelob' is my name.\"", [:HARDBREAKS, :SOURCEPOS])
+```ruby
+Commonmarker.to_html('"Hi *there*"', options: {
+    extension: { footnotes: true, description_lists: true },
+    render: { hardbreaks: false}
+})
 ```
 
-For more information on these options, see [the CMark documentation](https://git.io/v7nh1).
-
-## Extensions
-
-Both `render_html` and `render_doc` take an optional third argument defining the extensions you want enabled as your CommonMark document is being processed. The documentation for these extensions are [defined in this spec](https://github.github.com/gfm/), and the rationale is provided [in this blog post](https://githubengineering.com/a-formal-spec-for-github-markdown/).
+### Extension options
+
+| Name                     | Description                                                                                                         | Default |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------- | ------- |
+| `strikethrough`          | Enables the [strikethrough extension](https://github.github.com/gfm/#strikethrough-extension-) from the GFM spec.   | `true`  |
+| `tagfilter`              | Enables the [tagfilter extension](https://github.github.com/gfm/#disallowed-raw-html-extension-) from the GFM spec. | `true`  |
+| `table`                  | Enables the [table extension](https://github.github.com/gfm/#tables-extension-) from the GFM spec.                  | `true`  |
+| `autolink`               | Enables the [autolink extension](https://github.github.com/gfm/#autolinks-extension-) from the GFM spec.            | `true`  |
+| `tasklist`               | Enables the [task list extension](https://github.github.com/gfm/#task-list-items-extension-) from the GFM spec.     | `true`  |
+| `superscript`            | Enables the superscript Comrak extension.                                                                           | `false` |
+| `header_ids`             | Enables the header IDs Comrak extension. from the GFM spec.                                                         | `""`    |
+| `footnotes`              | Enables the footnotes extension per `cmark-gfm`.                                                                    | `false` |
+| `description_lists`      | Enables the description lists extension.                                                                            | `false` |
+| `front_matter_delimiter` | Enables the front matter extension.                                                                                 | `""`    |
+| `shortcodes`             | Enables the shortcodes extension.                                                                                   | `true`  |
+
+For more information on these options, see [the comrak documentation](https://github.com/kivikakk/comrak#usage).
+
+### Plugins
+
+In addition to the possibilities provided by generic CommonMark rendering, Commonmarker also supports plugins as a means of
+providing further niceties.
+
+#### Syntax Highlighter Plugin
+
+The library comes with [a set of pre-existing themes](https://docs.rs/syntect/5.0.0/syntect/highlighting/struct.ThemeSet.html#implementations) for highlighting code:
+
+- `"base16-ocean.dark"`
+- `"base16-eighties.dark"`
+- `"base16-mocha.dark"`
+- `"base16-ocean.light"`
+- `"InspiredGitHub"`
+- `"Solarized (dark)"`
+- `"Solarized (light)"`
+
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+  ```
+CODE
 
-The available extensions are:
+# pass in a theme name from a pre-existing set
+puts Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "InspiredGitHub" } })
 
-* `:table` - This provides support for tables.
-* `:tasklist` - This provides support for task list items.
-* `:strikethrough` - This provides support for strikethroughs.
-* `:autolink` - This provides support for automatically converting URLs to anchor tags.
-* `:tagfilter` - This escapes [several "unsafe" HTML tags](https://github.github.com/gfm/#disallowed-raw-html-extension-), causing them to not have any effect.
+# <pre style="background-color:#ffffff;" lang="ruby"><code>
+# <span style="font-weight:bold;color:#a71d5d;">def </span><span style="font-weight:bold;color:#795da3;">hello
+# </span><span style="color:#62a35c;">puts </span><span style="color:#183691;">&quot;hello&quot;
+# </span><span style="font-weight:bold;color:#a71d5d;">end
+# </span>
+# </code></pre>
+````
 
-## Output formats
+By default, the plugin uses the `"base16-ocean.dark"` theme to syntax highlight code.
 
-Like CMark, CommonMarker can generate output in several formats: HTML, XML, plaintext, and commonmark are currently supported.
+To disable this plugin, set the value to `nil`:
 
-### HTML
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+  ```
+CODE
 
-The default output format, HTML, will be generated when calling `to_html` or using `--to=html` on the command line.
+Commonmarker.to_html(code, plugins: { syntax_highlighter: nil })
 
-```ruby
-doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
-puts(doc.to_html)
+# <pre lang="ruby"><code>def hello
+#   puts &quot;hello&quot;
+# end
+# </code></pre>
+````
 
-<p><em>Hello</em> world!</p>
-```
+To output CSS classes instead of `style` attributes, set the `theme` key to `""`:
 
-### XML
-
-XML will be generated when calling `to_xml` or using `--to=xml` on the command line.
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+CODE
 
-```ruby
-doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
-puts(doc.to_xml)
-
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE document SYSTEM "CommonMark.dtd">
-<document xmlns="http://commonmark.org/xml/1.0">
-  <paragraph>
-    <emph>
-      <text xml:space="preserve">Hello</text>
-    </emph>
-    <text xml:space="preserve"> world!</text>
-  </paragraph>
-</document>
-```
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "" } })
 
-### Plaintext
+# <pre class="syntax-highlighting"><code><span class="source ruby"><span class="meta function ruby"><span class="keyword control def ruby">def</span></span><span class="meta function ruby"> # <span class="entity name function ruby">hello</span></span>
+#   <span class="support function builtin ruby">puts</span> <span class="string quoted double ruby"><span class="punctuation definition string begin ruby">&quot;</span>hello<span class="punctuation definition string end ruby">&quot;</span></span>
+# <span class="keyword control ruby">end</span>\n</span></code></pre>
+````
 
-Plaintext will be generated when calling `to_plaintext` or using `--to=plaintext` on the command line.
+To use a custom theme, you can provide a `path` to a directory containing `.tmtheme` files to load:
 
 ```ruby
-doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
-puts(doc.to_plaintext)
-
-Hello world!
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "Monokai", path: "./themes" } })
 ```
 
-### Commonmark
-
-Commonmark will be generated when calling `to_commonmark` or using `--to=commonmark` on the command line.
-
-``` ruby
-text = <<-TEXT
-1. I am a numeric list.
-2. I continue the list.
-* Suddenly, an unordered list!
-* What fun!
-TEXT
+## Output formats
 
-doc = CommonMarker.render_doc(text, :DEFAULT)
-puts(doc.to_commonmark)
+Commonmarker can currently only generate output in one format: HTML.
 
-1.  I am a numeric list.
-2.  I continue the list.
+### HTML
 
-<!-- end list -->
+```ruby
+puts Commonmarker.to_html('*Hello* world!')
 
-  - Suddenly, an unordered list\!
-  - What fun\!
+# <p><em>Hello</em> world!</p>
 ```
 
 ## Developing locally
@@ -264,7 +200,7 @@ script/bootstrap
 bundle exec rake compile
 ```
 
-If there were no errors, you're done! Otherwise, make sure to follow the CMark dependency instructions.
+If there were no errors, you're done! Otherwise, make sure to follow the comrak dependency instructions.
 
 ## Benchmarks
 
@@ -273,16 +209,21 @@ Some rough benchmarks:
 ```
 $ bundle exec rake benchmark
 
-input size = 11063727 bytes
+input size = 11064832 bytes
 
-redcarpet
-  0.070000   0.020000   0.090000 (  0.079641)
-github-markdown
-  0.070000   0.010000   0.080000 (  0.083535)
+Warming up --------------------------------------
+           redcarpet     2.000  i/100ms
+commonmarker with to_html
+                         1.000  i/100ms
+            kramdown     1.000  i/100ms
+Calculating -------------------------------------
+           redcarpet     22.317  (± 4.5%) i/s -    112.000  in   5.036374s
 commonmarker with to_html
-  0.100000   0.010000   0.110000 (  0.111947)
-commonmarker with ruby HtmlRenderer
-  1.830000   0.030000   1.860000 (  1.866203)
-kramdown
-  4.610000   0.070000   4.680000 (  4.678398)
+                          5.815  (± 0.0%) i/s -     30.000  in   5.168869s
+            kramdown      0.327  (± 0.0%) i/s -      2.000  in   6.121486s
+
+Comparison:
+           redcarpet:       22.3 i/s
+commonmarker with to_html:        5.8 i/s - 3.84x  (± 0.00) slower
+            kramdown:        0.3 i/s - 68.30x  (± 0.00) slower
 ```

data/ext/commonmarker/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "commonmarker"
+version = "1.0.0"
+edition = "2021"
+
+[dependencies]
+magnus =  "0.6"
+comrak = { version = "0.20", features = ["shortcodes"] }
+syntect = { version = "5.1", features = ["plist-load"] }
+
+[lib]
+name = "commonmarker"
+crate-type = ["cdylib"]

data/ext/commonmarker/extconf.rb

@@ -1,7 +1,4 @@
-# frozen_string_literal: true
+require "mkmf"
+require "rb_sys/mkmf"
 
-require 'mkmf'
-
-$CFLAGS << ' -std=c99'
-
-create_makefile('commonmarker/commonmarker')
+create_rust_makefile("commonmarker/commonmarker")

data/ext/commonmarker/src/lib.rs

@@ -0,0 +1,153 @@
+extern crate core;
+
+use std::path::PathBuf;
+
+use ::syntect::highlighting::ThemeSet;
+use comrak::{
+    adapters::SyntaxHighlighterAdapter,
+    markdown_to_html, markdown_to_html_with_plugins,
+    plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder},
+    ComrakOptions, ComrakPlugins,
+};
+use magnus::{
+    define_module, exception, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value,
+};
+
+mod options;
+use options::iterate_options_hash;
+
+mod plugins;
+use plugins::{
+    syntax_highlighting::{fetch_syntax_highlighter_path, fetch_syntax_highlighter_theme},
+    SYNTAX_HIGHLIGHTER_PLUGIN,
+};
+
+mod utils;
+
+pub const EMPTY_STR: &str = "";
+
+fn commonmark_to_html(args: &[Value]) -> Result<String, magnus::Error> {
+    let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
+    let (rb_commonmark,): (String,) = args.required;
+
+    let kwargs = scan_args::get_kwargs::<_, (), (Option<RHash>, Option<RHash>), ()>(
+        args.keywords,
+        &[],
+        &["options", "plugins"],
+    )?;
+    let (rb_options, rb_plugins) = kwargs.optional;
+
+    let mut comrak_options = ComrakOptions::default();
+
+    if let Some(rb_options) = rb_options {
+        rb_options.foreach(|key: Symbol, value: RHash| {
+            iterate_options_hash(&mut comrak_options, key, value)?;
+            Ok(ForEach::Continue)
+        })?;
+    }
+
+    if let Some(rb_plugins) = rb_plugins {
+        let mut comrak_plugins = ComrakPlugins::default();
+
+        let syntax_highlighter: Option<&dyn SyntaxHighlighterAdapter>;
+        let adapter: SyntectAdapter;
+
+        let theme = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
+            Some(syntax_highlighter_options) => {
+                match fetch_syntax_highlighter_theme(syntax_highlighter_options) {
+                    Ok(theme) => theme,
+                    Err(e) => {
+                        return Err(e);
+                    }
+                }
+            }
+            None => None, // no `syntax_highlighter:` defined
+        };
+
+        match theme {
+            None => syntax_highlighter = None,
+            Some(theme) => {
+                if theme.is_empty() {
+                    // no theme? uss css classes
+                    adapter = SyntectAdapter::new(None);
+                    syntax_highlighter = Some(&adapter);
+                } else {
+                    let path = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
+                        Some(syntax_highlighter_options) => {
+                            fetch_syntax_highlighter_path(syntax_highlighter_options)?
+                        }
+                        None => PathBuf::from("".to_string()), // no `syntax_highlighter:` defined
+                    };
+
+                    if path.exists() {
+                        if !path.is_dir() {
+                            return Err(Error::new(
+                                exception::arg_error(),
+                                "`path` needs to be a directory",
+                            ));
+                        }
+
+                        let builder = SyntectAdapterBuilder::new();
+                        let mut ts = ThemeSet::load_defaults();
+
+                        match ts.add_from_folder(&path) {
+                            Ok(_) => {}
+                            Err(e) => {
+                                return Err(Error::new(
+                                    exception::arg_error(),
+                                    format!("failed to load theme set from path: {e}"),
+                                ));
+                            }
+                        }
+
+                        // check if the theme exists in the dir
+                        match ts.themes.get(&theme) {
+                            Some(theme) => theme,
+                            None => {
+                                return Err(Error::new(
+                                    exception::arg_error(),
+                                    format!("theme `{}` does not exist", theme),
+                                ));
+                            }
+                        };
+
+                        adapter = builder.theme_set(ts).theme(&theme).build();
+
+                        syntax_highlighter = Some(&adapter);
+                    } else {
+                        // no path? default theme lookup
+                        ThemeSet::load_defaults()
+                            .themes
+                            .get(&theme)
+                            .ok_or_else(|| {
+                                Error::new(
+                                    exception::arg_error(),
+                                    format!("theme `{}` does not exist", theme),
+                                )
+                            })?;
+                        adapter = SyntectAdapter::new(Some(&theme));
+                        syntax_highlighter = Some(&adapter);
+                    }
+                }
+            }
+        }
+        comrak_plugins.render.codefence_syntax_highlighter = syntax_highlighter;
+
+        Ok(markdown_to_html_with_plugins(
+            &rb_commonmark,
+            &comrak_options,
+            &comrak_plugins,
+        ))
+    } else {
+        Ok(markdown_to_html(&rb_commonmark, &comrak_options))
+    }
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let module = define_module("Commonmarker")?;
+
+    module.define_module_function("commonmark_to_html", function!(commonmark_to_html, -1))?;
+
+    Ok(())
+}