greenmat 3.2.0.0

data/ext/greenmat/markdown.h

@@ -0,0 +1,138 @@
+/* markdown.h - generic markdown parser */
+
+/*
+ * Copyright (c) 2009, Natacha Porté
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef MARKDOWN_H__
+#define MARKDOWN_H__
+
+#include "buffer.h"
+#include "autolink.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/********************
+ * TYPE DEFINITIONS *
+ ********************/
+
+/* mkd_autolink - type of autolink */
+enum mkd_autolink {
+	MKDA_NOT_AUTOLINK,	/* used internally when it is not an autolink*/
+	MKDA_NORMAL,		/* normal http/http/ftp/mailto/etc link */
+	MKDA_EMAIL,			/* e-mail link without explit mailto: */
+};
+
+enum mkd_tableflags {
+	MKD_TABLE_ALIGN_L = 1,
+	MKD_TABLE_ALIGN_R = 2,
+	MKD_TABLE_ALIGN_CENTER = 3,
+	MKD_TABLE_ALIGNMASK = 3,
+	MKD_TABLE_HEADER = 4
+};
+
+enum mkd_extensions {
+	MKDEXT_NO_INTRA_EMPHASIS = (1 << 0),
+	MKDEXT_TABLES = (1 << 1),
+	MKDEXT_FENCED_CODE = (1 << 2),
+	MKDEXT_AUTOLINK = (1 << 3),
+	MKDEXT_STRIKETHROUGH = (1 << 4),
+	MKDEXT_UNDERLINE = (1 << 5),
+	MKDEXT_SPACE_HEADERS = (1 << 6),
+	MKDEXT_SUPERSCRIPT = (1 << 7),
+	MKDEXT_LAX_SPACING = (1 << 8),
+	MKDEXT_DISABLE_INDENTED_CODE = (1 << 9),
+	MKDEXT_HIGHLIGHT = (1 << 10),
+	MKDEXT_FOOTNOTES = (1 << 11),
+	MKDEXT_QUOTE = (1 << 12)
+};
+
+/* sd_callbacks - functions for rendering parsed data */
+struct sd_callbacks {
+	/* block level callbacks - NULL skips the block */
+	void (*blockcode)(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque);
+	void (*blockquote)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*blockhtml)(struct buf *ob,const  struct buf *text, void *opaque);
+	void (*header)(struct buf *ob, const struct buf *text, int level, void *opaque);
+	void (*hrule)(struct buf *ob, void *opaque);
+	void (*list)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+	void (*listitem)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+	void (*paragraph)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*table)(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque);
+	void (*table_row)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*table_cell)(struct buf *ob, const struct buf *text, int flags, void *opaque);
+	void (*footnotes)(struct buf *ob, const struct buf *text, void *opaque);
+	void (*footnote_def)(struct buf *ob, const struct buf *text, unsigned int num, void *opaque);
+
+	/* span level callbacks - NULL or return 0 prints the span verbatim */
+	int (*autolink)(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque);
+	int (*codespan)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*double_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*underline)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*highlight)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*quote)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*image)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque);
+	int (*linebreak)(struct buf *ob, void *opaque);
+	int (*link)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque);
+	int (*raw_html_tag)(struct buf *ob, const struct buf *tag, void *opaque);
+	int (*triple_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*strikethrough)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*superscript)(struct buf *ob, const struct buf *text, void *opaque);
+	int (*footnote_ref)(struct buf *ob, unsigned int num, void *opaque);
+
+	/* low level callbacks - NULL copies input directly into the output */
+	void (*entity)(struct buf *ob, const struct buf *entity, void *opaque);
+	void (*normal_text)(struct buf *ob, const struct buf *text, void *opaque);
+
+	/* header and footer */
+	void (*doc_header)(struct buf *ob, void *opaque);
+	void (*doc_footer)(struct buf *ob, void *opaque);
+};
+
+struct sd_markdown;
+
+/*********
+ * FLAGS *
+ *********/
+
+/* list/listitem flags */
+#define MKD_LIST_ORDERED	1
+#define MKD_LI_BLOCK		2  /* <li> containing block data */
+
+/**********************
+ * EXPORTED FUNCTIONS *
+ **********************/
+
+extern struct sd_markdown *
+sd_markdown_new(
+	unsigned int extensions,
+	size_t max_nesting,
+	const struct sd_callbacks *callbacks,
+	void *opaque);
+
+extern void
+sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md);
+
+extern void
+sd_markdown_free(struct sd_markdown *md);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/greenmat/stack.c

@@ -0,0 +1,62 @@
+#include "stack.h"
+#include <string.h>
+
+int
+greenmat_stack_grow(struct stack *st, size_t new_size)
+{
+	void **new_st;
+
+	if (st->asize >= new_size)
+		return 0;
+
+	new_st = realloc(st->item, new_size * sizeof(void *));
+	if (new_st == NULL)
+		return -1;
+
+	memset(new_st + st->asize, 0x0,
+		(new_size - st->asize) * sizeof(void *));
+
+	st->item = new_st;
+	st->asize = new_size;
+
+	if (st->size > new_size)
+		st->size = new_size;
+
+	return 0;
+}
+
+void
+greenmat_stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+greenmat_stack_init(struct stack *st, size_t initial_size)
+{
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+
+	if (!initial_size)
+		initial_size = 8;
+
+	return greenmat_stack_grow(st, initial_size);
+}
+
+int
+greenmat_stack_push(struct stack *st, void *item)
+{
+	if (greenmat_stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}

data/ext/greenmat/stack.h

@@ -0,0 +1,26 @@
+#ifndef STACK_H__
+#define STACK_H__
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct stack {
+	void **item;
+	size_t size;
+	size_t asize;
+};
+
+void greenmat_stack_free(struct stack *);
+int greenmat_stack_grow(struct stack *, size_t);
+int greenmat_stack_init(struct stack *, size_t);
+
+int greenmat_stack_push(struct stack *, void *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/greenmat.gemspec

@@ -0,0 +1,72 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'greenmat'
+
+Gem::Specification.new do |s|
+  s.name = 'greenmat'
+  s.version = Greenmat::VERSION
+  s.summary = "A Markdown parser for Qiita, based on Redcarpet."
+  s.description = s.summary
+  s.email = 'nkymyj@gmail.com'
+  s.homepage = 'https://github.com/increments/greenmat'
+  s.authors = ["Natacha Porté", "Vicent Martí"]
+  s.license = 'MIT'
+  s.required_ruby_version = '>= 2.0.0'
+  # = MANIFEST =
+  s.files = %w[
+    COPYING
+    Gemfile
+    README.md
+    Rakefile
+    bin/greenmat
+    ext/greenmat/autolink.c
+    ext/greenmat/autolink.h
+    ext/greenmat/buffer.c
+    ext/greenmat/buffer.h
+    ext/greenmat/extconf.rb
+    ext/greenmat/houdini.h
+    ext/greenmat/houdini_href_e.c
+    ext/greenmat/houdini_html_e.c
+    ext/greenmat/html.c
+    ext/greenmat/html.h
+    ext/greenmat/html_blocks.h
+    ext/greenmat/html_smartypants.c
+    ext/greenmat/markdown.c
+    ext/greenmat/markdown.h
+    ext/greenmat/gm_markdown.c
+    ext/greenmat/gm_render.c
+    ext/greenmat/greenmat.h
+    ext/greenmat/stack.c
+    ext/greenmat/stack.h
+    lib/greenmat.rb
+    lib/greenmat/compat.rb
+    lib/greenmat/render_man.rb
+    lib/greenmat/render_strip.rb
+    greenmat.gemspec
+    test/benchmark.rb
+    test/custom_render_test.rb
+    test/html5_test.rb
+    test/html_render_test.rb
+    test/html_toc_render_test.rb
+    test/markdown_test.rb
+    test/pathological_inputs_test.rb
+    test/greenmat_compat_test.rb
+    test/safe_render_test.rb
+    test/smarty_html_test.rb
+    test/smarty_pants_test.rb
+    test/stripdown_render_test.rb
+    test/test_helper.rb
+  ]
+  # = MANIFEST =
+  s.test_files = s.files.grep(%r{^test/})
+  s.extra_rdoc_files = ["COPYING"]
+  s.extensions = ["ext/greenmat/extconf.rb"]
+  s.executables = ["greenmat"]
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake-compiler", "~> 0.8.3"
+  s.add_development_dependency "rspec", "~> 3.2"
+  s.add_development_dependency "rubygems-xcodeproj_generator", '~> 0.1'
+  s.add_development_dependency "test-unit", "~> 3.0.9"
+end

data/lib/greenmat.rb

@@ -0,0 +1,92 @@
+require 'greenmat.so'
+require 'greenmat/compat'
+
+module Greenmat
+  VERSION = '3.2.0.0'
+
+  class Markdown
+    attr_reader :renderer
+  end
+
+  module Render
+
+    # XHTML Renderer
+    class XHTML < HTML
+      def initialize(extensions = {})
+        super(extensions.merge(xhtml: true))
+      end
+    end
+
+    # HTML + SmartyPants renderer
+    class SmartyHTML < HTML
+      include SmartyPants
+    end
+
+    # A renderer object you can use to deal with users' input. It
+    # enables +escape_html+ and +safe_links_only+ by default.
+    #
+    # The +block_code+ callback is also overriden not to include
+    # the lang's class as the user can basically specify anything
+    # with the vanilla one.
+    class Safe < HTML
+      def initialize(extensions = {})
+        super({
+          escape_html: true,
+          safe_links_only: true
+        }.merge(extensions))
+      end
+
+      def block_code(code, lang)
+        "<pre>" \
+          "<code>#{html_escape(code)}</code>" \
+        "</pre>"
+      end
+
+      private
+
+      # TODO: This is far from ideal to have such method as we
+      # are duplicating existing code from Houdini. This method
+      # should be defined at the C level.
+      def html_escape(string)
+        string.gsub(/['&\"<>\/]/, {
+          '&' => '&amp;',
+          '<' => '&lt;',
+          '>' => '&gt;',
+          '"' => '&quot;',
+          "'" => '&#x27;',
+          "/" => '&#x2F;',
+        })
+      end
+    end
+
+    # SmartyPants Mixin module
+    #
+    # Implements SmartyPants.postprocess, which
+    # performs smartypants replacements on the HTML file,
+    # once it has been fully rendered.
+    #
+    # To add SmartyPants postprocessing to your custom
+    # renderers, just mixin the module `include SmartyPants`
+    #
+    # You can also use this as a standalone SmartyPants
+    # implementation.
+    #
+    # Example:
+    #
+    #   # Mixin
+    #   class CoolRenderer < HTML
+    #     include SmartyPants
+    #     # more code here
+    #   end
+    #
+    #   # Standalone
+    #   Greenmat::Render::SmartyPants.render("you're")
+    #
+    module SmartyPants
+      extend self
+      def self.render(text)
+        postprocess text
+      end
+    end
+  end
+end

data/lib/greenmat/compat.rb

@@ -0,0 +1,73 @@
+require 'greenmat'
+
+# Creates an instance of Greenmat with the RedCloth API.
+class GreenmatCompat
+  attr_accessor :text
+
+  def initialize(text, *exts)
+    exts_hash, render_hash = *parse_extensions_and_renderer_options(exts)
+    @text = text
+    renderer = Greenmat::Render::HTML.new(render_hash)
+    @markdown = Greenmat::Markdown.new(renderer, exts_hash)
+  end
+
+  def to_html(*_dummy)
+    @markdown.render(text)
+  end
+
+  private
+
+  EXTENSION_MAP = {
+    # old name => new name
+    :autolink         => :autolink,
+    :fenced_code      => :fenced_code_blocks,
+    :filter_html      => :filter_html,
+    :hard_wrap        => :hard_wrap,
+    :prettify         => :prettify,
+    :lax_htmlblock    => :lax_spacing,
+    :no_image         => :no_images,
+    :no_intraemphasis => :no_intra_emphasis,
+    :no_links         => :no_links,
+    :filter_styles    => :no_styles,
+    :safelink         => :safe_links_only,
+    :space_header     => :space_after_headers,
+    :strikethrough    => :strikethrough,
+    :tables           => :tables,
+    :generate_toc     => :with_toc_data,
+    :xhtml            => :xhtml,
+
+    # old names with no new mapping
+    :gh_blockcode => nil,
+    :no_tables    => nil,
+    :smart        => nil,
+    :strict       => nil
+  }
+
+  RENDERER_OPTIONS = [:filter_html, :no_images, :no_links, :no_styles,
+    :safe_links_only, :with_toc_data, :hard_wrap, :prettify, :xhtml]
+
+  def rename_extensions(exts)
+    exts.map do |old_name|
+      if new_name = EXTENSION_MAP[old_name]
+        new_name
+      else
+        old_name
+      end
+    end.compact
+  end
+
+  # Returns two hashes, the extensions and renderer options
+  # given the extension list
+  def parse_extensions_and_renderer_options(exts)
+    exts = rename_extensions(exts)
+    exts.partition {|ext| !RENDERER_OPTIONS.include?(ext) }.
+      map {|list| list_to_truthy_hash(list) }
+  end
+
+  # Turns a list of symbols into a hash of <tt>symbol => true</tt>.
+  def list_to_truthy_hash(list)
+    list.inject({}) {|h, k| h[k] = true; h }
+  end
+end
+
+Markdown = GreenmatCompat unless defined? Markdown