tight-redcarpet 3.1.1

data/ext/redcarpet/redcarpet.h

@@ -0,0 +1,30 @@
+#ifndef REDCARPET_H__
+#define REDCARPET_H__
+
+#define RSTRING_NOT_MODIFIED
+#include "ruby.h"
+#include <stdio.h>
+
+#include <ruby/encoding.h>
+
+#include "markdown.h"
+#include "html.h"
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+void Init_redcarpet_rndr();
+
+struct redcarpet_renderopt {
+	struct html_renderopt html;
+	VALUE link_attributes;
+	VALUE self;
+	VALUE base_class;
+	rb_encoding *active_enc;
+};
+
+struct rb_redcarpet_rndr {
+	struct sd_callbacks callbacks;
+	struct redcarpet_renderopt options;
+};
+
+#endif

data/ext/redcarpet/stack.c

@@ -0,0 +1,62 @@
+#include "stack.h"
+#include <string.h>
+
+int
+redcarpet_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
+redcarpet_stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+redcarpet_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 redcarpet_stack_grow(st, initial_size);
+}
+
+int
+redcarpet_stack_push(struct stack *st, void *item)
+{
+	if (redcarpet_stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}

data/ext/redcarpet/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 redcarpet_stack_free(struct stack *);
+int redcarpet_stack_grow(struct stack *, size_t);
+int redcarpet_stack_init(struct stack *, size_t);
+
+int redcarpet_stack_push(struct stack *, void *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/redcarpet.rb

@@ -0,0 +1,125 @@
+require 'redcarpet.so'
+
+module Redcarpet
+  VERSION = '3.1.1'
+
+  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
+
+    # 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
+    #   Redcarpet::Render::SmartyPants.render("you're")
+    #
+    module SmartyPants
+      extend self
+      def self.render(text)
+        postprocess text
+      end
+    end
+  end
+end
+
+# Compatibility class;
+# Creates an instance of Redcarpet with the RedCloth API.
+class RedcarpetCompat
+  attr_accessor :text
+
+  def initialize(text, *exts)
+    exts_hash, render_hash = *parse_extensions_and_renderer_options(exts)
+    @text = text
+    renderer = Redcarpet::Render::HTML.new(render_hash)
+    @markdown = Redcarpet::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
+

data/lib/redcarpet/compat.rb

@@ -0,0 +1,3 @@
+require 'redcarpet'
+
+Markdown = RedcarpetCompat unless defined? Markdown

data/lib/redcarpet/render_man.rb

@@ -0,0 +1,65 @@
+module Redcarpet
+  module Render
+    class ManPage < Base
+
+      def normal_text(text)
+        text.gsub('-', '\\-').strip
+      end
+
+      def block_code(code, language)
+        "\n.nf\n#{normal_text(code)}\n.fi\n"
+      end
+
+      def codespan(code)
+        block_code(code, nil)
+      end
+
+      def header(title, level)
+        case level
+        when 1
+          "\n.TH #{title}\n"
+
+        when 2
+          "\n.SH #{title}\n"
+
+        when 3
+          "\n.SS #{title}\n"
+        end
+      end
+
+      def double_emphasis(text)
+        "\\fB#{text}\\fP"
+      end
+
+      def emphasis(text)
+        "\\fI#{text}\\fP"
+      end
+
+      def linebreak
+        "\n.LP\n"
+      end
+
+      def paragraph(text)
+        "\n.TP\n#{text}\n"
+      end
+
+      def list(content, list_type)
+        case list_type
+        when :ordered
+          "\n\n.nr step 0 1\n#{content}\n"
+        when :unordered
+          "\n.\n#{content}\n"
+        end
+      end
+
+      def list_item(content, list_type)
+        case list_type
+        when :ordered
+          ".IP \\n+[step]\n#{content.strip}\n"
+        when :unordered
+          ".IP \\[bu] 2 \n#{content.strip}\n"
+        end
+      end
+    end
+  end
+end

data/lib/redcarpet/render_strip.rb

@@ -0,0 +1,48 @@
+module Redcarpet
+  module Render
+    # Markdown-stripping renderer. Turns Markdown into plaintext
+    # Thanks to @toupeira (Markus Koller)
+    class StripDown < Base
+      # Methods where the first argument is the text content
+      [
+        # block-level calls
+        :block_code, :block_quote,
+        :block_html, :list, :list_item,
+
+        # span-level calls
+        :autolink, :codespan, :double_emphasis,
+        :emphasis, :underline, :raw_html,
+        :triple_emphasis, :strikethrough,
+        :superscript,
+
+        # footnotes
+        :footnotes, :footnote_def, :footnote_ref,
+
+        # low level rendering
+        :entity, :normal_text
+      ].each do |method|
+        define_method method do |*args|
+          args.first
+        end
+      end
+
+      # Other methods where the text content is in another argument
+      def link(link, title, content)
+        content
+      end
+
+      def image(link, title, content)
+        content &&= content + " "
+        "#{content}#{link}"
+      end
+
+      def paragraph(text)
+        text + "\n"
+      end
+
+      def header(text, header_level)
+        text + "\n"
+      end
+    end
+  end
+end

data/redcarpet.gemspec

@@ -0,0 +1,65 @@
+# encoding: utf-8
+Gem::Specification.new do |s|
+  s.name = 'tight-redcarpet'
+  s.version = '3.1.1'
+  s.summary = "Markdown that smells nice (patch level 'tight')"
+  s.description = 'A fast, safe and extensible Markdown to (X)HTML parser patched to have smaller headings and no quote-escaping'
+  s.date = '2014-07-04'
+  s.email = 'ujifgc@github.com'
+  s.homepage = 'http://github.com/ujifgc/redcarpet'
+  s.authors = ["Natacha Porté", "Vicent Martí", "Igor Bochkariov"]
+  s.license = 'MIT'
+  s.required_ruby_version = '>= 1.9.2'
+  # = MANIFEST =
+  s.files = %w[
+    COPYING
+    Gemfile
+    README.markdown
+    Rakefile
+    bin/redcarpet
+    ext/redcarpet/autolink.c
+    ext/redcarpet/autolink.h
+    ext/redcarpet/buffer.c
+    ext/redcarpet/buffer.h
+    ext/redcarpet/extconf.rb
+    ext/redcarpet/houdini.h
+    ext/redcarpet/houdini_href_e.c
+    ext/redcarpet/houdini_html_e.c
+    ext/redcarpet/html.c
+    ext/redcarpet/html.h
+    ext/redcarpet/html_blocks.h
+    ext/redcarpet/html_smartypants.c
+    ext/redcarpet/markdown.c
+    ext/redcarpet/markdown.h
+    ext/redcarpet/rc_markdown.c
+    ext/redcarpet/rc_render.c
+    ext/redcarpet/redcarpet.h
+    ext/redcarpet/stack.c
+    ext/redcarpet/stack.h
+    lib/redcarpet.rb
+    lib/redcarpet/compat.rb
+    lib/redcarpet/render_man.rb
+    lib/redcarpet/render_strip.rb
+    redcarpet.gemspec
+    test/test_helper.rb
+    test/custom_render_test.rb
+    test/html_render_test.rb
+    test/html_toc_render_test.rb
+    test/markdown_test.rb
+    test/pathological_inputs_test.rb
+    test/redcarpet_compat_test.rb
+    test/smarty_html_test.rb
+    test/smarty_pants_test.rb
+    test/stripdown_render_test.rb
+  ]
+  # = MANIFEST =
+  s.test_files = s.files.grep(%r{^test/})
+  s.extra_rdoc_files = ["COPYING"]
+  s.extensions = ["ext/redcarpet/extconf.rb"]
+  s.executables = ["redcarpet"]
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "nokogiri", "~> 1.6.0"
+  s.add_development_dependency "rake-compiler", "~> 0.8.3"
+  s.add_development_dependency "test-unit", "~> 2.5.4"
+end

data/test/custom_render_test.rb

@@ -0,0 +1,28 @@
+# coding: UTF-8
+require 'test_helper'
+
+class CustomRenderTest < Redcarpet::TestCase
+  class SimpleRender < Redcarpet::Render::HTML
+    def emphasis(text)
+      "<em class=\"cool\">#{text}</em>"
+    end
+  end
+
+  def test_simple_overload
+    md = Redcarpet::Markdown.new(SimpleRender)
+    html_equal "<p>This is <em class=\"cool\">just</em> a test</p>\n",
+      md.render("This is *just* a test")
+  end
+
+  class NilPreprocessRenderer < Redcarpet::Render::HTML
+    def preprocess(fulldoc)
+      nil
+    end
+  end
+
+  def test_preprocess_returning_nil
+    md = Redcarpet::Markdown.new(NilPreprocessRenderer)
+    assert_equal(nil,md.render("Anything"))
+  end
+
+end