gitlab-glfm-markdown 0.0.4 → 0.0.8

data/LICENSE

@@ -1,6 +1,13 @@
-The MIT License (MIT)
+Copyright (c) 2011-present GitLab B.V.
 
-Copyright (c) 2022-present GitLab B.V.
+Portions of this software are licensed as follows:
+
+* All content residing under the "doc/" directory of this repository is licensed under "Creative Commons: CC BY-SA 4.0 license".
+* All content that resides under the "ee/" directory of this repository, if that directory exists, is licensed under the license defined in "ee/LICENSE".
+* All content that resides under the "jh/" directory of this repository, if that directory exists, is licensed under the license defined in "jh/LICENSE".
+* All client-side JavaScript (when served directly or after being compiled, arranged, augmented, or combined), is licensed under the "MIT Expat" license.
+* All third party components incorporated into the GitLab Software are licensed under the original license provided by the owner of the applicable component.
+* Content outside of the above mentioned directories or restrictions above is available under the "MIT Expat" license as defined below.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,8 @@
 # GitLab Flavored Markdown
 
+[![Pipeline status](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/badges/main/pipeline.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/commits/main)
+[![Latest Release](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/badges/release.svg)](https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/releases)
+
 Implements GLFM (as used by GitLab) using a Rust-based markdown parser.
 
 This project is currently EXPLORATORY, so anything and everything will change.
@@ -22,7 +25,7 @@ Try on command line:
 rake compile
 bin/console
 
-GLFMMarkdown.to_html('# header', options: {sourcepos: true})
+GLFMMarkdown.to_html('# header', options: { glfm: true })
 ```
 
 ## Development
@@ -30,12 +33,32 @@ GLFMMarkdown.to_html('# header', options: {sourcepos: true})
 A command line executable can be built for debugging.
 
 ```
-cd ext/glfm_markdown
-cargo run --bin glfm_markdown -- --sourcepos
+cargo run --bin glfm_markdown --features="cli" -- --help
+cargo run --bin glfm_markdown --features="cli" -- --sourcepos
 ```
 
 There is a VSCode workspace that allows you to `Debug executable`
 
+When developing another project locally and using `gitlab-glfm-markdown` by linking
+directly to the gem's source directory, make sure that you're using the same version
+of Ruby for the project and the gem. Otherwise you can see unexplained errors when
+calling into the gem.
+
+### Releasing a new version
+
+To release a new version:
+
+1. Update `lib/glfm_markdown/version.rb` with the version number.
+1. Update `CHANGELOG.md` with the changes in the release.
+1. Create a merge request and merge it to `master`.
+1. Push a new tag to the repository.
+
+The new version with precompiled, native gems will automatically be
+published to [RubyGems](https://rubygems.org/gems/gitlab-glfm-markdown) when the
+pipeline for the tag completes.
+
 ## Contributing
 
 Bug reports and merge requests are welcome on GitLab at https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown.
+
+Please refer to [CONTRIBUTING](CONTRIBUTING.md) for more details.

data/ext/glfm_markdown/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "glfm_markdown"
-version = "0.0.3"
+version = "0.0.8"
 edition = "2021"
 authors = ["digitalmoksha <bwalker@gitlab.com>"]
+description = "GitLab Flavored Markdown parser and formatter. 100% CommonMark-compatible. Experimental."
 publish = false
 
 [lib]
@@ -10,8 +11,13 @@ crate-type = ["cdylib"]
 
 [[bin]]
 name = "glfm_markdown"
+required-features = ["cli"]
 
 [dependencies]
-magnus = { version = "0.4" }
-argparse = { version = ">= 0.2.1" }
-comrak = { git = "https://github.com/kivikakk/comrak.git" }
+clap = { version = "4.0", optional = true, features = ["derive", "string"] }
+comrak = { version = "0.20.0", default-features = false }
+magnus = "0.6.2"
+rb-sys = { version = "0.9.83", default-features = false, features = ["stable-api-compiled-fallback"] }
+
+[features]
+cli = ["clap", "comrak/syntect"]

data/ext/glfm_markdown/extconf.rb

@@ -3,4 +3,6 @@
 require 'mkmf'
 require 'rb_sys/mkmf'
 
-create_rust_makefile('glfm_markdown/glfm_markdown')
+create_rust_makefile('glfm_markdown') do |r|
+  r.auto_install_rust_toolchain = false
+end

data/ext/glfm_markdown/src/glfm.rs

@@ -1,6 +1,23 @@
 #[derive(Debug)]
 pub struct RenderOptions {
+    pub autolink: bool,
+    pub escape: bool,
+    pub description_lists: bool,
+    pub footnotes: bool,
+    pub full_info_string: bool,
+    pub github_pre_lang: bool,
+    pub hardbreaks: bool,
+    pub relaxed_autolinks: bool,
+    pub relaxed_tasklist_character: bool,
     pub sourcepos: bool,
+    pub smart: bool,
+    pub strikethrough: bool,
+    pub superscript: bool,
+    pub table: bool,
+    pub tagfilter: bool,
+    pub tasklist: bool,
+    pub unsafe_: bool,
+
     pub debug: bool,
 }
 
@@ -11,20 +28,25 @@ pub fn render(text: String, options: RenderOptions) -> String {
 fn render_comrak(text: String, options: RenderOptions) -> String {
     let mut comrak_options = comrak::ComrakOptions::default();
 
-    comrak_options.extension.strikethrough = true;
-    comrak_options.extension.table = true;
-    comrak_options.extension.autolink = true;
-    comrak_options.extension.tasklist = false;
-    comrak_options.extension.footnotes = true;
+    comrak_options.extension.autolink = options.autolink;
+    comrak_options.extension.description_lists = options.description_lists;
+    comrak_options.extension.footnotes = options.footnotes;
+    comrak_options.extension.strikethrough = options.strikethrough;
+    comrak_options.extension.superscript = options.superscript;
+    comrak_options.extension.table = options.table;
+    comrak_options.extension.tagfilter = options.tagfilter;
+    comrak_options.extension.tasklist = options.tasklist;
 
-    comrak_options.render.unsafe_ = true;
-    comrak_options.render.github_pre_lang = true;
-    comrak_options.render.full_info_string = true;
-    comrak_options.render.hardbreaks = false;
+    comrak_options.render.escape = options.escape;
+    comrak_options.render.full_info_string = options.full_info_string;
+    comrak_options.render.github_pre_lang = options.github_pre_lang;
+    comrak_options.render.hardbreaks = options.hardbreaks;
     comrak_options.render.sourcepos = options.sourcepos;
+    comrak_options.render.unsafe_ = options.unsafe_;
 
-    comrak_options.parse.smart = false;
-    comrak_options.parse.relaxed_autolinks = false;
+    comrak_options.parse.relaxed_autolinks = options.relaxed_autolinks;
+    comrak_options.parse.relaxed_tasklist_matching = options.relaxed_tasklist_character;
+    comrak_options.parse.smart = options.smart;
 
     comrak::markdown_to_html(&text, &comrak_options)
 }

data/ext/glfm_markdown/src/lib.rs

@@ -3,10 +3,33 @@ use magnus::{define_module, function, prelude::*, Error, RHash, Symbol};
 mod glfm;
 use glfm::{render, RenderOptions};
 
-pub fn render_to_html(text: String, options: RHash) -> String {
-    let sourcepos: bool = options.lookup::<_, bool>(Symbol::new("sourcepos")).unwrap();
-    let debug: bool = options.lookup::<_, bool>(Symbol::new("debug")).unwrap();
-    let render_options = RenderOptions { sourcepos, debug };
+/// Lookup symbol in provided `RHash`. Returns `false` if the key is not present
+/// or value cannot be converted to a boolean.
+fn get_opt(arg: &str, options: RHash) -> bool {
+    options.lookup(Symbol::new(arg)).unwrap_or_default()
+}
+
+pub fn render_to_html_rs(text: String, options: RHash) -> String {
+    let render_options = RenderOptions {
+        autolink: get_opt("autolink", options),
+        description_lists: get_opt("description_lists", options),
+        escape: get_opt("escape", options),
+        footnotes: get_opt("footnotes", options),
+        full_info_string: get_opt("full_info_string", options),
+        github_pre_lang: get_opt("github_pre_lang", options),
+        hardbreaks: get_opt("hardbreaks", options),
+        relaxed_autolinks: get_opt("relaxed_autolinks", options),
+        relaxed_tasklist_character: get_opt("relaxed_tasklist_character", options),
+        sourcepos: get_opt("sourcepos", options),
+        smart: get_opt("smart", options),
+        strikethrough: get_opt("strikethrough", options),
+        superscript: get_opt("superscript", options),
+        table: get_opt("table", options),
+        tagfilter: get_opt("tagfilter", options),
+        tasklist: get_opt("tasklist", options),
+        unsafe_: get_opt("unsafe", options),
+        debug: get_opt("debug", options),
+    };
 
     render(text, render_options)
 }
@@ -15,7 +38,7 @@ pub fn render_to_html(text: String, options: RHash) -> String {
 fn init() -> Result<(), Error> {
     let module = define_module("GLFMMarkdown")?;
 
-    module.define_singleton_method("render_to_html", function!(render_to_html, 2))?;
+    module.define_singleton_method("render_to_html_rs", function!(render_to_html_rs, 2))?;
 
     Ok(())
 }

data/ext/glfm_markdown/src/main.rs

@@ -3,52 +3,132 @@ use glfm::{render, RenderOptions};
 use std::io::Read;
 use std::io::Write;
 
+use clap::Parser;
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// CommonMark file(s) to parse; or standard input if none passed
+    #[arg(value_name = "FILE")]
+    file: Option<String>,
+
+    /// Enable 'autolink' extension
+    #[arg(long)]
+    autolink: bool,
+
+    /// Enable 'description-lists' extension
+    #[arg(long)]
+    description_lists: bool,
+
+    /// Escape raw HTML instead of clobbering it
+    #[arg(long)]
+    escape: bool,
+
+    /// Enable 'footnotes' extension
+    #[arg(long)]
+    footnotes: bool,
+
+    /// Enable full info strings for code blocks
+    #[arg(long)]
+    full_info_string: bool,
+
+    /// Use GitHub-style <pre lang> for code blocks
+    #[arg(long)]
+    github_pre_lang: bool,
+
+    /// Treat newlines as hard line breaks
+    #[arg(long)]
+    hardbreaks: bool,
+
+    /// Write output to FILE instead of stdout
+    #[arg(short, long, value_name = "FILE")]
+    output: Option<String>,
+
+    /// Enable relaxing of autolink parsing, allowing links to be recognized when in brackets
+    #[arg(long)]
+    relaxed_autolinks: bool,
+
+    /// Enable relaxing which character is allowed in a tasklists
+    #[arg(long)]
+    relaxed_tasklist_character: bool,
+
+    /// Include source mappings in HTML attributes
+    #[arg(long)]
+    sourcepos: bool,
+
+    /// Use smart punctuation
+    #[arg(long)]
+    smart: bool,
+
+    /// Enable 'strikethrough' extension
+    #[arg(long)]
+    strikethrough: bool,
+
+    /// Enable 'superscript' extension
+    #[arg(long)]
+    superscript: bool,
+
+    /// Enable 'table' extension
+    #[arg(long)]
+    table: bool,
+
+    /// Enable 'tagfilter' extension
+    #[arg(long)]
+    tagfilter: bool,
+
+    /// Enable 'tasklist' extension
+    #[arg(long)]
+    tasklist: bool,
+
+    /// Allow raw HTML and dangerous URLs
+    #[arg(long = "unsafe")]
+    unsafe_: bool,
+
+    /// Show debug information
+    #[arg(long)]
+    debug: bool,
+}
+
 fn main() {
-    let mut input = "-".to_owned();
-    let mut output = "-".to_owned();
-    let mut sourcepos = false;
-    let mut debug = false;
-
-    {
-        // this block limits scope of borrows by cli.refer() method
-        let mut cli = argparse::ArgumentParser::new();
-
-        cli.set_description("Gitlab Flavored Markdown. Experimental.");
-
-        cli.refer(&mut input)
-            .add_argument("file", argparse::Store, "File to read");
-        cli.refer(&mut output)
-            .add_option(&["-o", "--output"], argparse::Store, "File to write");
-        cli.refer(&mut sourcepos).add_option(
-            &["--sourcepos"],
-            argparse::StoreTrue,
-            "Include source mappings in HTML attributes.",
-        );
-        cli.refer(&mut debug).add_option(
-            &["--debug"],
-            argparse::StoreTrue,
-            "Show debug information",
-        );
-
-        cli.parse_args_or_exit();
-    }
-
-    let vec = if input == "-" {
-        let mut vec = Vec::new();
-        std::io::stdin().read_to_end(&mut vec).unwrap();
-        vec
-    } else {
-        std::fs::read(input).unwrap()
+    let mut s: Vec<u8> = Vec::with_capacity(2048);
+    let cli = Args::parse();
+
+    match cli.file {
+        None => {
+            std::io::stdin().read_to_end(&mut s).unwrap();
+        }
+        Some(fs) => {
+            s = std::fs::read(fs).unwrap();
+        }
     };
 
-    let source = String::from_utf8_lossy(&vec);
-    let options = RenderOptions { sourcepos, debug };
+    let source = String::from_utf8_lossy(&s);
+    let options = RenderOptions {
+        autolink: cli.autolink,
+        description_lists: cli.description_lists,
+        escape: cli.escape,
+        footnotes: cli.footnotes,
+        full_info_string: cli.full_info_string,
+        github_pre_lang: cli.github_pre_lang,
+        hardbreaks: cli.hardbreaks,
+        relaxed_autolinks: cli.relaxed_autolinks,
+        relaxed_tasklist_character: cli.relaxed_tasklist_character,
+        sourcepos: cli.sourcepos,
+        smart: cli.smart,
+        strikethrough: cli.strikethrough,
+        superscript: cli.superscript,
+        table: cli.table,
+        tagfilter: cli.tagfilter,
+        tasklist: cli.tasklist,
+        unsafe_: cli.unsafe_,
+        debug: cli.debug,
+    };
 
     let result = render(source.to_string(), options);
 
-    if output == "-" {
-        std::io::stdout().write_all(result.as_bytes()).unwrap();
+    if let Some(output_filename) = cli.output {
+        std::fs::write(output_filename, &result).unwrap();
     } else {
-        std::fs::write(output, &result).unwrap();
-    }
+        std::io::stdout().write_all(result.as_bytes()).unwrap();
+    };
 }

data/lib/glfm_markdown/loader.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+def load_rust_extension
+  ruby_version = /(\d+\.\d+)/.match(RUBY_VERSION)
+  require_relative "./#{ruby_version}/glfm_markdown"
+rescue LoadError
+  require 'glfm_markdown/glfm_markdown'
+end

data/lib/glfm_markdown/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GLFMMarkdown
-  VERSION = '0.0.4'
+  VERSION = '0.0.8'
 end

data/lib/glfm_markdown.rb

@@ -1,17 +1,39 @@
 # frozen_string_literal: true
 
 require_relative 'glfm_markdown/version'
-require_relative 'glfm_markdown/glfm_markdown'
+require_relative 'glfm_markdown/loader'
 
-DEFAULT_OPTIONS = {
+load_rust_extension
+
+GLFM_DEFAULT_OPTIONS = {
+  autolink: true,
+  footnotes: true,
+  full_info_string: true,
+  github_pre_lang: false,
+  hardbreaks: false,
+  relaxed_autolinks: false,
   sourcepos: true,
+  smart: false,
+  strikethrough: true,
+  table: true,
+  tagfilter: false,
+  tasklist: true,
+  unsafe: true,
+
   debug: false
 }.freeze
 
 module GLFMMarkdown
   class << self
-    def to_html(text, options: {})
-      render_to_html(text, DEFAULT_OPTIONS.merge(options))
+    def to_html(markdown, options: {})
+      raise TypeError, 'markdown must be a String' unless markdown.is_a?(String)
+      raise TypeError, 'markdown must be UTF-8 encoded' unless markdown.encoding.name == "UTF-8"
+      raise TypeError, 'options must be a Hash' unless options.is_a?(Hash)
+
+      default_options = options[:glfm] ? GLFM_DEFAULT_OPTIONS : {}
+      options = options.merge(unsafe: true) if options[:tagfilter]
+
+      render_to_html_rs(markdown, default_options.merge(options))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-glfm-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.8
 platform: ruby
 authors:
 - Brett Walker
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2023-07-08 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-description: GLFM Markdown
+description: Markdown processing for GitLab Flavored Markdown
 email:
 - bwalker@gitlab.com
 executables: []
@@ -97,13 +97,15 @@ files:
 - ext/glfm_markdown/src/lib.rs
 - ext/glfm_markdown/src/main.rs
 - lib/glfm_markdown.rb
+- lib/glfm_markdown/loader.rb
 - lib/glfm_markdown/version.rb
 homepage: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown
-licenses: []
+licenses:
+- MIT
 metadata:
   homepage_uri: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown
   source_code_uri: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown
-  changelog_uri: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/blob/main/CHANGELOG.md
+  changelog_uri: https://gitlab.com/gitlab-org/ruby/gems/gitlab-glfm-markdown/-/releases
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -112,14 +114,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.33
+      version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: GLFM Markdown