walrus 0.1

data/bin/walrus

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: diff.rb 89 2007-02-26 15:35:56Z wincent $
+
+module Walrus
+  
+  EXIT_LOAD_ERROR     = 1
+  EXIT_ARGUMENT_ERROR = 2
+  EXIT_OTHER_ERROR    = 3
+  
+  begin
+    require 'walrus/runner'
+  rescue LoadError => e
+    $stderr.puts <<-HERE
+Error: load error (#{e.to_s})
+
+If you are trying to run Walrus but have not yet installed it, it may be that
+Ruby cannot find the Walrus files. You can help Ruby to find the Walrus "lib"
+and "ext" directories by adding them to the RUBYLIB environment variable. For
+example, you could do the following if you are using the Bash shell,
+substituting absolute paths for "lib" and "ext":
+
+  export RUBYLIB="${RUBYLIB}:lib:ext"
+
+    HERE
+    exit EXIT_LOAD_ERROR
+  end
+  
+  begin  
+    Runner.new.run
+  rescue Runner::ArgumentError => e
+    $stderr.puts "Error: #{e.to_s}", "For usage information type: #{$0} --help"
+    exit EXIT_ARGUMENT_ERROR
+  rescue Runner::Error => e
+    $stderr.puts "Error: #{e.to_s}"
+    exit EXIT_OTHER_ERROR
+  end
+  
+end # module Walrus

data/ext/jindex/extconf.rb

@@ -0,0 +1,11 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'mkmf'
+create_makefile('jindex')
+

data/ext/jindex/jindex.c

@@ -0,0 +1,79 @@
+/* 
+Copyright 2007 Wincent Colaiuta
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+in the accompanying file, "LICENSE.txt", for more details.
+
+$Id$
+*/
+
+#include <ruby.h>
+
+/*
+
+Common code used by almost identical "jindex" and "jrindex" methods. A C extension is necessary here because with direct access to the rb_backref_get and rb_backref_set API there is no way to propagate $~ back to the caller after invoking the "index" and "rindex" methods. The code is basically equivalent to the following Ruby code:
+
+def index arg1, optional_arg
+  index = super                                     # plus code here for deciding whether or not to pass optional argument
+  match = ($~ ? $~.clone : nil)                     
+  index unpack('C*')[0...index].pack('C*').jlength  # jlength clobbers $~ as a side effect, should consider rewriting it
+  $~ = match                                        # in pure Ruby setting $~ here has only a local effect (not seen by caller)
+  index
+end
+
+*/
+static VALUE walrus_str_index_common(ID func, int argc, VALUE *argv, VALUE str)
+{
+    VALUE jindex                = Qnil;                                                                 /* default return value */
+    VALUE index                 = rb_funcall2(str, func, argc, argv);                                   /* call String#index or String#rindex*/
+    VALUE match                 = rb_backref_get();                                                     /* save $~ */
+    if (!NIL_P(index))
+    {
+        VALUE packing_format    = rb_str_new2("C*");
+        VALUE unpacked          = rb_funcall(str, rb_intern("unpack"), 1, packing_format);              /* unpack('C*') */
+        VALUE range             = rb_funcall(rb_cRange, rb_intern("new"), 3, INT2FIX(0), index, Qtrue);        
+        VALUE slice             = rb_funcall(unpacked, rb_intern("slice"), 1, range);                   /* [0...idx] */
+        VALUE packed            = rb_funcall(slice, rb_intern("pack"), 1, packing_format);              /* pack('C*') */
+        jindex                  = rb_funcall(packed, rb_intern("jlength"), 0);                          /* jlength */
+    }
+    rb_backref_set(match);                                                                              /* restore $~ */
+    return jindex;
+}
+
+/*
+
+call-seq:
+    str.jindex(substring [, offset])    -> Fixnum or nil
+    str.jindex(fixnum [, offset])       -> Fixnum or nil
+    str.jindex(regexp [, offset])       -> Fixnum or nil
+
+Multibyte-friendly equivalent of the String#index method. If $KCODE is appropriately set will return an accurate index based on character count rather than byte counts.
+
+*/
+static VALUE walrus_str_jindex_m(int argc, VALUE *argv, VALUE str)
+{
+    return walrus_str_index_common(rb_intern("index"), argc, argv, str);
+}
+
+/*
+
+call-seq:
+    str.jrindex(substring [, offset])   -> Fixnum or nil
+    str.jrindex(fixnum [, offset])      -> Fixnum or nil
+    str.jrindex(regexp [, offset])      -> Fixnum or nil
+
+Multibyte-friendly equivalent of the String#rindex method. If $KCODE is appropriately set will return an accurate index based on character count rather than byte counts.
+
+*/
+static VALUE walrus_str_jrindex_m(int argc, VALUE *argv, VALUE str)
+{
+    return walrus_str_index_common(rb_intern("rindex"), argc, argv, str);
+}
+
+void Init_jindex()
+{
+    rb_define_method(rb_cString, "jindex", walrus_str_jindex_m, -1);
+    rb_define_method(rb_cString, "jrindex", walrus_str_jrindex_m, -1);
+}
+

data/ext/mkdtemp/extconf.rb

@@ -0,0 +1,11 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'mkmf'
+create_makefile('mkdtemp')
+

data/ext/mkdtemp/mkdtemp.c

@@ -0,0 +1,41 @@
+/* 
+Copyright 2007 Wincent Colaiuta
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+in the accompanying file, "LICENSE.txt", for more details.
+
+$Id$
+*/
+
+#include <ruby.h>
+#include <errno.h>
+
+/*
+
+call-seq:
+    Dir.mkdtemp([string])   -> String or nil
+
+This method securely creates temporary directories. It is a wrapper for the mkdtemp() function in the standard C library. It takes an optional String parameter as a template describing the desired form of the directory name; if no template is supplied then "/tmp/temp.XXXXXX" is used as a default.
+
+*/
+static VALUE walrus_dir_mkdtemp_m(int argc, VALUE *argv, VALUE self)
+{
+    VALUE template;
+    if (rb_scan_args(argc, argv, "01", &template) == 0)                         /* check for 0 mandatory arguments, 1 optional argument */
+        template = Qnil;                                                        /* default to nil if no argument passed */
+    if (NIL_P(template))
+        template = rb_str_new2("/tmp/temp.XXXXXX");                             /* fallback to this template if passed nil */
+    SafeStringValue(template);                                                  /* raises if template is tainted and SAFE level > 0 */
+    VALUE safe  = StringValue(template);                                        /* duck typing support */
+    char *path  = mkdtemp(RSTRING(safe)->ptr);
+    if (path == NULL)
+        rb_raise(rb_eSystemCallError, "mkdtemp failed (error: %d)", errno);
+    return rb_str_new2(path);
+}
+
+void Init_mkdtemp()
+{
+    rb_define_module_function(rb_cDir, "mkdtemp", walrus_dir_mkdtemp_m, -1);
+}
+

data/lib/walrus/additions/module.rb

@@ -0,0 +1,36 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus'
+
+class Module
+  
+private
+  
+  def attr_accessor_bycopy(*symbols)
+    symbols.each { |symbol| attr_bycopy(symbol, true) }
+  end
+  
+  def attr_bycopy(symbol, writeable = false)
+    attr_reader symbol
+    attr_writer_bycopy(symbol) if writeable
+  end
+  
+  def attr_writer_bycopy(*symbols)
+    symbols.each do |symbol|
+      self.module_eval %Q{
+        def #{symbol.id2name}=(value)
+          @#{symbol.id2name} = value.clone
+        rescue TypeError
+          @#{symbol.id2name} = value
+        end
+      }
+    end
+  end
+  
+end # class Module

data/lib/walrus/additions/string.rb

@@ -0,0 +1,37 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus'
+
+# Additions to String class for Unicode support.
+class String
+  
+  # Converts the receiver of the form "FooBar" to "foo_bar".
+  # Concretely, the receiver is split into words, each word lowercased, and the words are joined together using a lower-case separator. "Words" are considered to be runs of characters starting with an initial capital letter (note that words may begin with consecutive capital letters), and numbers may mark the start or the end of a word.
+  # Note that some information loss may be incurred; for example, "EOLToken" would be reduced to "eol_token".
+  def to_require_name
+    base = self.gsub(/([^A-Z_])([A-Z])/, '\1_\2')       # insert an underscore before any initial capital letters
+    base.gsub!(/([A-Z])([A-Z])([^A-Z0-9_])/, '\1_\2\3') # consecutive capitals are words too, excluding any following capital that belongs to the next word
+    base.gsub!(/([^0-9_])(\d)/, '\1_\2')                # numbers mark the start of a new word
+    base.gsub!(/(\d)([^0-9_])/, '\1_\2')                # numbers also mark the end of a word
+    base.downcase                                       # lowercase everything
+  end
+  
+  # Converts the receiver of the form "foo_bar" to "FooBar".
+  # Specifically, the receiver is split into pieces delimited by underscores, each component is then converted to captial case (the first letter is capitalized and the remaining letters are lowercased) and finally the components are joined.
+  # Note that this method cannot recover information lost during a conversion using the require_name_from_classname method; for example, "EOL", when converted to "token", would be transformed back to "EolToken". Likewise, "Foo__bar" would be reduced to "foo__bar" and then in the reverse conversion would become "FooBar".
+  def to_class_name
+    self.split('_').collect { |component| component.capitalize}.join
+  end
+  
+  # Returns a copy of the receiver with occurrences of \ replaced with \\, and occurrences of ' replaced with \'
+  def to_source_string
+    gsub(/[\\']/, '\\\\\&')
+  end
+  
+end # class String

data/lib/walrus/additions/test/unit/error_collector.rb

@@ -0,0 +1,62 @@
+# Copyright 2007 Wincent Colaiuta
+# $Id$
+
+require 'walrus'
+
+module Test
+  module Unit
+    
+    # See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/138320
+    # Usage:
+    # 
+    #   require 'test/unit'
+    #   require 'walrus/additions/test/unit/error_collector'
+    #   
+    #   class TestClass < Test::Unit::TestCase
+    #     
+    #     include Test::Unit::ErrorCollector
+    #     
+    #     def test_method
+    #       collecting_errors do
+    #         assert false
+    #         assert false
+    #       end
+    #     end
+    #     
+    #   end
+    #   
+    module ErrorCollector
+      
+      def collecting_errors
+        # save state prior to yielding to block
+        is_collecting = @is_collecting
+        @is_collecting = true
+        yield
+      ensure
+        # restore state on leaving block
+        @is_collecting = is_collecting
+      end
+      
+      def raise(*)
+        super
+      rescue Test::Unit::AssertionFailedError
+        handle_error(:add_failure, $!)
+      rescue StandardError, ScriptError
+        handle_error(:add_error, $!)
+      end
+      
+      def handle_error(method, error)
+        backtrace = error.backtrace
+        backtrace.shift # raise shouldn't appear in the backtrace
+        if @is_collecting
+          backtrace.slice!(5, 2) # remove collecting_errors and corresponding block
+          send(method, error.message, backtrace)
+        else
+          Kernel.raise(error, error.message, backtrace)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/walrus/compile_error.rb

@@ -0,0 +1,28 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'walrus'
+
+module Walrus
+  class Grammar
+    
+    class CompileError < Exception
+      
+      # take an optional hash (for packing extra info into exception?)
+      # position in AST/source file
+      # line number, column number
+      # filename
+      def initialize(message, info = {})
+        super message
+      end
+      
+    end # class CompileError
+    
+  end # class Grammar
+end # module Walrus
+

data/lib/walrus/compiler.rb

@@ -0,0 +1,124 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/compiler.rb 6709 2007-04-10T05:38:46.657919Z wincent  $
+
+require 'walrus'
+require 'pathname'
+
+module Walrus
+  class Compiler
+    
+    BODY_INDENT     = ' ' * 8
+    OUTSIDE_INDENT  = ' ' * 6
+    DEFAULT_CLASS   = 'DocumentSubclass'
+    
+    # The public compiler class serves as the interface with the outside world. For thread-safety and concurrency, an inner, private Instance class is spawned in order to perform the actual compilation.
+    class Instance
+      
+      def initialize(options)        
+        @class_name     = (options[:class_name] || DEFAULT_CLASS).to_s
+        @template_body  = []  # will accumulate items for body, and joins them at the end of processing
+        @outside_body   = []  # will accumulate items for outside of body, and joins them at the end of processing
+      end
+      
+      def compile_subtree(subtree)
+        template_body   = [] # local variable
+        outside_body    = [] # local variable
+        subtree = [subtree] unless subtree.respond_to? :each
+        options = { :compiler_instance => self } # reset
+        subtree.each do |element|          
+          # def/block and include directives may return two items
+          if element.kind_of? WalrusGrammar::DefDirective or element.kind_of? WalrusGrammar::IncludeDirective
+            inner, outer = element.compile(options)
+            outer.each { |line| outside_body << OUTSIDE_INDENT + line } if outer
+            inner.each { |line| template_body << BODY_INDENT + line } if inner
+          elsif element.instance_of? WalrusGrammar::ExtendsDirective  # defines superclass and automatically invoke #super (super) at the head of the template_body
+            raise CompileError.new('#extends may be used only once per template') unless @extends_directive.nil?
+            raise CompileError.new('illegal #extends (#import already used in this template)') unless @import_directive.nil?
+            @extends_directive = element.compile(options)
+          elsif element.instance_of? WalrusGrammar::ImportDirective   # defines superclass with no automatic invocation of #super on the template_body
+            raise CompileError.new('#import may be used only once per template') unless @import_directive.nil?
+            raise CompileError.new('illegal #import (#extends already used in this template)') unless @extends_directive.nil?
+            @import_directive = element.compile(options)
+          elsif element.kind_of? WalrusGrammar::Comment and element.column_start == 0  # special case if comment is only thing on input line
+            template_body << BODY_INDENT + element.compile(options)
+            options[:slurping] = true
+            next
+          else                                                    # everything else gets added to the template_body
+            element.compile(options).each { |line| template_body << BODY_INDENT + line } # indent by 6 spaces
+          end
+          options = { :compiler_instance => self } # reset
+        end
+        [template_body, outside_body]
+      end
+      
+      def compile(tree)
+        inner, outer = compile_subtree(tree)
+        @template_body.concat inner if inner
+        @outside_body.concat outer if outer
+        if @import_directive
+          superclass_name = @import_directive.class_name
+          require_line    = "require 'walrus/document'\n" + @import_directive.require_line
+        elsif @extends_directive
+          superclass_name = @extends_directive.class_name
+          require_line    = "require 'walrus/document'\n" + @extends_directive.require_line
+          @template_body.unshift BODY_INDENT + "super # (invoked automatically due to Extends directive)\n"
+        else
+          superclass_name = 'Document'
+          require_line    = "require 'walrus/document'"
+        end
+
+        <<-RETURN
+\#!/usr/bin/env ruby
+\# Generated #{Time.new.to_s} by Walrus version #{VERSION}
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # installing Walrus via RubyGems is recommended
+  # otherwise Walrus must be installed in the RUBYLIB load path
+end
+
+#{require_line}
+
+module Walrus
+
+  class WalrusGrammar
+
+    class #{@class_name} < #{superclass_name}
+
+      def template_body
+
+#{@template_body.join}
+      end
+
+#{@outside_body.join}    
+      if __FILE__ == $0   # when run from the command line the default action is to call 'run'
+        new.run
+      end
+
+    end \# #{@class_name}
+
+  end \# WalrusGrammar
+
+end \# Walrus
+
+        RETURN
+        
+      end
+      
+    end
+    
+    # Walks the Abstract Syntax Tree, tree, that represents a parsed Walrus template.
+    # Returns a String that defines a Document subclass corresponding to the compiled version of the tree.
+    def compile(tree, options = {})
+      Instance.new(options).compile(tree)
+    end
+    
+  end # class Compiler
+end # module Walrus
+

data/lib/walrus/contrib/spec/walruscloth_spec.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id: /mirrors/Walrus/trunk/walrus/lib/walrus/contrib/spec/walruscloth_spec.rb 6702 2007-04-09T15:04:40.448669Z wincent  $
+
+require 'rubygems'
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'walruscloth')
+
+describe 'using WalrusCloth' do
+  
+  it 'should be able to create an unordered list' do
+    # => "<ul>\n\t<li>hello</li>\n\t</ul>"
+    WalrusCloth.new('* hello').to_html.should == RedCloth.new('* hello').to_html
+  end
+  
+  it 'should be able to create an ordered list' do
+    # => "<ol>\n\t<li>hello</li>\n\t</ol>"
+    WalrusCloth.new('` hello').to_html.should == RedCloth.new('# hello').to_html
+  end
+  
+  it 'should be able to nest lists' do
+    # => "<ol>\n\t<li>hello\n\t<ul>\n\t<li>world</li>\n\t</ol></li>\n\t</ul>"
+    WalrusCloth.new("` hello\n`* world").to_html.should == RedCloth.new("# hello\n#* world").to_html
+  end
+  
+end
+

data/lib/walrus/contrib/walruscloth.rb

@@ -0,0 +1,82 @@
+# Copyright 2007 Wincent Colaiuta
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# in the accompanying file, "LICENSE.txt", for more details.
+#
+# $Id$
+
+require 'rubygems'
+gem 'RedCloth', '= 3.0.4'; require 'redcloth'
+
+# WalrusCloth is a RedCloth subclass that makes minimal modifications for ease of use with Walrus. Specifically, it makes two changes:
+#
+#   1. The hash or pound character (#) no longer indicates an ordered list; the backtick (`) character is used instead.
+#   2. Only Textile rules are used by default, instead of Textile and Markdown.
+#
+# These changes are made because the hash character already has special meaning in Walrus as a directive marker. Textile is preferred over Markdown because it uses the hash character less extensively (in Markdown it is used as a heading indicator) and does not allow the backslash to be used as an escape marker (which again clashes with Walrus). Without these modifications it would be difficult to use RedCloth as a pre- or post-processor for Walrus templates because many characters would have to be specially escaped. This is particularly the case for the Walrus documentation itself where the documentation includes a lot of literal hash characters.
+#
+# I considered a number of possible workarounds to the problem, including making a fork of RedCloth. This fork basically consisted of a clean export of the latest RedCloth release with a project-wide replacement of "WalrusCloth" for "RedCloth" and "walruscloth" for "redcloth"; file names were also changed accordingly. Then the regular expressions that define Textile lists were modified. The benefit of this method was that there was no possibility of clashes with any installed version of RedCloth, but it was decidedly inelegant and the changes broke the RedCloth tests.
+#
+# In the end I decided to subclass RedCloth and override the list-detection regular expressions dynamically. This is somewhat cleaner and easier to maintain although it is still not a perfect solution (see limitations below). It's because of these limitations, together with the fact that I don't want to introduce a dependency on a third-party gem, that WalrusCloth is in the "contrib" subdirectory rather than in the Walrus core.
+#
+# Usage
+# =====
+#
+#   require 'walrus/contrib/walruscloth'
+#   WalrusCloth.new("` hello\n` world").to_html # note the space between the backtick and the list item content
+#   # => "<ul>\n\t<li>hello</li>\n\t\t<li>world</li>\n\t</ul>"
+#
+# Limitations
+# ===========
+#
+# * Fragility: This technique could break for any future release of RedCloth if the way in which list-detection is implemented is changed.
+# * Threading: Because this technique changes constants in the RedCloth namespace (albeit temporarily) it is not necessarily very "thread-friendly" if two threads are concurrently trying to use RedCloth and WalrusCloth concurrently. The only way to avoid this issues would be to reimplement the block_textile_lists entirely and that would again be a fragility consideration and a maintenance burden.
+# * Warnings: This technique temporarily overrides constants and then restores them to their initial values; this would normally cause "already initialized constant" warnings but they are suppressed here by temporarily altering the $VERBOSE global variable, which is not very elegant.
+# * Imparity: Given that this is only a partial override it is possible that some edge and corner cases will fail: for example, inspection of the RedCloth code indicates that it may be necessary to override the "blocks" method (and possibly others) to achieve total parity.
+#
+class WalrusCloth < RedCloth
+  
+  def to_html(*rules)
+    rules = :textile if rules.empty?
+    begin
+      old_lists_re          = RedCloth::LISTS_RE            # save original values
+      old_lists_content_re  = RedCloth::LISTS_CONTENT_RE
+      silently do                                           # override
+        RedCloth::const_set('LISTS_RE', /^([`*]+?#{RedCloth::C} .*?)$(?![^`*])/m)
+        RedCloth::const_set('LISTS_CONTENT_RE', /^([`*]+)(#{RedCloth::A}#{RedCloth::C}) (.*)$/m)
+      end      
+      super rules                                           # process
+    ensure                                                  # restore original values
+      silently do
+        RedCloth::const_set('LISTS_RE', old_lists_re)
+        RedCloth::const_set('LISTS_CONTENT_RE', old_lists_content_re)
+      end
+    end
+  end
+  
+  # "lT" presumably stands for "list type" (ordered or unordered)
+  def lT( text ) 
+    #text =~ /\#$/ ? 'o' : 'u'
+    text =~ /`$/ ? 'o' : 'u'
+  end
+  
+  def hard_break( text )
+    #text.gsub!( /(.)\n(?!\Z| *([#*=]+(\s|$)|[{|]))/, "\\1<br />" ) if hard_breaks
+    text.gsub!( /(.)\n(?!\Z| *([`*=]+(\s|$)|[{|]))/, "\\1<br />" ) if hard_breaks
+  end
+  
+private
+  
+  # Nasty hack to prevent Ruby from emitting "already initialized constant" warnings when overriding constants.
+  # Sets $VERBOSE to nil, executes the passed block, then restores $VERBOSE to its previous state.
+  def silently &block
+    begin
+      verbose = $VERBOSE; $VERBOSE = nil  # save
+      yield
+    ensure
+      $VERBOSE = verbose                  # restore
+    end
+  end
+  
+end # WalrusCloth