RedCloth 4.2.4.pre2-x86-mingw32

data/ext/redcloth_scan/redcloth.h

@@ -0,0 +1,220 @@
+#ifndef redcloth_h
+#define redcloth_h
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(arr)  RARRAY(arr)->len
+#define RSTRING_LEN(str) RSTRING(str)->len
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+
+// Different string conversions for ruby 1.8 and ruby 1.9. For 1.9, 
+// we need to set the encoding of the string.
+
+// For Ruby 1.9
+#ifdef HAVE_RUBY_ENCODING_H
+#include "ruby/encoding.h"
+#define STR_NEW(p,n) rb_enc_str_new((p),(n),rb_enc_from_index(ENCODING_GET(self)))
+#define STR_NEW2(p) rb_enc_str_new((p),strlen(p),rb_enc_from_index(ENCODING_GET(self)))
+
+// For Ruby 1.8
+#else
+#define STR_NEW(p,n) rb_str_new((p),(n))
+#define STR_NEW2(p) rb_str_new2((p))
+
+#endif
+
+
+/* variable defs */
+#ifndef redcloth_scan_c
+extern VALUE super_ParseError, mRedCloth, super_RedCloth;
+extern int SYM_escape_preformatted;
+#endif
+
+/* function defs */
+void rb_str_cat_escaped(VALUE self, VALUE str, char *ts, char *te);
+void rb_str_cat_escaped_for_preformatted(VALUE self, VALUE str, char *ts, char *te);
+VALUE redcloth_inline(VALUE, char *, char *, VALUE);
+VALUE redcloth_inline2(VALUE, VALUE, VALUE);
+VALUE redcloth_attribute_parser(int, VALUE, char *, char *);
+VALUE redcloth_attributes(VALUE, VALUE);
+VALUE redcloth_link_attributes(VALUE, VALUE);
+VALUE red_parse_title(VALUE, VALUE, VALUE);
+VALUE redcloth_transform(VALUE, char *, char *, VALUE);
+VALUE redcloth_transform2(VALUE, VALUE);
+void red_inc(VALUE, VALUE);
+VALUE red_block(VALUE, VALUE, VALUE, VALUE);
+VALUE red_blockcode(VALUE, VALUE, VALUE);
+VALUE red_pass(VALUE, VALUE, VALUE, ID, VALUE);
+VALUE red_pass_code(VALUE, VALUE, VALUE, ID);
+
+/* parser macros */
+#define CLEAR_REGS()   regs = rb_hash_new(); attr_regs = rb_hash_new();
+#define RESET_REG()    reg = NULL
+#define MARK()         reg = p;
+#define MARK_B()       bck = p;
+#define MARK_ATTR()    attr_reg = p;
+#define CAT(H)         rb_str_cat(H, ts, te-ts)
+#define CLEAR(H)       H = STR_NEW2("")
+#define RSTRIP_BANG(H)      rb_funcall(H, rb_intern("rstrip!"), 0)
+#define SET_PLAIN_BLOCK(T) plain_block = STR_NEW2(T)
+#define RESET_TYPE(T)  rb_hash_aset(regs, ID2SYM(rb_intern("type")), plain_block)
+#define INLINE(H, T)   rb_str_append(H, rb_funcall(self, rb_intern(T), 1, regs))
+#define DONE(H)        rb_str_append(html, H); CLEAR(H); CLEAR_REGS()
+#define PASS(H, A, T)  rb_str_append(H, red_pass(self, regs, ID2SYM(rb_intern(A)), rb_intern(T), refs))
+#define PARSE_ATTR(A)  red_parse_attr(self, regs, ID2SYM(rb_intern(A)))
+#define PARSE_LINK_ATTR(A)  red_parse_link_attr(self, regs, ID2SYM(rb_intern(A)))
+#define PARSE_IMAGE_ATTR(A)  red_parse_image_attr(self, regs, ID2SYM(rb_intern(A)))
+#define PASS_CODE(H, A, T) rb_str_append(H, red_pass_code(self, regs, ID2SYM(rb_intern(A)), rb_intern(T)))
+#define ADD_BLOCK() \
+  rb_str_append(html, red_block(self, regs, block, refs)); \
+  extend = Qnil; \
+  CLEAR(block); \
+  CLEAR_REGS()
+#define ADD_EXTENDED_BLOCK()    rb_str_append(html, red_block(self, regs, block, refs)); CLEAR(block);
+#define END_EXTENDED()     extend = Qnil; CLEAR_REGS();
+#define ADD_BLOCKCODE()    rb_str_append(html, red_blockcode(self, regs, block)); CLEAR(block); CLEAR_REGS()
+#define ADD_EXTENDED_BLOCKCODE()    rb_str_append(html, red_blockcode(self, regs, block)); CLEAR(block);
+#define ASET(T, V)     rb_hash_aset(regs, ID2SYM(rb_intern(T)), STR_NEW2(V));
+#define ATTR_SET(T, V) rb_hash_aset(attr_regs, ID2SYM(rb_intern(T)), STR_NEW2(V));
+#define ATTR_INC(T)        red_inc(attr_regs, ID2SYM(rb_intern(T)));
+#define INC(N)         N++;
+#define SET_ATTRIBUTES() \
+  SET_ATTRIBUTE("class_buf", "class"); \
+  SET_ATTRIBUTE("id_buf", "id"); \
+  SET_ATTRIBUTE("lang_buf", "lang"); \
+  SET_ATTRIBUTE("style_buf", "style"); \
+  rb_funcall(regs, rb_intern("merge!"), 1, attr_regs); \
+  attr_regs = rb_hash_new();
+#define SET_ATTRIBUTE(B, A) \
+  if (rb_hash_aref(regs, ID2SYM(rb_intern(B))) != Qnil) rb_hash_aset(regs, ID2SYM(rb_intern(A)), rb_hash_aref(regs, ID2SYM(rb_intern(B))));
+#define TRANSFORM(T) \
+  if (p > reg && reg >= ts) { \
+    VALUE str = redcloth_transform(self, reg, p, refs); \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), str); \
+    /*printf("TRANSFORM(" T ") '%s' (p:'%s' reg:'%s')\n", RSTRING_PTR(str), p, reg);*/  \
+  } else { \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), Qnil); \
+  }
+#define STORE(T)  \
+  if (p > reg && reg >= ts) { \
+    VALUE str = STR_NEW(reg, p-reg); \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), str); \
+    /*printf("STORE(" T ") '%s' (p:'%s' reg:'%s')\n", RSTRING_PTR(str), p, reg);*/  \
+  } else { \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), Qnil); \
+  }
+#define STORE_B(T)  \
+  if (p > bck && bck >= ts) { \
+    VALUE str = STR_NEW(bck, p-bck); \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), str); \
+    /*printf("STORE_B(" T ") '%s' (p:'%s' reg:'%s')\n", RSTRING_PTR(str), p, reg);*/  \
+  } else { \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), Qnil); \
+  }
+#define STORE_ATTR(T)  \
+  if (p > attr_reg && attr_reg >= ts) { \
+    VALUE str = STR_NEW(attr_reg, p-attr_reg); \
+    rb_hash_aset(attr_regs, ID2SYM(rb_intern(T)), str); \
+    /*printf("STORE_B(" T ") '%s' (p:'%s' reg:'%s')\n", RSTRING_PTR(str), p, reg);*/  \
+  } else { \
+    rb_hash_aset(attr_regs, ID2SYM(rb_intern(T)), Qnil); \
+  }
+
+#define STORE_URL(T) \
+  if (p > reg && reg >= ts) { \
+    char punct = 1; \
+    while (p > reg && punct == 1) { \
+      switch (*(p - 1)) { \
+        case ')': \
+          { /*needed to keep inside chars scoped for less memory usage*/\
+            char *temp_p = p - 1; \
+            signed char level = -1; \
+            while (temp_p > reg) { \
+              switch(*(temp_p - 1)) { \
+                case '(': ++level; break; \
+                case ')': --level; break; \
+              } \
+              --temp_p; \
+            } \
+            if (level == 0) { punct = 0; } else { --p; } \
+          } \
+          break;  \
+        case '!': case '"': case '#': case '$': case '%': case ']': case '[': case '&': case '\'': \
+        case '*': case '+': case ',': case '-': case '.': case '(':  case ':':  \
+        case ';': case '=': case '?': case '@': case '\\': case '^': case '_': \
+        case '`': case '|': case '~': p--; break; \
+        default: punct = 0; \
+      } \
+    } \
+    te = p; \
+  } \
+  STORE(T); \
+  if ( !NIL_P(refs) && rb_funcall(refs, rb_intern("has_key?"), 1, rb_hash_aref(regs, ID2SYM(rb_intern(T)))) ) { \
+    rb_hash_aset(regs, ID2SYM(rb_intern(T)), rb_hash_aref(refs, rb_hash_aref(regs, ID2SYM(rb_intern(T))))); \
+  }
+#define STORE_LINK_ALIAS() \
+  rb_hash_aset(refs_found, rb_hash_aref(regs, ID2SYM(rb_intern("text"))), rb_hash_aref(regs, ID2SYM(rb_intern("href"))))
+#define CLEAR_LIST() list_layout = rb_ary_new()
+#define SET_LIST_TYPE(T) list_type = T;
+#define NEST() nest ++;
+#define RESET_NEST() nest = 0;
+#define LIST_LAYOUT() \
+    int aint = 0; \
+    VALUE aval = rb_ary_entry(list_index, nest-1); \
+    if (aval != Qnil) aint = NUM2INT(aval); \
+    if (strcmp(list_type, "ol") == 0 && nest > 0) \
+    { \
+      rb_ary_store(list_index, nest-1, INT2NUM(aint + 1)); \
+    } \
+    if (nest > RARRAY_LEN(list_layout)) \
+    { \
+      SET_ATTRIBUTES(); \
+      sprintf(listm, "%s_open", list_type); \
+      if (!NIL_P(rb_hash_aref(regs, ID2SYM(rb_intern("list_continue"))))) \
+      { \
+        rb_hash_aset(regs, ID2SYM(rb_intern("list_continue")), Qnil); \
+        rb_hash_aset(regs, ID2SYM(rb_intern("start")), rb_ary_entry(list_index, nest-1)); \
+      } \
+      else \
+      { \
+        VALUE start = rb_hash_aref(regs, ID2SYM(rb_intern("start"))); \
+        if (NIL_P(start) ) \
+        { \
+          rb_ary_store(list_index, nest-1, INT2NUM(1)); \
+        } \
+        else \
+        { \
+          VALUE start_num = rb_funcall(start,rb_intern("to_i"),0); \
+          rb_ary_store(list_index, nest-1, start_num); \
+        } \
+      } \
+      rb_hash_aset(regs, ID2SYM(rb_intern("nest")), INT2NUM(nest)); \
+      rb_str_append(html, rb_funcall(self, rb_intern(listm), 1, regs)); \
+      rb_ary_store(list_layout, nest-1, STR_NEW2(list_type)); \
+      CLEAR_REGS(); \
+      ASET("first", "true"); \
+    } \
+    LIST_CLOSE(); \
+    if (nest != 0) LIST_ITEM_CLOSE(); \
+    CLEAR_REGS(); \
+    rb_hash_aset(regs, ID2SYM(rb_intern("nest")), INT2NUM(RARRAY_LEN(list_layout))); \
+    ASET("type", "li_open");
+#define LIST_ITEM_CLOSE() \
+    if ( rb_hash_aref(regs, ID2SYM(rb_intern("first"))) == Qnil ) \
+      rb_str_append(html, rb_funcall(self, rb_intern("li_close"), 1, regs));
+#define LIST_CLOSE() \
+    while (nest < RARRAY_LEN(list_layout)) \
+    { \
+      rb_hash_aset(regs, ID2SYM(rb_intern("nest")), INT2NUM(RARRAY_LEN(list_layout))); \
+      VALUE end_list = rb_ary_pop(list_layout); \
+      if (!NIL_P(end_list)) \
+      { \
+        StringValue(end_list); \
+        sprintf(listm, "%s_close", RSTRING_PTR(end_list)); \
+        LIST_ITEM_CLOSE(); \
+        rb_str_append(html, rb_funcall(self, rb_intern(listm), 1, regs)); \
+      } \
+    }
+
+#endif

data/lib/case_sensitive_require/RedCloth.rb

@@ -0,0 +1,6 @@
+# A workaround to make Rails 2.1 gem dependency easier on case-sensitive filesystems.
+# Since the gem name is RedCloth and the file is redcloth.rb, config.gem 'RedCloth' doesn't
+# work.  You'd have to use config.gem 'RedCloth', :lib => 'redcloth', and that's not 
+# immediately obvious.  This file remedies that.
+#
+require File.join(File.dirname(__FILE__), '..', 'redcloth')

data/lib/redcloth.rb

@@ -0,0 +1,44 @@
+# If this is a frozen gem in Rails 2.1 and RedCloth 3.x was already
+# loaded by Rails' ActionView::Helpers::TextHelper, the user will get
+# "redcloth_scan.bundle: Class is not a module (TypeError)"
+# This hack is to work around that Rails loading problem.  The problem
+# appears to be fixed in Edge Rails [51e4106].
+Object.send(:remove_const, :RedCloth) if Object.const_defined?(:RedCloth) && RedCloth.is_a?(Class)
+
+require 'rbconfig'
+begin
+  prefix = Config::CONFIG['arch'] =~ /mswin|mingw/ ? "#{Config::CONFIG['MAJOR']}.#{Config::CONFIG['MINOR']}/" : ''
+  lib = "#{prefix}redcloth_scan"
+  require lib
+rescue LoadError => e
+  e.message << %{\nCouldn't load #{lib}\nThe $LOAD_PATH was:\n#{$LOAD_PATH.join("\n")}}
+  raise e
+end
+
+require 'redcloth/version'
+require 'redcloth/textile_doc'
+require 'redcloth/formatters/base'
+require 'redcloth/formatters/html'
+require 'redcloth/formatters/latex'
+
+module RedCloth
+  
+  # A convenience method for creating a new TextileDoc. See
+  # RedCloth::TextileDoc.
+  def self.new( *args, &block )
+    RedCloth::TextileDoc.new( *args, &block )
+  end
+  
+  # Include extension modules (if any) in TextileDoc.
+  def self.include(*args)
+    RedCloth::TextileDoc.send(:include, *args)
+  end
+  
+end
+
+begin
+  require 'erb'
+  require 'redcloth/erb_extension'
+  include ERB::Util
+rescue LoadError
+end

data/lib/redcloth/erb_extension.rb

@@ -0,0 +1,27 @@
+class ERB
+  module Util
+
+    #
+    # A utility method for transforming Textile in _s_ to HTML.
+    # 
+    # 	require "erb"
+    # 	include ERB::Util
+    # 	
+    # 	puts textilize("Isn't ERB *great*?")
+    # 
+    # _Generates_
+    # 
+    # 	<p>Isn&#8217;t <span class="caps">ERB</span> <strong>great</strong>?</p>
+    #
+    def textilize( s )
+      if s && s.respond_to?(:to_s)
+        RedCloth.new( s.to_s ).to_html
+      end
+    end
+
+    alias t textilize
+    module_function :t
+    module_function :textilize
+
+  end
+end

data/lib/redcloth/formatters/base.rb

@@ -0,0 +1,63 @@
+module RedCloth::Formatters
+  module Base
+    
+    def ignore(opts)
+      opts[:text]
+    end
+    alias_method :notextile, :ignore
+    
+    def redcloth_version(opts)
+      p(:text => "#{opts[:prefix]}#{RedCloth::VERSION}")
+    end
+
+    def inline_redcloth_version(opts)
+      RedCloth::VERSION::STRING
+    end
+    
+    [:del_phrase, :sup_phrase, :sub_phrase, :span_phrase].each do |phrase_method|
+      method = phrase_method.to_s.split('_')[0]
+      define_method(phrase_method) do |opts|
+        "#{opts[:beginning_space]}#{self.send(method, opts)}"
+      end
+    end
+    
+  private
+    
+    def pba(opts)
+      opts.delete(:style) if filter_styles
+      opts.delete(:class) if filter_classes
+      opts.delete(:id) if filter_ids
+
+      atts = ''
+      opts[:"text-align"] = opts.delete(:align)
+      opts[:style] += ';' if opts[:style] && (opts[:style][-1..-1] != ';')
+      [:float, :"text-align", :"vertical-align"].each do |a|
+        opts[:style] = "#{a}:#{opts[a]};#{opts[:style]}" if opts[a]
+      end
+      [:"padding-right", :"padding-left"].each do |a|
+        opts[:style] = "#{a}:#{opts[a]}em;#{opts[:style]}" if opts[a]
+      end
+      [:style, :class, :lang, :id, :colspan, :rowspan, :title, :start, :align].each do |a|
+        atts << " #{a}=\"#{ html_esc(opts[a].to_s, :html_escape_attributes) }\"" if opts[a]
+      end
+      atts
+    end
+    
+    def method_missing(method, opts)
+      opts[:text] || ""
+    end
+    
+    def before_transform(text)
+      
+    end
+    
+    def after_transform(text)
+      
+    end
+    
+    def formatter_methods
+      singleton_methods.map! {|method| method.to_sym }
+    end
+
+  end
+end

data/lib/redcloth/formatters/html.rb

@@ -0,0 +1,345 @@
+module RedCloth::Formatters::HTML
+  include RedCloth::Formatters::Base
+  
+  [:h1, :h2, :h3, :h4, :h5, :h6, :p, :pre, :div].each do |m|
+    define_method(m) do |opts|
+      "<#{m}#{pba(opts)}>#{opts[:text]}</#{m}>\n"
+    end
+  end
+  
+  [:strong, :code, :em, :i, :b, :ins, :sup, :sub, :span, :cite].each do |m|
+    define_method(m) do |opts|
+      opts[:block] = true
+      "<#{m}#{pba(opts)}>#{opts[:text]}</#{m}>"
+    end
+  end
+  
+  def hr(opts)
+    "<hr />\n"
+  end
+  
+  def acronym(opts)
+    opts[:block] = true
+    "<acronym#{pba(opts)}>#{caps(:text => opts[:text])}</acronym>"
+  end
+  
+  def caps(opts)
+    if no_span_caps
+      opts[:text]
+    else
+      opts[:class] = 'caps'
+      span(opts)
+    end
+  end
+  
+  def del(opts)
+    opts[:block] = true
+    "<del#{pba(opts)}>#{opts[:text]}</del>"
+  end
+  
+  [:ol, :ul].each do |m|
+    define_method("#{m}_open") do |opts|
+      opts[:block] = true
+      "#{"\n" if opts[:nest] > 1}#{"\t" * (opts[:nest] - 1)}<#{m}#{pba(opts)}>\n"
+    end
+    define_method("#{m}_close") do |opts|
+      "#{"\t" * (opts[:nest] - 1)}</#{m}>#{"\n" if opts[:nest] <= 1}"
+    end
+  end
+  
+  def li_open(opts)
+    "#{"\t" * opts[:nest]}<li#{pba(opts)}>#{opts[:text]}"
+  end
+  
+  def li_close(opts=nil)
+    "</li>\n"
+  end
+  
+  def dl_open(opts)
+    opts[:block] = true
+    "<dl#{pba(opts)}>\n"
+  end
+  
+  def dl_close(opts=nil)
+    "</dl>\n"
+  end
+  
+  [:dt, :dd].each do |m|
+    define_method(m) do |opts|
+      "\t<#{m}#{pba(opts)}>#{opts[:text]}</#{m}>\n"
+    end
+  end
+  
+  def td(opts)
+    tdtype = opts[:th] ? 'th' : 'td'
+    "\t\t<#{tdtype}#{pba(opts)}>#{opts[:text]}</#{tdtype}>\n"
+  end
+  
+  def tr_open(opts)
+    "\t<tr#{pba(opts)}>\n"
+  end
+  
+  def tr_close(opts)
+    "\t</tr>\n"
+  end
+  
+  def table_open(opts)
+    "<table#{pba(opts)}>\n"
+  end
+  
+  def table_close(opts)
+    "</table>\n"
+  end
+  
+  def bc_open(opts)
+    opts[:block] = true
+    "<pre#{pba(opts)}>"
+  end
+  
+  def bc_close(opts)
+    "</pre>\n"
+  end
+  
+  def bq_open(opts)
+    opts[:block] = true
+    cite = opts[:cite] ? " cite=\"#{ escape_attribute opts[:cite] }\"" : ''
+    "<blockquote#{cite}#{pba(opts)}>\n"
+  end
+  
+  def bq_close(opts)
+    "</blockquote>\n"
+  end
+  
+  def link(opts)
+    "<a href=\"#{escape_attribute opts[:href]}\"#{pba(opts)}>#{opts[:name]}</a>"
+  end
+  
+  def image(opts)
+    opts.delete(:align)
+    opts[:alt] = opts[:title]
+    img = "<img src=\"#{escape_attribute opts[:src]}\"#{pba(opts)} alt=\"#{escape_attribute opts[:alt].to_s}\" />"  
+    img = "<a href=\"#{escape_attribute opts[:href]}\">#{img}</a>" if opts[:href]
+    img
+  end
+  
+  def footno(opts)
+    opts[:id] ||= opts[:text]
+    %Q{<sup class="footnote" id=\"fnr#{opts[:id]}\"><a href=\"#fn#{opts[:id]}\">#{opts[:text]}</a></sup>}
+  end
+  
+  def fn(opts)
+    no = opts[:id]
+    opts[:id] = "fn#{no}"
+    opts[:class] = ["footnote", opts[:class]].compact.join(" ")
+    "<p#{pba(opts)}><a href=\"#fnr#{no}\"><sup>#{no}</sup></a> #{opts[:text]}</p>\n"
+  end
+  
+  def snip(opts)
+    "<pre#{pba(opts)}><code>#{opts[:text]}</code></pre>\n"
+  end
+  
+  def quote1(opts)
+    "&#8216;#{opts[:text]}&#8217;"
+  end
+  
+  def quote2(opts)
+    "&#8220;#{opts[:text]}&#8221;"
+  end
+  
+  def multi_paragraph_quote(opts)
+    "&#8220;#{opts[:text]}"
+  end
+  
+  def ellipsis(opts)
+    "#{opts[:text]}&#8230;"
+  end
+  
+  def emdash(opts)
+    "&#8212;"
+  end
+  
+  def endash(opts)
+    " &#8211; "
+  end
+  
+  def arrow(opts)
+    "&#8594;"
+  end
+  
+  def dim(opts)
+    opts[:text].gsub!('x', '&#215;')
+    opts[:text].gsub!("'", '&#8242;')
+    opts[:text].gsub!('"', '&#8243;')
+    opts[:text]
+  end
+  
+  def trademark(opts)
+    "&#8482;"
+  end
+  
+  def registered(opts)
+    "&#174;"
+  end
+  
+  def copyright(opts)
+    "&#169;"
+  end
+  
+  def entity(opts)
+    "&#{opts[:text]};"
+  end
+  
+  def amp(opts)
+    "&amp;"
+  end
+  
+  def gt(opts)
+    "&gt;"
+  end
+  
+  def lt(opts)
+    "&lt;"
+  end
+  
+  def br(opts)
+    if hard_breaks == false
+      "\n"
+    else
+      "<br />\n"
+    end
+  end
+  
+  def quot(opts)
+    "&quot;"
+  end
+  
+  def squot(opts)
+    "&#8217;"
+  end
+  
+  def apos(opts)
+    "&#39;"
+  end
+  
+  def html(opts)
+    "#{opts[:text]}\n"
+  end
+  
+  def html_block(opts)
+    inline_html(:text => "#{opts[:indent_before_start]}#{opts[:start_tag]}#{opts[:indent_after_start]}") + 
+    "#{opts[:text]}" +
+    inline_html(:text => "#{opts[:indent_before_end]}#{opts[:end_tag]}#{opts[:indent_after_end]}")
+  end
+  
+  def notextile(opts)
+    if filter_html
+      html_esc(opts[:text], :html_escape_preformatted)
+    else
+      opts[:text]
+    end
+  end
+  
+  def inline_html(opts)
+    if filter_html
+      html_esc(opts[:text], :html_escape_preformatted)
+    else
+      "#{opts[:text]}" # nil-safe
+    end
+  end
+  
+  def ignored_line(opts)
+    opts[:text] + "\n"
+  end
+  
+private
+  
+  # escapement for regular HTML (not in PRE tag)
+  def escape(text)
+    html_esc(text)
+  end
+
+  # escapement for HTML in a PRE tag
+  def escape_pre(text)
+    html_esc(text, :html_escape_preformatted)
+  end
+  
+  # escaping for HTML attributes
+  def escape_attribute(text)
+    html_esc(text, :html_escape_attributes)
+  end
+  
+  def after_transform(text)
+    text.chomp!
+  end
+  
+  
+  def before_transform(text)
+    clean_html(text) if sanitize_html
+  end
+  
+  # HTML cleansing stuff
+  BASIC_TAGS = {
+      'a' => ['href', 'title'],
+      'img' => ['src', 'alt', 'title'],
+      'br' => [],
+      'i' => nil,
+      'u' => nil, 
+      'b' => nil,
+      'pre' => nil,
+      'kbd' => nil,
+      'code' => ['lang'],
+      'cite' => nil,
+      'strong' => nil,
+      'em' => nil,
+      'ins' => nil,
+      'sup' => nil,
+      'sub' => nil,
+      'del' => nil,
+      'table' => nil,
+      'tr' => nil,
+      'td' => ['colspan', 'rowspan'],
+      'th' => nil,
+      'ol' => ['start'],
+      'ul' => nil,
+      'li' => nil,
+      'p' => nil,
+      'h1' => nil,
+      'h2' => nil,
+      'h3' => nil,
+      'h4' => nil,
+      'h5' => nil,
+      'h6' => nil, 
+      'blockquote' => ['cite'],
+      'notextile' => nil
+  }
+  
+  # Clean unauthorized tags.
+  def clean_html( text, allowed_tags = BASIC_TAGS )
+    text.gsub!( /<!\[CDATA\[/, '' )
+    text.gsub!( /<(\/*)([A-Za-z]\w*)([^>]*?)(\s?\/?)>/ ) do |m|
+      raw = $~
+      tag = raw[2].downcase
+      if allowed_tags.has_key? tag
+        pcs = [tag]
+        allowed_tags[tag].each do |prop|
+          ['"', "'", ''].each do |q|
+            q2 = ( q != '' ? q : '\s' )
+            if raw[3] =~ /#{prop}\s*=\s*#{q}([^#{q2}]+)#{q}/i
+              attrv = $1
+              next if (prop == 'src' or prop == 'href') and not attrv =~ %r{^(http|https|ftp):}
+              pcs << "#{prop}=\"#{attrv.gsub('"', '\\"')}\""
+              break
+            end
+          end
+        end if allowed_tags[tag]
+        "<#{raw[1]}#{pcs.join " "}#{raw[4]}>"
+      else # Unauthorized tag
+        if block_given?
+          yield m
+        else
+          ''
+        end
+      end
+    end
+  end
+end