commonmarker 0.23.7.pre1 → 1.0.0.pre.2

data/ext/commonmarker/src/comrak_options.rs

@@ -0,0 +1,136 @@
+use std::borrow::Cow;
+
+use comrak::ComrakOptions;
+
+use magnus::{class, r_hash::ForEach, Error, RHash, Symbol, Value};
+
+const PARSE_SMART: &str = "smart";
+const PARSE_DEFAULT_INFO_STRING: &str = "default_info_string";
+
+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 = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(PARSE_DEFAULT_INFO_STRING)) => {
+                    comrak_options.parse.default_info_string = try_convert_string(value);
+                }
+                _ => {}
+            }
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+}
+
+const RENDER_HARDBREAKS: &str = "hardbreaks";
+const RENDER_GITHUB_PRE_LANG: &str = "github_pre_lang";
+const RENDER_WIDTH: &str = "width";
+const RENDER_UNSAFE: &str = "unsafe_";
+const RENDER_ESCAPE: &str = "escape";
+
+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 = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(RENDER_GITHUB_PRE_LANG)) => {
+                    comrak_options.render.github_pre_lang = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(RENDER_WIDTH)) => {
+                    comrak_options.render.width = value.try_convert::<usize>()?;
+                }
+                Ok(Cow::Borrowed(RENDER_UNSAFE)) => {
+                    comrak_options.render.unsafe_ = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(RENDER_ESCAPE)) => {
+                    comrak_options.render.escape = value.try_convert::<bool>()?;
+                }
+                _ => {}
+            }
+            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";
+
+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 = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TAGFILTER)) => {
+                    comrak_options.extension.tagfilter = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TABLE)) => {
+                    comrak_options.extension.table = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_AUTOLINK)) => {
+                    comrak_options.extension.autolink = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_TASKLIST)) => {
+                    comrak_options.extension.tasklist = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_SUPERSCRIPT)) => {
+                    comrak_options.extension.superscript = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_HEADER_IDS)) => {
+                    comrak_options.extension.header_ids = try_convert_string(value);
+                }
+                Ok(Cow::Borrowed(EXTENSION_FOOTNOTES)) => {
+                    comrak_options.extension.footnotes = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_DESCRIPTION_LISTS)) => {
+                    comrak_options.extension.description_lists = value.try_convert::<bool>()?;
+                }
+                Ok(Cow::Borrowed(EXTENSION_FRONT_MATTER_DELIMITER)) => {
+                    comrak_options.extension.front_matter_delimiter = try_convert_string(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)
+}
+
+fn try_convert_string(value: Value) -> Option<String> {
+    if value.is_kind_of(class::string()) {
+        Some(value.try_convert::<String>().unwrap())
+    } else {
+        None
+    }
+}

data/ext/commonmarker/src/lib.rs

@@ -0,0 +1,29 @@
+extern crate core;
+
+use comrak::{markdown_to_html, ComrakOptions};
+use magnus::{define_module, function, r_hash::ForEach, Error, RHash, Symbol};
+
+mod comrak_options;
+use comrak_options::iterate_options_hash;
+
+fn commonmark_to_html(rb_commonmark: String, rb_options: magnus::RHash) -> String {
+    let mut comrak_options = ComrakOptions::default();
+
+    rb_options
+        .foreach(|key: Symbol, value: RHash| {
+            iterate_options_hash(&mut comrak_options, key, value).unwrap();
+            Ok(ForEach::Continue)
+        })
+        .unwrap();
+
+    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, 2))?;
+
+    Ok(())
+}

data/lib/commonmarker/config.rb

@@ -1,54 +1,73 @@
 # 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
+    # For details, see
+    # https://github.com/kivikakk/comrak/blob/162ef9354deb2c9b4a4e05be495aa372ba5bb696/src/main.rs#L201
     OPTS = {
       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: "",
       }.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,
+        width: 80,
+        unsafe_: false,
+        escape: 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: nil,
+      },
+      format: [:html].freeze,
     }.freeze
 
     class << self
-      def process_options(option, type)
-        case option
-        when Symbol
-          OPTS.fetch(type).fetch(option)
-        when Array
-          raise TypeError if option.none?
+      def merged_with_defaults(options)
+        Commonmarker::Config::OPTS.merge(process_options(options))
+      end
 
-          # 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"
-        end
-      rescue KeyError => e
-        raise TypeError, "option ':#{e.key}' does not exist for #{name}::OPTS[:#{type}]"
+      def process_options(options)
+        {
+          parse: process_parse_options(options[:parse]),
+          render: process_render_options(options[:render]),
+          extension: process_extension_options(options[:extension]),
+        }
       end
   end
+
+    BOOLS = [true, false]
+    ["parse", "render", "extension"].each do |type|
+      define_singleton_method :"process_#{type}_options" do |options|
+        Commonmarker::Config::OPTS[type.to_sym].each_with_object({}) do |(key, value), hash|
+          if options.nil? # option not provided, go for the default
+            hash[key] = value
+            next
+          end
+
+          # option explicitly not included, remove it
+          next if options[key].nil?
+
+          value_klass = value.class
+          if BOOLS.include?(value) && BOOLS.include?(options[key])
+            hash[key] = options[key]
+          elsif options[key].is_a?(value_klass)
+            hash[key] = options[key]
+          else
+            expected_type = BOOLS.include?(value) ? "Boolean" : value_klass.to_s
+            raise TypeError, "#{type}_options[:#{key}] must be a #{expected_type}; got #{options[key].class}"
+          end
+        end
+      end
+    end
   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/renderer.rb

@@ -3,133 +3,7 @@
 require "set"
 require "stringio"
 
-module CommonMarker
+module Commonmarker
   class Renderer
-    attr_accessor :in_tight, :warnings, :in_plain
-
-    def initialize(options: :DEFAULT, extensions: [])
-      @opts = Config.process_options(options, :render)
-      @stream = StringIO.new(+"")
-      @need_blocksep = false
-      @warnings = Set.new([])
-      @in_tight = false
-      @in_plain = false
-      @tagfilter = extensions.include?(:tagfilter)
-    end
-
-    def out(*args)
-      args.each do |arg|
-        case arg
-        when :children
-          @node.each { |child| out(child) }
-        when Array
-          arg.each { |x| render(x) }
-        when Node
-          render(arg)
-        else
-          @stream.write(arg)
-        end
-      end
-    end
-
-    def render(node)
-      @node = node
-      if node.type == :document
-        document(node)
-        @stream.string
-      elsif @in_plain && node.type != :text && node.type != :softbreak
-        node.each { |child| render(child) }
-      else
-        begin
-          send(node.type, node)
-        rescue NoMethodError => e
-          @warnings.add("WARNING: #{node.type} not implemented.")
-          raise e
-        end
-      end
-    end
-
-    def document(_node)
-      out(:children)
-    end
-
-    def code_block(node)
-      code_block(node)
-    end
-
-    def reference_def(_node); end
-
-    def cr
-      return if @stream.string.empty? || @stream.string[-1] == "\n"
-
-      out("\n")
-    end
-
-    def blocksep
-      out("\n")
-    end
-
-    def containersep
-      cr unless @in_tight
-    end
-
-    def block
-      cr
-      yield
-      cr
-    end
-
-    def container(starter, ender)
-      out(starter)
-      yield
-      out(ender)
-    end
-
-    def plain
-      old_in_plain = @in_plain
-      @in_plain = true
-      yield
-      @in_plain = old_in_plain
-    end
-
-    private
-
-    def escape_href(str)
-      @node.html_escape_href(str)
-    end
-
-    def escape_html(str)
-      @node.html_escape_html(str)
-    end
-
-    def tagfilter(str)
-      if @tagfilter
-        str.gsub(
-          %r{
-            <
-            (
-            title|textarea|style|xmp|iframe|
-            noembed|noframes|script|plaintext
-            )
-            (?=\s|>|/>)
-          }xi,
-          '&lt;\1',
-        )
-      else
-        str
-      end
-    end
-
-    def sourcepos(node)
-      return "" unless option_enabled?(:SOURCEPOS)
-
-      s = node.sourcepos
-      " data-sourcepos=\"#{s[:start_line]}:#{s[:start_column]}-" \
-        "#{s[:end_line]}:#{s[:end_column]}\""
-    end
-
-    def option_enabled?(opt)
-      (@opts & CommonMarker::Config::OPTS.dig(:render, opt)) != 0
-    end
   end
 end

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module CommonMarker
-  VERSION = "0.23.7.pre1"
+module Commonmarker
+  VERSION = "1.0.0.pre.2"
 end

data/lib/commonmarker.rb

@@ -1,45 +1,30 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "commonmarker/commonmarker"
+require_relative "commonmarker/extension"
+
 require "commonmarker/config"
-require "commonmarker/node"
 require "commonmarker/renderer"
-require "commonmarker/renderer/html_renderer"
 require "commonmarker/version"
 
-begin
+if ENV.fetch("DEBUG", false)
   require "awesome_print"
-rescue LoadError; end # rubocop:disable Lint/SuppressedException
-module CommonMarker
+  require "debug"
+end
+
+module Commonmarker
   class << self
-    # Public:  Parses a Markdown string into an HTML string.
+    # Public: Parses a CommonMark string into an HTML string.
     #
     # text - A {String} of text
-    # option - Either a {Symbol} or {Array of Symbol}s indicating the render options
-    # extensions - An {Array of Symbol}s indicating the extensions to use
+    # option - A {Hash} of render, parse, and extension options to transform the text.
     #
     # Returns a {String} of converted HTML.
-    def render_html(text, options = :DEFAULT, extensions = [])
-      raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
-
-      opts = Config.process_options(options, :render)
-      Node.markdown_to_html(text.encode("UTF-8"), opts, extensions)
-    end
-
-    # Public: Parses a Markdown string into a `document` node.
-    #
-    # string - {String} to be parsed
-    # option - A {Symbol} or {Array of Symbol}s indicating the parse options
-    # extensions - An {Array of Symbol}s indicating the extensions to use
-    #
-    # Returns the `document` node.
-    def render_doc(text, options = :DEFAULT, extensions = [])
+    def to_html(text, options: Commonmarker::Config::OPTS)
       raise TypeError, "text must be a String; got a #{text.class}!" unless text.is_a?(String)
+      raise TypeError, "options must be a Hash; got a #{options.class}!" unless options.is_a?(Hash)
 
-      opts = Config.process_options(options, :parse)
-      text = text.encode("UTF-8")
-      Node.parse_document(text, text.bytesize, opts, extensions)
+      opts = Config.process_options(options)
+      commonmark_to_html(text.encode("UTF-8"), opts)
     end
-end
+  end
 end