commonmarker 0.23.10 → 2.1.1

data/ext/commonmarker/src/options.rs

@@ -0,0 +1,220 @@
+use std::borrow::Cow;
+
+use comrak::ComrakOptions;
+
+use magnus::value::ReprValue;
+use magnus::TryConvert;
+use magnus::{class, r_hash::ForEach, Error, 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";
+
+fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name() {
+                Ok(Cow::Borrowed(PARSE_SMART)) => {
+                    comrak_options.parse.smart = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(PARSE_DEFAULT_INFO_STRING)) => {
+                    comrak_options.parse.default_info_string = try_convert_string(value);
+                }
+                Ok(Cow::Borrowed(PARSE_RELAXED_TASKLIST_MATCHING)) => {
+                    comrak_options.parse.relaxed_tasklist_matching =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(PARSE_RELAXED_AUTOLINKS)) => {
+                    comrak_options.parse.relaxed_autolinks = 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";
+
+fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name() {
+                Ok(Cow::Borrowed(RENDER_HARDBREAKS)) => {
+                    comrak_options.render.hardbreaks = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_GITHUB_PRE_LANG)) => {
+                    comrak_options.render.github_pre_lang = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_FULL_INFO_STRING)) => {
+                    comrak_options.render.full_info_string = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_WIDTH)) => {
+                    comrak_options.render.width = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_UNSAFE)) => {
+                    comrak_options.render.unsafe_ = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_ESCAPE)) => {
+                    comrak_options.render.escape = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_SOURCEPOS)) => {
+                    comrak_options.render.sourcepos = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_ESCAPED_CHAR_SPANS)) => {
+                    comrak_options.render.escaped_char_spans = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_IGNORE_SETEXT)) => {
+                    comrak_options.render.ignore_setext = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_IGNORE_EMPTY_LINKS)) => {
+                    comrak_options.render.ignore_empty_links = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_GFM_QUIRKS)) => {
+                    comrak_options.render.gfm_quirks = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(RENDER_PREFER_FENCED)) => {
+                    comrak_options.render.prefer_fenced = 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_FOOTNOTES: &str = "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_ALERTS: &str = "alerts";
+
+fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: RHash) {
+    options_hash
+        .foreach(|key: Symbol, value: Value| {
+            match key.name() {
+                Ok(Cow::Borrowed(EXTENSION_STRIKETHROUGH)) => {
+                    comrak_options.extension.strikethrough = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TAGFILTER)) => {
+                    comrak_options.extension.tagfilter = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TABLE)) => {
+                    comrak_options.extension.table = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_AUTOLINK)) => {
+                    comrak_options.extension.autolink = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TASKLIST)) => {
+                    comrak_options.extension.tasklist = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SUPERSCRIPT)) => {
+                    comrak_options.extension.superscript = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_HEADER_IDS)) => {
+                    comrak_options.extension.header_ids = try_convert_string(value);
+                }
+                Ok(Cow::Borrowed(EXTENSION_FOOTNOTES)) => {
+                    comrak_options.extension.footnotes = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_DESCRIPTION_LISTS)) => {
+                    comrak_options.extension.description_lists = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_FRONT_MATTER_DELIMITER)) => {
+                    if let Some(option) = try_convert_string(value) {
+                        if !option.is_empty() {
+                            comrak_options.extension.front_matter_delimiter = Some(option);
+                        }
+                    }
+                }
+                Ok(Cow::Borrowed(EXTENSION_MULTILINE_BLOCK_QUOTES)) => {
+                    comrak_options.extension.multiline_block_quotes =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_MATH_DOLLARS)) => {
+                    comrak_options.extension.math_dollars = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_MATH_CODE)) => {
+                    comrak_options.extension.math_code = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SHORTCODES)) => {
+                    comrak_options.extension.shortcodes = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_AFTER_PIPE)) => {
+                    comrak_options.extension.wikilinks_title_after_pipe =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_WIKILINKS_TITLE_BEFORE_PIPE)) => {
+                    comrak_options.extension.wikilinks_title_before_pipe =
+                        TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_UNDERLINE)) => {
+                    comrak_options.extension.underline = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SPOILER)) => {
+                    comrak_options.extension.spoiler = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_GREENTEXT)) => {
+                    comrak_options.extension.greentext = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SUBSCRIPT)) => {
+                    comrak_options.extension.subscript = TryConvert::try_convert(value)?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_ALERTS)) => {
+                    comrak_options.extension.alerts = TryConvert::try_convert(value)?;
+                }
+                _ => {}
+            }
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+}
+
+pub fn iterate_options_hash(
+    comrak_options: &mut ComrakOptions,
+    key: Symbol,
+    value: RHash,
+) -> Result<ForEach, Error> {
+    assert!(value.is_kind_of(class::hash()));
+
+    if key.name().unwrap() == "parse" {
+        iterate_parse_options(comrak_options, value);
+    }
+    if key.name().unwrap() == "render" {
+        iterate_render_options(comrak_options, value);
+    }
+    if key.name().unwrap() == "extension" {
+        iterate_extension_options(comrak_options, value);
+    }
+    Ok(ForEach::Continue)
+}

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

@@ -0,0 +1,166 @@
+use std::path::PathBuf;
+
+use comrak::plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder};
+
+use magnus::value::ReprValue;
+use magnus::{exception, RHash, Symbol, TryConvert, Value};
+use syntect::highlighting::ThemeSet;
+
+use crate::EMPTY_STR;
+
+pub fn construct_syntax_highlighter_from_plugin(
+    rb_plugins: Option<RHash>,
+) -> Result<Option<SyntectAdapter>, magnus::Error> {
+    match rb_plugins {
+        None => Ok(None),
+        Some(rb_plugins) => {
+            let theme = match rb_plugins.get(Symbol::new(super::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
+            };
+
+            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(Symbol::new(super::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(magnus::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(magnus::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(magnus::Error::new(
+                                        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(
+                                        exception::arg_error(),
+                                        format!("theme `{}` does not exist", theme),
+                                    )
+                                })?;
+                            adapter = SyntectAdapter::new(Some(&theme));
+                            Ok(Some(adapter))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn fetch_syntax_highlighter_theme(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(
+            magnus::exception::type_error(),
+            "theme cannot be blank hash",
+        ));
+    }
+
+    let theme_key = Symbol::new(super::SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY);
+
+    match syntax_highlighter_plugin.get(theme_key) {
+        Some(theme) => {
+            if theme.is_nil() {
+                return Err(magnus::Error::new(
+                    magnus::exception::type_error(),
+                    "theme cannot be nil",
+                ));
+            }
+            Ok(TryConvert::try_convert(theme)?)
+        }
+        None => {
+            // `syntax_highlighter: { theme: nil }`
+            Ok(None)
+        }
+    }
+}
+
+fn fetch_syntax_highlighter_path(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 = Symbol::new(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,8 @@
+use magnus::{TryConvert, Value};
+
+pub fn try_convert_string(value: Value) -> Option<String> {
+    match TryConvert::try_convert(value) {
+        Ok(s) => Some(s),
+        Err(_) => None,
+    }
+}

data/lib/commonmarker/config.rb

@@ -1,54 +1,106 @@
 # 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,
       }.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_setext: false,
+        ignore_empty_links: false,
+        gfm_quirks: false,
+        prefer_fenced: false,
       }.freeze,
-      format: [:html, :xml, :commonmark, :plaintext].freeze,
+      extension: {
+        strikethrough: true,
+        tagfilter: true,
+        table: true,
+        autolink: true,
+        tasklist: true,
+        superscript: false,
+        header_ids: "",
+        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,
+        alerts: 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)