Add support for WASM compilation

.github/workflows/rust.yml

@@ -22,6 +22,20 @@ jobs:
       run: env SPEC=false script/cibuild
     - name: Run spec tests
       run: env SPEC=true script/cibuild
+  build_wasm:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        submodules: true
+    - name: Obtain Rust
+      run: rustup override set stable
+    - name: Setup for wasm
+      run: rustup target add wasm32-unknown-unknown
+    - name: Build
+      run: cargo build --verbose --target wasm32-unknown-unknown
+    - name: Build examples
+      run: cargo build --verbose --target wasm32-unknown-unknown --examples
   no_features_build_test:
     runs-on: ubuntu-latest
     strategy:

Cargo.toml

@@ -11,6 +11,7 @@ keywords = ["markdown", "commonmark"]
 license = "BSD-2-Clause"
 categories = ["text-processing", "parsing", "command-line-utilities"]
 exclude = ["/hooks/*", "/script/*", "/vendor/*", "/.travis.yml", "/Makefile", "/spec_out.txt"]
+resolver = "2"
 
 [profile.release]
 lto = true
@@ -31,14 +32,19 @@ twoway = "0.2"
 pest = "2"
 pest_derive = "2"
 shell-words = "1.0"
-syntect = { version = "4.6", optional = true, default-features = false, features = ["assets", "dump-load", "html", "regex-onig"] }
 
 [dev-dependencies]
 timebomb = "0.1.2"
+
+[target.'cfg(not(target_arch="wasm32"))'.dev-dependencies]
 propfuzz = "0.0.1"
 
 [features]
 default = ["clap", "syntect"]
 
-[target.'cfg(not(windows))'.dependencies]
+[target.'cfg(all(not(windows), not(target_arch="wasm32")))'.dependencies]
 xdg = "^2.1"
+syntect = { version = "4.6", optional = true, default-features = false, features = ["assets", "dump-load", "html", "regex-onig"] }
+
+[target.'cfg(target_arch="wasm32")'.dependencies]
+syntect = { version = "4.6", optional = true, default-features = false, features = ["default-fancy"] }

src/lib.rs

@@ -77,7 +77,7 @@ extern crate lazy_static;
 extern crate pest;
 #[macro_use]
 extern crate pest_derive;
-#[cfg(test)]
+#[cfg(all(test, not(target_arch = "wasm32")))]
 extern crate propfuzz;
 extern crate regex;
 #[cfg(feature = "syntect")]

src/main.rs

@@ -6,7 +6,7 @@ extern crate comrak;
 extern crate clap;
 extern crate shell_words;
 
-#[cfg(not(windows))]
+#[cfg(all(not(windows), not(target_arch = "wasm32")))]
 extern crate xdg;
 
 use comrak::{
@@ -291,7 +291,7 @@ if the file does not exist.\
     process::exit(EXIT_SUCCESS);
 }
 
-#[cfg(not(windows))]
+#[cfg(all(not(windows), not(target_arch = "wasm32")))]
 fn get_default_config_path() -> String {
     if let Ok(xdg_dirs) = xdg::BaseDirectories::with_prefix("comrak") {
         if let Ok(path) = xdg_dirs.place_config_file("config") {
@@ -303,8 +303,8 @@ fn get_default_config_path() -> String {
 
     "comrak.config".into()
 }
-
-#[cfg(windows)]
+// If on Windows or compiling to wasm, disable default config file check
+#[cfg(any(windows, target_arch = "wasm32"))]
 fn get_default_config_path() -> String {
     "none".into()
 }

src/tests.rs

@@ -4,20 +4,18 @@ use cm;
 use html;
 #[cfg(feature = "syntect")]
 use plugins::syntect::SyntectAdapter;
-use propfuzz::prelude::*;
 use std::collections::HashMap;
-use std::fmt::Debug;
 use strings::build_opening_tag;
 use timebomb::timeout_ms;
-use {
-    parse_document, Arena, ComrakExtensionOptions, ComrakOptions, ComrakParseOptions,
-    ComrakPlugins, ComrakRenderOptions,
-};
 
+#[cfg(not(target_arch = "wasm32"))]
+use propfuzz::prelude::*;
+
+#[cfg(not(target_arch = "wasm32"))]
 #[propfuzz]
 fn fuzz_doesnt_crash(md: String) {
-    let options = ComrakOptions {
-        extension: ComrakExtensionOptions {
+    let options = ::ComrakOptions {
+        extension: ::ComrakExtensionOptions {
             strikethrough: true,
             tagfilter: true,
             table: true,
@@ -29,11 +27,11 @@ fn fuzz_doesnt_crash(md: String) {
             description_lists: true,
             front_matter_delimiter: None,
         },
-        parse: ComrakParseOptions {
+        parse: ::ComrakParseOptions {
             smart: true,
             default_info_string: Some("Rust".to_string()),
         },
-        render: ComrakRenderOptions {
+        render: ::ComrakRenderOptions {
             hardbreaks: true,
             github_pre_lang: true,
             width: 80,
@@ -42,7 +40,7 @@ fn fuzz_doesnt_crash(md: String) {
         },
     };
 
-    parse_document(&Arena::new(), &md, &options);
+    ::parse_document(&::Arena::new(), &md, &options);
 }
 
 #[track_caller]
@@ -71,20 +69,20 @@ fn html(input: &str, expected: &str) {
 #[track_caller]
 fn html_opts<F>(input: &str, expected: &str, opts: F)
 where
-    F: Fn(&mut ComrakOptions),
+    F: Fn(&mut ::ComrakOptions),
 {
-    let arena = Arena::new();
-    let mut options = ComrakOptions::default();
+    let arena = ::Arena::new();
+    let mut options = ::ComrakOptions::default();
     opts(&mut options);
 
-    let root = parse_document(&arena, input, &options);
+    let root = ::parse_document(&arena, input, &options);
     let mut output = vec![];
     html::format_document(root, &options, &mut output).unwrap();
     compare_strs(&String::from_utf8(output).unwrap(), expected, "regular");
 
     let mut md = vec![];
     cm::format_document(root, &options, &mut md).unwrap();
-    let root = parse_document(&arena, &String::from_utf8(md).unwrap(), &options);
+    let root = ::parse_document(&arena, &String::from_utf8(md).unwrap(), &options);
     let mut output_from_rt = vec![];
     html::format_document(root, &options, &mut output_from_rt).unwrap();
     compare_strs(
@@ -105,18 +103,18 @@ macro_rules! html_opts {
     };
 }
 
-fn html_plugins(input: &str, expected: &str, plugins: &ComrakPlugins) {
-    let arena = Arena::new();
-    let options = ComrakOptions::default();
+fn html_plugins(input: &str, expected: &str, plugins: &::ComrakPlugins) {
+    let arena = ::Arena::new();
+    let options = ::ComrakOptions::default();
 
-    let root = parse_document(&arena, input, &options);
+    let root = ::parse_document(&arena, input, &options);
     let mut output = vec![];
     html::format_document_with_plugins(root, &options, &mut output, &plugins).unwrap();
     compare_strs(&String::from_utf8(output).unwrap(), expected, "regular");
 
     let mut md = vec![];
     cm::format_document(root, &options, &mut md).unwrap();
-    let root = parse_document(&arena, &String::from_utf8(md).unwrap(), &options);
+    let root = ::parse_document(&arena, &String::from_utf8(md).unwrap(), &options);
     let mut output_from_rt = vec![];
     html::format_document_with_plugins(root, &options, &mut output_from_rt, &plugins).unwrap();
     compare_strs(
@@ -199,7 +197,7 @@ fn syntax_highlighter_plugin() {
         "</code></pre>\n"
     );
 
-    let mut plugins = ComrakPlugins::default();
+    let mut plugins = ::ComrakPlugins::default();
     let adapter = MockAdapter {};
     plugins.render.codefence_syntax_highlighter = Some(&adapter);
 
@@ -219,7 +217,7 @@ fn syntect_plugin() {
         "</code></pre>\n"
     );
 
-    let mut plugins = ComrakPlugins::default();
+    let mut plugins = ::ComrakPlugins::default();
     plugins.render.codefence_syntax_highlighter = Some(&adapter);
 
     html_plugins(input, expected, &plugins);
@@ -425,9 +423,9 @@ fn blockquote_hard_linebreak_nonlazy_space() {
 fn backticks_num() {
     let input = "Some `code1`. More ``` code2 ```.\n";
 
-    let arena = Arena::new();
-    let options = ComrakOptions::default();
-    let root = parse_document(&arena, input, &options);
+    let arena = ::Arena::new();
+    let options = ::ComrakOptions::default();
+    let root = ::parse_document(&arena, input, &options);
 
     let code1 = NodeValue::Code(NodeCode {
         num_backticks: 1,
@@ -1043,19 +1041,19 @@ fn nested_tables_3() {
 #[test]
 fn no_stack_smash_html() {
     let s: String = ::std::iter::repeat('>').take(150_000).collect();
-    let arena = Arena::new();
-    let root = parse_document(&arena, &s, &ComrakOptions::default());
+    let arena = ::Arena::new();
+    let root = ::parse_document(&arena, &s, &::ComrakOptions::default());
     let mut output = vec![];
-    html::format_document(root, &ComrakOptions::default(), &mut output).unwrap()
+    html::format_document(root, &::ComrakOptions::default(), &mut output).unwrap()
 }
 
 #[test]
 fn no_stack_smash_cm() {
     let s: String = ::std::iter::repeat('>').take(150_000).collect();
-    let arena = Arena::new();
-    let root = parse_document(&arena, &s, &ComrakOptions::default());
+    let arena = ::Arena::new();
+    let root = ::parse_document(&arena, &s, &::ComrakOptions::default());
     let mut output = vec![];
-    cm::format_document(root, &ComrakOptions::default(), &mut output).unwrap()
+    cm::format_document(root, &::ComrakOptions::default(), &mut output).unwrap()
 }
 
 #[test]