kramdown 0.11.0 → 0.12.0

data/doc/tests.page

@@ -30,8 +30,8 @@ kramdown comes with a small benchmark to test how fast it is in regard to four o
 implementations: Maruku, BlueFeather, BlueCloth and RDiscount. The first two are written using only
 Ruby, the latter two use the C discount library for the actual hard work (which makes them really
 fast but they do not provide additional syntax elements). As one can see below, kramdown is
-currently (June 2010) ~4x faster than Maruku, ~9x faster than BlueFeather but ~30x slower than
-BlueCloth and rdiscount:
+currently (November 2010) ~3-4x faster than Maruku, ~4-5x faster than BlueFeather but ~30x slower
+than BlueCloth and rdiscount:
 
 <pre><code>
 {execute_cmd: {command: "ruby -Ilib -rubygems benchmark/benchmark.rb", process_output: false, escape_html: true}}
@@ -41,11 +41,12 @@ BlueCloth and rdiscount:
 And here are some graphs which show the execution times of the various kramdown releases on
 different Ruby interpreters:
 
-![ruby 1.8.6]({relocatable: img/graph-ruby-1.8.6.png})
-![ruby 1.8.7]({relocatable: img/graph-ruby-1.8.7.png})
-![ruby 1.9.1p243]({relocatable: img/graph-ruby-1.9.1p243.png})
-![ruby 1.9.2dev]({relocatable: img/graph-ruby-1.9.2dev.png})
-![jruby 1.4.0]({relocatable: img/graph-jruby-1.4.0.png})
+![ruby 1.8.5p231]({relocatable: img/graph-ruby-1.8.5-231.png})
+![ruby 1.8.6p399]({relocatable: img/graph-ruby-1.8.6-399.png})
+![ruby 1.8.7p249]({relocatable: img/graph-ruby-1.8.7-249.png})
+![ruby 1.8.7p302]({relocatable: img/graph-ruby-1.8.7-302.png})
+![ruby 1.9.2p0]({relocatable: img/graph-ruby-1.9.2p0-0.png})
+![jruby 1.5.3]({relocatable: img/graph-jruby-1.5.3-249.png})
 
 [Markdown Test Suite]: http://daringfireball.net/projects/downloads/MarkdownTest_1.0.zip
 [MDTest]: http://www.michelf.com/docs/projets/mdtest-1.0.zip

data/lib/kramdown/compatibility.rb

@@ -19,8 +19,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 #
-
 # All the code in this file is backported from Ruby 1.8.7 sothat kramdown works under 1.8.5
+#
+# :stopdoc:
 
 if RUBY_VERSION == '1.8.5'
   require 'rexml/parsers/baseparser'

data/lib/kramdown/converter.rb

@@ -22,14 +22,12 @@
 
 module Kramdown
 
-  # == Converter Module
+  # This module contains all available converters, i.e. classes that take a root Element and convert
+  # it to a specific output format. The result is normally a string. For example, the
+  # Converter::Html module converts an element tree into valid HTML.
   #
-  # This module contains all available converters, i.e. classes that take a document and convert the
-  # document tree to a specific output format, normally a string. For example, the Html module
-  # converts the document tree into HTML.
-  #
-  # Converters use the Base class for common functionality (like applying a template to the output)-
-  # see its API documentation for how to create a converter class.
+  # Converters use the Base class for common functionality (like applying a template to the output)
+  # \- see its API documentation for how to create a custom converter class.
   module Converter
 
     autoload :Base, 'kramdown/converter/base'

data/lib/kramdown/converter/base.rb

@@ -26,57 +26,91 @@ module Kramdown
 
   module Converter
 
-    # == Base class for converters
+    # == \Base class for converters
     #
     # This class serves as base class for all converters. It provides methods that can/should be
     # used by all converters (like #generate_id) as well as common functionality that is
     # automatically applied to the result (for example, embedding the output into a template).
     #
-    # == Implementing a converter
+    # A converter object is used as a throw-away object, i.e. it is only used for storing the needed
+    # state information during conversion. Therefore one can't instantiate a converter object
+    # directly but only use the Base::convert method.
     #
-    # Implementing a new converter is rather easy: just create a new sub class from this class and
-    # put it in the Kramdown::Converter module (the latter is only needed if auto-detection should
-    # work properly). Then you need to implement the #convert(tree) method which takes a document
-    # tree and should return the converted output.
+    # == Implementing a converter
     #
-    # The document instance is automatically set as @doc in Base#initialize. Furthermore, the
-    # document instance provides a hash called `conversion_infos` that is also automatically cleared
-    # and can be used to store information about the conversion process.
+    # Implementing a new converter is rather easy: just derive a new class from this class and put
+    # it in the Kramdown::Converter module (the latter is only needed if auto-detection should work
+    # properly). Then you need to implement the <tt>convert(el)</tt> method which has to contain
+    # the conversion code for converting an element and has to return the conversion result.
     #
     # The actual transformation of the document tree can be done in any way. However, writing one
-    # method per tree element type is a straight forward way to do it - this is how the Html and
-    # Latex converters do the transformation.
+    # method per element type is a straight forward way to do it - this is how the Html and Latex
+    # converters do the transformation.
+    #
+    # Have a look at the Base::convert method for additional information!
     class Base
 
-      # Initialize the converter with the given Kramdown document +doc+.
-      def initialize(doc)
-        @doc = doc
-        @doc.conversion_infos.clear
+      # Can be used by a converter for storing arbitrary information during the conversion process.
+      attr_reader :data
+
+      # The hash with the conversion options.
+      attr_reader :options
+
+      # The root element that is converted.
+      attr_reader :root
+
+      # The warnings array.
+      attr_reader :warnings
+
+      # Initialize the converter with the given +root+ element and +options+ hash.
+      def initialize(root, options)
+        @options = options
+        @root = root
+        @data = {}
+        @warnings = []
       end
       private_class_method(:new, :allocate)
 
-      # Convert the Kramdown document +doc+ to the output format implemented by a subclass.
+      # Convert the element tree +tree+ and return the resulting conversion object (normally a
+      # string) and an array with warning messages. The parameter +options+ specifies the conversion
+      # options that should be used.
+      #
+      # Initializes a new instance of the calling class and then calls the #convert method with
+      # +tree+ as parameter. If the +template+ option is specified and non-empty, the result is
+      # rendered into the specified template. The template resolution is done in the following way:
+      #
+      # 1. Look in the current working directory for the template.
+      #
+      # 2. Append <tt>.convertername</tt> (e.g. +.html+) to the template name and look for the
+      #    resulting file in the current working directory.
       #
-      # Initializes a new instance of the calling class and then calls the #convert method that must
-      # be implemented by each subclass. If the +template+ option is specified and non-empty, the
-      # result is rendered into the specified template.
-      def self.convert(doc)
-        result = new(doc).convert(doc.tree)
-        result = apply_template(doc, result) if !doc.options[:template].empty?
-        result
+      # 3. Append <tt>.convertername</tt> to the template name and look for it in the kramdown data
+      #    directory.
+      def self.convert(tree, options = {})
+        converter = new(tree, ::Kramdown::Options.merge(options.merge(tree.options[:options] || {})))
+        result = converter.convert(tree)
+        result = apply_template(converter, result) if !converter.options[:template].empty?
+        [result, converter.warnings]
       end
 
-      # Apply the template specified in the +doc+ options, using +body+ as the body string.
-      def self.apply_template(doc, body)
-        erb = ERB.new(get_template(doc.options[:template]))
+      # Convert the element +el+ and return the resulting object.
+      #
+      # This is the only method that has to be implemented by sub-classes!
+      def convert(el)
+        raise NotImplementedError
+      end
+
+      # Apply the +template+ using +body+ as the body string.
+      def self.apply_template(converter, body) # :nodoc:
+        erb = ERB.new(get_template(converter.options[:template]))
         obj = Object.new
-        obj.instance_variable_set(:@doc, doc)
+        obj.instance_variable_set(:@converter, converter)
         obj.instance_variable_set(:@body, body)
         erb.result(obj.instance_eval{binding})
       end
 
       # Return the template specified by +template+.
-      def self.get_template(template)
+      def self.get_template(template) # :nodoc:
         format_ext = '.' + self.name.split(/::/).last.downcase
         shipped = File.join(::Kramdown.data_dir, template + format_ext)
         if File.exist?(template)
@@ -90,18 +124,39 @@ module Kramdown
         end
       end
 
+      # Add the given warning +text+ to the warning array.
+      def warning(text)
+        @warnings << text
+      end
 
-      # Generate an unique alpha-numeric ID from the the string +str+ for use as header ID.
+      # Return +true+ if the header element +el+ should be used for the table of contents (as
+      # specified by the +toc_levels+ option).
+      def in_toc?(el)
+        if @options[:toc_depth] >= 0
+          warn('Option toc_depth is deprecated, use the new option toc_levels instead')
+          @options[:toc_depth] == 0 || el.options[:level] <= @options[:toc_depth]
+        else
+          @options[:toc_levels].include?(el.options[:level])
+        end
+      end
+
+      # Generate an unique alpha-numeric ID from the the string +str+ for use as a header ID.
+      #
+      # Uses the option +auto_id_prefix+: the value of this option is prepended to every generated
+      # ID.
       def generate_id(str)
-        gen_id = str.gsub(/[^a-zA-Z0-9 -]/, '').gsub(/^[^a-zA-Z]*/, '').gsub(' ', '-').downcase
+        gen_id = str.gsub(/^[^a-zA-Z]+/, '')
+        gen_id.tr!('^a-zA-Z0-9 -', '')
+        gen_id.tr!(' ', '-')
+        gen_id.downcase!
         gen_id = 'section' if gen_id.length == 0
         @used_ids ||= {}
         if @used_ids.has_key?(gen_id)
-          gen_id += '-' + (@used_ids[gen_id] += 1).to_s
+          gen_id += '-' << (@used_ids[gen_id] += 1).to_s
         else
           @used_ids[gen_id] = 0
         end
-        @doc.options[:auto_id_prefix] + gen_id
+        @options[:auto_id_prefix] + gen_id
       end
 
     end

data/lib/kramdown/converter/html.rb

@@ -27,74 +27,97 @@ module Kramdown
   module Converter
 
     # Converts a Kramdown::Document to HTML.
+    #
+    # You can customize the HTML converter by sub-classing it and overriding the
+    # <tt>convert_NAME</tt> methods. Each such method takes the following parameters:
+    #
+    # [+el+] The element of type +NAME+ to be converted.
+    #
+    # [+indent+] A number representing the current amount of spaces for indent (only used for
+    #            block-level elements).
+    #
+    # The return value of such a method has to be a string containing the element +el+ formatted as
+    # HTML element.
     class Html < Base
 
-      include ::Kramdown::Utils::HTML
-
-      # :stopdoc:
-
-      # Defines the amount of indentation used when nesting HTML tags.
-      INDENTATION = 2
-
       begin
         require 'coderay'
 
         # Highlighting via coderay is available if this constant is +true+.
         HIGHLIGHTING_AVAILABLE = true
       rescue LoadError => e
-        HIGHLIGHTING_AVAILABLE = false
+        HIGHLIGHTING_AVAILABLE = false  # :nodoc:
       end
 
+      include ::Kramdown::Utils::Html
+
+
+      # The amount of indentation used when nesting HTML tags.
+      attr_accessor :indent
+
       # Initialize the HTML converter with the given Kramdown document +doc+.
-      def initialize(doc)
+      def initialize(root, options)
         super
-        @footnote_counter = @footnote_start = @doc.options[:footnote_nr]
+        @footnote_counter = @footnote_start = @options[:footnote_nr]
         @footnotes = []
         @toc = []
         @toc_code = nil
+        @indent = 2
+        @stack = []
       end
 
-      def convert(el, indent = -INDENTATION, opts = {})
-        send("convert_#{el.type}", el, indent, opts)
+      # The mapping of element type to conversion method.
+      DISPATCHER = Hash.new {|h,k| h[k] = "convert_#{k}"}
+
+      # Dispatch the conversion of the element +el+ to a <tt>convert_TYPE</tt> method using the
+      # +type+ of the element.
+      def convert(el, indent = -@indent)
+        send(DISPATCHER[el.type], el, indent)
       end
 
-      def inner(el, indent, opts)
+      # Return the converted content of the children of +el+ as a string. The parameter +indent+ has
+      # to be the amount of indentation used for the element +el+.
+      #
+      # Pushes +el+ onto the <tt>@stack</tt> before converting the child elements and pops it from
+      # the stack afterwards.
+      def inner(el, indent)
         result = ''
-        indent += INDENTATION
+        indent += @indent
+        @stack.push(el)
         el.children.each do |inner_el|
-          opts[:parent] = el
-          result << send("convert_#{inner_el.type}", inner_el, indent, opts)
+          result << send(DISPATCHER[inner_el.type], inner_el, indent)
         end
+        @stack.pop
         result
       end
 
-      def convert_blank(el, indent, opts)
+      def convert_blank(el, indent)
         "\n"
       end
 
-      def convert_text(el, indent, opts)
+      def convert_text(el, indent)
         escape_html(el.value, :text)
       end
 
-      def convert_p(el, indent, opts)
+      def convert_p(el, indent)
         if el.options[:transparent]
-          "#{inner(el, indent, opts)}"
+          inner(el, indent)
         else
-          "#{' '*indent}<p#{html_attributes(el)}>#{inner(el, indent, opts)}</p>\n"
+          "#{' '*indent}<p#{html_attributes(el.attr)}>#{inner(el, indent)}</p>\n"
         end
       end
 
-      def convert_codeblock(el, indent, opts)
-        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
-        lang = el.attr.delete('lang')
-        if lang && HIGHLIGHTING_AVAILABLE
-          opts = {:wrap => @doc.options[:coderay_wrap], :line_numbers => @doc.options[:coderay_line_numbers],
-            :line_number_start => @doc.options[:coderay_line_number_start], :tab_width => @doc.options[:coderay_tab_width],
-            :bold_every => @doc.options[:coderay_bold_every], :css => @doc.options[:coderay_css]}
-          result = CodeRay.scan(el.value, lang.to_sym).html(opts).chomp + "\n"
-          "#{' '*indent}<div#{html_attributes(el)}>#{result}#{' '*indent}</div>\n"
+      def convert_codeblock(el, indent)
+        if el.attr['lang'] && HIGHLIGHTING_AVAILABLE
+          attr = el.attr.dup
+          opts = {:wrap => @options[:coderay_wrap], :line_numbers => @options[:coderay_line_numbers],
+            :line_number_start => @options[:coderay_line_number_start], :tab_width => @options[:coderay_tab_width],
+            :bold_every => @options[:coderay_bold_every], :css => @options[:coderay_css]}
+          result = CodeRay.scan(el.value, attr.delete('lang').to_sym).html(opts).chomp << "\n"
+          "#{' '*indent}<div#{html_attributes(attr)}>#{result}#{' '*indent}</div>\n"
         else
           result = escape_html(el.value)
+          result.chomp!
           if el.attr['class'].to_s =~ /\bshow-whitespaces\b/
             result.gsub!(/(?:(^[ \t]+)|([ \t]+$)|([ \t]+))/) do |m|
               suffix = ($1 ? '-l' : ($2 ? '-r' : ''))
@@ -106,45 +129,41 @@ module Kramdown
               end.join('')
             end
           end
-          "#{' '*indent}<pre#{html_attributes(el)}><code>#{result}#{result =~ /\n\Z/ ? '' : "\n"}</code></pre>\n"
+          "#{' '*indent}<pre#{html_attributes(el.attr)}><code>#{result}\n</code></pre>\n"
         end
       end
 
-      def convert_blockquote(el, indent, opts)
-        "#{' '*indent}<blockquote#{html_attributes(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</blockquote>\n"
+      def convert_blockquote(el, indent)
+        "#{' '*indent}<blockquote#{html_attributes(el.attr)}>\n#{inner(el, indent)}#{' '*indent}</blockquote>\n"
       end
 
-      def convert_header(el, indent, opts)
-        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
-        if @doc.options[:auto_ids] && !el.attr['id']
-          el.attr['id'] = generate_id(el.options[:raw_text])
+      def convert_header(el, indent)
+        attr = el.attr.dup
+        if @options[:auto_ids] && !attr['id']
+          attr['id'] = generate_id(el.options[:raw_text])
         end
-        @toc << [el.options[:level], el.attr['id'], el.children] if el.attr['id'] && within_toc_depth?(el)
-        "#{' '*indent}<h#{el.options[:level]}#{html_attributes(el)}>#{inner(el, indent, opts)}</h#{el.options[:level]}>\n"
+        @toc << [el.options[:level], attr['id'], el.children] if attr['id'] && in_toc?(el)
+        "#{' '*indent}<h#{el.options[:level]}#{html_attributes(attr)}>#{inner(el, indent)}</h#{el.options[:level]}>\n"
       end
 
-      def within_toc_depth?(el)
-        @doc.options[:toc_depth] <= 0 || el.options[:level] <= @doc.options[:toc_depth]
-      end
-
-      def convert_hr(el, indent, opts)
+      def convert_hr(el, indent)
         "#{' '*indent}<hr />\n"
       end
 
-      def convert_ul(el, indent, opts)
+      def convert_ul(el, indent)
         if !@toc_code && (el.options[:ial][:refs].include?('toc') rescue nil) && (el.type == :ul || el.type == :ol)
           @toc_code = [el.type, el.attr, (0..128).to_a.map{|a| rand(36).to_s(36)}.join]
           @toc_code.last
         else
-          "#{' '*indent}<#{el.type}#{html_attributes(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</#{el.type}>\n"
+          "#{' '*indent}<#{el.type}#{html_attributes(el.attr)}>\n#{inner(el, indent)}#{' '*indent}</#{el.type}>\n"
         end
       end
       alias :convert_ol :convert_ul
       alias :convert_dl :convert_ul
 
-      def convert_li(el, indent, opts)
-        output = ' '*indent << "<#{el.type}" << html_attributes(el) << ">"
-        res = inner(el, indent, opts)
+      def convert_li(el, indent)
+        output = ' '*indent << "<#{el.type}" << html_attributes(el.attr) << ">"
+        res = inner(el, indent)
         if el.children.empty? || (el.children.first.type == :p && el.children.first.options[:transparent])
           output << res << (res =~ /\n\Z/ ? ' '*indent : '')
         else
@@ -154,22 +173,22 @@ module Kramdown
       end
       alias :convert_dd :convert_li
 
-      def convert_dt(el, indent, opts)
-        "#{' '*indent}<dt#{html_attributes(el)}>#{inner(el, indent, opts)}</dt>\n"
+      def convert_dt(el, indent)
+        "#{' '*indent}<dt#{html_attributes(el.attr)}>#{inner(el, indent)}</dt>\n"
       end
 
-      HTML_TAGS_WITH_BODY=['div', 'script', 'iframe', 'textarea']
+      # A list of all HTML tags that need to have a body (even if the body is empty).
+      HTML_TAGS_WITH_BODY=['div', 'script', 'iframe', 'textarea'] # :nodoc:
 
-      def convert_html_element(el, indent, opts)
-        parent = opts[:parent]
-        res = inner(el, indent, opts)
+      def convert_html_element(el, indent)
+        res = inner(el, indent)
         if el.options[:category] == :span
-          "<#{el.value}#{html_attributes(el)}" << (!res.empty? || HTML_TAGS_WITH_BODY.include?(el.value) ? ">#{res}</#{el.value}>" : " />")
+          "<#{el.value}#{html_attributes(el.attr)}" << (!res.empty? || HTML_TAGS_WITH_BODY.include?(el.value) ? ">#{res}</#{el.value}>" : " />")
         else
           output = ''
-          output << ' '*indent if parent.type != :html_element || parent.options[:parse_type] != :raw
-          output << "<#{el.value}#{html_attributes(el)}"
-          if !res.empty? && el.options[:parse_type] != :block
+          output << ' '*indent if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
+          output << "<#{el.value}#{html_attributes(el.attr)}"
+          if !res.empty? && el.options[:content_model] != :block
             output << ">#{res}</#{el.value}>"
           elsif !res.empty?
             output << ">\n#{res.chomp}\n"  << ' '*indent << "</#{el.value}>"
@@ -178,46 +197,47 @@ module Kramdown
           else
             output << " />"
           end
-          output << "\n" if parent.type != :html_element || parent.options[:parse_type] != :raw
+          output << "\n" if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
           output
         end
       end
 
-      def convert_xml_comment(el, indent, opts)
-        if el.options[:category] == :block && (opts[:parent].type != :html_element || opts[:parent].options[:parse_type] != :raw)
-          ' '*indent + el.value + "\n"
+      def convert_xml_comment(el, indent)
+        if el.options[:category] == :block && (@stack.last.type != :html_element || @stack.last.options[:content_model] != :raw)
+          ' '*indent << el.value << "\n"
         else
           el.value
         end
       end
       alias :convert_xml_pi :convert_xml_comment
-      alias :convert_html_doctype :convert_xml_comment
 
-      def convert_table(el, indent, opts)
+      def convert_table(el, indent)
         if el.options[:alignment].all? {|a| a == :default}
           alignment = ''
         else
           alignment = el.options[:alignment].map do |a|
-            "#{' '*(indent + INDENTATION)}" + (a == :default ? "<col />" : "<col align=\"#{a}\" />") + "\n"
+            "#{' '*(indent + @indent)}" << (a == :default ? "<col />" : "<col align=\"#{a}\" />") << "\n"
           end.join('')
         end
-        "#{' '*indent}<table#{html_attributes(el)}>\n#{alignment}#{inner(el, indent, opts)}#{' '*indent}</table>\n"
+        "#{' '*indent}<table#{html_attributes(el.attr)}>\n#{alignment}#{inner(el, indent)}#{' '*indent}</table>\n"
       end
 
-      def convert_thead(el, indent, opts)
-        "#{' '*indent}<#{el.type}#{html_attributes(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</#{el.type}>\n"
+      def convert_thead(el, indent)
+        "#{' '*indent}<#{el.type}#{html_attributes(el.attr)}>\n#{inner(el, indent)}#{' '*indent}</#{el.type}>\n"
       end
       alias :convert_tbody :convert_thead
       alias :convert_tfoot :convert_thead
       alias :convert_tr  :convert_thead
 
-      def convert_td(el, indent, opts)
-        res = inner(el, indent, opts)
-        "#{' '*indent}<#{el.type}#{html_attributes(el)}>#{res.empty? ? "&nbsp;" : res}</#{el.type}>\n"
+      ENTITY_NBSP = ::Kramdown::Utils::Entities.entity('nbsp') # :nodoc:
+
+      def convert_td(el, indent)
+        res = inner(el, indent)
+        type = (@stack[-2].type == :thead ? :th : :td)
+        "#{' '*indent}<#{type}#{html_attributes(el.attr)}>#{res.empty? ? entity_to_str(ENTITY_NBSP) : res}</#{type}>\n"
       end
-      alias :convert_th :convert_td
 
-      def convert_comment(el, indent, opts)
+      def convert_comment(el, indent)
         if el.options[:category] == :block
           "#{' '*indent}<!-- #{el.value} -->\n"
         else
@@ -225,46 +245,42 @@ module Kramdown
         end
       end
 
-      def convert_br(el, indent, opts)
+      def convert_br(el, indent)
         "<br />"
       end
 
-      def convert_a(el, indent, opts)
-        do_obfuscation = el.attr['href'] =~ /^mailto:/
-        if do_obfuscation
-          el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
-          href = obfuscate(el.attr['href'].sub(/^mailto:/, ''))
-          mailto = obfuscate('mailto')
-          el.attr['href'] = "#{mailto}:#{href}"
+      def convert_a(el, indent)
+        res = inner(el, indent)
+        attr = el.attr.dup
+        if attr['href'] =~ /^mailto:/
+          attr['href'] = obfuscate('mailto') << ":" << obfuscate(attr['href'].sub(/^mailto:/, ''))
+          res = obfuscate(res)
         end
-        res = inner(el, indent, opts)
-        res = obfuscate(res) if do_obfuscation
-        "<a#{html_attributes(el)}>#{res}</a>"
+        "<a#{html_attributes(attr)}>#{res}</a>"
       end
 
-      def convert_img(el, indent, opts)
-        "<img#{html_attributes(el)} />"
+      def convert_img(el, indent)
+        "<img#{html_attributes(el.attr)} />"
       end
 
-      def convert_codespan(el, indent, opts)
-        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
-        lang = el.attr.delete('lang')
-        if lang && HIGHLIGHTING_AVAILABLE
-          result = CodeRay.scan(el.value, lang.to_sym).html(:wrap => :span, :css => @doc.options[:coderay_css]).chomp
-          "<code#{html_attributes(el)}>#{result}</code>"
+      def convert_codespan(el, indent)
+        if el.attr['lang'] && HIGHLIGHTING_AVAILABLE
+          attr = el.attr.dup
+          result = CodeRay.scan(el.value, attr.delete('lang').to_sym).html(:wrap => :span, :css => @options[:coderay_css]).chomp
+          "<code#{html_attributes(attr)}>#{result}</code>"
         else
-          "<code#{html_attributes(el)}>#{escape_html(el.value)}</code>"
+          "<code#{html_attributes(el.attr)}>#{escape_html(el.value)}</code>"
         end
       end
 
-      def convert_footnote(el, indent, opts)
+      def convert_footnote(el, indent)
         number = @footnote_counter
         @footnote_counter += 1
-        @footnotes << [el.options[:name], @doc.parse_infos[:footnotes][el.options[:name]]]
+        @footnotes << [el.options[:name], el.value]
         "<sup id=\"fnref:#{el.options[:name]}\"><a href=\"#fn:#{el.options[:name]}\" rel=\"footnote\">#{number}</a></sup>"
       end
 
-      def convert_raw(el, indent, opts)
+      def convert_raw(el, indent)
         if !el.options[:type] || el.options[:type].empty? || el.options[:type].include?('html')
           el.value + (el.options[:category] == :block ? "\n" : '')
         else
@@ -272,12 +288,12 @@ module Kramdown
         end
       end
 
-      def convert_em(el, indent, opts)
-        "<#{el.type}#{html_attributes(el)}>#{inner(el, indent, opts)}</#{el.type}>"
+      def convert_em(el, indent)
+        "<#{el.type}#{html_attributes(el.attr)}>#{inner(el, indent)}</#{el.type}>"
       end
       alias :convert_strong :convert_em
 
-      def convert_entity(el, indent, opts)
+      def convert_entity(el, indent)
         entity_to_str(el.value, el.options[:original])
       end
 
@@ -289,32 +305,27 @@ module Kramdown
         :raquo_space => [::Kramdown::Utils::Entities.entity('nbsp'), ::Kramdown::Utils::Entities.entity('raquo')],
         :laquo => [::Kramdown::Utils::Entities.entity('laquo')],
         :raquo => [::Kramdown::Utils::Entities.entity('raquo')]
-      }
-      def convert_typographic_sym(el, indent, opts)
+      } # :nodoc:
+      def convert_typographic_sym(el, indent)
         TYPOGRAPHIC_SYMS[el.value].map {|e| entity_to_str(e)}.join('')
       end
 
-      def convert_smart_quote(el, indent, opts)
+      def convert_smart_quote(el, indent)
         entity_to_str(::Kramdown::Utils::Entities.entity(el.value.to_s))
       end
 
-      def convert_math(el, indent, opts)
-        el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
-        el.attr['class'] ||= ''
-        el.attr['class'] += (el.attr['class'].empty? ? '' : ' ') + 'math'
-        type = 'span'
-        type = 'div' if el.options[:category] == :block
-        "<#{type}#{html_attributes(el)}>#{escape_html(el.value)}</#{type}>#{type == 'div' ? "\n" : ''}"
+      def convert_math(el, indent)
+        block = (el.options[:category] == :block)
+        "<script type=\"math/tex#{block ? '; mode=display' : ''}\">#{el.value}</script>#{block ? "\n" : ''}"
       end
 
-      def convert_abbreviation(el, indent, opts)
-        title = @doc.parse_infos[:abbrev_defs][el.value]
-        title = nil if title.empty?
-        "<abbr#{title ? " title=\"#{title}\"" : ''}>#{el.value}</abbr>"
+      def convert_abbreviation(el, indent)
+        title = @root.options[:abbrev_defs][el.value]
+        "<abbr#{!title.empty? ? " title=\"#{title}\"" : ''}>#{el.value}</abbr>"
       end
 
-      def convert_root(el, indent, opts)
-        result = inner(el, indent, opts)
+      def convert_root(el, indent)
+        result = inner(el, indent)
         result << footnote_content
         if @toc_code
           toc_tree = generate_toc_tree(@toc, @toc_code[0], @toc_code[1] || {})
@@ -328,6 +339,7 @@ module Kramdown
         result
       end
 
+      # Generate and return an element tree for the table of contents.
       def generate_toc_tree(toc, type, attr)
         sections = Element.new(type, nil, attr)
         sections.attr['id'] ||= 'markdown-toc'
@@ -336,7 +348,7 @@ module Kramdown
           li = Element.new(:li, nil, nil, {:level => level})
           li.children << Element.new(:p, nil, nil, {:transparent => true})
           a = Element.new(:a, nil, {'href' => "##{id}"})
-          a.children += children
+          a.children.concat(children)
           li.children.last.children << a
           li.children << Element.new(type)
 
@@ -363,23 +375,23 @@ module Kramdown
         sections
       end
 
-      # Helper method for obfuscating the +text+ by using HTML entities.
+      # Obfuscate the +text+ by using HTML entities.
       def obfuscate(text)
         result = ""
         text.each_byte do |b|
-          result += (b > 128 ? b.chr : "&#%03d;" % b)
+          result << (b > 128 ? b.chr : "&#%03d;" % b)
         end
         result.force_encoding(text.encoding) if RUBY_VERSION >= '1.9'
         result
       end
 
-      # Return a HTML list with the footnote content for the used footnotes.
+      # Return a HTML ordered list with the footnote content for the used footnotes.
       def footnote_content
         ol = Element.new(:ol)
         ol.attr['start'] = @footnote_start if @footnote_start != 1
         @footnotes.each do |name, data|
-          li = Element.new(:li, nil, {'id' => "fn:#{name}"}, {:first_is_block => true})
-          li.children = Marshal.load(Marshal.dump(data[:content].children))
+          li = Element.new(:li, nil, {'id' => "fn:#{name}"})
+          li.children = Marshal.load(Marshal.dump(data.children))
           ol.children << li
 
           ref = Element.new(:raw, "<a href=\"#fnref:#{name}\" rev=\"footnote\">&#8617;</a>")