redcarpet 1.5.0 → 2.0.0

data/ext/redcarpet/redcarpet.h

@@ -0,0 +1,33 @@
+#ifndef REDCARPET_H__
+#define REDCARPET_H__
+
+#define RSTRING_NOT_MODIFIED
+#include "ruby.h"
+#include <stdio.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#	include <ruby/encoding.h>
+#	define redcarpet_str_new(data, size) rb_enc_str_new(data, size, rb_utf8_encoding())
+#else
+#	define redcarpet_str_new(data, size) rb_str_new(data, size)
+#endif
+
+#include "markdown.h"
+#include "html.h"
+
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+
+extern void Init_redcarpet_rndr();
+
+struct redcarpet_renderopt {
+	struct html_renderopt html;
+	VALUE self;
+	VALUE base_class;
+};
+
+struct rb_redcarpet_rndr {
+	struct sd_callbacks callbacks;
+	struct redcarpet_renderopt options;
+};
+
+#endif

data/ext/redcarpet/stack.c

@@ -0,0 +1,81 @@
+#include "stack.h"
+#include <string.h>
+
+int
+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
+stack_free(struct stack *st)
+{
+	if (!st)
+		return;
+
+	free(st->item);
+
+	st->item = NULL;
+	st->size = 0;
+	st->asize = 0;
+}
+
+int
+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 stack_grow(st, initial_size);
+}
+
+void *
+stack_pop(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[--st->size];
+}
+
+int
+stack_push(struct stack *st, void *item)
+{
+	if (stack_grow(st, st->size * 2) < 0)
+		return -1;
+
+	st->item[st->size++] = item;
+	return 0;
+}
+
+void *
+stack_top(struct stack *st)
+{
+	if (!st->size)
+		return NULL;
+
+	return st->item[st->size - 1];
+}
+

data/ext/redcarpet/stack.h

@@ -0,0 +1,21 @@
+#ifndef STACK_H__
+#define STACK_H__
+
+#include <stdlib.h>
+
+struct stack {
+	void **item;
+	size_t size;
+	size_t asize;
+};
+
+void stack_free(struct stack *);
+int stack_grow(struct stack *, size_t);
+int stack_init(struct stack *, size_t);
+
+int stack_push(struct stack *, void *);
+
+void *stack_pop(struct stack *);
+void *stack_top(struct stack *);
+
+#endif

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.rb

@@ -1,80 +1,73 @@
-# Upskirt is an implementation of John Gruber's Markdown markup
-# language. Upskirt is safe, fast and production ready.
-#
-# Redcarpet is Upskirt with a touch of Ruby. It is mostly based on Ryan
-# Tomayko's RDiscount, and inspired by Rick Astley wearing a kilt.
-#
-# Redcarpet is a drop-in replacement for BlueCloth, RedCloth and RDiscount.
-#
-# == Usage
-#
-# Redcarpet implements the basic protocol popularized by RedCloth and adopted
-# by BlueCloth:
-#   require 'redcarpet'
-#   markdown = Redcarpet.new("Hello World!")
-#   puts markdown.to_html
-#
-# == Replacing BlueCloth
-#
-# Inject Redcarpet into your BlueCloth-using code by replacing your bluecloth
-# require statements with the following:
-#   begin
-#     require 'redcarpet'
-#     BlueCloth = Redcarpet
-#   rescue LoadError
-#     require 'bluecloth'
-#   end
-#
-class Redcarpet
-  VERSION = '1.5.0'
-
-  # Original Markdown formatted text.
-  attr_reader :text
-
-  # Set true to have smarty-like quote translation performed.
-  attr_accessor :smart
-
-  # Do not output <tt><style></tt> tags included in the source text.
-  attr_accessor :filter_styles
-
-  attr_accessor :fold_lines # Ignore, just for compatibility
-
-  # Do not output any raw HTML included in the source text.
-  attr_accessor :filter_html
-
-  # Do not process <tt>![]</tt> and remove <tt><img></tt> tags from the output.
-  attr_accessor :no_image
-
-  # Do not process <tt>[]</tt> and remove <tt><a></tt> tags from the output.
-  attr_accessor :no_links
-
-  # Disable superscript and relaxed emphasis processing.
-  attr_accessor :strict
-
-  # Convert URL in links, even if they aren't encased in <tt><></tt>
-  attr_accessor :autolink
-
-  # Don't make hyperlinks from <tt>[][]</tt> links that have unknown URL types.
-  attr_accessor :safelink
+require 'redcarpet.so'
 
-  # Add TOC anchors to every header
-  attr_accessor :generate_toc
+module Redcarpet
+  VERSION = '2.0.0b5'
 
-  # Do not process tables
-  attr_accessor :no_tables
+  class Markdown
+    attr_reader :renderer
+  end
 
-  # Do not process ~~strikethrough~~
-  attr_accessor :no_strikethrough
+  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
 
-  # Do not process fenced code blocks
-  attr_accessor :no_fencedcode
+# Compatibility class;
+# Creates a instance of Redcarpet with the RedCloth
+# API. This instance has no extensions enabled whatsoever,
+# and no accessors to change this. 100% pure, standard
+# Markdown.
+class RedcarpetCompat
+  attr_accessor :text
+
+  def initialize(text, *_dummy)
+    @text = text
+    @markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML)
+  end
 
-  def initialize(text, *extensions)
-    @text  = text
-    extensions.each { |e| send("#{e}=", true) }
+  def to_html(*_dummy)
+    @markdown.render(@text)
   end
 end
 
-Markdown = Redcarpet unless defined? Markdown
-
-require 'redcarpet.so'

data/redcarpet.gemspec

@@ -1,11 +1,12 @@
+# encoding: utf-8
 Gem::Specification.new do |s|
   s.name = 'redcarpet'
-  s.version = '1.5.0'
-  s.summary = "Ruby bindings for libupskirt"
-  s.date = '2011-04-11'
+  s.version = '2.0.0'
+  s.summary = "Markdown that smells nice"
+  s.description = 'A fast, safe and extensible Markdown to (X)HTML parser'
+  s.date = '2011-09-14'
   s.email = 'vicent@github.com'
   s.homepage = 'http://github.com/tanoku/redcarpet'
-  s.has_rdoc = true
   s.authors = ["Natacha Porté", "Vicent Martí"]
   # = MANIFEST =
   s.files = %w[
@@ -13,28 +14,36 @@ Gem::Specification.new do |s|
     README.markdown
     Rakefile
     bin/redcarpet
-    ext/array.c
-    ext/array.h
-    ext/buffer.c
-    ext/buffer.h
-    ext/extconf.rb
-    ext/markdown.c
-    ext/markdown.h
-    ext/redcarpet.c
-    ext/xhtml.c
-    ext/xhtml.h
-    lib/markdown.rb
+    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/render_man.rb
     redcarpet.gemspec
-    test/benchmark.rb
-    test/benchmark.txt
-    test/markdown_test.rb
+    sundown
     test/redcarpet_test.rb
   ]
   # = MANIFEST =
-  s.test_files = ["test/markdown_test.rb", "test/redcarpet_test.rb"]
+  s.test_files = ["test/redcarpet_test.rb"]
   s.extra_rdoc_files = ["COPYING"]
-  s.extensions = ["ext/extconf.rb"]
+  s.extensions = ["ext/redcarpet/extconf.rb"]
   s.executables = ["redcarpet"]
   s.require_paths = ["lib"]
+  s.add_development_dependency "rake-compiler"
 end