kramdown 1.17.0 → 2.0.0.beta1

data/doc/tests.page

@@ -1,104 +0,0 @@
----
-title: Tests and Benchmark
----
-# Tests and Benchmark
-
-## Tests
-
-There exist several test suites for testing the correctness of a Markdown implementation. The
-original [Markdown Test Suite] is the standard which one needs to test against. The [PHP Markdown
-suite][MDTest] contains the original test suite and several more tests (some specifically geared
-towards the extension of the PHP Markdown Extra package). I have used the latter test tool to
-roughly verify that kramdown is able to parse standard Markdown. However, since the syntax used by
-kramdown varies slightly from standard Markdown most of the tests fail - which is fine. When looking
-at the differences one can see that the failures result from these differences.
-
-Besides using the above mentioned test suite kramdown comes with its own set of tests which is used
-to verify that the implementation matches the kramdown specification.
-
-If you believe you have found a bug in the implementation, please follow these steps:
-
-* Check the [syntax page](syntax.html) and see if the behaviour is not intended.
-
-* If the behaviour is not intended and it seems that kramdown should parse some text in another
-  fashion, please open a [bug report] and attach two files: one with the text and one with the HTML
-  conversion you think is correct.
-
-[bug report]: http://github.com/gettalong/kramdown/issues
-
-
-## Benchmark
-
-kramdown comes with a small benchmark to test how fast it is in regard to four other Ruby Markdown
-implementations: Maruku, BlueFeather, BlueCloth, RDiscount and Redcarpet. The first two are written
-using only Ruby, the latter three are written in C and need to be compiled.
-
-As one can see below, kramdown is currently (September 2014) ~3x faster than Maruku, ~4.5x faster
-than BlueFeather but ~30x slower than RDiscount and ~150x slower than Redcarpet:
-
-<pre><code>
-Running tests on 2014-09-16 under ruby 2.1.2p95 (2014-05-08 revision 45877) [x86_64-linux]
-
-Test using file mdsyntax.text and 20 runs
-Rehearsal ----------------------------------------------------
-kramdown 1.4.2     0.900000   0.010000   0.910000 (  0.914992)
-Maruku 0.7.1       2.360000   0.040000   2.400000 (  2.403571)
-BlueFeather 0.41   3.760000   0.010000   3.770000 (  3.776421)
-BlueCloth 2.2.0    0.050000   0.000000   0.050000 (  0.050221)
-RDiscount 2.1.7    0.020000   0.000000   0.020000 (  0.024180)
-redcarpet 3.1.2    0.010000   0.000000   0.010000 (  0.004579)
-------------------------------------------- total: 7.160000sec
-
-                       user     system      total        real
-kramdown 1.4.2     0.830000   0.000000   0.830000 (  0.834144)
-Maruku 0.7.1       2.250000   0.030000   2.280000 (  2.286579)
-BlueFeather 0.41   3.680000   0.010000   3.690000 (  3.693769)
-BlueCloth 2.2.0    0.050000   0.000000   0.050000 (  0.044831)
-RDiscount 2.1.7    0.020000   0.000000   0.020000 (  0.022847)
-redcarpet 3.1.2    0.010000   0.000000   0.010000 (  0.004601)
-
-Real time of X divided by real time of kramdown
-Maruku             2.7412
-BlueFeather        4.4282
-BlueCloth          0.0537
-RDiscount          0.0274
-redcarpet          0.0055
-
-Test using file mdbasics.text and 20 runs
-Rehearsal ----------------------------------------------------
-kramdown 1.4.2     0.150000   0.000000   0.150000 (  0.149989)
-Maruku 0.7.1       0.580000   0.010000   0.590000 (  0.584910)
-BlueFeather 0.41   0.780000   0.000000   0.780000 (  0.788740)
-BlueCloth 2.2.0    0.020000   0.000000   0.020000 (  0.014700)
-RDiscount 2.1.7    0.000000   0.000000   0.000000 (  0.007692)
-redcarpet 3.1.2    0.010000   0.000000   0.010000 (  0.002064)
-------------------------------------------- total: 1.550000sec
-
-                       user     system      total        real
-kramdown 1.4.2     0.150000   0.000000   0.150000 (  0.151586)
-Maruku 0.7.1       0.520000   0.000000   0.520000 (  0.525707)
-BlueFeather 0.41   0.770000   0.010000   0.780000 (  0.763559)
-BlueCloth 2.2.0    0.020000   0.000000   0.020000 (  0.015509)
-RDiscount 2.1.7    0.010000   0.000000   0.010000 (  0.006545)
-redcarpet 3.1.2    0.000000   0.000000   0.000000 (  0.001475)
-
-Real time of X divided by real time of kramdown
-Maruku             3.468
-BlueFeather        5.0371
-BlueCloth          0.1023
-RDiscount          0.0432
-redcarpet          0.0097
-</code></pre>
-
-And here are some graphs which show the execution times of the various kramdown releases on
-different Ruby interpreters:
-
-![ruby 1.8.7p302]({relocatable: img/graph-ruby-1.8.7-302.png})
-![ruby 1.9.3p448]({relocatable: img/graph-ruby-1.9.3p448-448.png})
-![ruby 2.0.0p247]({relocatable: img/graph-ruby-2.0.0p247-247.png})
-![ruby 2.1.2p95]({relocatable: img/graph-ruby-2.1.2p95-95.png})
-![jruby 1.7.15]({relocatable: img/graph-jruby-1.7.15-392.png})
-![rubinius 2.2.10]({relocatable: img/graph-rubinius-2.2.10-0.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/doc/virtual

@@ -1,14 +0,0 @@
-rdoc/index.html:
-  title: API Documentation
-
-/options.en.html#option-syntax-highlighter:
-  dest_path: options.html#option-syntax-highlighter
-
-/options.en.html#option-syntax-highlighter-opts:
-  dest_path: options.html#option-syntax-highlighter-opts
-
-/options.en.html#option-math-engine:
-  dest_path: options.html#option-math-engine
-
-/options.en.html#option-math-engine-opts:
-  dest_path: options.html#option-math-engine-opts

data/lib/kramdown/converter/math_engine/itex2mml.rb

@@ -1,39 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown::Converter::MathEngine
-
-  # Uses the Itex2MML library for converting math formulas to MathML.
-  module Itex2MML
-
-    begin
-      require 'itextomml'
-
-      # Itex2MML is available if this constant is +true+.
-      AVAILABLE = true
-    rescue LoadError
-      AVAILABLE = false  # :nodoc:
-    end
-
-    def self.call(converter, el, opts)
-      type = el.options[:category]
-      parser = ::Itex2MML::Parser.new
-      result = (type == :block ? parser.block_filter(el.value) : parser.inline_filter(el.value))
-
-      attr = el.attr.dup
-      attr.delete('xmlns')
-      attr.delete('display')
-      result.insert("<math".length, converter.html_attributes(attr))
-
-      (type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
-    end
-
-  end
-
-end

data/lib/kramdown/converter/math_engine/katex.rb

@@ -1,35 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2018 Gleb Mazovetskiy <glex.spb@gmail.com>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-
-module Kramdown::Converter::MathEngine
-  # Uses the KaTeX gem for converting math formulas to KaTeX HTML.
-  module Katex
-    AVAILABLE = begin
-      require 'katex'
-      true
-    rescue LoadError
-      false
-    end
-
-    def self.call(converter, el, opts)
-      display_mode = el.options[:category] == :block
-      result = ::Katex.render(
-          el.value,
-          display_mode: display_mode,
-          throw_on_error: false,
-          **converter.options[:math_engine_opts]
-      )
-      attr = el.attr.dup
-      attr.delete('xmlns')
-      attr.delete('display')
-      result.insert(result =~ /[[:space:]>]/, converter.html_attributes(attr))
-      result = "#{' ' * opts[:indent]}#{result}\n" if display_mode
-      result
-    end
-  end
-end

data/lib/kramdown/converter/math_engine/mathjaxnode.rb

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown::Converter::MathEngine
-
-  # Uses the mathjax-node-cli library for converting math formulas to MathML.
-  module MathjaxNode
-
-    # MathjaxNode is available if this constant is +true+.
-    AVAILABLE = begin
-      %x{node --version}[1..-2] >= '4.5'
-    rescue
-      begin
-        %x{nodejs --version}[1..-2] >= '4.5'
-      rescue
-        false
-      end
-    end && begin
-      npm = %x{npm --global --depth=1 list mathjax-node-cli 2>&1}
-
-      unless /mathjax-node-cli@/ === npm.lines.drop(1).join("\n")
-        npm = %x{npm --depth=1 list mathjax-node-cli 2>&1}
-      end
-
-      T2MPATH = File.join(npm.lines.first.strip, "node_modules/mathjax-node-cli/bin/tex2mml")
-      /mathjax-node-cli@/ === npm.lines.drop(1).join("\n") && File.exist?(T2MPATH)
-    rescue
-      false
-    end
-
-    def self.call(converter, el, opts)
-      type = el.options[:category]
-
-      cmd = [T2MPATH]
-      cmd << "--inline" unless type == :block
-      cmd << "--semantics" if converter.options[:math_engine_opts][:semantics] == true
-      cmd << "--notexhints" if converter.options[:math_engine_opts][:texhints] == false
-      result = IO.popen(cmd << el.value).read.strip
-
-      attr = el.attr.dup
-      attr.delete('xmlns')
-      attr.delete('display')
-      result.insert("<math".length, converter.html_attributes(attr))
-
-      (type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
-    end
-
-  end
-
-end

data/lib/kramdown/converter/math_engine/ritex.rb

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown::Converter::MathEngine
-
-  # Uses the Ritex library for converting math formulas to MathML.
-  module Ritex
-
-    begin
-      require 'ritex'
-
-      # Ritex is available if this constant is +true+.
-      AVAILABLE = true
-    rescue LoadError
-      AVAILABLE = false  # :nodoc:
-    end
-
-    def self.call(converter, el, opts)
-      type = el.options[:category]
-      result = ::Ritex::Parser.new.parse(el.value, :display => (type == :block))
-
-      attr = el.attr.dup
-      attr.delete('xmlns')
-      attr.delete('display')
-      result.insert("<math".length, converter.html_attributes(attr))
-
-      (type == :block ? "#{' '*opts[:indent]}#{result}\n" : result)
-    end
-
-  end
-
-end

data/lib/kramdown/converter/math_engine/sskatex.rb

@@ -1,97 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2017 Christian Cornelssen <ccorn@1tein.de>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-
-module Kramdown::Converter::MathEngine
-
-  # Consider this a lightweight alternative to MathjaxNode. Uses KaTeX and ExecJS (via ::SsKaTeX)
-  # instead of MathJax and Node.js. Javascript execution context initialization is done only once.
-  # As a result, the performance is reasonable.
-  module SsKaTeX
-
-    # Indicate whether SsKaTeX may be available.
-    #
-    # This test is incomplete; it cannot test the existence of _katex_js_ nor the availability of a
-    # specific _js_run_ because those depend on configuration not given here. This test mainly
-    # indicates whether static dependencies such as the +sskatex+ and +execjs+ gems are available.
-    AVAILABLE = begin
-      require 'sskatex'
-      # No test for any JS engine availability here; specifics are config-dependent anyway
-      true
-    rescue LoadError
-      false
-    end
-
-    if AVAILABLE
-
-      # Class-level cache for ::SsKaTeX converter state, queried by configuration. Note: KTXC
-      # contents may become stale if the contents of used JS files change while the configuration
-      # remains unchanged.
-      KTXC = ::Kramdown::Utils::LRUCache.new(10)
-
-      # A logger that routes messages to the debug channel only. No need to create this dynamically.
-      DEBUG_LOGGER = lambda { |level, &expr| warn(expr.call) }
-
-      class << self
-        private
-
-        # Given a Kramdown::Converter::Base object _converter_, retrieves the logging options and
-        # builds an object usable for ::SsKaTeX#logger. The result is either +nil+ (no logging) or a
-        # +Proc+ object which, when given a _level_ (either +:verbose+ or +:debug+) and a block,
-        # decides whether logging is enabled, and if so, evaluates the given block for the message
-        # and routes that message to the appropriate channels. With <tt>level == :verbose+</tt>,
-        # messages are passed to _converter_.warning if the _converter_'s +:verbose+ option is set.
-        # All messages are passed to +warn+ if the _converter_'s +:debug+ option is set.
-        #
-        # Note that the returned logger may contain references to the given _converter_ and is not
-        # affected by subsequent changes in the _converter_'s logging options.
-        def logger(converter)
-          config = converter.options[:math_engine_opts]
-          debug = config[:debug]
-          if config[:verbose]
-            # Need a closure
-            lambda do |level, &expr|
-              verbose = (level == :verbose)
-              msg = expr.call if debug || verbose
-              warn(msg) if debug
-              converter.warning(msg) if verbose
-            end
-          elsif debug
-            DEBUG_LOGGER
-          end
-        end
-
-        # Given a Kramdown::Converter::Base object _converter_, return a ::SsKaTeX converter _sktx_
-        # that has been configured with _converter_'s +math_engine_opts+, but not for logging. Cache
-        # _sktx_ for reuse, without references to _converter_.
-        def katex_conv(converter)
-          config = converter.options[:math_engine_opts]
-            # Could .reject { |key, _| [:verbose, :debug].include?(key.to_sym) }
-            # because the JS engine setup can be reused for different logging settings.
-            # But then the +math_engine_opts+ dict would be essentially dup'ed every time,
-            # and late activation of logging would miss the initialization if the engine is reused.
-          KTXC[config] ||= ::SsKaTeX.new(config)
-        end
-
-        public
-
-        # The function used by kramdown for rendering TeX math to HTML
-        def call(converter, el, opts)
-          display_mode = el.options[:category]
-          ans = katex_conv(converter).call(el.value, display_mode == :block, &logger(converter))
-          attr = el.attr.dup
-          attr.delete('xmlns')
-          attr.delete('display')
-          ans.insert(ans =~ /[[:space:]>]/, converter.html_attributes(attr))
-          ans = ' ' * opts[:indent] << ans << "\n" if display_mode == :block
-          ans
-        end
-
-      end
-    end
-  end
-end

data/lib/kramdown/converter/pdf.rb

@@ -1,625 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-require 'prawn'
-require 'prawn/table'
-require 'kramdown/converter'
-require 'kramdown/utils'
-require 'open-uri'
-
-module Kramdown
-
-  module Converter
-
-    # Converts an element tree to a PDF using the prawn PDF library.
-    #
-    # This basic version provides a nice starting point for customizations but can also be used
-    # directly.
-    #
-    # There can be the following two methods for each element type: render_TYPE(el, opts) and
-    # TYPE_options(el, opts) where +el+ is a kramdown element and +opts+ an hash with rendering
-    # options.
-    #
-    # The render_TYPE(el, opts) is used for rendering the specific element. If the element is a span
-    # element, it should return a hash or an array of hashes that can be used by the #formatted_text
-    # method of Prawn::Document. This method can then be used in block elements to actually render
-    # the span elements.
-    #
-    # The rendering options are passed from the parent to its child elements. This allows one to
-    # define general options at the top of the tree (the root element) that can later be changed or
-    # amended.
-    #
-    #
-    # Currently supports the conversion of all elements except those of the following types:
-    #
-    #   :html_element, :img, :footnote
-    #
-    #
-    class Pdf < Base
-
-      include Prawn::Measurements
-
-      def initialize(root, options)
-        super
-        @stack = []
-        @dests = {}
-      end
-
-      # PDF templates are applied before conversion. They should contain code to augment the
-      # converter object (i.e. to override the methods).
-      def apply_template_before?
-        true
-      end
-
-      # Returns +false+.
-      def apply_template_after?
-        false
-      end
-
-      DISPATCHER_RENDER = Hash.new {|h,k| h[k] = "render_#{k}"} #:nodoc:
-      DISPATCHER_OPTIONS = Hash.new {|h,k| h[k] = "#{k}_options"} #:nodoc:
-
-      # Invoke the special rendering method for the given element +el+.
-      #
-      # A PDF destination is also added at the current location if th element has an ID or if the
-      # element is of type :header and the :auto_ids option is set.
-      def convert(el, opts = {})
-        id = el.attr['id']
-        id = generate_id(el.options[:raw_text]) if !id && @options[:auto_ids] && el.type == :header
-        if !id.to_s.empty? && !@dests.has_key?(id)
-          @pdf.add_dest(id, @pdf.dest_xyz(0, @pdf.y))
-          @dests[id] = @pdf.dest_xyz(0, @pdf.y)
-        end
-        send(DISPATCHER_RENDER[el.type], el, opts)
-      end
-
-      protected
-
-      # Render the children of this element with the given options and return the results as array.
-      #
-      # Each time a child is rendered, the +TYPE_options+ method is invoked (if it exists) to get
-      # the specific options for the element with which the given options are updated.
-      def inner(el, opts)
-        @stack.push([el, opts])
-        result = el.children.map do |inner_el|
-          options = opts.dup
-          options.update(send(DISPATCHER_OPTIONS[inner_el.type], inner_el, options))
-          convert(inner_el, options)
-        end.flatten.compact
-        @stack.pop
-        result
-      end
-
-
-      # ----------------------------
-      # :section: Element rendering methods
-      # ----------------------------
-
-
-      def root_options(root, opts)
-        {:font => 'Times-Roman', :size => 12, :leading => 2}
-      end
-
-      def render_root(root, opts)
-        @pdf = setup_document(root)
-        inner(root, root_options(root, opts))
-        create_outline(root)
-        finish_document(root)
-        @pdf.render
-      end
-
-      def header_options(el, opts)
-        size = opts[:size] * 1.15**(6 - el.options[:level])
-        {
-          :font => "Helvetica", :styles => (opts[:styles] || []) + [:bold],
-          :size => size, :bottom_padding => opts[:size], :top_padding => opts[:size]
-        }
-      end
-
-      def render_header(el, opts)
-        render_padded_and_formatted_text(el, opts)
-      end
-
-      def p_options(el, opts)
-        bpad = (el.options[:transparent] ? opts[:leading] : opts[:size])
-        {:align => :justify, :bottom_padding => bpad}
-      end
-
-      def render_p(el, opts)
-        if el.children.size == 1 && el.children.first.type == :img
-          render_standalone_image(el, opts)
-        else
-          render_padded_and_formatted_text(el, opts)
-        end
-      end
-
-      def render_standalone_image(el, opts)
-        img = el.children.first
-        line = img.options[:location]
-
-        if img.attr['src'].empty?
-          warning("Rendering an image without a source is not possible#{line ? " (line #{line})" : ''}")
-          return nil
-        elsif img.attr['src'] !~ /\.jpe?g$|\.png$/
-          warning("Cannot render images other than JPEG or PNG, got #{img.attr['src']}#{line ? " on line #{line}" : ''}")
-          return nil
-        end
-
-        img_dirs = (@options[:image_directories] || ['.']).dup
-        begin
-          img_path = File.join(img_dirs.shift, img.attr['src'])
-          image_obj, image_info = @pdf.build_image_object(open(img_path))
-        rescue
-          img_dirs.empty? ? raise : retry
-        end
-
-        options = {:position => :center}
-        if img.attr['height'] && img.attr['height'] =~ /px$/
-          options[:height] = img.attr['height'].to_i / (@options[:image_dpi] || 150.0) * 72
-        elsif img.attr['width'] && img.attr['width'] =~ /px$/
-          options[:width] = img.attr['width'].to_i / (@options[:image_dpi] || 150.0) * 72
-        else
-          options[:scale] =[(@pdf.bounds.width - mm2pt(20)) / image_info.width.to_f, 1].min
-        end
-
-        if img.attr['class'] =~ /\bright\b/
-          options[:position] = :right
-          @pdf.float { @pdf.embed_image(image_obj, image_info, options) }
-        else
-          with_block_padding(el, opts) do
-            @pdf.embed_image(image_obj, image_info, options)
-          end
-        end
-      end
-
-      def blockquote_options(el, opts)
-        {:styles => [:italic]}
-      end
-
-      def render_blockquote(el, opts)
-        @pdf.indent(mm2pt(10), mm2pt(10)) { inner(el, opts) }
-      end
-
-      def ul_options(el, opts)
-        {:bottom_padding => opts[:size]}
-      end
-
-      def render_ul(el, opts)
-        with_block_padding(el, opts) do
-          el.children.each do |li|
-            @pdf.float { @pdf.formatted_text([text_hash("•", opts)]) }
-            @pdf.indent(mm2pt(6)) { convert(li, opts) }
-          end
-        end
-      end
-
-      def ol_options(el, opts)
-        {:bottom_padding => opts[:size]}
-      end
-
-      def render_ol(el, opts)
-        with_block_padding(el, opts) do
-          el.children.each_with_index do |li, index|
-            @pdf.float { @pdf.formatted_text([text_hash("#{index+1}.", opts)]) }
-            @pdf.indent(mm2pt(6)) { convert(li, opts) }
-          end
-        end
-      end
-
-      def li_options(el, opts)
-        {}
-      end
-
-      def render_li(el, opts)
-        inner(el, opts)
-      end
-
-      def dl_options(el, opts)
-        {}
-      end
-
-      def render_dl(el, opts)
-        inner(el, opts)
-      end
-
-      def dt_options(el, opts)
-        {:styles => (opts[:styles] || []) + [:bold], :bottom_padding => 0}
-      end
-
-      def render_dt(el, opts)
-        render_padded_and_formatted_text(el, opts)
-      end
-
-      def dd_options(el, opts)
-        {}
-      end
-
-      def render_dd(el, opts)
-        @pdf.indent(mm2pt(10)) { inner(el, opts) }
-      end
-
-      def math_options(el, opts)
-        {}
-      end
-
-      def render_math(el, opts)
-        if el.options[:category] == :block
-          @pdf.formatted_text([{:text => el.value}], block_hash(opts))
-        else
-          {:text => el.value}
-        end
-      end
-
-      def hr_options(el, opts)
-        {:top_padding => opts[:size], :bottom_padding => opts[:size]}
-      end
-
-      def render_hr(el, opts)
-        with_block_padding(el, opts) do
-          @pdf.stroke_horizontal_line(@pdf.bounds.left + mm2pt(5), @pdf.bounds.right - mm2pt(5))
-        end
-      end
-
-      def codeblock_options(el, opts)
-        {
-          :font => 'Courier', :color => '880000',
-          :bottom_padding => opts[:size]
-        }
-      end
-
-      def render_codeblock(el, opts)
-        with_block_padding(el, opts) do
-          @pdf.formatted_text([text_hash(el.value, opts, false)], block_hash(opts))
-        end
-      end
-
-      def table_options(el, opts)
-        {:bottom_padding => opts[:size]}
-      end
-
-      def render_table(el, opts)
-        data = []
-        el.children.each do |container|
-          container.children.each do |row|
-            data << []
-            row.children.each do |cell|
-              if cell.children.any? {|child| child.options[:category] == :block}
-                line = el.options[:location]
-                warning("Can't render tables with cells containing block elements#{line ? " (line #{line})" : ''}")
-                return
-              end
-              cell_data = inner(cell, opts)
-              data.last << cell_data.map {|c| c[:text]}.join('')
-            end
-          end
-        end
-        with_block_padding(el, opts) do
-          @pdf.table(data, :width => @pdf.bounds.right) do
-            el.options[:alignment].each_with_index do |alignment, index|
-              columns(index).align = alignment unless alignment == :default
-            end
-          end
-        end
-      end
-
-
-
-      def text_options(el, opts)
-        {}
-      end
-
-      def render_text(el, opts)
-        text_hash(el.value.to_s, opts)
-      end
-
-      def em_options(el, opts)
-        if opts[:styles] && opts[:styles].include?(:italic)
-          {:styles => opts[:styles].reject {|i| i == :italic}}
-        else
-          {:styles => (opts[:styles] || []) << :italic}
-        end
-      end
-
-      def strong_options(el, opts)
-        {:styles => (opts[:styles] || []) + [:bold]}
-      end
-
-      def a_options(el, opts)
-        hash = {:color => '000088'}
-        if el.attr['href'].start_with?('#')
-          hash[:anchor] = el.attr['href'].sub(/\A#/, '')
-        else
-          hash[:link] = el.attr['href']
-        end
-        hash
-      end
-
-      def render_em(el, opts)
-        inner(el, opts)
-      end
-      alias_method :render_strong, :render_em
-      alias_method :render_a, :render_em
-
-      def codespan_options(el, opts)
-        {:font => 'Courier', :color => '880000'}
-      end
-
-      def render_codespan(el, opts)
-        text_hash(el.value, opts)
-      end
-
-      def br_options(el, opts)
-        {}
-      end
-
-      def render_br(el, opts)
-        text_hash("\n", opts, false)
-      end
-
-      def smart_quote_options(el, opts)
-        {}
-      end
-
-      def render_smart_quote(el, opts)
-        text_hash(smart_quote_entity(el).char, opts)
-      end
-
-      def typographic_sym_options(el, opts)
-        {}
-      end
-
-      def render_typographic_sym(el, opts)
-        str = if el.value == :laquo_space
-                ::Kramdown::Utils::Entities.entity('laquo').char +
-                  ::Kramdown::Utils::Entities.entity('nbsp').char
-              elsif el.value == :raquo_space
-                ::Kramdown::Utils::Entities.entity('raquo').char +
-                  ::Kramdown::Utils::Entities.entity('nbsp').char
-              else
-                ::Kramdown::Utils::Entities.entity(el.value.to_s).char
-              end
-        text_hash(str, opts)
-      end
-
-      def entity_options(el, opts)
-        {}
-      end
-
-      def render_entity(el, opts)
-        text_hash(el.value.char, opts)
-      end
-
-      def abbreviation_options(el, opts)
-        {}
-      end
-
-      def render_abbreviation(el, opts)
-        text_hash(el.value, opts)
-      end
-
-      def img_options(el, opts)
-        {}
-      end
-
-      def render_img(el, *args) #:nodoc:
-        line = el.options[:location]
-        warning("Rendering span images is not supported for PDF converter#{line ? " (line #{line})" : ''}")
-        nil
-      end
-
-
-
-      def xml_comment_options(el, opts) #:nodoc:
-        {}
-      end
-      alias_method :xml_pi_options, :xml_comment_options
-      alias_method :comment_options, :xml_comment_options
-      alias_method :blank_options, :xml_comment_options
-      alias_method :footnote_options, :xml_comment_options
-      alias_method :raw_options, :xml_comment_options
-      alias_method :html_element_options, :xml_comment_options
-
-      def render_xml_comment(el, opts) #:nodoc:
-        # noop
-      end
-      alias_method :render_xml_pi, :render_xml_comment
-      alias_method :render_comment, :render_xml_comment
-      alias_method :render_blank, :render_xml_comment
-
-      def render_footnote(el, *args) #:nodoc:
-        line = el.options[:location]
-        warning("Rendering #{el.type} not supported for PDF converter#{line ? " (line #{line})" : ''}")
-        nil
-      end
-      alias_method :render_raw, :render_footnote
-      alias_method :render_html_element, :render_footnote
-
-
-      # ----------------------------
-      # :section: Organizational methods
-      #
-      # These methods are used, for example, to up the needed Prawn::Document instance or to create
-      # a PDF outline.
-      # ----------------------------
-
-
-      # This module gets mixed into the Prawn::Document instance.
-      module PrawnDocumentExtension
-
-        # Extension for the formatted box class to recognize images and move text around them.
-        module CustomBox
-
-          def available_width
-            return super unless @document.respond_to?(:converter) && @document.converter
-
-            @document.image_floats.each do |pn, x, y, w, h|
-              next if @document.page_number != pn
-              if @at[1] + @baseline_y <= y - @document.bounds.absolute_bottom &&
-                  (@at[1] + @baseline_y + @arranger.max_line_height + @leading >= y - h - @document.bounds.absolute_bottom)
-                return @width - w
-              end
-            end
-
-            return super
-          end
-
-        end
-
-        Prawn::Text::Formatted::Box.extensions << CustomBox
-
-        # Access the converter instance from within Prawn
-        attr_accessor :converter
-
-        def image_floats
-          @image_floats ||= []
-        end
-
-        # Override image embedding method for adding image positions to #image_floats.
-        def embed_image(pdf_obj, info, options)
-          # find where the image will be placed and how big it will be
-          w,h = info.calc_image_dimensions(options)
-
-          if options[:at]
-            x,y = map_to_absolute(options[:at])
-          else
-            x,y = image_position(w,h,options)
-            move_text_position h
-          end
-
-          #--> This part is new
-          if options[:position] == :right
-            image_floats << [page_number, x - 15, y, w + 15, h + 15]
-          end
-
-          # add a reference to the image object to the current page
-          # resource list and give it a label
-          label = "I#{next_image_id}"
-          state.page.xobjects.merge!(label => pdf_obj)
-
-          # add the image to the current page
-          instruct = "\nq\n%.3f 0 0 %.3f %.3f %.3f cm\n/%s Do\nQ"
-          add_content instruct % [ w, h, x, y - h, label ]
-        end
-
-      end
-
-
-      # Return a hash with options that are suitable for Prawn::Document.new.
-      #
-      # Used in #setup_document.
-      def document_options(root)
-        {
-          :page_size => 'A4', :page_layout => :portrait, :margin => mm2pt(20),
-          :info => {
-            :Creator => 'kramdown PDF converter',
-            :CreationDate => Time.now
-          },
-          :compress => true, :optimize_objects => true
-        }
-      end
-
-      # Create a Prawn::Document object and return it.
-      #
-      # Can be used to define repeatable content or register fonts.
-      #
-      # Used in #render_root.
-      def setup_document(root)
-        doc = Prawn::Document.new(document_options(root))
-        doc.extend(PrawnDocumentExtension)
-        doc.converter = self
-        doc
-      end
-
-      #
-      #
-      # Used in #render_root.
-      def finish_document(root)
-        # no op
-      end
-
-      # Create the PDF outline from the header elements in the TOC.
-      def create_outline(root)
-        toc = ::Kramdown::Converter::Toc.convert(root).first
-
-        text_of_header = lambda do |el|
-          if el.type == :text
-            el.value
-          else
-            el.children.map {|c| text_of_header.call(c)}.join('')
-          end
-        end
-
-        add_section = lambda do |item, parent|
-          text = text_of_header.call(item.value)
-          destination = @dests[item.attr[:id]]
-          if !parent
-            @pdf.outline.page(:title => text, :destination => destination)
-          else
-            @pdf.outline.add_subsection_to(parent) do
-              @pdf.outline.page(:title => text, :destination => destination)
-            end
-          end
-          item.children.each {|c| add_section.call(c, text)}
-        end
-
-        toc.children.each do |item|
-          add_section.call(item, nil)
-        end
-      end
-
-
-      # ----------------------------
-      # :section: Helper methods
-      # ----------------------------
-
-
-      # Move the prawn document cursor down before and/or after yielding the given block.
-      #
-      # The :top_padding and :bottom_padding options are used for determinig the padding amount.
-      def with_block_padding(el, opts)
-        @pdf.move_down(opts[:top_padding]) if opts.has_key?(:top_padding)
-        yield
-        @pdf.move_down(opts[:bottom_padding]) if opts.has_key?(:bottom_padding)
-      end
-
-      # Render the children of the given element as formatted text and respect the top/bottom
-      # padding (see #with_block_padding).
-      def render_padded_and_formatted_text(el, opts)
-        with_block_padding(el, opts) { @pdf.formatted_text(inner(el, opts), block_hash(opts)) }
-      end
-
-      # Helper function that returns a hash with valid "formatted text" options.
-      #
-      # The +text+ parameter is used as value for the :text key and if +squeeze_whitespace+ is
-      # +true+, all whitespace is converted into spaces.
-      def text_hash(text, opts, squeeze_whitespace = true)
-        text = text.gsub(/\s+/, ' ') if squeeze_whitespace
-        hash = {:text => text}
-        [:styles, :size, :character_spacing, :font, :color, :link,
-         :anchor, :draw_text_callback, :callback].each do |key|
-          hash[key] = opts[key] if opts.has_key?(key)
-        end
-        hash
-      end
-
-      # Helper function that returns a hash with valid options for the prawn #text_box extracted
-      # from the given options.
-      def block_hash(opts)
-        hash = {}
-        [:align, :valign, :mode, :final_gap, :leading, :fallback_fonts,
-         :direction, :indent_paragraphs].each do |key|
-          hash[key] = opts[key] if opts.has_key?(key)
-        end
-        hash
-      end
-
-    end
-
-  end
-end