commonmarker 1.0.0.pre.2-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19f73d371f214e5c5119a677cd5550b81ede6b0b93456d7eff990e61884edeb9
+  data.tar.gz: bc4333e0c3f94d2c7d216e013e49bd0c8137fd24ee9d553d8996b442dc6c67ed
+SHA512:
+  metadata.gz: 98dda0885461ea8a9fb590126cd3e34e6420769f6996eea6263287db5da43c6da77d087142b9aebc2c294d9b5468692be6b38df9368c9e35fb3061d6ed91ef0c
+  data.tar.gz: 75392e3ca4fae39a0920fe39f3cec6c331bd005ebbb5bbc83009637b15652ea5a2f38ad3d0c73684cdd6ca883d2df242eac0301b32b9a05a374f4d8a64c0fc93

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Garen J. Torikian
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,146 @@
+# Commonmarker
+
+> **Note**
+> This README refers to the behavior in the new 1.0.0.pre gem.
+
+Ruby wrapper for Rust's [comrak](https://github.com/kivikakk/comrak) crate.
+
+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).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'commonmarker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install commonmarker
+
+## Usage
+
+### Converting to HTML
+
+Call `render_html` on a string to convert it to HTML:
+
+```ruby
+require 'commonmarker'
+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.
+
+## Parse and Render Options
+
+Commonmarker accepts the same options that comrak does, as a hash dictionary with symbol keys:
+
+```ruby
+Commonmarker.to_html('"Hi *there*"', options:{
+  parse: { smart: true },
+  render: { hardbreaks: false}
+})
+```
+
+Note that there is a distinction in comrak for "parse" options and "render" options, which are represented in the tables below.
+
+### Parse options
+
+| Name                  | Description                                                                          | Default |
+| --------------------- | ------------------------------------------------------------------------------------ | ------- |
+| `smart`               | Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation. | `false` |
+| `default_info_string` | The default info string for fenced code blocks.                                      | `""`    |
+
+### Render options
+
+| Name              | Description                                                                                            | Default |
+| ----------------- | ------------------------------------------------------------------------------------------------------ | ------- |
+| `hardbreaks`      | [Soft line breaks](http://spec.commonmark.org/0.27/#soft-line-breaks) translate into hard line breaks. | `true`  |
+| `github_pre_lang` | GitHub-style `<pre lang="xyz">` is used for fenced code blocks with info tags.                         | `true`  |
+| `width`           | The wrap column when outputting CommonMark.                                                            | `80`    |
+| `unsafe_`         | Allow rendering of raw HTML and potentially dangerous links.                                           | `false` |
+| `escape`          | Escape raw HTML instead of clobbering it.                                                              | `false` |
+
+As well, there are several extensions which you can toggle in the same manner:
+
+```ruby
+Commonmarker.to_html('"Hi *there*"', options: {
+    extensions: { footnotes: true, description_lists: true },
+    render: { hardbreaks: false}
+})
+```
+
+### 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.                                                                                 | `""`    |
+
+For more information on these options, see [the comrak documentation](https://github.com/kivikakk/comrak#usage).
+
+## Output formats
+
+Commonmarker can currently only generate output in one format: HTML.
+
+### HTML
+
+```ruby
+html = CommonMarker.to_html('*Hello* world!', :DEFAULT)
+puts(html)
+
+# <p><em>Hello</em> world!</p>
+```
+
+## Developing locally
+
+After cloning the repo:
+
+```
+script/bootstrap
+bundle exec rake compile
+```
+
+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 = 11064832 bytes
+
+Warming up --------------------------------------
+           redcarpet     2.000  i/100ms
+commonmarker with to_html
+                         1.000  i/100ms
+            kramdown     1.000  i/100ms
+Calculating -------------------------------------
+           redcarpet     22.317  (± 4.5%) i/s -    112.000  in   5.036374s
+commonmarker with to_html
+                          5.815  (± 0.0%) i/s -     30.000  in   5.168869s
+            kramdown      0.327  (± 0.0%) i/s -      2.000  in   6.121486s
+
+Comparison:
+           redcarpet:       22.3 i/s
+commonmarker with to_html:        5.8 i/s - 3.84x  (± 0.00) slower
+            kramdown:        0.3 i/s - 68.30x  (± 0.00) slower
+```

data/commonmarker.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "commonmarker/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "commonmarker"
+  spec.version = Commonmarker::VERSION
+  spec.summary = "CommonMark parser and renderer. Written in Rust, wrapped in Ruby."
+  spec.description = "A fast, safe, extensible parser for CommonMark. This wraps the comrak Rust crate."
+  spec.authors = ["Garen Torikian", "Ashe Connor"]
+  spec.license = "MIT"
+  spec.homepage = "https://github.com/gjtorikian/commonmarker"
+
+  spec.required_ruby_version = "~> 3.1"
+  # https://github.com/rubygems/rubygems/pull/5852#issuecomment-1231118509
+  spec.required_rubygems_version = ">= 3.3.22"
+
+  spec.files = ["LICENSE.txt", "README.md", "commonmarker.gemspec"]
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("ext/**/*.{rs,toml,lock,rb}")
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/commonmarker/Cargo.toml"]
+
+  spec.metadata = {
+    "allowed_push_host" => "https://rubygems.org",
+    "funding_uri" => "https://github.com/sponsors/gjtorikian/",
+    "source_code_uri" => "https://github.com/gjtorikian/commonmarker",
+    "rubygems_mfa_required" => "true",
+  }
+
+  spec.add_dependency("rb_sys", "~> 0.9")
+
+  spec.add_development_dependency("rake", "~> 13.0")
+  spec.add_development_dependency("rake-compiler", "~> 1.2")
+  spec.add_development_dependency("rake-compiler-dock", "~> 1.2")
+end

data/ext/commonmarker/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "commonmarker"
+version = "1.0.0"
+edition = "2021"
+
+[dependencies]
+magnus = { git = "https://github.com/gjtorikian/magnus", branch = "main" } # waiting for release with full rb-sys backend
+comrak = "0.15.0"
+
+[lib]
+name = "commonmarker"
+crate-type = ["cdylib"]

data/ext/commonmarker/_util.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RUBY_MAJOR, RUBY_MINOR = RUBY_VERSION.split(".").collect(&:to_i)
+
+PACKAGE_ROOT_DIR = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+PACKAGE_EXT_DIR = File.join(PACKAGE_ROOT_DIR, "ext", "commonmarker")
+
+OS = case os = RbConfig::CONFIG["host_os"].downcase
+when /linux/
+  # The official ruby-alpine Docker containers pre-build Ruby. As a result,
+  # Ruby doesn't know that it's on a musl-based platform. `ldd` is the
+  # a more reliable way to detect musl.
+  # See https://github.com/skylightio/skylight-ruby/issues/92
+  if ENV["SKYLIGHT_MUSL"] || %x(ldd --version 2>&1).include?("musl")
+    "linux-musl"
+  else
+    "linux"
+  end
+when /darwin/
+  "darwin"
+when /freebsd/
+  "freebsd"
+when /netbsd/
+  "netbsd"
+when /openbsd/
+  "openbsd"
+when /sunos|solaris/
+  "solaris"
+when /mingw|mswin/
+  "windows"
+else
+  os
+end
+
+# Normalize the platform CPU
+ARCH = case cpu = RbConfig::CONFIG["host_cpu"].downcase
+when /amd64|x86_64|x64/
+  "x86_64"
+when /i?86|x86|i86pc/
+  "x86"
+when /ppc|powerpc/
+  "powerpc"
+when /^aarch/
+  "aarch"
+when /^arm/
+  "arm"
+else
+  cpu
+end
+
+def windows?
+  OS == "windows"
+end
+
+def solaris?
+  OS == solaries
+end
+
+def darwin?
+  OS == "darwin"
+end
+
+def macos?
+  darwin? || OS == "macos"
+end
+
+def openbsd?
+  OS == "openbsd"
+end
+
+def aix?
+  OS == "aix"
+end
+
+def nix?
+  !(windows? || solaris? || darwin?)
+end
+
+def x86_64?
+  ARCH == "x86_64"
+end
+
+def x86?
+  ARCH == "x86"
+end
+
+def abs_path(path)
+  File.join(PACKAGE_EXT_DIR, path)
+end
+
+def find_header_or_abort(header, *paths)
+  find_header(header, *paths) || abort("#{header} was expected in `#{paths.join(", ")}`, but it is missing.")
+end
+
+def find_library_or_abort(lib, func, *paths)
+  find_library(lib, func, *paths) || abort("#{lib} was expected in `#{paths.join(", ")}`, but it is missing.")
+end
+
+def concat_flags(*args)
+  args.compact.join(" ")
+end
+

data/ext/commonmarker/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+require_relative "_util"
+
+create_rust_makefile("commonmarker")

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Commonmarker
+  module Config
+    # For details, see
+    # https://github.com/kivikakk/comrak/blob/162ef9354deb2c9b4a4e05be495aa372ba5bb696/src/main.rs#L201
+    OPTS = {
+      parse: {
+        smart: false,
+        default_info_string: "",
+      }.freeze,
+      render: {
+        hardbreaks: true,
+        github_pre_lang: true,
+        width: 80,
+        unsafe_: false,
+        escape: false,
+      }.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 merged_with_defaults(options)
+        Commonmarker::Config::OPTS.merge(process_options(options))
+      end
+
+      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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "set"
+require "stringio"
+
+module Commonmarker
+  class Renderer
+  end
+end

data/lib/commonmarker/version.rb

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

data/lib/commonmarker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "commonmarker/extension"
+
+require "commonmarker/config"
+require "commonmarker/renderer"
+require "commonmarker/version"
+
+if ENV.fetch("DEBUG", false)
+  require "awesome_print"
+  require "debug"
+end
+
+module Commonmarker
+  class << self
+    # Public: Parses a CommonMark string into an HTML string.
+    #
+    # text - A {String} of text
+    # option - A {Hash} of render, parse, and extension options to transform the text.
+    #
+    # Returns a {String} of converted HTML.
+    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)
+      commonmark_to_html(text.encode("UTF-8"), opts)
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: commonmarker
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.2
+platform: x86_64-linux
+authors:
+- Garen Torikian
+- Ashe Connor
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A fast, safe, extensible parser for CommonMark. This wraps the comrak
+  Rust crate.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- commonmarker.gemspec
+- ext/commonmarker/Cargo.toml
+- ext/commonmarker/_util.rb
+- ext/commonmarker/extconf.rb
+- ext/commonmarker/src/comrak_options.rs
+- ext/commonmarker/src/lib.rs
+- lib/commonmarker.rb
+- lib/commonmarker/3.1/commonmarker.so
+- lib/commonmarker/config.rb
+- lib/commonmarker/extension.rb
+- lib/commonmarker/renderer.rb
+- lib/commonmarker/version.rb
+homepage: https://github.com/gjtorikian/commonmarker
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  funding_uri: https://github.com/sponsors/gjtorikian/
+  source_code_uri: https://github.com/gjtorikian/commonmarker
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.2.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.3.22
+signing_key:
+specification_version: 4
+summary: CommonMark parser and renderer. Written in Rust, wrapped in Ruby.
+test_files: []