kramdown 0.13.2 → 0.13.3

data/lib/kramdown/converter/kramdown.rb

@@ -43,14 +43,16 @@ module Kramdown
 
       def convert(el, opts = {:indent => 0})
         res = send("convert_#{el.type}", el, opts)
-        if el.type != :html_element && el.type != :li && el.type != :dd && (ial = ial_for_element(el))
+        if ![:html_element, :li, :dd, :td].include?(el.type) && (ial = ial_for_element(el))
           res << ial
           res << "\n\n" if Element.category(el) == :block
         elsif [:ul, :dl, :ol, :codeblock].include?(el.type) && opts[:next] &&
             ([el.type, :codeblock].include?(opts[:next].type) ||
              (opts[:next].type == :blank && opts[:nnext] && [el.type, :codeblock].include?(opts[:nnext].type)))
           res << "^\n\n"
-        elsif Element.category(el) == :block && ![:li, :dd, :dt, :td, :th, :tr, :thead, :tbody, :tfoot, :blank].include?(el.type) &&
+        elsif Element.category(el) == :block &&
+            ![:li, :dd, :dt, :td, :th, :tr, :thead, :tbody, :tfoot, :blank].include?(el.type) &&
+            (el.type != :html_element || @stack.last.type != :html_element) &&
             (el.type != :p || !el.options[:transparent])
           res << "\n"
         end
@@ -213,7 +215,7 @@ module Kramdown
         if el.options[:category] == :block && (@stack.last.type != :html_element || @stack.last.options[:content_model] != :raw)
           el.value + "\n"
         else
-          el.value
+          el.value.dup
         end
       end
       alias :convert_xml_pi :convert_xml_comment

data/lib/kramdown/converter/latex.rb

@@ -30,13 +30,13 @@ module Kramdown
     #
     # This converter uses ideas from other Markdown-to-LaTeX converters like Pandoc and Maruku.
     #
-    # You can customize this converter by sub-classing it and overriding the <tt>convert_NAME</tt>
-    # methods. Each such method takes the following parameters:
+    # You can customize this converter by sub-classing it and overriding the +convert_NAME+ methods.
+    # Each such method takes the following parameters:
     #
     # [+el+] The element of type +NAME+ to be converted.
     #
     # [+opts+] A hash containing processing options that are passed down from parent elements. The
-    #          key <tt>:parent</tt> is always set and contains the parent element as value.
+    #          key :parent is always set and contains the parent element as value.
     #
     # The return value of such a method has to be a string containing the element +el+ formatted
     # correctly as LaTeX markup.
@@ -50,8 +50,8 @@ module Kramdown
         @data[:packages] = Set.new
       end
 
-      # Dispatch the conversion of the element +el+ to a <tt>convert_TYPE</tt> method using the
-      # +type+ of the element.
+      # Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
+      # the element.
       def convert(el, opts = {})
         send("convert_#{el.type}", el, opts)
       end
@@ -88,8 +88,8 @@ module Kramdown
         end
       end
 
-      # Helper method used by +convert_p+ to convert a paragraph that only contains a single
-      # <tt>:img</tt> element.
+      # Helper method used by +convert_p+ to convert a paragraph that only contains a single :img
+      # element.
       def convert_standalone_image(el, opts, img)
         attrs = attribute_list(el)
         "\\begin{figure}#{attrs}\n\\begin{center}\n#{img}\n\\end{center}\n\\caption{#{escape(el.children.first.attr['alt'])}}\n#{latex_link_target(el, true)}\n\\end{figure}#{attrs}\n"
@@ -180,9 +180,10 @@ module Kramdown
       TABLE_ALIGNMENT_CHAR = {:default => 'l', :left => 'l', :center => 'c', :right => 'r'} # :nodoc:
 
       def convert_table(el, opts)
+        @data[:packages] << 'longtable'
         align = el.options[:alignment].map {|a| TABLE_ALIGNMENT_CHAR[a]}.join('|')
         attrs = attribute_list(el)
-        "#{latex_link_target(el)}\\begin{tabular}{|#{align}|}#{attrs}\n\\hline\n#{inner(el, opts)}\\hline\n\\end{tabular}#{attrs}\n\n"
+        "#{latex_link_target(el)}\\begin{longtable}{|#{align}|}#{attrs}\n\\hline\n#{inner(el, opts)}\\hline\n\\end{longtable}#{attrs}\n\n"
       end
 
       def convert_thead(el, opts)
@@ -228,7 +229,7 @@ module Kramdown
         if el.attr['src'] =~ /^(https?|ftps?):\/\//
           warning("Cannot include non-local image")
           ''
-        elsif !el.options.attr['src'].empty?
+        elsif !el.attr['src'].empty?
           @data[:packages] << 'graphicx'
           "#{latex_link_target(el)}\\includegraphics{#{el.attr['src']}}"
         else
@@ -560,17 +561,16 @@ module Kramdown
       end
 
       # Wrap the +text+ inside a LaTeX environment of type +type+. The element +el+ is passed on to
-      # the method #attribute_list -- the resulting string is appended to both the <tt>\\begin</tt>
-      # and the <tt>\\end</tt> lines of the LaTeX environment for easier post-processing of LaTeX
-      # environments.
+      # the method #attribute_list -- the resulting string is appended to both the \\begin and the
+      # \\end lines of the LaTeX environment for easier post-processing of LaTeX environments.
       def latex_environment(type, el, text)
         attrs = attribute_list(el)
         "\\begin{#{type}}#{latex_link_target(el)}#{attrs}\n#{text.rstrip}\n\\end{#{type}}#{attrs}\n"
       end
 
-      # Return a string containing a valid <tt>\hypertarget</tt> command if the element has an ID
-      # defined, or +nil+ otherwise. If the parameter +add_label+ is +true+, a <tt>\label</tt>
-      # command will also be used additionally to the <tt>\hypertarget</tt> command.
+      # Return a string containing a valid \hypertarget command if the element has an ID defined, or
+      # +nil+ otherwise. If the parameter +add_label+ is +true+, a \label command will also be used
+      # additionally to the \hypertarget command.
       def latex_link_target(el, add_label = false)
         if (id = el.attr['id'])
           "\\hypertarget{#{id}}{}" << (add_label ? "\\label{#{id}}" : '')
@@ -579,7 +579,7 @@ module Kramdown
         end
       end
 
-      # Return a LaTeX comment containing all attributes as <tt>key="value"</tt> pairs.
+      # Return a LaTeX comment containing all attributes as 'key="value"' pairs.
       def attribute_list(el)
         attrs = el.attr.map {|k,v| v.nil? ? '' : " #{k}=\"#{v.to_s}\""}.compact.sort.join('')
         attrs = "   % #{attrs}" if !attrs.empty?

data/lib/kramdown/document.rb

@@ -74,10 +74,10 @@ module Kramdown
     # Create a new Kramdown document from the string +source+ and use the provided +options+. The
     # options that can be used are defined in the Options module.
     #
-    # The special options key <tt>:input</tt> can be used to select the parser that should parse the
+    # The special options key :input can be used to select the parser that should parse the
     # +source+. It has to be the name of a class in the Kramdown::Parser module. For example, to
-    # select the kramdown parser, one would set the <tt>:input</tt> key to +Kramdown+. If this key
-    # is not set, it defaults to +Kramdown+.
+    # select the kramdown parser, one would set the :input key to +Kramdown+. If this key is not
+    # set, it defaults to +Kramdown+.
     #
     # The +source+ is immediately parsed by the selected parser so that the root element is
     # immediately available and the output can be generated.
@@ -132,11 +132,11 @@ module Kramdown
   #
   # The root element contains the following option keys:
   #
-  # <tt>:encoding</tt>:: When running on Ruby 1.9 this key has to be set to the encoding used for
-  #                      the text parts of the kramdown document.
+  # :encoding:: When running on Ruby 1.9 this key has to be set to the encoding used for the text
+  #             parts of the kramdown document.
   #
-  # <tt>:abbrev_defs</tt>:: This key may be used to store the mapping of abbreviation to
-  #                         abbreviation definition.
+  # :abbrev_defs:: This key may be used to store the mapping of abbreviation to abbreviation
+  #                definition.
   #
   #
   # === :blank
@@ -159,8 +159,8 @@ module Kramdown
   #
   # Represents a paragraph.
   #
-  # If the option <tt>:transparent</tt> is +true+, this element just represents a block of text.
-  # I.e. this element just functions as a container for span-level elements.
+  # If the option :transparent is +true+, this element just represents a block of text. I.e. this
+  # element just functions as a container for span-level elements.
   #
   #
   # === :header
@@ -171,8 +171,8 @@ module Kramdown
   #
   # Represents a header.
   #
-  # The option <tt>:level</tt> specifies the header level and has to contain a number between 1 and
-  # \6. The option <tt>:raw_text</tt> has to contain the raw header text.
+  # The option :level specifies the header level and has to contain a number between 1 and \6. The
+  # option :raw_text has to contain the raw header text.
   #
   #
   # === :blockquote
@@ -269,9 +269,8 @@ module Kramdown
   # Represents a table. Each table row (i.e. :tr element) of the table has to contain the same
   # number of :td elements.
   #
-  # The option <tt>:alignment</tt> has to be an array containing the alignment values, exactly one
-  # for each column of the table. The possible alignment values are <tt>:left</tt>,
-  # <tt>:center</tt>, <tt>:right</tt> and <tt>:default</tt>.
+  # The option :alignment has to be an array containing the alignment values, exactly one for each
+  # column of the table. The possible alignment values are :left, :center, :right and :default.
   #
   #
   # === :thead
@@ -330,8 +329,8 @@ module Kramdown
   #
   # The +value+ field has to contain the actual mathematical text.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the context where the element is used.
+  # The option :category has to be set to either :span or :block depending on the context where the
+  # element is used.
   #
   #
   # == Text Markup Elements
@@ -400,9 +399,9 @@ module Kramdown
   # Represents a footnote marker.
   #
   # The +value+ field has to contain an element whose children are the content of the footnote. The
-  # option <tt>:name</tt> has to contain a valid and unique footnote name. A valid footnote name
-  # consists of a word character or a digit and then optionally followed by other word characters,
-  # digits or dashes.
+  # option :name has to contain a valid and unique footnote name. A valid footnote name consists of
+  # a word character or a digit and then optionally followed by other word characters, digits or
+  # dashes.
   #
   #
   # === :em
@@ -432,7 +431,7 @@ module Kramdown
   # Represents an HTML entity.
   #
   # The +value+ field has to contain an instance of Kramdown::Utils::Entities::Entity. The option
-  # <tt>:original</tt> can be used to store the original representation of the entity.
+  # :original can be used to store the original representation of the entity.
   #
   #
   # === :typographic_sym
@@ -446,13 +445,13 @@ module Kramdown
   # The +value+ field needs to contain a Symbol representing the specific typographic symbol from
   # the following list:
   #
-  # <tt>:mdash</tt>:: An mdash character (---)
-  # <tt>:ndash</tt>:: An ndash character (--)
-  # <tt>:hellip</tt>:: An ellipsis (...)
-  # <tt>:laquo</tt>:: A left guillemet (<<)
-  # <tt>:raquo</tt>:: A right guillemet (>>)
-  # <tt>:laquo_space</tt>:: A left guillemet with a space (<< )
-  # <tt>:raquo_space</tt>:: A right guillemet with a space ( >>)
+  # :mdash:: An mdash character (---)
+  # :ndash:: An ndash character (--)
+  # :hellip:: An ellipsis (...)
+  # :laquo:: A left guillemet (<<)
+  # :raquo:: A right guillemet (>>)
+  # :laquo_space:: A left guillemet with a space (<< )
+  # :raquo_space:: A right guillemet with a space ( >>)
   #
   #
   # === :smart_quote
@@ -465,10 +464,10 @@ module Kramdown
   #
   # The +value+ field needs to contain a Symbol representing the specific quotation character:
   #
-  # <tt>:lsquo</tt>:: Left single quote
-  # <tt>:rsquo</tt>:: Right single quote
-  # <tt>:ldquo</tt>:: Left double quote
-  # <tt>:rdquo</tt>:: Right double quote
+  # :lsquo:: Left single quote
+  # :rsquo:: Right single quote
+  # :ldquo:: Left double quote
+  # :rdquo:: Right double quote
   #
   #
   # === :abbreviation
@@ -480,7 +479,7 @@ module Kramdown
   # Represents a text part that is an abbreviation.
   #
   # The +value+ field has to contain the text part that is the abbreviation. The definition of the
-  # abbreviation is stored in the <tt>:root</tt> element of the document.
+  # abbreviation is stored in the :root element of the document.
   #
   #
   # == Other Elements
@@ -495,11 +494,10 @@ module Kramdown
   #
   # The +value+ field has to contain the name of the HTML element the element is representing.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the whether the element is a block-level or a span-level element. The option
-  # <tt>:content_model</tt> has to be set to the content model for the element (either
-  # <tt>:block</tt> if it contains block-level elements, <tt>:span</tt> if it contains span-level
-  # elements or <tt>:raw</tt> if it contains raw content).
+  # The option :category has to be set to either :span or :block depending on the whether the
+  # element is a block-level or a span-level element. The option :content_model has to be set to the
+  # content model for the element (either :block if it contains block-level elements, :span if it
+  # contains span-level elements or :raw if it contains raw content).
   #
   #
   # === :xml_comment
@@ -512,8 +510,8 @@ module Kramdown
   #
   # The +value+ field has to contain the whole XML/HTML comment including the delimiters.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the context where the element is used.
+  # The option :category has to be set to either :span or :block depending on the context where the
+  # element is used.
   #
   #
   # === :xml_pi
@@ -527,8 +525,8 @@ module Kramdown
   # The +value+ field has to contain the whole XML/HTML processing instruction including the
   # delimiters.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the context where the element is used.
+  # The option :category has to be set to either :span or :block depending on the context where the
+  # element is used.
   #
   #
   # === :comment
@@ -541,8 +539,8 @@ module Kramdown
   #
   # The +value+ field has to contain the comment.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the context where the element is used.
+  # The option :category has to be set to either :span or :block depending on the context where the
+  # element is used.
   #
   #
   # === :raw
@@ -556,12 +554,12 @@ module Kramdown
   #
   # The +value+ field has to contain the actual raw text.
   #
-  # The option <tt>:category</tt> has to be set to either <tt>:span</tt> or <tt>:block</tt>
-  # depending on the context where the element is used. The option <tt>:type</tt> can be set to an
-  # array of strings to define for which converters the raw string is valid.
+  # The option :category has to be set to either :span or :block depending on the context where the
+  # element is used. The option :type can be set to an array of strings to define for which
+  # converters the raw string is valid.
   class Element
 
-    # A symbol representing the element type. For example, <tt>:p</tt> or <tt>:blockquote</tt>.
+    # A symbol representing the element type. For example, :p or :blockquote.
     attr_accessor :type
 
     # The value of the element. The interpretation of this field depends on the type of the element.
@@ -598,11 +596,10 @@ module Kramdown
     [:text, :a, :br, :img, :codespan, :footnote, :em, :strong, :entity, :typographic_sym,
      :smart_quote, :abbreviation].each {|b| CATEGORY[b] = :span}
 
-    # Return the category of +el+ which can be <tt>:block</tt>, <tt>:span</tt> or +nil+.
+    # Return the category of +el+ which can be :block, :span or +nil+.
     #
     # Most elements have a fixed category, however, some elements can either appear in a block-level
-    # or a span-level context. These elements need to have the option <tt>:category</tt> correctly
-    # set.
+    # or a span-level context. These elements need to have the option :category correctly set.
     def self.category(el)
       CATEGORY[el.type] || el.options[:category]
     end

data/lib/kramdown/parser/base.rb

@@ -37,8 +37,8 @@ module Kramdown
     #
     # Implementing a new parser is rather easy: just derive a new class from this class and put it
     # in the Kramdown::Parser module -- the latter is needed so that the auto-detection of the new
-    # parser works correctly. Then you need to implement the <tt>#parse</tt> method which has to
-    # contain the parsing code.
+    # parser works correctly. Then you need to implement the +#parse+ method which has to contain
+    # the parsing code.
     #
     # Have a look at the Base::parse, Base::new and Base#parse methods for additional information!
     class Base
@@ -57,8 +57,8 @@ module Kramdown
 
       # Initialize the parser object with the +source+ string and the parsing +options+.
       #
-      # The <tt>@root</tt> element, the <tt>@warnings</tt> array and <tt>@text_type</tt> (specifies
-      # the default type for newly created text nodes) are automatically initialized.
+      # The @root element, the @warnings array and @text_type (specifies the default type for newly
+      # created text nodes) are automatically initialized.
       def initialize(source, options)
         @source = source
         @options = Kramdown::Options.merge(options)
@@ -71,7 +71,7 @@ module Kramdown
       # Parse the +source+ string into an element tree, possibly using the parsing +options+, and
       # return the root element of the element tree and an array with warning messages.
       #
-      # Initializes a new instance of the calling class and then calls the #parse method that must
+      # Initializes a new instance of the calling class and then calls the +#parse+ method that must
       # be implemented by each subclass.
       def self.parse(source, options = {})
         parser = new(source, options)
@@ -81,8 +81,8 @@ module Kramdown
 
       # Parse the source string into an element tree.
       #
-      # The parsing code should parse the source provided in <tt>@source</tt> and build an element
-      # tree the root of which should be <tt>@root</tt>.
+      # The parsing code should parse the source provided in @source and build an element tree the
+      # root of which should be @root.
       #
       # This is the only method that has to be implemented by sub-classes!
       def parse
@@ -96,7 +96,7 @@ module Kramdown
       end
 
       # Modify the string +source+ to be usable by the parser (unifies line ending characters to
-      # <tt>\n</tt> and makes sure +source+ ends with a new line character).
+      # +\n+ and makes sure +source+ ends with a new line character).
       def adapt_source(source)
         source.gsub(/\r\n?/, "\n").chomp + "\n"
       end

data/lib/kramdown/parser/html.rb

@@ -45,13 +45,15 @@ module Kramdown
         HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::UNAME_STR})\s*>/m
         HTML_ENTITY_RE = /&([\w:][\-\w\.:]*);|&#(\d+);|&\#x([0-9a-fA-F]+);/
 
-
-        HTML_CONTENT_MODEL_BLOCK = %w{applet button blockquote body colgroup dd div dl fieldset
-             form iframe li map noscript object ol table tbody thead tfoot tr td ul}
-        HTML_CONTENT_MODEL_SPAN  = %w{a abbr acronym address b bdo big cite caption del dfn dt em
+        HTML_CONTENT_MODEL_BLOCK = %w{address applet article aside button blockquote body
+             dd div dl fieldset figure figcaption footer form header hgroup iframe li map menu nav
+              noscript object section td}
+        HTML_CONTENT_MODEL_SPAN  = %w{a abbr acronym b bdo big button cite caption del dfn dt em
              h1 h2 h3 h4 h5 h6 i ins kbd label legend optgroup p q rb rbc
-             rp rt rtc ruby samp select small span strong sub sup th tt var}
+             rp rt rtc ruby samp select small span strong sub sup summary th tt var}
         HTML_CONTENT_MODEL_RAW   = %w{script math option textarea pre code}
+        # The following elements are also parsed as raw since they need child elements that cannot
+        # be expressed using kramdown syntax: colgroup table tbody thead tfoot tr ul ol
 
         HTML_CONTENT_MODEL = Hash.new {|h,k| h[k] = :raw}
         HTML_CONTENT_MODEL_BLOCK.each {|i| HTML_CONTENT_MODEL[i] = :block}
@@ -64,7 +66,7 @@ module Kramdown
                               ins kbd label option q rb rbc rp rt rtc ruby samp select small span
                               strong sub sup textarea tt var}
         HTML_BLOCK_ELEMENTS = %w{address article aside applet body button blockquote caption col colgroup dd div dl dt fieldset
-                               figcaption footer form h1 h2 h3 h4 h5 h6 header hgroup hr html head iframe legend listing menu
+                               figcaption footer form h1 h2 h3 h4 h5 h6 header hgroup hr html head iframe legend menu
                                li map nav ol optgroup p pre section summary table tbody td th thead tfoot tr ul}
         HTML_ELEMENTS_WITHOUT_BODY = %w{area base br col command embed hr img input keygen link meta param source track wbr}
       end
@@ -72,13 +74,13 @@ module Kramdown
 
       # Contains the parsing methods. This module can be mixed into any parser to get HTML parsing
       # functionality. The only thing that must be provided by the class are instance variable
-      # <tt>@stack</tt> for storing the needed state and <tt>@src</tt> (instance of StringScanner)
-      # for the actual parsing.
+      # @stack for storing the needed state and @src (instance of StringScanner) for the actual
+      # parsing.
       module Parser
 
         include Constants
 
-        # Process the HTML start tag that has already be <tt>scan</tt>ned/<tt>check</tt>ed.
+        # Process the HTML start tag that has already be scanned/checked via @src.
         #
         # Does the common processing steps and then yields to the caller for further processing
         # (first parameter is the created element, the second parameter is +true+ if the HTML
@@ -215,28 +217,32 @@ module Kramdown
           else return
           end
 
-          type = el.value
-          remove_text_children(el) if REMOVE_TEXT_CHILDREN.include?(type)
-
           mname = "convert_#{el.value}"
           if do_conversion && self.class.method_defined?(mname)
             send(mname, el)
-          elsif do_conversion && SIMPLE_ELEMENTS.include?(type)
-            set_basics(el, type.intern)
-            process_children(el, do_conversion, preserve_text)
           else
-            process_html_element(el, do_conversion, preserve_text)
-          end
+            type = el.value
+            remove_text_children(el) if do_conversion && REMOVE_TEXT_CHILDREN.include?(type)
+
+            if do_conversion && SIMPLE_ELEMENTS.include?(type)
+              set_basics(el, type.intern)
+              process_children(el, do_conversion, preserve_text)
+            else
+              process_html_element(el, do_conversion, preserve_text)
+            end
 
-          strip_whitespace(el) if STRIP_WHITESPACE.include?(type)
-          remove_whitespace_children(el) if REMOVE_WHITESPACE_CHILDREN.include?(type)
-          wrap_text_children(el) if WRAP_TEXT_CHILDREN.include?(type)
+            if do_conversion
+              strip_whitespace(el) if STRIP_WHITESPACE.include?(type)
+              remove_whitespace_children(el) if REMOVE_WHITESPACE_CHILDREN.include?(type)
+              wrap_text_children(el) if WRAP_TEXT_CHILDREN.include?(type)
+            end
+          end
         end
 
         def process_children(el, do_conversion = true, preserve_text = false)
           el.children.map! do |c|
             if c.type == :text
-              process_text(c.value, preserve_text)
+              process_text(c.value, preserve_text || !do_conversion)
             else
               process(c, do_conversion, preserve_text, el)
               c
@@ -277,7 +283,7 @@ module Kramdown
 
         def process_html_element(el, do_conversion = true, preserve_text = false)
           el.options.replace(:category => HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
-                             :content_model => HTML_CONTENT_MODEL[el.value])
+                             :content_model => (do_conversion ? HTML_CONTENT_MODEL[el.value] : :raw))
           process_children(el, do_conversion, preserve_text)
         end
 
@@ -411,28 +417,26 @@ module Kramdown
             process_html_element(el, false)
             return
           end
+          remove_text_children(el)
           process_children(el)
           set_basics(el, :table)
-          el.options[:alignment] = []
 
-          nr_cols = 0
           calc_alignment = lambda do |c|
-            align = c.attr['align']
-            if c.type == :html_element && c.value == 'col' && (align.nil? || %w{left right center}.include?(align))
-              el.options[:alignment] << (align.nil? ? :default : align.to_sym)
-            elsif c.type == :tr
-              nr_cols = c.children.length
-              break
+            if c.type == :tr
+              el.options[:alignment] = c.children.map do |td|
+                if td.attr['style']
+                  td.attr['style'].slice!(/(?:;\s*)?text-align:\s+(center|left|right)/)
+                  td.attr.delete('style') if td.attr['style'].strip.empty?
+                  $1.to_sym
+                else
+                  :default
+                end
+              end
             else
               c.children.each {|cc| calc_alignment.call(cc)}
             end
           end
           calc_alignment.call(el)
-          if el.options[:alignment].length > nr_cols
-            el.options[:alignment][nr_cols..-1] = []
-          else
-            el.options[:alignment] += [:default] * (nr_cols - el.options[:alignment].length)
-          end
           el.children.delete_if {|c| c.type == :html_element}
 
           change_th_type = lambda do |c|
@@ -485,12 +489,28 @@ module Kramdown
           check_nr_cells.call(el)
           return false if nr_cells == -1
 
+          alignment = nil
+          check_alignment = Proc.new do |t|
+            if t.value == 'tr'
+              cur_alignment = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.map do |cell|
+                md = /text-align:\s+(center|left|right|justify|inherit)/.match(cell.attr['style'].to_s)
+                return false if md && (md[1] == 'justify' || md[1] == 'inherit')
+                md.nil? ? :default : md[1]
+              end
+              alignment = cur_alignment if alignment.nil?
+              return false if alignment != cur_alignment
+            else
+              t.children.each {|cc| check_alignment.call(cc)}
+            end
+          end
+          check_alignment.call(el)
+
           check_rows = lambda do |t, type|
             t.children.all? {|r| (r.value == 'tr' || r.type == :text) && r.children.all? {|c| c.value == type || c.type == :text}}
           end
           check_rows.call(el, 'td') ||
             (el.children.all? do |t|
-               t.type == :text || t.value == 'col' || (t.value == 'thead' && check_rows.call(t, 'th')) ||
+               t.type == :text || (t.value == 'thead' && check_rows.call(t, 'th')) ||
                  ((t.value == 'tfoot' || t.value == 'tbody') && check_rows.call(t, 'td'))
              end && el.children.any? {|t| t.value == 'tbody'})
         end