commonmarker 0.23.7.pre1 → 1.0.0.pre.2

data/ext/commonmarker/xml.c

@@ -1,181 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-#include "config.h"
-#include "cmark-gfm.h"
-#include "node.h"
-#include "buffer.h"
-#include "houdini.h"
-#include "syntax_extension.h"
-
-#define BUFFER_SIZE 100
-
-// Functions to convert cmark_nodes to XML strings.
-
-static void escape_xml(cmark_strbuf *dest, const unsigned char *source,
-                       bufsize_t length) {
-  houdini_escape_html0(dest, source, length, 0);
-}
-
-struct render_state {
-  cmark_strbuf *xml;
-  int indent;
-};
-
-static CMARK_INLINE void indent(struct render_state *state) {
-  int i;
-  for (i = 0; i < state->indent; i++) {
-    cmark_strbuf_putc(state->xml, ' ');
-  }
-}
-
-static int S_render_node(cmark_node *node, cmark_event_type ev_type,
-                         struct render_state *state, int options) {
-  cmark_strbuf *xml = state->xml;
-  bool literal = false;
-  cmark_delim_type delim;
-  bool entering = (ev_type == CMARK_EVENT_ENTER);
-  char buffer[BUFFER_SIZE];
-
-  if (entering) {
-    indent(state);
-    cmark_strbuf_putc(xml, '<');
-    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
-
-    if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) {
-      snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"",
-               node->start_line, node->start_column, node->end_line,
-               node->end_column);
-      cmark_strbuf_puts(xml, buffer);
-    }
-
-    if (node->extension && node->extension->xml_attr_func) {
-      const char* r = node->extension->xml_attr_func(node->extension, node);
-      if (r != NULL)
-        cmark_strbuf_puts(xml, r);
-    }
-
-    literal = false;
-
-    switch (node->type) {
-    case CMARK_NODE_DOCUMENT:
-      cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\"");
-      break;
-    case CMARK_NODE_TEXT:
-    case CMARK_NODE_CODE:
-    case CMARK_NODE_HTML_BLOCK:
-    case CMARK_NODE_HTML_INLINE:
-      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
-      escape_xml(xml, node->as.literal.data, node->as.literal.len);
-      cmark_strbuf_puts(xml, "</");
-      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
-      literal = true;
-      break;
-    case CMARK_NODE_LIST:
-      switch (cmark_node_get_list_type(node)) {
-      case CMARK_ORDERED_LIST:
-        cmark_strbuf_puts(xml, " type=\"ordered\"");
-        snprintf(buffer, BUFFER_SIZE, " start=\"%d\"",
-                 cmark_node_get_list_start(node));
-        cmark_strbuf_puts(xml, buffer);
-        delim = cmark_node_get_list_delim(node);
-        if (delim == CMARK_PAREN_DELIM) {
-          cmark_strbuf_puts(xml, " delim=\"paren\"");
-        } else if (delim == CMARK_PERIOD_DELIM) {
-          cmark_strbuf_puts(xml, " delim=\"period\"");
-        }
-        break;
-      case CMARK_BULLET_LIST:
-        cmark_strbuf_puts(xml, " type=\"bullet\"");
-        break;
-      default:
-        break;
-      }
-      snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"",
-               (cmark_node_get_list_tight(node) ? "true" : "false"));
-      cmark_strbuf_puts(xml, buffer);
-      break;
-    case CMARK_NODE_HEADING:
-      snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level);
-      cmark_strbuf_puts(xml, buffer);
-      break;
-    case CMARK_NODE_CODE_BLOCK:
-      if (node->as.code.info.len > 0) {
-        cmark_strbuf_puts(xml, " info=\"");
-        escape_xml(xml, node->as.code.info.data, node->as.code.info.len);
-        cmark_strbuf_putc(xml, '"');
-      }
-      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
-      escape_xml(xml, node->as.code.literal.data, node->as.code.literal.len);
-      cmark_strbuf_puts(xml, "</");
-      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
-      literal = true;
-      break;
-    case CMARK_NODE_CUSTOM_BLOCK:
-    case CMARK_NODE_CUSTOM_INLINE:
-      cmark_strbuf_puts(xml, " on_enter=\"");
-      escape_xml(xml, node->as.custom.on_enter.data,
-                 node->as.custom.on_enter.len);
-      cmark_strbuf_putc(xml, '"');
-      cmark_strbuf_puts(xml, " on_exit=\"");
-      escape_xml(xml, node->as.custom.on_exit.data,
-                 node->as.custom.on_exit.len);
-      cmark_strbuf_putc(xml, '"');
-      break;
-    case CMARK_NODE_LINK:
-    case CMARK_NODE_IMAGE:
-      cmark_strbuf_puts(xml, " destination=\"");
-      escape_xml(xml, node->as.link.url.data, node->as.link.url.len);
-      cmark_strbuf_putc(xml, '"');
-      cmark_strbuf_puts(xml, " title=\"");
-      escape_xml(xml, node->as.link.title.data, node->as.link.title.len);
-      cmark_strbuf_putc(xml, '"');
-      break;
-    default:
-      break;
-    }
-    if (node->first_child) {
-      state->indent += 2;
-    } else if (!literal) {
-      cmark_strbuf_puts(xml, " /");
-    }
-    cmark_strbuf_puts(xml, ">\n");
-
-  } else if (node->first_child) {
-    state->indent -= 2;
-    indent(state);
-    cmark_strbuf_puts(xml, "</");
-    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
-    cmark_strbuf_puts(xml, ">\n");
-  }
-
-  return 1;
-}
-
-char *cmark_render_xml(cmark_node *root, int options) {
-  return cmark_render_xml_with_mem(root, options, cmark_node_mem(root));
-}
-
-char *cmark_render_xml_with_mem(cmark_node *root, int options, cmark_mem *mem) {
-  char *result;
-  cmark_strbuf xml = CMARK_BUF_INIT(mem);
-  cmark_event_type ev_type;
-  cmark_node *cur;
-  struct render_state state = {&xml, 0};
-
-  cmark_iter *iter = cmark_iter_new(root);
-
-  cmark_strbuf_puts(state.xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
-  cmark_strbuf_puts(state.xml,
-                    "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n");
-  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
-    cur = cmark_iter_get_node(iter);
-    S_render_node(cur, ev_type, &state, options);
-  }
-  result = (char *)cmark_strbuf_detach(&xml);
-
-  cmark_iter_free(iter);
-  return result;
-}

data/lib/commonmarker/node/inspect.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "pp"
-
-module CommonMarker
-  class Node
-    module Inspect
-      PP_INDENT_SIZE = 2
-
-      def inspect
-        PP.pp(self, +"", Float::INFINITY)
-      end
-
-      # @param printer [PrettyPrint] pp
-      def pretty_print(printer)
-        printer.group(PP_INDENT_SIZE, "#<#{self.class}(#{type}):", ">") do
-          printer.breakable
-
-          attrs = [:sourcepos, :string_content, :url, :title, :header_level, :list_type, :list_start, :list_tight, :fence_info].map do |name|
-            [name, __send__(name)]
-          rescue NodeError
-            nil
-          end.compact
-
-          printer.seplist(attrs) do |name, value|
-            printer.text("#{name}=")
-            printer.pp(value)
-          end
-
-          if first_child
-            printer.breakable
-            printer.group(PP_INDENT_SIZE) do
-              children = []
-              node = first_child
-              while node
-                children << node
-                node = node.next
-              end
-              printer.text("children=")
-              printer.pp(children)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/commonmarker/node.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "commonmarker/node/inspect"
-
-module CommonMarker
-  class Node
-    include Enumerable
-    include Inspect
-
-    # Public: An iterator that "walks the tree," descending into children recursively.
-    #
-    # blk - A {Proc} representing the action to take for each child
-    def walk(&block)
-      return enum_for(:walk) unless block
-
-      yield self
-      each do |child|
-        child.walk(&block)
-      end
-    end
-
-    # Public: Convert the node to an HTML string.
-    #
-    # options - A {Symbol} or {Array of Symbol}s indicating the render options
-    # extensions - An {Array of Symbol}s indicating the extensions to use
-    #
-    # Returns a {String}.
-    def to_html(options = :DEFAULT, extensions = [])
-      opts = Config.process_options(options, :render)
-      _render_html(opts, extensions).force_encoding("utf-8")
-    end
-
-    # Public: Convert the node to an XML string.
-    #
-    # options - A {Symbol} or {Array of Symbol}s indicating the render options
-    #
-    # Returns a {String}.
-    def to_xml(options = :DEFAULT)
-      opts = Config.process_options(options, :render)
-      _render_xml(opts).force_encoding("utf-8")
-    end
-
-    # Public: Convert the node to a CommonMark string.
-    #
-    # options - A {Symbol} or {Array of Symbol}s indicating the render options
-    # width - Column to wrap the output at
-    #
-    # Returns a {String}.
-    def to_commonmark(options = :DEFAULT, width = 120)
-      opts = Config.process_options(options, :render)
-      _render_commonmark(opts, width).force_encoding("utf-8")
-    end
-
-    # Public: Convert the node to a plain text string.
-    #
-    # options - A {Symbol} or {Array of Symbol}s indicating the render options
-    # width - Column to wrap the output at
-    #
-    # Returns a {String}.
-    def to_plaintext(options = :DEFAULT, width = 120)
-      opts = Config.process_options(options, :render)
-      _render_plaintext(opts, width).force_encoding("utf-8")
-    end
-
-    # Public: Iterate over the children (if any) of the current pointer.
-    def each
-      return enum_for(:each) unless block_given?
-
-      child = first_child
-      while child
-        nextchild = child.next
-        yield child
-        child = nextchild
-      end
-    end
-
-    # Deprecated: Please use `each` instead
-    def each_child(&block)
-      warn("[DEPRECATION] `each_child` is deprecated.  Please use `each` instead.")
-      each(&block)
-    end
-  end
-end

data/lib/commonmarker/renderer/html_renderer.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-module CommonMarker
-  class HtmlRenderer < Renderer
-    def document(_)
-      super
-      out("</ol>\n</section>\n") if @written_footnote_ix
-    end
-
-    def header(node)
-      block do
-        out("<h", node.header_level, "#{sourcepos(node)}>", :children,
-          "</h", node.header_level, ">")
-      end
-    end
-
-    def paragraph(node)
-      if @in_tight && node.parent.type != :blockquote
-        out(:children)
-      else
-        block do
-          container("<p#{sourcepos(node)}>", "</p>") do
-            out(:children)
-            if node.parent.type == :footnote_definition && node.next.nil?
-              out(" ")
-              out_footnote_backref
-            end
-          end
-        end
-      end
-    end
-
-    def list(node)
-      old_in_tight = @in_tight
-      @in_tight = node.list_tight
-
-      block do
-        if node.list_type == :bullet_list
-          container("<ul#{sourcepos(node)}>\n", "</ul>") do
-            out(:children)
-          end
-        else
-          start = if node.list_start == 1
-            "<ol#{sourcepos(node)}>\n"
-          else
-            "<ol start=\"#{node.list_start}\"#{sourcepos(node)}>\n"
-          end
-          container(start, "</ol>") do
-            out(:children)
-          end
-        end
-      end
-
-      @in_tight = old_in_tight
-    end
-
-    def list_item(node)
-      block do
-        tasklist_data = tasklist(node)
-        container("<li#{sourcepos(node)}#{tasklist_data}>#{" " if tasklist?(node)}", "</li>") do
-          out(:children)
-        end
-      end
-    end
-
-    def tasklist(node)
-      return "" unless tasklist?(node)
-
-      state = if checked?(node)
-        'checked="" disabled=""'
-      else
-        'disabled=""'
-      end
-      "><input type=\"checkbox\" #{state} /"
-    end
-
-    def blockquote(node)
-      block do
-        container("<blockquote#{sourcepos(node)}>\n", "</blockquote>") do
-          out(:children)
-        end
-      end
-    end
-
-    def hrule(node)
-      block do
-        out("<hr#{sourcepos(node)} />")
-      end
-    end
-
-    def code_block(node)
-      block do
-        if option_enabled?(:GITHUB_PRE_LANG)
-          out("<pre#{sourcepos(node)}")
-          out(' lang="', node.fence_info.split(/\s+/)[0], '"') if node.fence_info && !node.fence_info.empty?
-          out("><code>")
-        else
-          out("<pre#{sourcepos(node)}><code")
-          if node.fence_info && !node.fence_info.empty?
-            out(' class="language-', node.fence_info.split(/\s+/)[0], '">')
-          else
-            out(">")
-          end
-        end
-        out(escape_html(node.string_content))
-        out("</code></pre>")
-      end
-    end
-
-    def html(node)
-      block do
-        if option_enabled?(:UNSAFE)
-          out(tagfilter(node.string_content))
-        else
-          out("<!-- raw HTML omitted -->")
-        end
-      end
-    end
-
-    def inline_html(node)
-      if option_enabled?(:UNSAFE)
-        out(tagfilter(node.string_content))
-      else
-        out("<!-- raw HTML omitted -->")
-      end
-    end
-
-    def emph(_)
-      out("<em>", :children, "</em>")
-    end
-
-    def strong(_)
-      out("<strong>", :children, "</strong>")
-    end
-
-    def link(node)
-      out('<a href="', node.url.nil? ? "" : escape_href(node.url), '"')
-      out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
-      out(">", :children, "</a>")
-    end
-
-    def image(node)
-      out('<img src="', escape_href(node.url), '"')
-      plain do
-        out(' alt="', :children, '"')
-      end
-      out(' title="', escape_html(node.title), '"') if node.title && !node.title.empty?
-      out(" />")
-    end
-
-    def text(node)
-      out(escape_html(node.string_content))
-    end
-
-    def code(node)
-      out("<code>")
-      out(escape_html(node.string_content))
-      out("</code>")
-    end
-
-    def linebreak(_node)
-      out("<br />\n")
-    end
-
-    def softbreak(_)
-      if option_enabled?(:HARDBREAKS)
-        out("<br />\n")
-      elsif option_enabled?(:NOBREAKS)
-        out(" ")
-      else
-        out("\n")
-      end
-    end
-
-    def table(node)
-      @alignments = node.table_alignments
-      @needs_close_tbody = false
-      out("<table#{sourcepos(node)}>\n", :children)
-      out("</tbody>\n") if @needs_close_tbody
-      out("</table>\n")
-    end
-
-    def table_header(node)
-      @column_index = 0
-
-      @in_header = true
-      out("<thead>\n<tr#{sourcepos(node)}>\n", :children, "</tr>\n</thead>\n")
-      @in_header = false
-    end
-
-    def table_row(node)
-      @column_index = 0
-      if !@in_header && !@needs_close_tbody
-        @needs_close_tbody = true
-        out("<tbody>\n")
-      end
-      out("<tr#{sourcepos(node)}>\n", :children, "</tr>\n")
-    end
-
-    def table_cell(node)
-      align = case @alignments[@column_index]
-      when :left then ' align="left"'
-      when :right then ' align="right"'
-      when :center then ' align="center"'
-      else; ""
-      end
-      out(@in_header ? "<th#{align}#{sourcepos(node)}>" : "<td#{align}#{sourcepos(node)}>", :children, @in_header ? "</th>\n" : "</td>\n")
-      @column_index += 1
-    end
-
-    def strikethrough(_)
-      out("<del>", :children, "</del>")
-    end
-
-    def footnote_reference(node)
-      out("<sup class=\"footnote-ref\"><a href=\"#fn#{node.string_content}\" id=\"fnref#{node.string_content}\">#{node.string_content}</a></sup>")
-    end
-
-    def footnote_definition(_)
-      unless @footnote_ix
-        out("<section class=\"footnotes\">\n<ol>\n")
-        @footnote_ix = 0
-      end
-
-      @footnote_ix += 1
-      out("<li id=\"fn#{@footnote_ix}\">\n", :children)
-      out("\n") if out_footnote_backref
-      out("</li>\n")
-      # </ol>
-      # </section>
-    end
-
-    private
-
-    def out_footnote_backref
-      return false if @written_footnote_ix == @footnote_ix
-
-      @written_footnote_ix = @footnote_ix
-
-      out("<a href=\"#fnref#{@footnote_ix}\" class=\"footnote-backref\">↩</a>")
-      true
-    end
-
-    def tasklist?(node)
-      node.type_string == "tasklist"
-    end
-
-    def checked?(node)
-      node.tasklist_item_checked?
-    end
-  end
-end