commonmarker 1.0.0.pre7 → 1.0.0.pre11

data/Cargo.toml

@@ -0,0 +1,6 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions depedencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["ext/commonmarker"]

data/README.md

@@ -131,9 +131,16 @@ Commonmarker.to_html(code, plugins: { syntax_highlighter: nil })
 Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: nil } })
 ```
 
+You can also provide a `path` to a directory containing `.tmtheme` files to load:
+
+```ruby
+
+Commonmarker.to_html(code, plugins: { syntax_highlighter: { theme: "Monokai", path: "./themes" } })
+```
+
 ##### Available themes
 
-Here's [a list of available themes](https://docs.rs/syntect/5.0.0/syntect/highlighting/struct.ThemeSet.html#implementations):
+Here's [a list of themes available by default](https://docs.rs/syntect/5.0.0/syntect/highlighting/struct.ThemeSet.html#implementations):
 
 - `"base16-ocean.dark"`
 - `"base16-eighties.dark"`

data/ext/commonmarker/Cargo.toml

@@ -4,8 +4,9 @@ version = "1.0.0"
 edition = "2021"
 
 [dependencies]
-magnus =  "0.4"
-comrak = { version = "0.16", features = ["shortcodes"] }
+magnus =  "0.6"
+comrak = { version = "0.19", features = ["shortcodes"] }
+syntect = { version = "5.1", features = ["plist-load"] }
 
 [lib]
 name = "commonmarker"

data/ext/commonmarker/extconf.rb

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

data/ext/commonmarker/src/lib.rs

@@ -1,10 +1,17 @@
 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, ComrakOptions, ComrakPlugins,
+    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,
 };
-use magnus::{define_module, function, r_hash::ForEach, scan_args, Error, RHash, Symbol, Value};
 
 mod options;
 use options::iterate_options_hash;
@@ -12,7 +19,8 @@ use options::iterate_options_hash;
 mod plugins;
 use plugins::{
     syntax_highlighting::{
-        fetch_syntax_highlighter_theme, SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME,
+        fetch_syntax_highlighter_path, fetch_syntax_highlighter_theme,
+        SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME,
     },
     SYNTAX_HIGHLIGHTER_PLUGIN,
 };
@@ -21,13 +29,9 @@ 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)?;
+fn commonmark_to_html(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,
@@ -52,13 +56,75 @@ fn commonmark_to_html<'a>(args: &[Value]) -> Result<String, magnus::Error> {
         let adapter: SyntectAdapter;
 
         let theme = match rb_plugins.get(Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN)) {
-            Some(theme_val) => fetch_syntax_highlighter_theme(theme_val)?,
+            Some(syntax_highlighter_options) => {
+                fetch_syntax_highlighter_theme(syntax_highlighter_options)?
+            }
             None => SYNTAX_HIGHLIGHTER_PLUGIN_DEFAULT_THEME.to_string(), // no `syntax_highlighter:` defined
         };
 
-        if theme.is_empty() || theme == "none" {
+        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(),
+                "path does not exist".to_string(),
+            ));
+        }
+
+        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);
         }

data/ext/commonmarker/src/options.rs

@@ -2,6 +2,8 @@ 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;
@@ -14,7 +16,7 @@ fn iterate_parse_options(comrak_options: &mut ComrakOptions, options_hash: RHash
         .foreach(|key: Symbol, value: Value| {
             match key.name() {
                 Ok(Cow::Borrowed(PARSE_SMART)) => {
-                    comrak_options.parse.smart = value.try_convert::<bool>()?;
+                    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);
@@ -37,19 +39,19 @@ fn iterate_render_options(comrak_options: &mut ComrakOptions, options_hash: RHas
         .foreach(|key: Symbol, value: Value| {
             match key.name() {
                 Ok(Cow::Borrowed(RENDER_HARDBREAKS)) => {
-                    comrak_options.render.hardbreaks = value.try_convert::<bool>()?;
+                    comrak_options.render.hardbreaks = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(RENDER_GITHUB_PRE_LANG)) => {
-                    comrak_options.render.github_pre_lang = value.try_convert::<bool>()?;
+                    comrak_options.render.github_pre_lang = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(RENDER_WIDTH)) => {
-                    comrak_options.render.width = value.try_convert::<usize>()?;
+                    comrak_options.render.width = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(RENDER_UNSAFE)) => {
-                    comrak_options.render.unsafe_ = value.try_convert::<bool>()?;
+                    comrak_options.render.unsafe_ = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(RENDER_ESCAPE)) => {
-                    comrak_options.render.escape = value.try_convert::<bool>()?;
+                    comrak_options.render.escape = TryConvert::try_convert(value)?;
                 }
                 _ => {}
             }
@@ -75,37 +77,41 @@ fn iterate_extension_options(comrak_options: &mut ComrakOptions, options_hash: R
         .foreach(|key: Symbol, value: Value| {
             match key.name() {
                 Ok(Cow::Borrowed(EXTENSION_STRIKETHROUGH)) => {
-                    comrak_options.extension.strikethrough = value.try_convert::<bool>()?;
+                    comrak_options.extension.strikethrough = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_TAGFILTER)) => {
-                    comrak_options.extension.tagfilter = value.try_convert::<bool>()?;
+                    comrak_options.extension.tagfilter = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_TABLE)) => {
-                    comrak_options.extension.table = value.try_convert::<bool>()?;
+                    comrak_options.extension.table = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_AUTOLINK)) => {
-                    comrak_options.extension.autolink = value.try_convert::<bool>()?;
+                    comrak_options.extension.autolink = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_TASKLIST)) => {
-                    comrak_options.extension.tasklist = value.try_convert::<bool>()?;
+                    comrak_options.extension.tasklist = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_SUPERSCRIPT)) => {
-                    comrak_options.extension.superscript = value.try_convert::<bool>()?;
+                    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 = value.try_convert::<bool>()?;
+                    comrak_options.extension.footnotes = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_DESCRIPTION_LISTS)) => {
-                    comrak_options.extension.description_lists = value.try_convert::<bool>()?;
+                    comrak_options.extension.description_lists = TryConvert::try_convert(value)?;
                 }
                 Ok(Cow::Borrowed(EXTENSION_FRONT_MATTER_DELIMITER)) => {
-                    comrak_options.extension.front_matter_delimiter = try_convert_string(value);
+                    if let Some(option) = try_convert_string(value) {
+                        if !option.is_empty() {
+                            comrak_options.extension.front_matter_delimiter = Some(option);
+                        }
+                    }
                 }
                 Ok(Cow::Borrowed(EXTENSION_SHORTCODES)) => {
-                    comrak_options.extension.shortcodes = value.try_convert::<bool>()?;
+                    comrak_options.extension.shortcodes = TryConvert::try_convert(value)?;
                 }
                 _ => {}
             }

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

@@ -1,8 +1,12 @@
-use magnus::{RHash, Symbol, Value};
+use std::path::PathBuf;
+
+use magnus::value::ReprValue;
+use magnus::{RHash, Symbol, TryConvert, 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> {
@@ -11,7 +15,7 @@ pub fn fetch_syntax_highlighter_theme(value: Value) -> Result<String, magnus::Er
         return Ok(EMPTY_STR.to_string());
     }
 
-    let syntax_highlighter_plugin = value.try_convert::<RHash>()?;
+    let syntax_highlighter_plugin: RHash = TryConvert::try_convert(value)?;
     let theme_key = Symbol::new(SYNTAX_HIGHLIGHTER_PLUGIN_THEME_KEY);
 
     match syntax_highlighter_plugin.get(theme_key) {
@@ -28,3 +32,28 @@ pub fn fetch_syntax_highlighter_theme(value: Value) -> Result<String, magnus::Er
         }
     }
 }
+
+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: RHash = TryConvert::try_convert(value)?;
+    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));
+            }
+            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

@@ -1,21 +1,3 @@
-// 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,7 +1,7 @@
-use magnus::Value;
+use magnus::{TryConvert, Value};
 
 pub fn try_convert_string(value: Value) -> Option<String> {
-    match value.try_convert::<String>() {
+    match TryConvert::try_convert(value) {
         Ok(s) => Some(s),
         Err(_) => None,
     }

data/lib/commonmarker/config.rb

@@ -26,7 +26,7 @@ module Commonmarker
         header_ids: "",
         footnotes: false,
         description_lists: false,
-        front_matter_delimiter: nil,
+        front_matter_delimiter: "",
         shortcodes: true,
       },
       format: [:html].freeze,
@@ -35,6 +35,7 @@ module Commonmarker
     PLUGINS = {
       syntax_highlighter: {
         theme: "base16-ocean.dark",
+        path: "",
       },
     }
 
@@ -78,7 +79,7 @@ module Commonmarker
 
     [:syntax_highlighter].each do |type|
       define_singleton_method :"process_#{type}_plugin" do |plugin|
-        return nil if plugin.nil? # plugin explicitly nil, remove it
+        return if plugin.nil? # plugin explicitly nil, remove it
 
         Commonmarker::Config::PLUGINS[type].each_with_object({}) do |(key, value), hash|
           if plugin.nil? # option not provided, go for the default

data/lib/commonmarker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Commonmarker
-  VERSION = "1.0.0.pre7"
+  VERSION = "1.0.0.pre11"
 end

data/lib/commonmarker.rb

@@ -7,11 +7,6 @@ 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.

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: commonmarker
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre7
+  version: 1.0.0.pre11
 platform: ruby
 authors:
 - Garen Torikian
 - Ashe Connor
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-26 00:00:00.000000000 Z
+date: 2023-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -54,33 +54,19 @@ dependencies:
     - - "~>"
       - !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: 
+email:
 executables: []
 extensions:
 - ext/commonmarker/extconf.rb
 extra_rdoc_files: []
 files:
 - Cargo.lock
+- Cargo.toml
 - LICENSE.txt
 - README.md
 - ext/commonmarker/Cargo.toml
-- ext/commonmarker/_util.rb
 - ext/commonmarker/extconf.rb
 - ext/commonmarker/src/lib.rs
 - ext/commonmarker/src/options.rs
@@ -102,7 +88,7 @@ metadata:
   funding_uri: https://github.com/sponsors/gjtorikian/
   source_code_uri: https://github.com/gjtorikian/commonmarker
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 3.4.4
-signing_key: 
+rubygems_version: 3.4.21
+signing_key:
 specification_version: 4
 summary: CommonMark parser and renderer. Written in Rust, wrapped in Ruby.
 test_files: []

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
-