commonmarker 0.23.10 → 2.8.0

data/ext/commonmarker/src/options.rs

@@ -0,0 +1,241 @@
+use std::borrow::Cow;
+
+use magnus::TryConvert;
+use magnus::{r_hash::ForEach, RHash, Symbol, Value};
+
+use crate::utils::try_convert_string;
+
+const PARSE_SMART: &str = "smart";
+const PARSE_DEFAULT_INFO_STRING: &str = "default_info_string";
+const PARSE_RELAXED_TASKLIST_MATCHING: &str = "relaxed_tasklist_matching";
+const PARSE_RELAXED_AUTOLINKS: &str = "relaxed_autolinks";
+const PARSE_LEAVE_FOOTNOTE_DEFINITIONS: &str = "leave_footnote_definitions";
+const PARSE_SOURCEPOS_CHARS: &str = "sourcepos_chars";
+
+pub fn iterate_parse_options(comrak_options: &mut comrak::options::Parse, options_hash: RHash) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name()? {
+                Cow::Borrowed(PARSE_SMART) => {
+                    comrak_options.smart = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(PARSE_DEFAULT_INFO_STRING) => {
+                    comrak_options.default_info_string = try_convert_string(value);
+                }
+                Cow::Borrowed(PARSE_RELAXED_TASKLIST_MATCHING) => {
+                    comrak_options.relaxed_tasklist_matching = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_IGNORE_SETEXT) => {
+                    comrak_options.ignore_setext = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(PARSE_RELAXED_AUTOLINKS) => {
+                    comrak_options.relaxed_autolinks = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(PARSE_LEAVE_FOOTNOTE_DEFINITIONS) => {
+                    comrak_options.leave_footnote_definitions = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(PARSE_SOURCEPOS_CHARS) => {
+                    comrak_options.sourcepos_chars = TryConvert::try_convert(value)?;
+                }
+                _ => {}
+            }
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+}
+
+const RENDER_HARDBREAKS: &str = "hardbreaks";
+const RENDER_GITHUB_PRE_LANG: &str = "github_pre_lang";
+const RENDER_FULL_INFO_STRING: &str = "full_info_string";
+const RENDER_WIDTH: &str = "width";
+const RENDER_UNSAFE: &str = "unsafe";
+const RENDER_ESCAPE: &str = "escape";
+const RENDER_SOURCEPOS: &str = "sourcepos";
+const RENDER_ESCAPED_CHAR_SPANS: &str = "escaped_char_spans";
+const RENDER_IGNORE_SETEXT: &str = "ignore_setext";
+const RENDER_IGNORE_EMPTY_LINKS: &str = "ignore_empty_links";
+const RENDER_GFM_QUIRKS: &str = "gfm_quirks";
+const RENDER_PREFER_FENCED: &str = "prefer_fenced";
+const RENDER_TASKLIST_CLASSES: &str = "tasklist_classes";
+const RENDER_COMPACT_HTML: &str = "compact_html";
+
+pub fn iterate_render_options(comrak_options: &mut comrak::options::Render, options_hash: RHash) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name()? {
+                Cow::Borrowed(RENDER_HARDBREAKS) => {
+                    comrak_options.hardbreaks = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_GITHUB_PRE_LANG) => {
+                    comrak_options.github_pre_lang = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_FULL_INFO_STRING) => {
+                    comrak_options.full_info_string = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_WIDTH) => {
+                    comrak_options.width = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_UNSAFE) => {
+                    comrak_options.r#unsafe = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_ESCAPE) => {
+                    comrak_options.escape = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_SOURCEPOS) => {
+                    comrak_options.sourcepos = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_ESCAPED_CHAR_SPANS) => {
+                    comrak_options.escaped_char_spans = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_IGNORE_EMPTY_LINKS) => {
+                    comrak_options.ignore_empty_links = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_GFM_QUIRKS) => {
+                    comrak_options.gfm_quirks = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_PREFER_FENCED) => {
+                    comrak_options.prefer_fenced = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_TASKLIST_CLASSES) => {
+                    comrak_options.tasklist_classes = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(RENDER_COMPACT_HTML) => {
+                    comrak_options.compact_html = TryConvert::try_convert(value)?;
+                }
+                _ => {}
+            }
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+}
+
+const EXTENSION_STRIKETHROUGH: &str = "strikethrough";
+const EXTENSION_TAGFILTER: &str = "tagfilter";
+const EXTENSION_TABLE: &str = "table";
+const EXTENSION_AUTOLINK: &str = "autolink";
+const EXTENSION_TASKLIST: &str = "tasklist";
+const EXTENSION_SUPERSCRIPT: &str = "superscript";
+const EXTENSION_HEADER_IDS: &str = "header_ids";
+const EXTENSION_HEADER_ID_PREFIX_IN_HREF: &str = "header_id_prefix_in_href";
+const EXTENSION_FOOTNOTES: &str = "footnotes";
+const EXTENSION_INLINE_FOOTNOTES: &str = "inline_footnotes";
+const EXTENSION_DESCRIPTION_LISTS: &str = "description_lists";
+const EXTENSION_FRONT_MATTER_DELIMITER: &str = "front_matter_delimiter";
+const EXTENSION_MULTILINE_BLOCK_QUOTES: &str = "multiline_block_quotes";
+const EXTENSION_MATH_DOLLARS: &str = "math_dollars";
+const EXTENSION_MATH_CODE: &str = "math_code";
+const EXTENSION_SHORTCODES: &str = "shortcodes";
+const EXTENSION_WIKILINKS_TITLE_AFTER_PIPE: &str = "wikilinks_title_after_pipe";
+const EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE: &str = "wikilinks_title_before_pipe";
+const EXTENSION_UNDERLINE: &str = "underline";
+const EXTENSION_SPOILER: &str = "spoiler";
+const EXTENSION_GREENTEXT: &str = "greentext";
+const EXTENSION_SUBSCRIPT: &str = "subscript";
+const EXTENSION_SUBTEXT: &str = "subtext";
+const EXTENSION_ALERTS: &str = "alerts";
+const EXTENSION_CJK_FRIENDLY_EMPHASIS: &str = "cjk_friendly_emphasis";
+const EXTENSION_HIGHLIGHT: &str = "highlight";
+const EXTENSION_INSERT: &str = "insert";
+const EXTENSION_BLOCK_DIRECTIVE: &str = "block_directive";
+
+pub fn iterate_extension_options(
+    comrak_options: &mut comrak::options::Extension,
+    options_hash: RHash,
+) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name()? {
+                Cow::Borrowed(EXTENSION_STRIKETHROUGH) => {
+                    comrak_options.strikethrough = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_TAGFILTER) => {
+                    comrak_options.tagfilter = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_TABLE) => {
+                    comrak_options.table = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_AUTOLINK) => {
+                    comrak_options.autolink = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_TASKLIST) => {
+                    comrak_options.tasklist = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SUPERSCRIPT) => {
+                    comrak_options.superscript = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_HEADER_IDS) => {
+                    comrak_options.header_id_prefix = try_convert_string(value);
+                }
+                Cow::Borrowed(EXTENSION_HEADER_ID_PREFIX_IN_HREF) => {
+                    comrak_options.header_id_prefix_in_href = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_FOOTNOTES) => {
+                    comrak_options.footnotes = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_INLINE_FOOTNOTES) => {
+                    comrak_options.inline_footnotes = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_DESCRIPTION_LISTS) => {
+                    comrak_options.description_lists = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_FRONT_MATTER_DELIMITER) => {
+                    if let Some(option) = try_convert_string(value) {
+                        if !option.is_empty() {
+                            comrak_options.front_matter_delimiter = Some(option);
+                        }
+                    }
+                }
+                Cow::Borrowed(EXTENSION_MULTILINE_BLOCK_QUOTES) => {
+                    comrak_options.multiline_block_quotes = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_MATH_DOLLARS) => {
+                    comrak_options.math_dollars = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_MATH_CODE) => {
+                    comrak_options.math_code = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SHORTCODES) => {
+                    comrak_options.shortcodes = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_AFTER_PIPE) => {
+                    comrak_options.wikilinks_title_after_pipe = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE) => {
+                    comrak_options.wikilinks_title_before_pipe = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_UNDERLINE) => {
+                    comrak_options.underline = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SPOILER) => {
+                    comrak_options.spoiler = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_GREENTEXT) => {
+                    comrak_options.greentext = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SUBSCRIPT) => {
+                    comrak_options.subscript = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_SUBTEXT) => {
+                    comrak_options.subtext = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_ALERTS) => {
+                    comrak_options.alerts = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_CJK_FRIENDLY_EMPHASIS) => {
+                    comrak_options.cjk_friendly_emphasis = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_HIGHLIGHT) => {
+                    comrak_options.highlight = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_INSERT) => {
+                    comrak_options.insert = TryConvert::try_convert(value)?;
+                }
+                Cow::Borrowed(EXTENSION_BLOCK_DIRECTIVE) => {
+                    comrak_options.block_directive = TryConvert::try_convert(value)?;
+                }
+                _ => {}
+            }
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+}

data/ext/commonmarker/src/plugins/syntax_highlighting.rs

@@ -0,0 +1,171 @@
+use std::path::PathBuf;
+
+use comrak::plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder};
+
+use magnus::value::ReprValue;
+use magnus::{RHash, Ruby, TryConvert, Value};
+use syntect::highlighting::ThemeSet;
+
+use crate::EMPTY_STR;
+
+pub fn construct_syntax_highlighter_from_plugin(
+    ruby: &Ruby,
+    rb_plugins: Option<RHash>,
+) -> Result<Option<SyntectAdapter>, magnus::Error> {
+    match rb_plugins {
+        None => Ok(None),
+        Some(rb_plugins) => {
+            let theme = match rb_plugins.get(ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN)) {
+                Some(syntax_highlighter_options) => {
+                    match fetch_syntax_highlighter_theme(ruby, syntax_highlighter_options) {
+                        Ok(theme) => theme,
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+                None => None, // no `syntax_highlighter:` defined
+            };
+
+            let adapter: SyntectAdapter;
+
+            match theme {
+                None => Ok(None),
+                Some(theme) => {
+                    if theme.is_empty() {
+                        // no theme? uss css classes
+                        adapter = SyntectAdapter::new(None);
+                        Ok(Some(adapter))
+                    } else {
+                        let path = match rb_plugins
+                            .get(ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN))
+                        {
+                            Some(syntax_highlighter_options) => {
+                                fetch_syntax_highlighter_path(ruby, syntax_highlighter_options)?
+                            }
+                            None => PathBuf::from("".to_string()), // no `syntax_highlighter:` defined
+                        };
+
+                        if path.exists() {
+                            if !path.is_dir() {
+                                return Err(magnus::Error::new(
+                                    ruby.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(magnus::Error::new(
+                                        ruby.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(magnus::Error::new(
+                                        ruby.exception_arg_error(),
+                                        format!("theme `{}` does not exist", theme),
+                                    ));
+                                }
+                            };
+
+                            adapter = builder.theme_set(ts).theme(&theme).build();
+
+                            Ok(Some(adapter))
+                        } else {
+                            // no path? default theme lookup
+                            ThemeSet::load_defaults()
+                                .themes
+                                .get(&theme)
+                                .ok_or_else(|| {
+                                    magnus::Error::new(
+                                        ruby.exception_arg_error(),
+                                        format!("theme `{}` does not exist", theme),
+                                    )
+                                })?;
+                            adapter = SyntectAdapter::new(Some(&theme));
+                            Ok(Some(adapter))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn fetch_syntax_highlighter_theme(
+    ruby: &Ruby,
+    value: Value,
+) -> Result<Option<String>, magnus::Error> {
+    if value.is_nil() {
+        // `syntax_highlighter: nil`
+        return Ok(None);
+    }
+
+    let syntax_highlighter_plugin: RHash = match TryConvert::try_convert(value) {
+        Ok(plugin) => plugin, // `syntax_highlighter: { theme: "<something>" }`
+        Err(e) => {
+            // not a hash!
+            return Err(e);
+        }
+    };
+
+    if syntax_highlighter_plugin.is_nil() || syntax_highlighter_plugin.is_empty() {
+        return Err(magnus::Error::new(
+            ruby.exception_type_error(),
+            "theme cannot be blank hash",
+        ));
+    }
+
+    let theme_key = ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY);
+
+    match syntax_highlighter_plugin.get(theme_key) {
+        Some(theme) => {
+            if theme.is_nil() {
+                return Err(magnus::Error::new(
+                    ruby.exception_type_error(),
+                    "theme cannot be nil",
+                ));
+            }
+            Ok(TryConvert::try_convert(theme)?)
+        }
+        None => {
+            // `syntax_highlighter: { theme: nil }`
+            Ok(None)
+        }
+    }
+}
+
+fn fetch_syntax_highlighter_path(ruby: &Ruby, value: Value) -> Result<PathBuf, magnus::Error> {
+    if value.is_nil() {
+        // `syntax_highlighter: nil`
+        return Ok(PathBuf::from(EMPTY_STR));
+    }
+
+    let syntax_highlighter_plugin: RHash = TryConvert::try_convert(value)?;
+    let path_key = ruby.to_symbol(super::SYNTAX_HIGHLIGHTER_PLUGIN_PATH_KEY);
+
+    match syntax_highlighter_plugin.get(path_key) {
+        Some(path) => {
+            if path.is_nil() {
+                // `syntax_highlighter: { path: nil }`
+                return Ok(PathBuf::from(EMPTY_STR));
+            }
+            let val: String = TryConvert::try_convert(path)?;
+            Ok(PathBuf::from(val))
+        }
+        None => {
+            // `syntax_highlighter: {  }`
+            Ok(PathBuf::from(EMPTY_STR))
+        }
+    }
+}

data/ext/commonmarker/src/plugins.rs

@@ -0,0 +1,6 @@
+pub mod syntax_highlighting;
+
+pub const SYNTAX_HIGHLIGHTER_PLUGIN: &str = "syntax_highlighter";
+
+pub const SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY: &str = "theme";
+pub const SYNTAX_HIGHLIGHTER_PLUGIN_PATH_KEY: &str = "path";

data/ext/commonmarker/src/utils.rs

@@ -0,0 +1,5 @@
+use magnus::{TryConvert, Value};
+
+pub fn try_convert_string(value: Value) -> Option<String> {
+    TryConvert::try_convert(value).ok()
+}

data/lib/commonmarker/config.rb

@@ -1,54 +1,117 @@
 # frozen_string_literal: true
 
-module CommonMarker
-  # For Ruby::Enum, these must be classes, not modules
+module Commonmarker
   module Config
-    # See https://github.com/github/cmark-gfm/blob/master/src/cmark-gfm.h#L673
-    OPTS = {
+    # For details, see
+    # https://github.com/kivikakk/comrak/blob/162ef9354deb2c9b4a4e05be495aa372ba5bb696/src/main.rs#L201
+    OPTIONS = {
       parse: {
-        DEFAULT: 0,
-        SOURCEPOS: (1 << 1),
-        UNSAFE: (1 << 17),
-        VALIDATE_UTF8: (1 << 9),
-        SMART: (1 << 10),
-        LIBERAL_HTML_TAG: (1 << 12),
-        FOOTNOTES: (1 << 13),
-        STRIKETHROUGH_DOUBLE_TILDE: (1 << 14),
+        smart: false,
+        default_info_string: "",
+        relaxed_tasklist_matching: false,
+        relaxed_autolinks: false,
+        leave_footnote_definitions: false,
+        ignore_setext: false,
+        sourcepos_chars: false,
       }.freeze,
       render: {
-        DEFAULT: 0,
-        SOURCEPOS: (1 << 1),
-        HARDBREAKS: (1 << 2),
-        UNSAFE: (1 << 17),
-        NOBREAKS: (1 << 4),
-        VALIDATE_UTF8: (1 << 9),
-        SMART: (1 << 10),
-        GITHUB_PRE_LANG: (1 << 11),
-        LIBERAL_HTML_TAG: (1 << 12),
-        FOOTNOTES: (1 << 13),
-        STRIKETHROUGH_DOUBLE_TILDE: (1 << 14),
-        TABLE_PREFER_STYLE_ATTRIBUTES: (1 << 15),
-        FULL_INFO_STRING: (1 << 16),
+        hardbreaks: true,
+        github_pre_lang: true,
+        full_info_string: false,
+        width: 80,
+        unsafe: false,
+        escape: false,
+        sourcepos: false,
+        escaped_char_spans: true,
+        ignore_empty_links: false,
+        gfm_quirks: false,
+        prefer_fenced: false,
+        tasklist_classes: false,
+        compact_html: false,
       }.freeze,
-      format: [:html, :xml, :commonmark, :plaintext].freeze,
+      extension: {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        tasklist: true,
+        superscript: false,
+        header_ids: "",
+        header_id_prefix_in_href: false,
+        footnotes: false,
+        inline_footnotes: false,
+        description_lists: false,
+        front_matter_delimiter: "",
+        multiline_block_quotes: false,
+        math_dollars: false,
+        math_code: false,
+        shortcodes: true,
+        wikilinks_title_before_pipe: false,
+        wikilinks_title_after_pipe: false,
+        underline: false,
+        spoiler: false,
+        greentext: false,
+        subscript: false,
+        subtext: false,
+        alerts: false,
+        cjk_friendly_emphasis: false,
+        highlight: false,
+        insert: false,
+        block_directive: false,
+      }.freeze,
+      format: [:html].freeze,
     }.freeze
 
+    PLUGINS = {
+      syntax_highlighter: {
+        theme: "base16-ocean.dark",
+        path: "",
+      },
+    }
+
     class << self
-      def process_options(option, type)
-        case option
-        when Symbol
-          OPTS.fetch(type).fetch(option)
-        when Array
-          raise TypeError if option.none?
-
-          # neckbearding around. the map will both check the opts and then bitwise-OR it
-          OPTS.fetch(type).fetch_values(*option).inject(0, :|)
-        else
-          raise TypeError, "option type must be a valid symbol or array of symbols within the #{name}::OPTS[:#{type}] context"
+      include Commonmarker::Utils
+
+      def process_options(options)
+        {
+          parse: process_parse_options(options[:parse].dup),
+          render: process_render_options(options[:render].dup),
+          extension: process_extension_options(options[:extension].dup),
+        }
+      end
+
+      def process_plugins(plugins)
+        {
+          syntax_highlighter: process_syntax_highlighter_plugin(plugins&.fetch(:syntax_highlighter, nil)),
+        }
+      end
+    end
+
+    [:parse, :render, :extension].each do |type|
+      define_singleton_method :"process_#{type}_options" do |options|
+        Commonmarker::Config::OPTIONS[type].each_with_object({}) do |(key, value), hash|
+          if options.nil? || !options.key?(key) # option not provided, use the default
+            hash[key] = value
+            next
+          end
+
+          if options[key].nil? # # option explicitly not included, remove it
+            options.delete(key)
+            next
+          end
+
+          hash[key] = fetch_kv(options, key, value, type)
         end
-      rescue KeyError => e
-        raise TypeError, "option ':#{e.key}' does not exist for #{name}::OPTS[:#{type}]"
       end
-  end
+    end
+
+    define_singleton_method :process_syntax_highlighter_plugin do |options|
+      return if options.nil? # plugin explicitly nil, remove it
+
+      raise TypeError, "Expected a Hash for syntax_highlighter plugin, got #{options.class}" unless options.is_a?(Hash)
+      raise TypeError, "Expected a Hash for syntax_highlighter plugin, got nothing" if options.empty?
+
+      Commonmarker::Config::PLUGINS[:syntax_highlighter].merge(options)
+    end
   end
 end

data/lib/commonmarker/constants.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  module Constants
+    BOOLS = [true, false].freeze
+  end
+end

data/lib/commonmarker/extension.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+begin
+  # native precompiled gems package shared libraries in <gem_dir>/lib/commonmarker/<ruby_version>
+  # load the precompiled extension file
+  ruby_version = /\d+\.\d+/.match(RUBY_VERSION)
+  require_relative "#{ruby_version}/commonmarker"
+rescue LoadError
+  # fall back to the extension compiled upon installation.
+  # use "require" instead of "require_relative" because non-native gems will place C extension files
+  # in Gem::BasicSpecification#extension_dir after compilation (during normal installation), which
+  # is in $LOAD_PATH but not necessarily relative to this file (see nokogiri#2300)
+  require "commonmarker/commonmarker"
+end

data/lib/commonmarker/node/ast.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  class Node
+    class Ast
+    end
+  end
+end

data/lib/commonmarker/node/inspect.rb

@@ -2,7 +2,7 @@
 
 require "pp"
 
-module CommonMarker
+module Commonmarker
   class Node
     module Inspect
       PP_INDENT_SIZE = 2
@@ -16,9 +16,19 @@ module CommonMarker
         printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", ">") do
           printer.breakable
 
-          attrs = [:sourcepos, :string_content, :url, :title, :header_level, :list_type, :list_start, :list_tight, :fence_info].map do |name|
+          attrs = [
+            :source_position,
+            :string_content,
+            :url,
+            :title,
+            :header_level,
+            :list_type,
+            :list_start,
+            :list_tight,
+            :fence_info,
+          ].filter_map do |name|
             [name, __send__(name)]
-          rescue NodeError
+          rescue StandardError
             nil
           end.compact
 
@@ -34,7 +44,7 @@ module CommonMarker
               node = first_child
               while node
                 children << node
-                node = node.next
+                node = node.next_sibling
               end
               printer.text("children=")
               printer.pp(children)