qiita_marker 0.23.2.2 → 0.23.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15d5d73e2386cf310ae997adc33bfca334a51c241a0345b8d5fddc2af9a988bf
-  data.tar.gz: c45e0c3f30cfd5dfad5d8beb4dc0f3ee08fc6bb405e2dfb188623393180fa104
+  metadata.gz: 343d2a549df9aee75c4bb3890307425d9a82251a2dfe46826afd6f8a8bfcb245
+  data.tar.gz: bf76c480df59b28e13cace472228b3ca39a60d9ce3406a866125f347c18689c1
 SHA512:
-  metadata.gz: 88d95a7228008d65a57f13d571370c3fe9a3701319e2e6a801a16659c032646d592345e155a23a8ac4f70b8d87a347b152a72b8447399c73285f2b475e3426d5
-  data.tar.gz: b3a3a996bfac4705044451fee3ecd7cd29909de05b3a1c9b52f64e9cc9cf14497820b8a74f67f49225c7ab777d87a83e9a0da104fa15219df03a3efb1c054a66
+  metadata.gz: 0c8c25dda4cadad88e855c84fa02d42de53c54c87665ca6b5530483a78b57e100b3df9869fe1f451faf16679a5de3ed7c6f630c9568258fdb559fd0d255cb2e2
+  data.tar.gz: d0927839957a98673181f2235f8a4e16a6ddfc2fa5bb88259d0cb7723bf925472e8214f98aa5ede40a24d3420af48b8b8e877472278efeb683eba80c171edd92

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/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/blocks.c

@@ -22,6 +22,7 @@
 #include "houdini.h"
 #include "buffer.h"
 #include "footnotes.h"
+#include "qfm_custom_block.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -289,7 +290,9 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
     b->end_column = parser->last_line_length;
   } else if (S_type(b) == CMARK_NODE_DOCUMENT ||
              (S_type(b) == CMARK_NODE_CODE_BLOCK && b->as.code.fenced) ||
-             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext)) {
+             (S_type(b) == CMARK_NODE_HEADING && b->as.heading.setext) ||
+             /* For make the sourcepos of the `qfm_custom_block` accurate */
+             (cmark_node_get_type(b) == CMARK_NODE_QFM_CUSTOM_BLOCK)) {
     b->end_line = parser->line_number;
     b->end_column = parser->curline.size;
     if (b->end_column && parser->curline.ptr[b->end_column - 1] == '\n')

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/qfm_custom_block.c

@@ -6,14 +6,13 @@
 #include "houdini.h"
 #include "qfm_custom_block.h"
 #include "qfm_scanners.h"
-#include "strikethrough.h"
 
 cmark_node_type CMARK_NODE_QFM_CUSTOM_BLOCK;
 
 typedef struct {
+  /* info: Text following the opening custom block fence (optional). This is
+   * trimmed of leading and trailing whitespace. */
   cmark_chunk info;
-  bool opening;
-  cmark_strbuf *xml_attr_buff;
 } node_qfm_custom_block;
 
 static void escape_html(cmark_strbuf *dest, const unsigned char *source,
@@ -21,33 +20,6 @@ static void escape_html(cmark_strbuf *dest, const unsigned char *source,
   houdini_escape_html0(dest, source, length, 0);
 }
 
-static bool get_qfm_custom_block_opening(cmark_node *node) {
-  if (node == NULL) {
-    return false;
-  }
-
-  cmark_node_type node_type = cmark_node_get_type(node);
-  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
-    return ((node_qfm_custom_block *)node->as.opaque)->opening;
-  } else {
-    return false;
-  }
-}
-
-static bool set_qfm_custom_block_opening(cmark_node *node, bool opening) {
-  if (node == NULL) {
-    return false;
-  }
-
-  cmark_node_type node_type = cmark_node_get_type(node);
-  if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
-    ((node_qfm_custom_block *)node->as.opaque)->opening = opening;
-    return true;
-  } else {
-    return false;
-  }
-}
-
 static cmark_chunk *get_qfm_custom_block_info(cmark_node *node) {
   if (node == NULL) {
     return NULL;
@@ -81,26 +53,21 @@ static void free_node_qfm_custom_block(cmark_mem *mem, void *ptr) {
   node_qfm_custom_block *cb = (node_qfm_custom_block *)ptr;
 
   cmark_chunk_free(mem, &cb->info);
-  cmark_strbuf_free(cb->xml_attr_buff);
   mem->free(cb);
 }
 
+/* Now, a custom block can contain another custom block, but this behavior is
+ * not a specification. */
 static int matches(cmark_syntax_extension *self, cmark_parser *parser,
                    unsigned char *input, int len,
                    cmark_node *parent_container) {
-  int res = 0;
-
-  if (get_qfm_custom_block_opening(parent_container)) {
-    bufsize_t matched = scan_close_qfm_custom_block_fence(
-        input, len, cmark_parser_get_first_nonspace(parser));
+  int res = 1;
+  bufsize_t matched = scan_close_qfm_custom_block_fence(
+      input, len, cmark_parser_get_first_nonspace(parser));
 
-    if (matched > 0) {
-      set_qfm_custom_block_opening(parent_container, false);
-      cmark_parser_advance_offset(parser, (char *)input,
-                                  len - cmark_parser_get_offset(parser), 0);
-    } else {
-      res = 1;
-    }
+  if (matched > 0) {
+    cmark_parser_advance_offset(parser, (char *)input, matched, 0);
+    res = 0;
   }
 
   return res;
@@ -120,21 +87,34 @@ static cmark_node *try_opening_qfm_custom_block_block(
 
     cmark_node *custom_block_node = cmark_parser_add_child(
         parser, parent_container, CMARK_NODE_QFM_CUSTOM_BLOCK,
-        parser->first_nonspace_column);
+        parser->first_nonspace + 1);
     custom_block_node->as.opaque = (node_qfm_custom_block *)parser->mem->calloc(
         1, sizeof(node_qfm_custom_block));
 
     cmark_strbuf *info = parser->mem->calloc(1, sizeof(cmark_strbuf));
-    cmark_strbuf_init(parser->mem, info, len - matched);
-    cmark_strbuf_put(info, input + matched, len - matched);
-    cmark_strbuf_trim(info);
+    bufsize_t info_startpos = cmark_parser_get_first_nonspace(parser) + matched;
+
+    /* Length from after opening custom block fence to before newline character.
+     */
+    bufsize_t info_len = len - info_startpos;
+    if (info_len > 0 && input[len - 1] == '\n') {
+      info_len -= 1;
+    }
+    if (info_len > 0 && input[len - 1] == '\r') {
+      info_len -= 1;
+    }
 
-    set_qfm_custom_block_opening(custom_block_node, true);
+    cmark_strbuf_init(parser->mem, info, info_len);
+    cmark_strbuf_put(info, input + info_startpos, info_len);
+    cmark_strbuf_trim(info);
     set_qfm_custom_block_info(custom_block_node, (char *)info->ptr);
 
     cmark_node_set_syntax_extension(custom_block_node, self);
     cmark_parser_advance_offset(parser, (char *)input,
-                                len - cmark_parser_get_offset(parser), 0);
+                                cmark_parser_get_first_nonspace(parser) +
+                                    matched + info_len -
+                                    cmark_parser_get_offset(parser),
+                                0);
 
     return custom_block_node;
   }
@@ -155,12 +135,14 @@ static const char *get_type_string(cmark_syntax_extension *self,
 
 static int can_contain(cmark_syntax_extension *self, cmark_node *node,
                        cmark_node_type child_type) {
+  /* Can contain all block nodes */
   cmark_node_type node_type = cmark_node_get_type(node);
 
   return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
 }
 
 static int contains_inlines(cmark_syntax_extension *self, cmark_node *node) {
+  /* Can contain all inline nodes */
   cmark_node_type node_type = cmark_node_get_type(node);
 
   return node_type == CMARK_NODE_QFM_CUSTOM_BLOCK;
@@ -210,9 +192,8 @@ static const char *xml_attr(cmark_syntax_extension *self, cmark_node *node) {
   if (node_type == CMARK_NODE_QFM_CUSTOM_BLOCK) {
     cmark_chunk *info = get_qfm_custom_block_info(node);
     cmark_mem *mem = node->content.mem;
-
     cmark_strbuf *xml_attr_buff = mem->calloc(1, sizeof(cmark_strbuf));
-    ((node_qfm_custom_block *)node->as.opaque)->xml_attr_buff = xml_attr_buff;
+
     cmark_strbuf_init(
         mem, xml_attr_buff,
         17 + info->len); // `17` is length of ` data-metadata="` and `"`.
@@ -220,7 +201,7 @@ static const char *xml_attr(cmark_syntax_extension *self, cmark_node *node) {
     cmark_strbuf_puts(xml_attr_buff, (char *)info->data);
     cmark_strbuf_putc(xml_attr_buff, '"');
 
-    return (char *)xml_attr_buff->ptr;
+    return (char *)cmark_strbuf_detach(xml_attr_buff);
   }
 
   return NULL;

data/ext/qiita_marker/qiita_marker.c

@@ -115,25 +115,23 @@ static void rb_parent_removed(VALUE val) {
   RDATA(val)->dfree = rb_free_c_struct;
 }
 
-static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark_mem *mem) {
+static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions) {
   int options;
-  int extensions_len;
   VALUE rb_ext_name;
   int i;
 
-  Check_Type(rb_options, T_FIXNUM);
+  FIXNUM_P(rb_options);
+  options = FIX2INT(rb_options);
+
   Check_Type(rb_extensions, T_ARRAY);
 
-  options = FIX2INT(rb_options);
-  extensions_len = RARRAY_LEN(rb_extensions);
+  cmark_parser *parser = cmark_parser_new(options);
 
-  cmark_parser *parser = cmark_parser_new_with_mem(options, mem);
-  for (i = 0; i < extensions_len; ++i) {
-    rb_ext_name = RARRAY_PTR(rb_extensions)[i];
+  for (i = 0; i < RARRAY_LEN(rb_extensions); ++i) {
+    rb_ext_name = rb_ary_entry(rb_extensions, i);
 
     if (!SYMBOL_P(rb_ext_name)) {
       cmark_parser_free(parser);
-      cmark_arena_reset();
       rb_raise(rb_eTypeError, "extension names should be Symbols; got a %"PRIsVALUE"", rb_obj_class(rb_ext_name));
     }
 
@@ -142,7 +140,6 @@ static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark
 
     if (!syntax_extension) {
       cmark_parser_free(parser);
-      cmark_arena_reset();
       rb_raise(rb_eArgError, "extension %s not found", rb_id2name(SYM2ID(rb_ext_name)));
     }
 
@@ -157,33 +154,28 @@ static cmark_parser *prepare_parser(VALUE rb_options, VALUE rb_extensions, cmark
  *
  */
 static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) {
-  char *str, *html;
-  int len;
+  char *html;
   cmark_parser *parser;
   cmark_node *doc;
-  Check_Type(rb_text, T_STRING);
-  Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_arena_mem_allocator());
+  Check_Type(rb_text, T_STRING);
 
-  str = (char *)RSTRING_PTR(rb_text);
-  len = RSTRING_LEN(rb_text);
+  parser = prepare_parser(rb_options, rb_extensions);
 
-  cmark_parser_feed(parser, str, len);
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
   doc = cmark_parser_finish(parser);
+
   if (doc == NULL) {
-    cmark_arena_reset();
+    cmark_parser_free(parser);
     rb_raise(rb_eNodeError, "error parsing document");
   }
 
-  cmark_mem *default_mem = cmark_get_default_mem_allocator();
-  html = cmark_render_html_with_mem(doc, FIX2INT(rb_options), parser->syntax_extensions, default_mem);
-  cmark_arena_reset();
+  html = cmark_render_html(doc, parser->options, parser->syntax_extensions);
 
-  VALUE ruby_html = rb_str_new2(html);
-  default_mem->free(html);
+  cmark_parser_free(parser);
+  cmark_node_free(doc);
 
-  return ruby_html;
+  return rb_utf8_str_new_cstr(html);
 }
 
 /*
@@ -191,33 +183,28 @@ static VALUE rb_markdown_to_html(VALUE self, VALUE rb_text, VALUE rb_options, VA
  *
  */
 static VALUE rb_markdown_to_xml(VALUE self, VALUE rb_text, VALUE rb_options, VALUE rb_extensions) {
-  char *str, *xml;
-  int len;
+  char *xml;
   cmark_parser *parser;
   cmark_node *doc;
-  Check_Type(rb_text, T_STRING);
-  Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_arena_mem_allocator());
+  Check_Type(rb_text, T_STRING);
 
-  str = (char *)RSTRING_PTR(rb_text);
-  len = RSTRING_LEN(rb_text);
+  parser = prepare_parser(rb_options, rb_extensions);
 
-  cmark_parser_feed(parser, str, len);
+  cmark_parser_feed(parser, StringValuePtr(rb_text), RSTRING_LEN(rb_text));
   doc = cmark_parser_finish(parser);
+
   if (doc == NULL) {
-    cmark_arena_reset();
+    cmark_parser_free(parser);
     rb_raise(rb_eNodeError, "error parsing document");
   }
 
-  cmark_mem *default_mem = cmark_get_default_mem_allocator();
-  xml = cmark_render_xml_with_mem(doc, FIX2INT(rb_options), default_mem);
-  cmark_arena_reset();
+  xml = cmark_render_xml(doc, parser->options);
 
-  VALUE ruby_xml = rb_str_new2(xml);
-  default_mem->free(xml);
+  cmark_parser_free(parser);
+  cmark_node_free(doc);
 
-  return ruby_xml;
+  return rb_utf8_str_new_cstr(xml);
 }
 
 /*
@@ -308,18 +295,17 @@ static VALUE rb_node_new(VALUE self, VALUE type) {
 static VALUE rb_parse_document(VALUE self, VALUE rb_text, VALUE rb_len,
                                VALUE rb_options, VALUE rb_extensions) {
   char *text;
-  int len, options;
+  int len;
   cmark_parser *parser;
   cmark_node *doc;
   Check_Type(rb_text, T_STRING);
   Check_Type(rb_len, T_FIXNUM);
   Check_Type(rb_options, T_FIXNUM);
 
-  parser = prepare_parser(rb_options, rb_extensions, cmark_get_default_mem_allocator());
+  parser = prepare_parser(rb_options, rb_extensions);
 
   text = (char *)RSTRING_PTR(rb_text);
   len = FIX2INT(rb_len);
-  options = FIX2INT(rb_options);
 
   cmark_parser_feed(parser, text, len);
   doc = cmark_parser_finish(parser);
@@ -614,7 +600,6 @@ static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
  */
 static VALUE rb_render_xml(VALUE self, VALUE rb_options) {
   int options;
-  int i;
   cmark_node *node;
   Check_Type(rb_options, T_FIXNUM);
 
@@ -1270,6 +1255,7 @@ __attribute__((visibility("default"))) void Init_qiita_marker() {
   rb_define_singleton_method(module, "extensions", rb_extensions, 0);
   rb_eNodeError = rb_define_class_under(module, "NodeError", rb_eStandardError);
   rb_cNode = rb_define_class_under(module, "Node", rb_cObject);
+  rb_undef_alloc_func(rb_cNode);
   rb_define_singleton_method(rb_cNode, "markdown_to_html", rb_markdown_to_html,
                              3);
   rb_define_singleton_method(rb_cNode, "markdown_to_xml", rb_markdown_to_xml,