kramdown 0.3.0 → 0.4.0

data/lib/kramdown/converter.rb

@@ -31,6 +31,15 @@ module Kramdown
     # Converts a Kramdown::Document to HTML.
     class Html
 
+      INDENTATION = 2
+
+      begin
+        require 'coderay'
+        HIGHLIGHTING_AVAILABLE = true
+      rescue LoadError => e
+        HIGHLIGHTING_AVAILABLE = false
+      end
+
       # Initialize the HTML converter with the given Kramdown document +doc+.
       def initialize(doc)
         @doc = doc
@@ -45,94 +54,107 @@ module Kramdown
       end
 
       # Convert the element tree +el+, setting the indentation level to +indent+.
-      def convert(el, indent = -2)
+      def convert(el, indent = -INDENTATION, opts = {})
+        send("convert_#{el.type}", el, indent, opts)
+      end
+
+      def inner(el, indent, opts)
         result = ''
+        indent += INDENTATION
         el.children.each do |inner_el|
-          result << convert(inner_el, indent + 2)
+          result << send("convert_#{inner_el.type}", inner_el, indent, opts)
         end
-        send("convert_#{el.type}", el, result, indent)
+        result
       end
 
-      def convert_blank(el, inner, indent)
+      def convert_blank(el, indent, opts)
         "\n"
       end
 
-      def convert_text(el, inner, indent)
+      def convert_text(el, indent, opts)
         escape_html(el.value, false)
       end
 
-      def convert_eob(el, inner, indent)
+      def convert_eob(el, indent, opts)
         ''
       end
 
-      def convert_p(el, inner, indent)
-        "#{' '*indent}<p#{options_for_element(el)}>#{inner}</p>\n"
+      def convert_p(el, indent, opts)
+        "#{' '*indent}<p#{options_for_element(el)}>#{inner(el, indent, opts)}</p>\n"
       end
 
-      def convert_codeblock(el, inner, indent)
-        result = escape_html(el.value)
-        if el.options[:attr] && el.options[:attr].has_key?('class') && el.options[:attr]['class'] =~ /\bshow-whitespaces\b/
-          result.gsub!(/(?:(^[ \t]+)|([ \t]+$)|([ \t]+))/) do |m|
-            suffix = ($1 ? '-l' : ($2 ? '-r' : ''))
-            m.scan(/./).map do |c|
-              case c
-              when "\t" then "<span class=\"ws-tab#{suffix}\">\t</span>"
-              when " " then "<span class=\"ws-space#{suffix}\">&sdot;</span>"
-              end
-            end.join('')
+      def convert_codeblock(el, indent, opts)
+        if el.options[:attr] && el.options[:attr]['lang'] && HIGHLIGHTING_AVAILABLE && @doc.options[:coderay]
+          el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
+          result = CodeRay.scan(el.value, el.options[:attr].delete('lang').to_sym).html(@doc.options[:coderay]).chomp + "\n"
+          "#{' '*indent}<div#{options_for_element(el)}>#{result}#{' '*indent}</div>\n"
+        else
+          result = escape_html(el.value)
+          if el.options[:attr] && el.options[:attr].has_key?('class') && el.options[:attr]['class'] =~ /\bshow-whitespaces\b/
+            result.gsub!(/(?:(^[ \t]+)|([ \t]+$)|([ \t]+))/) do |m|
+              suffix = ($1 ? '-l' : ($2 ? '-r' : ''))
+              m.scan(/./).map do |c|
+                case c
+                when "\t" then "<span class=\"ws-tab#{suffix}\">\t</span>"
+                when " " then "<span class=\"ws-space#{suffix}\">&sdot;</span>"
+                end
+              end.join('')
+            end
           end
+          "#{' '*indent}<pre#{options_for_element(el)}><code>#{result}#{result =~ /\n\Z/ ? '' : "\n"}</code></pre>\n"
         end
-        "#{' '*indent}<pre#{options_for_element(el)}><code>#{result}#{result =~ /\n\Z/ ? '' : "\n"}</code></pre>\n"
       end
 
-      def convert_blockquote(el, inner, indent)
-        "#{' '*indent}<blockquote#{options_for_element(el)}>\n#{inner}#{' '*indent}</blockquote>\n"
+      def convert_blockquote(el, indent, opts)
+        "#{' '*indent}<blockquote#{options_for_element(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</blockquote>\n"
       end
 
-      def convert_header(el, inner, indent)
-        "#{' '*indent}<h#{el.options[:level]}#{options_for_element(el)}>#{inner}</h#{el.options[:level]}>\n"
+      def convert_header(el, indent, opts)
+        "#{' '*indent}<h#{el.options[:level]}#{options_for_element(el)}>#{inner(el, indent, opts)}</h#{el.options[:level]}>\n"
       end
 
-      def convert_hr(el, inner, indent)
+      def convert_hr(el, indent, opts)
         "#{' '*indent}<hr />\n"
       end
 
-      def convert_ul(el, inner, indent)
-        "#{' '*indent}<#{el.type}#{options_for_element(el)}>\n#{inner}#{' '*indent}</#{el.type}>\n"
+      def convert_ul(el, indent, opts)
+        "#{' '*indent}<#{el.type}#{options_for_element(el)}>\n#{inner(el, indent, opts)}#{' '*indent}</#{el.type}>\n"
       end
       alias :convert_ol :convert_ul
       alias :convert_dl :convert_ul
 
-      def convert_li(el, inner, indent)
+      def convert_li(el, indent, opts)
         output = ' '*indent << "<#{el.type}" << options_for_element(el) << ">"
+        res = inner(el, indent, opts)
         if el.options[:first_is_block]
-          output << "\n" << inner << ' '*indent
+          output << "\n" << res << ' '*indent
         else
-          output << inner << (inner =~ /\n\Z/ ? ' '*indent : '')
+          output << res << (res =~ /\n\Z/ ? ' '*indent : '')
         end
         output << "</#{el.type}>\n"
       end
       alias :convert_dd :convert_li
 
-      def convert_dt(el, inner, indent)
-        "#{' '*indent}<dt#{options_for_element(el)}>#{inner}</dt>\n"
+      def convert_dt(el, indent, opts)
+        "#{' '*indent}<dt#{options_for_element(el)}>#{inner(el, indent, opts)}</dt>\n"
       end
 
       HTML_TAGS_WITH_BODY=['div', 'script']
 
-      def convert_html_element(el, inner, indent)
+      def convert_html_element(el, indent, opts)
+        res = inner(el, indent, opts)
         if @doc.options[:filter_html].include?(el.value)
-          inner.chomp + (el.options[:type] == :block ? "\n" : '')
+          res.chomp + (el.options[:type] == :block ? "\n" : '')
         elsif el.options[:type] == :span
-          "<#{el.value}#{options_for_element(el)}" << (!inner.empty? ? ">#{inner}</#{el.value}>" : " />")
+          "<#{el.value}#{options_for_element(el)}" << (!res.empty? ? ">#{res}</#{el.value}>" : " />")
         else
           output = ''
           output << ' '*indent if el.options[:parse_type] != :raw && !el.options[:parent_is_raw]
           output << "<#{el.value}#{options_for_element(el)}"
-          if !inner.empty? && el.options[:parse_type] != :block
-            output << ">#{inner}</#{el.value}>"
-          elsif !inner.empty?
-            output << ">\n#{inner}"  << ' '*indent << "</#{el.value}>"
+          if !res.empty? && el.options[:parse_type] != :block
+            output << ">#{res}</#{el.value}>"
+          elsif !res.empty?
+            output << ">\n#{res}"  << ' '*indent << "</#{el.value}>"
           elsif HTML_TAGS_WITH_BODY.include?(el.value)
             output << "></#{el.value}>"
           else
@@ -143,55 +165,84 @@ module Kramdown
         end
       end
 
-      def convert_html_text(el, inner, indent)
+      def convert_html_text(el, indent, opts)
         escape_html(el.value, false)
       end
 
-      def convert_xml_comment(el, inner, indent)
+      def convert_xml_comment(el, indent, opts)
         el.value + (el.options[:type] == :block ? "\n" : '')
       end
       alias :convert_xml_pi :convert_xml_comment
 
-      def convert_br(el, inner, indent)
+      def convert_table(el, indent, opts)
+        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"
+          end.join('')
+        end
+        "#{' '*indent}<table#{options_for_element(el)}>\n#{alignment}#{inner(el, indent, opts)}#{' '*indent}</table>\n"
+      end
+
+      def convert_thead(el, indent, opts)
+        opts[:cell_type] = case el.type
+                           when :thead then 'th'
+                           when :tbody, :tfoot then 'td'
+                           else opts[:cell_type]
+                           end
+        "#{' '*indent}<#{el.type}#{options_for_element(el)}>\n#{inner(el, indent, opts)}#{' '*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}<#{opts[:cell_type]}#{options_for_element(el)}>#{res.empty? ? "&nbsp;" : res}</#{opts[:cell_type]}>\n"
+      end
+
+      def convert_br(el, indent, opts)
         "<br />"
       end
 
-      def convert_a(el, inner, indent)
+      def convert_a(el, indent, opts)
         if el.options[:attr]['href'] =~ /^mailto:/
           el = Marshal.load(Marshal.dump(el)) # so that the original is not changed
           href = obfuscate(el.options[:attr]['href'].sub(/^mailto:/, ''))
           mailto = obfuscate('mailto')
           el.options[:attr]['href'] = "#{mailto}:#{href}"
         end
-        inner = obfuscate(inner) if el.options[:obfuscate_text]
-        "<a#{options_for_element(el)}>#{inner}</a>"
+        res = inner(el, indent, opts)
+        res = obfuscate(res) if el.options[:obfuscate_text]
+        "<a#{options_for_element(el)}>#{res}</a>"
       end
 
-      def convert_img(el, inner, indent)
+      def convert_img(el, indent, opts)
         "<img#{options_for_element(el)} />"
       end
 
-      def convert_codespan(el, inner, indent)
+      def convert_codespan(el, indent, opts)
         "<code#{options_for_element(el)}>#{escape_html(el.value)}</code>"
       end
 
-      def convert_footnote(el, inner, indent)
+      def convert_footnote(el, indent, opts)
         number = @footnote_counter
         @footnote_counter += 1
         @footnotes << [el.options[:name], @doc.parse_infos[:footnotes][el.options[:name]]]
         "<sup id=\"fnref:#{el.options[:name]}\"><a href=\"#fn:#{el.options[:name]}\" rel=\"footnote\">#{number}</a></sup>"
       end
 
-      def convert_raw(el, inner, indent)
+      def convert_raw(el, indent, opts)
         el.value
       end
 
-      def convert_em(el, inner, indent)
-        "<#{el.type}#{options_for_element(el)}>#{inner}</#{el.type}>"
+      def convert_em(el, indent, opts)
+        "<#{el.type}#{options_for_element(el)}>#{inner(el, indent, opts)}</#{el.type}>"
       end
       alias :convert_strong :convert_em
 
-      def convert_entity(el, inner, indent)
+      def convert_entity(el, indent, opts)
         el.value
       end
 
@@ -200,12 +251,12 @@ module Kramdown
         :laquo_space => '&laquo;&nbsp;', :raquo_space => '&nbsp;&raquo;',
         :laquo => '&laquo;', :raquo => '&raquo;'
       }
-      def convert_typographic_sym(el, inner, indent)
+      def convert_typographic_sym(el, indent, opts)
         TYPOGRAPHIC_SYMS[el.value]
       end
 
-      def convert_root(el, inner, indent)
-        inner << footnote_content
+      def convert_root(el, indent, opts)
+        inner(el, indent, opts) << footnote_content
       end
 
       # Helper method for obfuscating the +text+ by using HTML entities.
@@ -234,7 +285,7 @@ module Kramdown
           end
           para.children << ref
         end
-        (ol.children.empty? ? '' : "<div class=\"kramdown-footnotes\">\n#{convert(ol, 2)}</div>\n")
+        (ol.children.empty? ? '' : "<div class=\"footnotes\">\n#{convert(ol, 2)}</div>\n")
       end
 
       # Return the string with the attributes of the element +el+.

data/lib/kramdown/document.rb

@@ -50,17 +50,30 @@ module Kramdown
     #
     # [:auto_ids (used by the parser)]
     #    A boolean value deciding whether automatic header ID generation is used. Default: +false+.
+    #
+    # [:coderay (used by the HTML converter)]
+    #    A hash containing options for the CodeRay syntax highlighter. If this is set to +nil+,
+    #    syntax highlighting is disabled. When using the +options+ extension, any CodeRay option can
+    #    be set by prefixing it with +coderay_+.
+    #
+    #    Default:
+    #      {:wrap => :div, :line_numbers => :inline, :line_number_start => 1,
+    #       :tab_width => 8, :bold_every => 10, :css => :style}
+    #
     # [:filter_html (used by the HTML converter)]
     #    An array of HTML tag names that defines which tags should be filtered from the output. For
     #    example, if the value contains +iframe+, then all HTML +iframe+ tags are filtered out and
     #    only the body is displayed. Default: empty array. When using the +options+ extension, the
     #    string value needs to hold the HTML tag names separated by one or more spaces.
+    #
     # [:footnote_nr (used by the HTML converter)]
     #    The initial number used for creating the link to the first footnote. Default: +1+. When
     #    using the +options+ extension, the string value needs to be a valid number.
+    #
     # [:parse_block_html (used by the parser)]
     #    A boolean value deciding whether kramdown syntax is processed in block HTML tags. Default:
     #    +false+.
+    #
     # [:parse_span_html (used by the parser)]
     #    A boolean value deciding whether kramdown syntax is processed in span HTML tags. Default:
     #    +true+.
@@ -73,7 +86,9 @@ module Kramdown
       :filter_html => [],
       :auto_ids => true,
       :parse_block_html => false,
-      :parse_span_html => true
+      :parse_span_html => true,
+      :coderay => {:wrap => :div, :line_numbers => :inline,
+        :line_number_start => 1, :tab_width => 8, :bold_every => 10, :css => :style}
     }
 
 

data/lib/kramdown/extension.rb

@@ -65,6 +65,25 @@ module Kramdown
       if val = opts.delete('parse_span_html')
         parser.doc.options[:parse_span_html] = boolean_value(val)
       end
+      if val = opts.delete('coderay_wrap')
+        (parser.doc.options[:coderay] ||= {})[:wrap] = (val.empty? ? nil : val.to_sym)
+      end
+      if val = opts.delete('coderay_css')
+        (parser.doc.options[:coderay] ||= {})[:css] = val.to_sym
+      end
+      if val = opts.delete('coderay_tab_width')
+        (parser.doc.options[:coderay] ||= {})[:tab_width] = val.to_i
+      end
+      if val = opts.delete('coderay_line_numbers')
+        (parser.doc.options[:coderay] ||= {})[:line_numbers] = (val.empty? ? nil : val.to_sym)
+      end
+      if val = opts.delete('coderay_line_number_start')
+        (parser.doc.options[:coderay] ||= {})[:line_number_start] = val.to_i
+      end
+      if val = opts.delete('coderay_bold_every')
+        (parser.doc.options[:coderay] ||= {})[:bold_every] = val.to_i
+      end
+
       opts.each {|k,v| parser.warning("Unknown kramdown options '#{k}'")}
     end
 

data/lib/kramdown/parser/kramdown.rb

@@ -81,7 +81,7 @@ module Kramdown
       private
       #######
 
-      BLOCK_PARSERS = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :atx_header,
+      BLOCK_PARSERS = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :table, :atx_header,
                        :setext_header, :horizontal_rule, :list, :definition_list, :link_definition, :block_html,
                        :footnote_definition, :ald, :block_ial, :extension_block, :eob_marker, :paragraph]
       SPAN_PARSERS =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link,
@@ -249,6 +249,7 @@ module Kramdown
       require 'kramdown/parser/kramdown/paragraph'
       require 'kramdown/parser/kramdown/header'
       require 'kramdown/parser/kramdown/blockquote'
+      require 'kramdown/parser/kramdown/table'
       require 'kramdown/parser/kramdown/codeblock'
       require 'kramdown/parser/kramdown/horizontal_rule'
       require 'kramdown/parser/kramdown/list'

data/lib/kramdown/parser/kramdown/attribute_list.rb

@@ -51,7 +51,7 @@ module Kramdown
       ALD_ID_CHARS = /[\w\d-]/
       ALD_ANY_CHARS = /\\\}|[^\}]/
       ALD_ID_NAME = /(?:\w|\d)#{ALD_ID_CHARS}*/
-      ALD_TYPE_KEY_VALUE_PAIR = /(#{ALD_ID_NAME})=("|')((?:\\\}|\\\2|[^\}\2])+?)\2/
+      ALD_TYPE_KEY_VALUE_PAIR = /(#{ALD_ID_NAME})=("|')((?:\\\}|\\\2|[^\}\2])*?)\2/
       ALD_TYPE_CLASS_NAME = /\.(#{ALD_ID_NAME})/
       ALD_TYPE_ID_NAME = /#(#{ALD_ID_NAME})/
       ALD_TYPE_REF = /(#{ALD_ID_NAME})/
@@ -72,7 +72,7 @@ module Kramdown
       # Parse the inline attribute list at the current location.
       def parse_block_ial
         @src.pos += @src.matched_size
-        if @tree.children.last && @tree.children.last.type != :blank
+        if @tree.children.last && @tree.children.last.type != :blank && @tree.children.last.type != :eob
           parse_attribute_list(@src[1], @tree.children.last.options[:ial] ||= {})
         end
         true

data/lib/kramdown/parser/kramdown/codeblock.rb

@@ -20,23 +20,19 @@
 #++
 #
 
+require 'kramdown/parser/kramdown/blank_line'
+
 module Kramdown
   module Parser
     class Kramdown
 
       CODEBLOCK_START = INDENT
-      CODEBLOCK_MATCH = /(?:#{INDENT}.*?\S.*?\n)+/
+      CODEBLOCK_LINE =  /(?:#{INDENT}.*?\S.*?\n)+/
+      CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?#{CODEBLOCK_LINE})*/
 
       # Parse the indented codeblock at the current location.
       def parse_codeblock
-        result = @src.scan(CODEBLOCK_MATCH).gsub(INDENT, '')
-        children = @tree.children
-        if children.length >= 2 && children[-1].type == :blank && children[-2].type == :codeblock
-          children[-2].value << children[-1].value.gsub(INDENT, '') << result
-          children.pop
-        else
-          @tree.children << Element.new(:codeblock, result)
-        end
+        @tree.children << Element.new(:codeblock, @src.scan(CODEBLOCK_MATCH).gsub!(INDENT, ''))
         true
       end
       define_parser(:codeblock, CODEBLOCK_START)

data/lib/kramdown/parser/kramdown/escaped_chars.rb

@@ -24,7 +24,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      ESCAPED_CHARS = /\\([\\.*_+-`()\[\]{}#!])/
+      ESCAPED_CHARS = /\\([\\.*_+`()\[\]{}#!:|-])/
 
       # Parse the backslash-escaped character at the current location.
       def parse_escaped_chars

data/lib/kramdown/parser/kramdown/footnote.rb

@@ -28,7 +28,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      FOOTNOTE_DEFINITION_START = /^#{OPT_SPACE}\[\^(#{ALD_ID_NAME})\]:\s*?(.*?\n(?:#{BLANK_LINE}?#{CODEBLOCK_MATCH})*)/
+      FOOTNOTE_DEFINITION_START = /^#{OPT_SPACE}\[\^(#{ALD_ID_NAME})\]:\s*?(.*?\n(?:#{BLANK_LINE}?#{CODEBLOCK_LINE})*)/
 
       # Parse the foot note definition at the current location.
       def parse_footnote_definition
@@ -38,6 +38,7 @@ module Kramdown
         parse_blocks(el, @src[2].gsub(INDENT, ''))
         warning("Duplicate footnote name '#{@src[1]}' - overwriting") if @doc.parse_infos[:footnotes][@src[1]]
         (@doc.parse_infos[:footnotes][@src[1]] = {})[:content] = el
+        true
       end
       define_parser(:footnote_definition, FOOTNOTE_DEFINITION_START)
 

data/lib/kramdown/parser/kramdown/table.rb

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2010 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown.
+#
+# kramdown is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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 for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#++
+#
+
+require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/eob'
+require 'kramdown/parser/kramdown/horizontal_rule'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      TABLE_SEP_LINE = /^#{OPT_SPACE}(?:\||\+)([ ]?:?-[+|: -]*)[ \t]*\n/
+      TABLE_HSEP_ALIGN = /[ ]?(:?)-+(:?)[ ]?/
+      TABLE_FSEP_LINE = /^#{OPT_SPACE}(\||\+)[ ]?:?=[+|: =]*[ \t]*\n/
+      TABLE_ROW_LINE = /^#{OPT_SPACE}\|(.*?)[ \t]*\n/
+      TABLE_START = /^#{OPT_SPACE}\|(?:-|(?!=))/
+
+      # Parse the table at the current location.
+      def parse_table
+        orig_pos = @src.pos
+        table = Element.new(:table, nil, :alignment => [])
+
+        @src.scan(TABLE_SEP_LINE)
+
+        rows = []
+        has_footer = false
+        columns = 0
+
+        add_container = lambda do |type, force|
+          if force || type != :tbody || !has_footer
+            cont = Element.new(type)
+            cont.children, rows = rows, []
+            table.children << cont
+          end
+        end
+
+        while !@src.eos?
+          if @src.scan(TABLE_SEP_LINE) && !rows.empty?
+            if table.options[:alignment].empty? && !has_footer
+              add_container.call(:thead, false)
+              table.options[:alignment] = @src[1].scan(TABLE_HSEP_ALIGN).map do |left, right|
+                (left.empty? && right.empty? && :default) || (right.empty? && :left) || (left.empty? && :right) || :center
+              end
+            else # treat as normal separator line
+              add_container.call(:tbody, false)
+            end
+          elsif @src.scan(TABLE_FSEP_LINE)
+            add_container.call(:tbody, true) if !rows.empty?
+            has_footer = true
+          elsif @src.scan(TABLE_ROW_LINE)
+            trow = Element.new(:tr)
+            cells = (@src[1] + ' ').split(/\|/)
+            i = 0
+            while i < cells.length - 1
+              backslashes = cells[i].scan(/\\+$/).first
+              if backslashes && backslashes.length % 2 == 1
+                cells[i] = cells[i].chop + '|' + cells[i+1]
+                cells.delete_at(i+1)
+              else
+                i += 1
+              end
+            end
+            cells.pop if cells.last.strip.empty?
+            cells.each do |cell_text|
+              tcell = Element.new(:td)
+              tcell.children << Element.new(:text, cell_text.strip)
+              trow.children << tcell
+            end
+            columns = [columns, cells.length].max
+            rows << trow
+          else
+            break
+          end
+        end
+
+        add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
+
+        if !table.children.any? {|c| c.type == :tbody}
+          warning("Found table without body - ignoring it")
+          @src.pos = orig_pos
+          return false
+        end
+
+        # adjust all table rows to have equal number of columns, same for alignment defs
+        table.children.each do |kind|
+          kind.children.each do |row|
+            (columns - row.children.length).times do
+              row.children << Element.new(:td)
+            end
+          end
+        end
+        if table.options[:alignment].length > columns
+          table.options[:alignment] = table.options[:alignment][0...columns]
+        else
+          table.options[:alignment] += [:default] * (columns - table.options[:alignment].length)
+        end
+
+        @tree.children << table
+
+        true
+      end
+      define_parser(:table, TABLE_START)
+
+    end
+  end
+end