commonmarker 1.0.0.pre8-x64-mingw-ucrt → 1.0.0.pre10-x64-mingw-ucrt

data/ext/commonmarker/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "commonmarker"
-version = "1.0.0"
-edition = "2021"
-
-[dependencies]
-magnus =  "0.5"
-comrak = { version = "0.16", features = ["shortcodes"] }
-syntect = { version = "5.0", features = ["plist-load"] }
-
-[lib]
-name = "commonmarker"
-crate-type = ["cdylib"]

data/ext/commonmarker/_util.rb

@@ -1,102 +0,0 @@
-# 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

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

data/ext/commonmarker/src/lib.rs

@@ -1,155 +0,0 @@
-extern crate core;
-
-use std::path::PathBuf;
-
-use ::syntect::highlighting::ThemeSet;
-use comrak::{
-    adapters::SyntaxHighlighterAdapter,
-    markdown_to_html, markdown_to_html_with_plugins,
-    plugins::syntect::{SyntectAdapter, SyntectAdapterBuilder},
-    ComrakOptions, ComrakPlugins,
-};
-use magnus::{
-    define_module, exception, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value,
-};
-
-mod options;
-use options::iterate_options_hash;
-
-mod plugins;
-use plugins::{
-    syntax_highlighting::{
-        fetch_syntax_highlighter_path, fetch_syntax_highlighter_theme,
-        SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME,
-    },
-    SYNTAX_HIGHLIGHTER_PLUGIN,
-};
-
-mod utils;
-
-pub const EMPTY_STR: &str = "";
-
-fn commonmark_to_html<'a>(args: &[Value]) -> Result<String, magnus::Error> {
-    let args = scan_args::scan_args(args)?;
-    let (rb_commonmark,): (String,) = args.required;
-    let _: () = args.optional;
-    let _: () = args.splat;
-    let _: () = args.trailing;
-    let _: () = args.block;
-
-    let kwargs = scan_args::get_kwargs::<_, (), (Option<RHash>, Option<RHash>), ()>(
-        args.keywords,
-        &[],
-        &["options", "plugins"],
-    )?;
-    let (rb_options, rb_plugins) = kwargs.optional;
-
-    let mut comrak_options = ComrakOptions::default();
-
-    if let Some(rb_options) = rb_options {
-        rb_options.foreach(|key: Symbol, value: RHash| {
-            iterate_options_hash(&mut comrak_options, key, value)?;
-            Ok(ForEach::Continue)
-        })?;
-    }
-
-    if let Some(rb_plugins) = rb_plugins {
-        let mut comrak_plugins = ComrakPlugins::default();
-
-        let syntax_highlighter: Option<&dyn SyntaxHighlighterAdapter>;
-        let adapter: SyntectAdapter;
-
-        let theme = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
-            Some(syntax_highlighter_options) => {
-                fetch_syntax_highlighter_theme(syntax_highlighter_options)?
-            }
-            None => SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME.to_string(), // no `syntax_highlighter:` defined
-        };
-
-        let path = match rb_plugins.get(Symbol::new(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.eq(&PathBuf::from("".to_string())) && !path.exists() {
-            return Err(Error::new(
-                exception::arg_error(),
-                format!("path does not exist"),
-            ));
-        }
-
-        if theme.is_empty() && path.exists() {
-            return Err(Error::new(
-                exception::arg_error(),
-                "`path` also needs `theme` passed into the `syntax_highlighter`",
-            ));
-        }
-        if path.exists() && !path.is_dir() {
-            return Err(Error::new(
-                exception::arg_error(),
-                "`path` needs to be a directory",
-            ));
-        }
-
-        if path.exists() {
-            let builder = SyntectAdapterBuilder::new();
-            let mut ts = ThemeSet::load_defaults();
-
-            match ts.add_from_folder(&path) {
-                Ok(_) => {}
-                Err(e) => {
-                    return Err(Error::new(
-                        exception::arg_error(),
-                        format!("failed to load theme set from path: {e}"),
-                    ));
-                }
-            }
-
-            ts.themes.get(&theme).ok_or_else(|| {
-                Error::new(
-                    exception::arg_error(),
-                    format!("theme `{}` does not exist", theme),
-                )
-            })?;
-
-            adapter = builder.theme_set(ts).theme(&theme).build();
-
-            syntax_highlighter = Some(&adapter);
-        } else if theme.is_empty() || theme == "none" {
-            syntax_highlighter = None;
-        } else {
-            ThemeSet::load_defaults()
-                .themes
-                .get(&theme)
-                .ok_or_else(|| {
-                    Error::new(
-                        exception::arg_error(),
-                        format!("theme `{}` does not exist", theme),
-                    )
-                })?;
-            adapter = SyntectAdapter::new(&theme);
-            syntax_highlighter = Some(&adapter);
-        }
-
-        comrak_plugins.render.codefence_syntax_highlighter = syntax_highlighter;
-
-        Ok(markdown_to_html_with_plugins(
-            &rb_commonmark,
-            &comrak_options,
-            &comrak_plugins,
-        ))
-    } else {
-        Ok(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, -1))?;
-
-    Ok(())
-}

data/ext/commonmarker/src/options.rs

@@ -1,134 +0,0 @@
-use std::borrow::Cow;
-
-use comrak::ComrakOptions;
-
-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";
-
-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";
-const EXTENSION_SHORTCODES: &str = "shortcodes";
-
-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(Cow::Borrowed(EXTENSION_SHORTCODES)) => {
-                    comrak_options.extension.shortcodes = value.try_convert::<bool>()?;
-                }
-                _ => {}
-            }
-            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

@@ -1,58 +0,0 @@
-use std::path::PathBuf;
-
-use magnus::{RHash, Symbol, Value};
-
-use crate::EMPTY_STR;
-
-pub const SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY: &str = "theme";
-pub const SYNTAX_HIGHLIGHTER_PLUGIN_PATH_KEY: &str = "path";
-pub const SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME: &str = "base16-ocean.dark";
-
-pub fn fetch_syntax_highlighter_theme(value: Value) -> Result<String, magnus::Error> {
-    if value.is_nil() {
-        // `syntax_highlighter: nil`
-        return Ok(EMPTY_STR.to_string());
-    }
-
-    let syntax_highlighter_plugin = value.try_convert::<RHash>()?;
-    let theme_key = Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY);
-
-    match syntax_highlighter_plugin.get(theme_key) {
-        Some(theme) => {
-            if theme.is_nil() {
-                // `syntax_highlighter: { theme: nil }`
-                return Ok(EMPTY_STR.to_string());
-            }
-            Ok(theme.try_convert::<String>()?)
-        }
-        None => {
-            // `syntax_highlighter: {  }`
-            Ok(EMPTY_STR.to_string())
-        }
-    }
-}
-
-pub 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 = value.try_convert::<RHash>()?;
-    let path_key = Symbol::new(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));
-            }
-
-            Ok(PathBuf::from(path.try_convert::<String>()?))
-        }
-        None => {
-            // `syntax_highlighter: {  }`
-            Ok(PathBuf::from(EMPTY_STR))
-        }
-    }
-}

data/ext/commonmarker/src/plugins.rs

@@ -1,21 +0,0 @@
-// use comrak::ComrakPlugins;
-// use magnus::{class, r_hash::ForEach, RHash, Symbol, Value};
-
-// use crate::plugins::syntax_highlighting::fetch_syntax_highlighter_theme;
-
-pub mod syntax_highlighting;
-
-pub const SYNTAX_HIGHLIGHTER_PLUGIN: &str = "syntax_highlighter";
-
-// pub fn iterate_plugins_hash(
-//     comrak_plugins: &mut ComrakPlugins,
-//     mut theme: String,
-//     key: Symbol,
-//     value: Value,
-// ) -> Result<ForEach, magnus::Error> {
-//     if key.name().unwrap() == SYNTAX_HIGHLIGHTER_PLUGIN {
-//         theme = fetch_syntax_highlighter_theme(value)?;
-//     }
-
-//     Ok(ForEach::Continue)
-// }

data/ext/commonmarker/src/utils.rs

@@ -1,8 +0,0 @@
-use magnus::Value;
-
-pub fn try_convert_string(value: Value) -> Option<String> {
-    match value.try_convert::<String>() {
-        Ok(s) => Some(s),
-        Err(_) => None,
-    }
-}