qiita_marker 0.23.2.1 → 0.23.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0579157ad4abb4038246ef4dc4752fd1de6cd281daa619b2ef42adec5b147982'
-  data.tar.gz: c671815ff61ab460fcf6c3a42a614018a250c62ceaa41ee0aa3e899f34c12b16
+  metadata.gz: 15bfc4813af77558d6c0b4ffbb931229e00d558d0c417048b636ce7c27ac31a7
+  data.tar.gz: af9febe461508838d294f9d2d20dfe896c30c467b82b50b36924040c7287c070
 SHA512:
-  metadata.gz: 32f16ce193b82d6a7214c851fdd81126d42d872fdd4508b798ccfc4faba4668793274f88f9ef25e61ae57545041d1062c65169b05cd756eec55df0aa042d0140
-  data.tar.gz: da050452749a3eee8d998db24aa45d6a8b1a282672283e427f8deca374405bfaebe572e954c7906ceb84bea2ff08ad737da05707b2ed5d378158d2738ac0e318
+  metadata.gz: 2fc608ddea2a044b4c64b9f32e8dbc44cf838213f6c67e9457f36fa303b7223a20c932a261e3f21fac256ceab34d018b9c6d9757ce86eecf250a3aefa585407b
+  data.tar.gz: 66b65a1652e9a0904423490cb8999de85d21928f169f72965ca2b90bc32cfadda46193662ebdae70dea6bcb5819a349256a24911f53c65d168bd9285db107968

data/LICENSE.txt

@@ -1,21 +1,23 @@
-MIT License
+Copyright (c) 2015 Garen J. Torikian
+Copyright (c) 2021 Qiita Inc.
 
-Copyright 2021 Qiita Inc.
+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:
+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 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.
+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

@@ -20,6 +20,7 @@ In addition to CommonMarker's options and extensions, the following are availabl
 | Name | Description |
 | --- | --- |
 | `:MENTION_NO_EMPHASIS` | Prevent parsing mentions as emphasis. |
+| `:AUTOLINK_CLASS_NAME` | Append `class="autolink"` to extension's autolinks. |
 
 #### Render options
 
@@ -27,6 +28,7 @@ In addition to CommonMarker's options and extensions, the following are availabl
 | --- | --- |
 | `:CODE_DATA_METADATA` | Use `<code data-metadata>` for fenced code blocks. |
 | `:MENTION_NO_EMPHASIS` | Prevent parsing mentions as emphasis. |
+| `:AUTOLINK_CLASS_NAME` | Append `class="autolink"` to extension's autolinks. |
 
 ### Original extensions
 

data/Rakefile

@@ -1,113 +1,114 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'rake/clean'
-require 'rake/extensiontask'
-require 'digest/md5'
+require "date"
+require "rake/clean"
+require "rake/extensiontask"
+require "digest/md5"
 
-host_os = RbConfig::CONFIG['host_os']
-require 'devkit' if host_os == 'mingw32'
+host_os = RbConfig::CONFIG["host_os"]
+require "devkit" if host_os == "mingw32"
 
 task default: [:test]
 
 # Gem Spec
-gem_spec = Gem::Specification.load('qiita_marker.gemspec')
+gem_spec = Gem::Specification.load("qiita_marker.gemspec")
 
 # Ruby Extension
-Rake::ExtensionTask.new('qiita_marker', gem_spec) do |ext|
-  ext.lib_dir = File.join('lib', 'qiita_marker')
+Rake::ExtensionTask.new("qiita_marker", gem_spec) do |ext|
+  ext.lib_dir = File.join("lib", "qiita_marker")
 end
 
 # Packaging
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
 
 # Testing
-require 'rake/testtask'
+require "rake/testtask"
 
-Rake::TestTask.new('test:unit') do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/test_*.rb'
+Rake::TestTask.new("test:unit") do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/test_*.rb"
   t.verbose = true
   t.warning = false
 end
 
-task 'test:unit' => :compile
+desc "Run unit tests"
+task "test:unit" => :compile
 
-desc 'Run unit and conformance tests'
-task test: %w[test:unit]
+desc "Run unit and conformance tests"
+task test: ["test:unit"]
 
-require 'rubocop/rake_task'
+require "rubocop/rake_task"
 
 RuboCop::RakeTask.new(:rubocop)
 
-desc 'Run benchmarks'
+desc "Run benchmarks"
 task :benchmark do
-  if ENV['FETCH_PROGIT']
-    `rm -rf test/progit`
-    `git clone https://github.com/progit/progit.git test/progit`
-    langs = %w[ar az be ca cs de en eo es es-ni fa fi fr hi hu id it ja ko mk nl no-nb pl pt-br ro ru sr th tr uk vi zh zh-tw]
+  if ENV["FETCH_PROGIT"]
+    %x(rm -rf test/progit)
+    %x(git clone https://github.com/progit/progit.git test/progit)
+    langs = ["ar", "az", "be", "ca", "cs", "de", "en", "eo", "es", "es-ni", "fa", "fi", "fr", "hi", "hu", "id", "it", "ja", "ko", "mk", "nl", "no-nb", "pl", "pt-br", "ro", "ru", "sr", "th", "tr", "uk", "vi", "zh", "zh-tw"]
     langs.each do |lang|
-      `cat test/progit/#{lang}/*/*.markdown >> test/benchinput.md`
+      %x(cat test/progit/#{lang}/*/*.markdown >> test/benchinput.md)
     end
   end
-  $LOAD_PATH.unshift 'lib'
-  load 'test/benchmark.rb'
+  $LOAD_PATH.unshift("lib")
+  load "test/benchmark.rb"
 end
 
-desc 'Match C style of cmark'
+desc "Match C style of cmark"
 task :format do
-  sh 'clang-format -style llvm -i ext/qiita_marker/*.c ext/qiita_marker/*.h'
+  sh "clang-format -style llvm -i ext/qiita_marker/*.c ext/qiita_marker/*.h"
 end
 
 # Documentation
-require 'rdoc/task'
+require "rdoc/task"
 
-desc 'Generate API documentation'
+desc "Generate API documentation"
 RDoc::Task.new do |rd|
-  rd.rdoc_dir = 'docs'
-  rd.main     = 'README.md'
-  rd.rdoc_files.include 'README.md', 'lib/**/*.rb', 'ext/qiita_marker/qiita_marker.c'
-
-  rd.options << '--markup tomdoc'
-  rd.options << '--inline-source'
-  rd.options << '--line-numbers'
-  rd.options << '--all'
-  rd.options << '--fileboxes'
+  rd.rdoc_dir = "docs"
+  rd.main     = "README.md"
+  rd.rdoc_files.include("README.md", "lib/**/*.rb", "ext/qiita_marker/qiita_marker.c")
+
+  rd.options << "--markup tomdoc"
+  rd.options << "--inline-source"
+  rd.options << "--line-numbers"
+  rd.options << "--all"
+  rd.options << "--fileboxes"
 end
 
-desc 'Generate the documentation and run a web server'
+desc "Generate the documentation and run a web server"
 task serve: [:rdoc] do
-  require 'webrick'
+  require "webrick"
 
-  puts 'Navigate to http://localhost:3000 to see the docs'
+  puts "Navigate to http://localhost:3000 to see the docs"
 
-  server = WEBrick::HTTPServer.new Port: 3000
-  server.mount '/', WEBrick::HTTPServlet::FileHandler, 'docs'
-  trap('INT') { server.stop }
+  server = WEBrick::HTTPServer.new(Port: 3000)
+  server.mount("/", WEBrick::HTTPServlet::FileHandler, "docs")
+  trap("INT") { server.stop }
   server.start
 end
 
-desc 'Generate and publish docs to gh-pages'
+desc "Generate and publish docs to gh-pages"
 task publish: [:rdoc] do
-  require 'tmpdir'
-  require 'shellwords'
+  require "tmpdir"
+  require "shellwords"
 
   Dir.mktmpdir do |tmp|
     system "mv docs/* #{tmp}"
-    system 'git checkout origin/gh-pages'
-    system 'rm -rf *'
+    system "git checkout origin/gh-pages"
+    system "rm -rf *"
     system "mv #{tmp}/* ."
     message = Shellwords.escape("Site updated at #{Time.now.utc}")
-    system 'git add .'
+    system "git add ."
     system "git commit -am #{message}"
-    system 'git push origin gh-pages --force'
-    system 'git checkout master'
-    system 'echo yolo'
+    system "git push origin gh-pages --force"
+    system "git checkout master"
+    system "echo yolo"
   end
 end
 
 # Custom tasks
-Dir.glob('tasks/*.rake').each do |f|
+Dir.glob("tasks/*.rake").each do |f|
   load f
 end

data/bin/qiita_marker

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require 'optparse'
-require 'ostruct'
 
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 require 'qiita_marker'
@@ -11,17 +10,13 @@ root = File.expand_path('..', __dir__)
 $LOAD_PATH.unshift File.expand_path('lib', root)
 
 def parse_options
-  options = OpenStruct.new
+  options = Struct.new(:active_extensions, :active_parse_options, :active_render_options, :output_format, :renderer)
+                  .new([], [:DEFAULT], [:DEFAULT], :html)
   extensions = QiitaMarker.extensions
   parse_options = QiitaMarker::Config::OPTS.fetch(:parse)
   render_options = QiitaMarker::Config::OPTS.fetch(:render)
   format_options = QiitaMarker::Config::OPTS.fetch(:format)
 
-  options.active_extensions = []
-  options.active_parse_options = [:DEFAULT]
-  options.active_render_options = [:DEFAULT]
-  options.output_format = :html
-
   option_parser = OptionParser.new do |opts|
     opts.banner = 'Usage: qiita_marker [--html-renderer] [--extension=EXTENSION]'
     opts.separator '                    [--to=FORMAT]'

data/ext/qiita_marker/autolink.c

@@ -1,5 +1,9 @@
 #include "autolink.h"
+#include "houdini.h"
+#include "qfm.h"
+#include "scanners.h"
 #include <parser.h>
+#include <render.h>
 #include <string.h>
 #include <utf8.h>
 
@@ -9,6 +13,11 @@
 #include <strings.h>
 #endif
 
+static void escape_html(cmark_strbuf *dest, const unsigned char *source,
+                        bufsize_t length) {
+  houdini_escape_html0(dest, source, length, 0);
+}
+
 static int is_valid_hostchar(const uint8_t *link, size_t link_len) {
   int32_t ch;
   int r = cmark_utf8proc_iterate(link, (bufsize_t)link_len, &ch);
@@ -144,7 +153,8 @@ static size_t check_domain(uint8_t *data, size_t size, int allow_short) {
 }
 
 static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
-                             cmark_inline_parser *inline_parser) {
+                             cmark_inline_parser *inline_parser,
+                             cmark_syntax_extension *ext) {
   cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
   size_t max_rewind = cmark_inline_parser_get_offset(inline_parser);
   uint8_t *data = chunk->data + max_rewind;
@@ -176,6 +186,9 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
   cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(node, ext);
+  }
 
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
@@ -199,7 +212,8 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
 }
 
 static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
-                             cmark_inline_parser *inline_parser) {
+                             cmark_inline_parser *inline_parser,
+                             cmark_syntax_extension *ext) {
   size_t link_end, domain_len;
   int rewind = 0;
 
@@ -237,6 +251,9 @@ static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
   cmark_node_unput(parent, rewind);
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(node, ext);
+  }
 
   cmark_chunk url = cmark_chunk_dup(chunk, max_rewind - rewind,
                                     (bufsize_t)(link_end + rewind));
@@ -257,10 +274,10 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
     return NULL;
 
   if (c == ':')
-    return url_match(parser, parent, inline_parser);
+    return url_match(parser, parent, inline_parser, ext);
 
   if (c == 'w')
-    return www_match(parser, parent, inline_parser);
+    return www_match(parser, parent, inline_parser, ext);
 
   return NULL;
 
@@ -269,7 +286,8 @@ static cmark_node *match(cmark_syntax_extension *ext, cmark_parser *parser,
   // inline was finished in inlines.c.
 }
 
-static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset, int depth) {
+static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
+                             int depth, cmark_syntax_extension *ext) {
   // postprocess_text can recurse very deeply if there is a very long line of
   // '@' only.  Stop at a reasonable depth to ensure it cannot crash.
   if (depth > 1000) return;
@@ -311,7 +329,7 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   }
 
   if (rewind == 0 || ns > 0) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
@@ -331,20 +349,23 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
 
   if (link_end < 2 || nb != 1 || np == 0 ||
       (!cmark_isalpha(data[link_end - 1]) && data[link_end - 1] != '.')) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
   link_end = autolink_delim(data, link_end);
 
   if (link_end == 0) {
-    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1);
+    postprocess_text(parser, text, max_rewind + 1 + offset, depth + 1, ext);
     return;
   }
 
   cmark_chunk_to_cstr(parser->mem, &text->as.literal);
 
   cmark_node *link_node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
+  if (parser->options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+    cmark_node_set_syntax_extension(link_node, ext);
+  }
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
   cmark_strbuf_puts(&buf, "mailto:");
@@ -373,7 +394,7 @@ static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset,
   text->as.literal.len = offset + max_rewind - rewind;
   text->as.literal.data[text->as.literal.len] = 0;
 
-  postprocess_text(parser, post, 0, depth + 1);
+  postprocess_text(parser, post, 0, depth + 1, ext);
 }
 
 static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser, cmark_node *root) {
@@ -400,7 +421,7 @@ static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser
     }
 
     if (ev == CMARK_EVENT_ENTER && node->type == CMARK_NODE_TEXT) {
-      postprocess_text(parser, node, 0, /*depth*/0);
+      postprocess_text(parser, node, 0, /*depth*/ 0, ext);
     }
   }
 
@@ -409,12 +430,38 @@ static cmark_node *postprocess(cmark_syntax_extension *ext, cmark_parser *parser
   return root;
 }
 
+static void html_render(cmark_syntax_extension *extension,
+                        cmark_html_renderer *renderer, cmark_node *node,
+                        cmark_event_type ev_type, int options) {
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  cmark_strbuf *html = renderer->html;
+
+  if (entering) {
+    cmark_strbuf_puts(html, "<a href=\"");
+    if ((options & CMARK_OPT_UNSAFE) ||
+        !(scan_dangerous_url(&node->as.link.url, 0))) {
+      houdini_escape_href(html, node->as.link.url.data, node->as.link.url.len);
+    }
+    if (node->as.link.title.len) {
+      cmark_strbuf_puts(html, "\" title=\"");
+      escape_html(html, node->as.link.title.data, node->as.link.title.len);
+    }
+    if (options & CMARK_OPT_AUTOLINK_CLASS_NAME) {
+      cmark_strbuf_puts(html, "\" class=\"autolink");
+    }
+    cmark_strbuf_puts(html, "\">");
+  } else {
+    cmark_strbuf_puts(html, "</a>");
+  }
+}
+
 cmark_syntax_extension *create_autolink_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("autolink");
   cmark_llist *special_chars = NULL;
 
   cmark_syntax_extension_set_match_inline_func(ext, match);
   cmark_syntax_extension_set_postprocess_func(ext, postprocess);
+  cmark_syntax_extension_set_html_render_func(ext, html_render);
 
   cmark_mem *mem = cmark_get_default_mem_allocator();
   special_chars = cmark_llist_append(mem, special_chars, (void *)':');

data/ext/qiita_marker/cmark-gfm_version.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_GFM_VERSION_H
 #define CMARK_GFM_VERSION_H
 
-#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 2)
-#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.2"
+#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 4)
+#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.4"
 
 #endif

data/ext/qiita_marker/html.c

@@ -227,7 +227,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_puts(html, "><code data-metadata=\"");
-        escape_html(html, node->as.code.info.data, first_tag);
+        escape_html(html, node->as.code.info.data, node->as.code.info.len);
         if (first_tag < node->as.code.info.len &&
             (options & CMARK_OPT_FULL_INFO_STRING)) {
           cmark_strbuf_puts(html, "\" data-meta=\"");

data/ext/qiita_marker/qfm.h

@@ -12,6 +12,9 @@ extern "C" {
 /* Prevent parsing Qiita-style Mentions as emphasis. */
 #define CMARK_OPT_MENTION_NO_EMPHASIS (1 << 26)
 
+/* Render autolinks with class name  */
+#define CMARK_OPT_AUTOLINK_CLASS_NAME (1 << 27)
+
 #ifdef __cplusplus
 }
 #endif

data/ext/qiita_marker/qfm_custom_block.c

@@ -157,20 +157,7 @@ static int can_contain(cmark_syntax_extension *self, cmark_node *node,
                        cmark_node_type child_type) {
   cmark_node_type node_type = cmark_node_get_type(node);
 
-  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
-    return
-        // Block
-        child_type == CMARK_NODE_LIST || child_type == CMARK_NODE_PARAGRAPH ||
-        // Inline
-        child_type == CMARK_NODE_TEXT || child_type == CMARK_NODE_CODE ||
-        child_type == CMARK_NODE_HTML_INLINE || child_type == CMARK_NODE_EMPH ||
-        child_type == CMARK_NODE_STRONG || child_type == CMARK_NODE_LINK ||
-        child_type == CMARK_NODE_IMAGE ||
-        child_type == CMARK_NODE_FOOTNOTE_REFERENCE ||
-        child_type == CMARK_NODE_STRIKETHROUGH;
-  }
-
-  return 0;
+  return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
 }
 
 static int contains_inlines(cmark_syntax_extension *self, cmark_node *node) {

data/ext/qiita_marker/qfm_mention_no_emphasis.c

@@ -1,5 +1,5 @@
-#include "cmark_ctype.h"
 #include "cmark-gfm.h"
+#include "cmark_ctype.h"
 #include "config.h"
 
 static bool is_wordchar(char c) {