redcarpet 1.0.0

data/COPYING

@@ -0,0 +1,14 @@
+Copyright (c) 2009, Natacha Porté
+Copyright (c) 2011, Vicent Marti
+
+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.

data/README.markdown

@@ -0,0 +1,38 @@
+Markdown + Ruby + libupskirt
+============================
+
+> Inspired by Rick Astley wearing a kilt
+
+Upskirt is an implementation of John Gruber's Markdown markup
+language. Upskirt is safe, fast and production ready. Check out
+the original version at <http://git.instinctive.eu/cgit/libupskirt/>
+
+Redcarpet is Upskirt with a touch of Ruby. It is mostly based on Ryan
+Tomayko's RDiscount wrapper, and inspired by Rick Astley wearing a kilt.
+
+Redcarpet is powered by a modified version of Upskirt, which has been
+updated to pass the official Markdown test suite and now has support
+for many additional features: autolinks, smartypants, safe filters,
+and a long etcetera.
+
+Redcarpet is a drop-in replacement for BlueCloth, RedCloth and RDiscount.
+
+* Upskirt is (C)2009 Natacha Porté
+* Upskirt has been brought back to life and made standards-compilant in 2011 by Vicent Marti
+* Redcarpet is (C)2011 Vicent Marti
+ 
+
+License
+-------
+
+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.

data/Rakefile

@@ -0,0 +1,135 @@
+require 'date'
+require 'rake/clean'
+require 'digest/md5'
+
+task :default => :test
+
+# ==========================================================
+# Ruby Extension
+# ==========================================================
+
+DLEXT = Config::MAKEFILE_CONFIG['DLEXT']
+RUBYDIGEST = Digest::MD5.hexdigest(`#{RUBY} --version`)
+
+file "ext/ruby-#{RUBYDIGEST}" do |f|
+  rm_f FileList["ext/ruby-*"]
+  touch f.name
+end
+CLEAN.include "ext/ruby-*"
+
+file 'ext/Makefile' => FileList['ext/*.{c,h,rb}', "ext/ruby-#{RUBYDIGEST}"] do
+  chdir('ext') { ruby 'extconf.rb' }
+end
+CLEAN.include 'ext/Makefile', 'ext/mkmf.log'
+
+file "ext/redcarpet.#{DLEXT}" => FileList["ext/Makefile"] do |f|
+  sh 'cd ext && make clean && make && rm -rf conftest.dSYM'
+end
+CLEAN.include 'ext/*.{o,bundle,so,dll}'
+
+file "lib/redcarpet.#{DLEXT}" => "ext/redcarpet.#{DLEXT}" do |f|
+  cp f.prerequisites, "lib/", :preserve => true
+end
+
+desc 'Build the redcarpet extension'
+task :build => "lib/redcarpet.#{DLEXT}"
+
+# ==========================================================
+# Testing
+# ==========================================================
+
+require 'rake/testtask'
+Rake::TestTask.new('test:unit') do |t|
+  t.test_files = FileList['test/*_test.rb']
+  t.ruby_opts += ['-rubygems'] if defined? Gem
+end
+task 'test:unit' => [:build]
+
+desc 'Run conformance tests (MARKDOWN_TEST_VER=1.0)'
+task 'test:conformance' => [:build] do |t|
+  script = "#{pwd}/bin/redcarpet"
+  test_version = ENV['MARKDOWN_TEST_VER'] || '1.0.3'
+  lib_dir = "#{pwd}/lib"
+  chdir("test/MarkdownTest_#{test_version}") do
+    sh "RUBYLIB=#{lib_dir} ./MarkdownTest.pl --script='#{script}' --tidy"
+  end
+end
+
+desc 'Run version 1.0 conformance suite'
+task 'test:conformance:1.0' => [:build] do |t|
+  ENV['MARKDOWN_TEST_VER'] = '1.0'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run 1.0.3 conformance suite'
+task 'test:conformance:1.0.3' => [:build] do |t|
+  ENV['MARKDOWN_TEST_VER'] = '1.0.3'
+  Rake::Task['test:conformance'].invoke
+end
+
+desc 'Run unit and conformance tests'
+task :test => %w[test:unit test:conformance]
+
+desc 'Run benchmarks'
+task :benchmark => :build do |t|
+  $:.unshift 'lib'
+  load 'test/benchmark.rb'
+end
+
+# PACKAGING =================================================================
+
+require 'rubygems'
+$spec = eval(File.read('redcarpet.gemspec'))
+
+def package(ext='')
+  "pkg/redcarpet-#{$spec.version}" + ext
+end
+
+desc 'Build packages'
+task :package => %w[.gem .tar.gz].map {|e| package(e)}
+
+desc 'Build and install as local gem'
+task :install => package('.gem') do
+  sh "gem install #{package('.gem')}"
+end
+
+desc 'Update the gemspec'
+task :update_gem => file('redcarpet.gemspec')
+
+directory 'pkg/'
+
+file package('.gem') => %w[pkg/ redcarpet.gemspec] + $spec.files do |f|
+  sh "gem build redcarpet.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file package('.tar.gz') => %w[pkg/] + $spec.files do |f|
+  sh "git archive --format=tar HEAD | gzip > #{f.name}"
+end
+
+# GEMSPEC HELPERS ==========================================================
+
+def source_version
+  line = File.read('lib/redcarpet.rb')[/^\s*VERSION = .*/]
+  line.match(/.*VERSION = '(.*)'/)[1]
+end
+
+file 'redcarpet.gemspec' => FileList['Rakefile','lib/redcarpet.rb'] do |f|
+  # read spec file and split out manifest section
+  spec = File.read(f.name)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+  head.sub!(/\.version = '.*'/, ".version = '#{source_version}'")
+  head.sub!(/\.date = '.*'/, ".date = '#{Date.today.to_s}'")
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject{ |file| file =~ /^\./ || file =~ /^test\/MarkdownTest/ }.
+    map{ |file| "    #{file}" }.
+    join("\n")
+  # piece file back together and write...
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head,manifest,tail].join("  # = MANIFEST =\n")
+  File.open(f.name, 'w') { |io| io.write(spec) }
+  puts "updated #{f.name}"
+end

data/bin/redcarpet

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# Usage: redcarpet [<file>...]
+# Convert one or more Markdown files to HTML and write to standard output. With
+# no <file> or when <file> is '-', read Markdown source text from standard input.
+if ARGV.include?('--help')
+  File.read(__FILE__).split("\n").grep(/^# /).each do |line|
+    puts line[2..-1]
+  end
+  exit 0
+end
+
+require 'redcarpet'
+STDOUT.write(Redcarpet.new(ARGF.read).to_html)

data/ext/array.c

@@ -0,0 +1,300 @@
+/* array.c - automatic dynamic array for pointers */
+
+/*
+ * Copyright (c) 2008, 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.
+ */
+
+#include "array.h"
+
+#include <string.h>
+
+
+/***************************
+ * STATIC HELPER FUNCTIONS *
+ ***************************/
+
+/* arr_realloc • realloc memory of a struct array */
+static int
+arr_realloc(struct array* arr, int neosz) {
+	void* neo;
+	neo = realloc(arr->base, neosz * arr->unit);
+	if (neo == 0) return 0;
+	arr->base = neo;
+	arr->asize = neosz;
+	if (arr->size > neosz) arr->size = neosz;
+	return 1; }
+
+
+/* parr_realloc • realloc memory of a struct parray */
+static int
+parr_realloc(struct parray* arr, int neosz) {
+	void* neo;
+	neo = realloc(arr->item, neosz * sizeof (void*));
+	if (neo == 0) return 0;
+	arr->item = neo;
+	arr->asize = neosz;
+	if (arr->size > neosz) arr->size = neosz;
+	return 1; }
+
+
+
+/***************************
+ * GENERIC ARRAY FUNCTIONS *
+ ***************************/
+
+/* arr_adjust • shrink the allocated memory to fit exactly the needs */
+int
+arr_adjust(struct array *arr) {
+	return arr_realloc(arr, arr->size); }
+
+
+/* arr_free • frees the structure contents (buf NOT the struct itself) */
+void
+arr_free(struct array *arr) {
+	if (!arr) return;
+	free(arr->base);
+	arr->base = 0;
+	arr->size = arr->asize = 0; }
+
+
+/* arr_grow • increases the array size to fit the given number of elements */
+int
+arr_grow(struct array *arr, int need) {
+	if (arr->asize >= need) return 1;
+	else return arr_realloc(arr, need); }
+
+
+/* arr_init • initialization of the contents of the struct */
+void
+arr_init(struct array *arr, size_t unit) {
+	arr->base = 0;
+	arr->size = arr->asize = 0;
+	arr->unit = unit; }
+
+
+/* arr_insert • inserting nb elements before the nth one */
+int
+arr_insert(struct array *arr, int nb, int n) {
+	char *src, *dst;
+	size_t len;
+	if (!arr || nb <= 0 || n < 0
+	|| !arr_grow(arr, arr->size + nb))
+		return 0;
+	if (n < arr->size) {
+		src = arr->base;
+		src += n * arr->unit;
+		dst = src + nb * arr->unit;
+		len = (arr->size - n) * arr->unit;
+		memmove(dst, src, len); }
+	arr->size += nb;
+	return 1; }
+
+
+/* arr_item • returns a pointer to the n-th element */
+void *
+arr_item(struct array *arr, int no) {
+	char *ptr;
+	if (!arr || no < 0 || no >= arr->size) return 0;
+	ptr = arr->base;
+	ptr += no * arr->unit;
+	return ptr; }
+
+
+/* arr_newitem • returns the index of a new element appended to the array */
+int
+arr_newitem(struct array *arr) {
+	if (!arr_grow(arr, arr->size + 1)) return -1;
+	arr->size += 1;
+	return arr->size - 1; }
+
+
+/* arr_remove • removes the n-th elements of the array */
+void
+arr_remove(struct array *arr, int idx) {
+	if (!arr || idx < 0 || idx >= arr->size) return;
+	arr->size -= 1;
+	if (idx < arr->size) {
+		char *dst = arr->base;
+		char *src;
+		dst += idx * arr->unit;
+		src = dst + arr->unit;
+		memmove(dst, src, (arr->size - idx) * arr->unit); } }
+
+
+/* arr_sorted_find • O(log n) search in a sorted array, returning entry */
+void *
+arr_sorted_find(struct array *arr, void *key, array_cmp_fn cmp) {
+	int mi, ma, cu, ret;
+	char *ptr = arr->base;
+	mi = -1;
+	ma = arr->size;
+	while (mi < ma - 1) {
+		cu = mi + (ma - mi) / 2;
+		ret = cmp(key, ptr + cu * arr->unit);
+		if (ret == 0) return ptr + cu * arr->unit;
+		else if (ret < 0) ma = cu;
+		else /* if (ret > 0) */ mi = cu; }
+	return 0; }
+
+
+/* arr_sorted_find_i • O(log n) search in a sorted array,
+ *      returning index of the smallest element larger than the key */
+int
+arr_sorted_find_i(struct array *arr, void *key, array_cmp_fn cmp) {
+	int mi, ma, cu, ret;
+	char *ptr = arr->base;
+	mi = -1;
+	ma = arr->size;
+	while (mi < ma - 1) {
+		cu = mi + (ma - mi) / 2;
+		ret = cmp(key, ptr + cu * arr->unit);
+		if (ret == 0) {
+			while (cu < arr->size && ret == 0) {
+				cu += 1;
+				ret = cmp(key, ptr + cu * arr->unit); }
+			return cu; }
+		else if (ret < 0) ma = cu;
+		else /* if (ret > 0) */ mi = cu; }
+	return ma; }
+
+
+
+/***************************
+ * POINTER ARRAY FUNCTIONS *
+ ***************************/
+
+/* parr_adjust • shrinks the allocated memory to fit exactly the needs */
+int
+parr_adjust(struct parray* arr) {
+	return parr_realloc (arr, arr->size); }
+
+
+/* parr_free • frees the structure contents (buf NOT the struct itself) */
+void
+parr_free(struct parray *arr) {
+	if (!arr) return;
+	free (arr->item);
+	arr->item = 0;
+	arr->size = 0;
+	arr->asize = 0; }
+
+
+/* parr_grow • increases the array size to fit the given number of elements */
+int
+parr_grow(struct parray *arr, int need) {
+	if (arr->asize >= need) return 1;
+	else return parr_realloc (arr, need); }
+
+
+/* parr_init • initialization of the struct (which is equivalent to zero) */
+void
+parr_init(struct parray *arr) {
+	arr->item = 0;
+	arr->size = 0;
+	arr->asize = 0; }
+
+
+/* parr_insert • inserting nb elements before the nth one */
+int
+parr_insert(struct parray *parr, int nb, int n) {
+	char *src, *dst;
+	size_t len, i;
+	if (!parr || nb == 0 || n < 0
+	|| !parr_grow(parr, parr->size + nb))
+		return 0;
+	if (n < parr->size) {
+		src = (void *)parr->item;
+		src += n * sizeof (void *);
+		dst = src + nb * sizeof (void *);
+		len = (parr->size - n) * sizeof (void *);
+		memmove(dst, src, len);
+		for (i = 0; i < (size_t)nb; ++i)
+			parr->item[n + i] = 0; }
+	parr->size += nb;
+	return 1; }
+
+
+/* parr_pop • pops the last item of the array and returns it */
+void *
+parr_pop(struct parray *arr) {
+	if (arr->size <= 0) return 0;
+	arr->size -= 1;
+	return arr->item[arr->size]; }
+
+
+/* parr_push • pushes a pointer at the end of the array (= append) */
+int
+parr_push(struct parray *arr, void *i) {
+	if (!parr_grow(arr, arr->size + 1)) return 0;
+	arr->item[arr->size] = i;
+	arr->size += 1;
+	return 1; }
+
+
+/* parr_remove • removes the n-th element of the array and returns it */
+void *
+parr_remove(struct parray *arr, int idx) {
+	void* ret;
+	int i;
+	if (!arr || idx < 0 || idx >= arr->size) return 0;
+	ret = arr->item[idx];
+	for (i = idx+1; i < arr->size; ++i)
+		arr->item[i - 1] = arr->item[i];
+	arr->size -= 1;
+	return ret; }
+
+
+/* parr_sorted_find • O(log n) search in a sorted array, returning entry */
+void *
+parr_sorted_find(struct parray *arr, void *key, array_cmp_fn cmp) {
+	int mi, ma, cu, ret;
+	mi = -1;
+	ma = arr->size;
+	while (mi < ma - 1) {
+		cu = mi + (ma - mi) / 2;
+		ret = cmp(key, arr->item[cu]);
+		if (ret == 0) return arr->item[cu];
+		else if (ret < 0) ma = cu;
+		else /* if (ret > 0) */ mi = cu; }
+	return 0; }
+
+
+/* parr_sorted_find_i • O(log n) search in a sorted array,
+ *      returning index of the smallest element larger than the key */
+int
+parr_sorted_find_i(struct parray *arr, void *key, array_cmp_fn cmp) {
+	int mi, ma, cu, ret;
+	mi = -1;
+	ma = arr->size;
+	while (mi < ma - 1) {
+		cu = mi + (ma - mi) / 2;
+		ret = cmp(key, arr->item[cu]);
+		if (ret == 0) {
+			while (cu < arr->size && ret == 0) {
+				cu += 1;
+				ret = cmp(key, arr->item[cu]); }
+			return cu; }
+		else if (ret < 0) ma = cu;
+		else /* if (ret > 0) */ mi = cu; }
+	return ma; }
+
+
+/* parr_top • returns the top the stack (i.e. the last element of the array) */
+void *
+parr_top(struct parray *arr) {
+	if (arr == 0 || arr->size <= 0) return 0;
+	else return arr->item[arr->size - 1]; }
+
+/* vim: set filetype=c: */