commonmarker 0.23.10 → 2.2.0

data/Cargo.toml

@@ -0,0 +1,7 @@
+# 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"]
+resolver = "2"

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)
+Ruby wrapper for Rust's [comrak](https://github.com/kivikakk/comrak) crate.
 
-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.
+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](#extensions).
+> [!NOTE]
+> By default, several extensions not in any spec have been enabled, for the sake of end user convenience when generating HTML.
+>
+> For more information on the available options and extensions, see [the documentation below](#options-and-plugins).
 
 ## Installation
 
@@ -23,47 +25,79 @@ Or install it yourself as:
 
 ## Usage
 
+This gem expects to receive UTF-8 strings. Ensure your strings are the right encoding before passing them into `Commonmarker`.
+
 ### Converting to HTML
 
-Call `render_html` on a string to convert it to HTML:
+Call `to_html` on a string to convert it to HTML:
 
-``` ruby
+```ruby
 require 'commonmarker'
-CommonMarker.render_html('Hi *there*', :DEFAULT)
-# <p>Hi <em>there</em></p>\n
+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.
+(The second argument is optional--[see below](#options-and-plugins) for more information.)
 
 ### Generating a document
 
-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:
+You can also parse a string to receive a `:document` node. You can then print that node to HTML, iterate over the children, and do 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 = Commonmarker.parse("*Hello* world", options: {
+    parse: { smart: true }
+})
+puts(doc.to_html) # => <p><em>Hello</em> world</p>\n
 
 doc.walk do |node|
-  puts node.type # [:document, :paragraph, :text, :emph, :text]
+  puts node.type # => [:document, :paragraph, :emph, :text, :text]
 end
 ```
 
-The second argument is optional--[see below](#options) for more information.
+(The second argument is optional--[see below](#options-and-plugins) for more information.)
+
+When it comes to modifying the document, you can perform the following operations:
+
+- `insert_before`
+- `insert_after`
+- `prepend_child`
+- `append_child`
+- `delete`
+
+You can also get the source position of a node by calling `source_position`:
+
+```ruby
+doc = Commonmarker.parse("*Hello* world")
+puts doc.first_child.first_child.source_position
+# => {:start_line=>1, :start_column=>1, :end_line=>1, :end_column=>7}
+```
+
+You can also modify the following attributes:
+
+- `url`
+- `title`
+- `header_level`
+- `list_type`
+- `list_start`
+- `list_tight`
+- `fence_info`
 
-#### Example: walking the AST
+#### 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.
+- `each` will iterate on a node's direct children, but no further.
 
-``` ruby
+```ruby
 require 'commonmarker'
 
-# parse the files specified on the command line
-doc = CommonMarker.render_doc("# The site\n\n [GitHub](https://www.github.com)")
+# parse some string
+doc = Commonmarker.parse("# The site\n\n [GitHub](https://www.github.com)")
 
 # Walk tree and print out URLs for links
 doc.walk do |node|
@@ -71,17 +105,7 @@ doc.walk do |node|
     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
+# => URL = https://www.github.com
 
 # Transform links to regular text
 doc.walk do |node|
@@ -90,169 +114,199 @@ doc.walk do |node|
     node.delete
   end
 end
+# => <h1><a href=\"#the-site\"></a>The site</h1>\n<p>GitHub</p>\n
 ```
 
-### Creating a custom renderer
+#### Example: Converting a document back into raw CommonMark
 
-You can also derive a class from CommonMarker's `HtmlRenderer` class. This produces slower output, but is far more customizable. For example:
+You can use `to_commonmark` on a node to render it as raw text:
 
-``` ruby
-class MyHtmlRenderer < CommonMarker::HtmlRenderer
-  def initialize
-    super
-    @headerid = 1
-  end
+```ruby
+require 'commonmarker'
+
+# parse some string
+doc = Commonmarker.parse("# The site\n\n [GitHub](https://www.github.com)")
 
-  def header(node)
-    block do
-      out("<h", node.header_level, " id=\"", @headerid, "\">",
-               :children, "</h", node.header_level, ">")
-      @headerid += 1
-    end
+# Transform links to regular text
+doc.walk do |node|
+  if node.type == :link
+    node.insert_before(node.first_child)
+    node.delete
   end
 end
 
-myrenderer = MyHtmlRenderer.new
-puts myrenderer.render(doc)
-
-# Print any warnings to STDERR
-renderer.warnings.each do |w|
-  STDERR.write("#{w}\n")
-end
+doc.to_commonmark
+# => # The site\n\nGitHub\n
 ```
 
-## Options
+## Options and plugins
 
-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.
+### Options
 
-### 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))
-
-### Render options
+Commonmarker accepts the same parse, render, and extensions options that comrak does, as a hash dictionary with symbol keys:
 
-| 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
+```ruby
+Commonmarker.to_html('"Hi *there*"', options:{
+  parse: { smart: true },
+  render: { hardbreaks: false}
+})
 ```
 
-To have multiple options applied, pass in an array of symbols:
+Note that there is a distinction in comrak for "parse" options and "render" options, which are represented in the tables below. As well, if you wish to disable any-non boolean option, pass in `nil`.
 
-``` ruby
-CommonMarker.render_html("\"'Shelob' is my name.\"", [:HARDBREAKS, :SOURCEPOS])
-```
+### Parse options
 
-For more information on these options, see [the CMark documentation](https://git.io/v7nh1).
+| 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.                                                                                             | `""`    |
+| `relaxed_tasklist_matching` | Enables relaxing of the tasklist extension matching, allowing any non-space to be used for the "checked" state instead of only `x` and `X`. | `false` |
+| `relaxed_autolinks`         | Enable relaxing of the autolink extension parsing, allowing links to be recognized when in brackets, as well as permitting any url scheme.  | `false` |
 
-## Extensions
+### Render options
 
-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/).
+| 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`  |
+| `full_info_string`   | Gives info string data after a space in a `data-meta` attribute on code blocks.                        | `false` |
+| `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` |
+| `sourcepos`          | Include source position attribute in HTML and XML output.                                              | `false` |
+| `escaped_char_spans` | Wrap escaped characters in span tags.                                                                  | `true`  |
+| `ignore_setext`      | Ignores setext-style headings.                                                                         | `false` |
+| `ignore_empty_links` | Ignores empty links, leaving the Markdown text in place.                                               | `false` |
+| `gfm_quirks`         | Outputs HTML with GFM-style quirks; namely, not nesting `<strong>` inlines.                            | `false` |
+| `prefer_fenced`      | Always output fenced code blocks, even where an indented one could be used.                            | `false` |
+
+As well, there are several extensions which you can toggle in the same manner:
 
-The available extensions are:
+```ruby
+Commonmarker.to_html('"Hi *there*"', options: {
+    extension: { footnotes: true, description_lists: true },
+    render: { hardbreaks: false }
+})
+```
 
-* `: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.
+### 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.                                                                                 | `""`    |
+| `multiline_block_quotes`      | Enables the multiline block quotes extension.                                                                       | `false` |
+| `math_dollars`, `math_code`   | Enables the math extension.                                                                                         | `false` |
+| `shortcodes`                  | Enables the shortcodes extension.                                                                                   | `true`  |
+| `wikilinks_title_before_pipe` | Enables the wikilinks extension, placing the title before the dividing pipe.                                        | `false` |
+| `wikilinks_title_after_pipe`  | Enables the shortcodes extension, placing the title after the dividing pipe.                                        | `false` |
+| `underline`                   | Enables the underline extension.                                                                                    | `false` |
+| `spoiler`                     | Enables the spoiler extension.                                                                                      | `false` |
+| `greentext`                   | Enables the greentext extension.                                                                                    | `false` |
+| `subscript`                   | Enables the subscript extension.                                                                                    | `false` |
+| `alerts`                      | Enables the alerts extension.                                                                                       | `false` |
+
+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
 
-## Output formats
+# pass in a theme name from a pre-existing set
+puts Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "InspiredGitHub" } })
 
-Like CMark, CommonMarker can generate output in several formats: HTML, XML, plaintext, and commonmark are currently supported.
+# <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>
+````
 
-### HTML
+By default, the plugin uses the `"base16-ocean.dark"` theme to syntax highlight code.
 
-The default output format, HTML, will be generated when calling `to_html` or using `--to=html` on the command line.
+To disable this plugin, set the value to `nil`:
 
-```ruby
-doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
-puts(doc.to_html)
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+  ```
+CODE
 
-<p><em>Hello</em> world!</p>
-```
+Commonmarker.to_html(code, plugins: { syntax_highlighter: nil })
 
-### XML
+# <pre lang="ruby"><code>def hello
+#   puts &quot;hello&quot;
+# end
+# </code></pre>
+````
 
-XML will be generated when calling `to_xml` or using `--to=xml` on the command line.
+To output CSS classes instead of `style` attributes, set the `theme` key to `""`:
 
-```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>
-```
+````ruby
+code = <<~CODE
+  ```ruby
+  def hello
+    puts "hello"
+  end
+CODE
 
-### Plaintext
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "" } })
 
-Plaintext will be generated when calling `to_plaintext` or using `--to=plaintext` on the command line.
+# <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>
+````
 
-```ruby
-doc = CommonMarker.render_doc('*Hello* world!', :DEFAULT)
-puts(doc.to_plaintext)
+To use a custom theme, you can provide a `path` to a directory containing `.tmtheme` files to load:
 
-Hello world!
+```ruby
+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,25 +318,36 @@ 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
 
-Some rough benchmarks:
-
 ```
-$ bundle exec rake benchmark
-
-input size = 11063727 bytes
-
-redcarpet
-  0.070000   0.020000   0.090000 (  0.079641)
-github-markdown
-  0.070000   0.010000   0.080000 (  0.083535)
-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)
+❯ bundle exec rake benchmark
+input size = 11064832 bytes
+
+ruby 3.3.0 (2023-12-25 revision 5124f9ac75) [arm64-darwin23]
+Warming up --------------------------------------
+  Markly.render_html     1.000 i/100ms
+Markly::Node#to_html     1.000 i/100ms
+Commonmarker.to_html     1.000 i/100ms
+Commonmarker::Node.to_html
+                         1.000 i/100ms
+Kramdown::Document#to_html
+                         1.000 i/100ms
+Calculating -------------------------------------
+  Markly.render_html     15.606 (±25.6%) i/s -     71.000 in   5.047132s
+Markly::Node#to_html     15.692 (±25.5%) i/s -     72.000 in   5.095810s
+Commonmarker.to_html      4.482 (± 0.0%) i/s -     23.000 in   5.137680s
+Commonmarker::Node.to_html
+                          5.092 (±19.6%) i/s -     25.000 in   5.072220s
+Kramdown::Document#to_html
+                          0.379 (± 0.0%) i/s -      2.000 in   5.277770s
+
+Comparison:
+Markly::Node#to_html:       15.7 i/s
+  Markly.render_html:       15.6 i/s - same-ish: difference falls within error
+Commonmarker::Node.to_html:        5.1 i/s - 3.08x  slower
+Commonmarker.to_html:        4.5 i/s - 3.50x  slower
+Kramdown::Document#to_html:        0.4 i/s - 41.40x  slower
 ```

data/ext/commonmarker/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "commonmarker"
+version = "1.0.0"
+edition = "2021"
+rust-version = "1.75.0"
+publish = false
+
+[dependencies]
+magnus = { version = "0.7", features = ["rb-sys"] }
+rb-sys = { version = "*", default-features = false, features = [
+    "stable-api-compiled-fallback",
+] }
+comrak = { version = "0.37", features = ["shortcodes"] }
+syntect = { version = "5.2", features = ["plist-load"] }
+typed-arena = "2.0"
+rctree = "0.6"
+
+[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,103 @@
+extern crate core;
+
+use comrak::{markdown_to_html_with_plugins, parse_document, ComrakOptions};
+use magnus::{define_module, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value};
+use node::CommonmarkerNode;
+use plugins::syntax_highlighting::construct_syntax_highlighter_from_plugin;
+
+mod options;
+use options::iterate_options_hash;
+
+mod plugins;
+
+use typed_arena::Arena;
+
+mod node;
+mod utils;
+
+pub const EMPTY_STR: &str = "";
+
+fn commonmark_parse(args: &[Value]) -> Result<CommonmarkerNode, magnus::Error> {
+    let args = scan_args::scan_args::<_, (), (), (), _, ()>(args)?;
+    let (rb_commonmark,): (String,) = args.required;
+
+    let kwargs =
+        scan_args::get_kwargs::<_, (), (Option<RHash>,), ()>(args.keywords, &[], &["options"])?;
+    let (rb_options,) = 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)
+        })?;
+    }
+
+    let arena = Arena::new();
+    let root = parse_document(&arena, &rb_commonmark, &comrak_options);
+
+    CommonmarkerNode::new_from_comrak_node(root)
+}
+
+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 comrak_options = match format_options(rb_options) {
+        Ok(options) => options,
+        Err(err) => return Err(err),
+    };
+
+    let mut comrak_plugins = comrak::Plugins::default();
+
+    let syntect_adapter = match construct_syntax_highlighter_from_plugin(rb_plugins) {
+        Ok(Some(adapter)) => Some(adapter),
+        Ok(None) => None,
+        Err(err) => return Err(err),
+    };
+
+    match syntect_adapter {
+        Some(ref adapter) => comrak_plugins.render.codefence_syntax_highlighter = Some(adapter),
+        None => comrak_plugins.render.codefence_syntax_highlighter = None,
+    }
+
+    Ok(markdown_to_html_with_plugins(
+        &rb_commonmark,
+        &comrak_options,
+        &comrak_plugins,
+    ))
+}
+
+fn format_options<'c>(rb_options: Option<RHash>) -> Result<comrak::Options<'c>, magnus::Error> {
+    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)
+        })?;
+    }
+
+    Ok(comrak_options)
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let m_commonmarker = define_module("Commonmarker")?;
+
+    m_commonmarker.define_module_function("commonmark_parse", function!(commonmark_parse, -1))?;
+    m_commonmarker
+        .define_module_function("commonmark_to_html", function!(commonmark_to_html, -1))?;
+
+    node::init(m_commonmarker).expect("cannot define Commonmarker::Node class");
+
+    Ok(())
+}