kramdown 0.11.0 → 0.12.0

data/lib/kramdown/parser/kramdown/smart_quotes.rb

@@ -200,7 +200,7 @@ module Kramdown
         regexp, substs = SQ_RULES.find {|reg, subst| @src.scan(reg)}
         substs.each do |subst|
           if subst.kind_of?(Integer)
-            add_text(@src[subst].to_s)
+            add_text(@src[subst])
           else
             val = SQ_SUBSTS[[subst, @src[subst.to_s[-1,1].to_i]]] || subst
             @tree.children << Element.new(:smart_quote, val)

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

@@ -30,7 +30,8 @@ module Kramdown
       TABLE_HSEP_ALIGN = /[ ]?(:?)-+(:?)[ ]?/
       TABLE_FSEP_LINE = /^[+|: =]*?=[+|: =]*?[ \t]*\n/
       TABLE_ROW_LINE = /^(.*?)[ \t]*\n/
-      TABLE_LINE = /(?:\||.*?[^\\\n]\|).*?\n/
+      TABLE_PIPE_CHECK = /(?:\||.*?[^\\\n]\|)/
+      TABLE_LINE = /#{TABLE_PIPE_CHECK}.*?\n/
       TABLE_START = /^#{OPT_SPACE}(?=\S)#{TABLE_LINE}/
 
       # Parse the table at the current location.
@@ -47,7 +48,7 @@ module Kramdown
         columns = 0
 
         add_container = lambda do |type, force|
-          if force || type != :tbody || !has_footer
+          if !has_footer || type != :tbody || force
             cont = Element.new(type)
             cont.children, rows = rows, []
             table.children << cont
@@ -70,17 +71,32 @@ module Kramdown
             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)
+
+            # parse possible code spans on the line
+            env = save_env
+            reset_env(:src => StringScanner.new(@src[1] + ' '))
+            root = Element.new(:root)
+            parse_spans(root, nil, [:codespan])
+            restore_env(env)
+
+            # correctly split the line into cells
+            cells = []
+            root.children.each do |c|
+              if c.type == :raw_text
+                # Only on Ruby 1.9: f, *l = c.value.split(/(?<!\\)\|/).map {|t| t.gsub(/\\\|/, '|')}
+                f, *l = c.value.split(/\\\|/).map {|t| t.split(/\|/)}.inject([]) do |memo, t|
+                  memo.last << "|" << t.shift if memo.size > 0
+                  memo.concat(t)
+                end
+                (cells.empty? ? cells : cells.last) << f
+                cells.concat(l)
               else
-                i += 1
+                delim = (c.value.scan(/`+/).max || '') + '`'
+                tmp = "#{delim}#{' ' if delim.size > 1}#{c.value}#{' ' if delim.size > 1}#{delim}"
+                (cells.empty? ? cells : cells.last) << tmp
               end
             end
+
             cells.shift if leading_pipe && cells.first.strip.empty?
             cells.pop if cells.last.strip.empty?
             cells.each do |cell_text|
@@ -100,9 +116,33 @@ module Kramdown
           return false
         end
 
+        # Parse all lines of the table with the code span parser
+        env = save_env
+        reset_env(:src => StringScanner.new(extract_string(orig_pos...(@src.pos-1), @src)))
+        root = Element.new(:root)
+        parse_spans(root, nil, [:codespan])
+        restore_env(env)
+
+        # Check if each line has at least one unescaped backslash that is not inside a code span
+        pipe_on_line = false
+        while (c = root.children.shift)
+          lines = c.value.split(/\n/)
+          if c.type == :codespan
+            if lines.size > 2 || (lines.size == 2 && !pipe_on_line)
+              break
+            elsif lines.size == 2 && pipe_on_line
+              pipe_on_line = false
+            end
+          else
+            break if lines.size > 1 && !pipe_on_line && lines.first !~ /^#{TABLE_PIPE_CHECK}/
+            pipe_on_line = (lines.size > 1 ? false : pipe_on_line) || (lines.last =~ /^#{TABLE_PIPE_CHECK}/)
+          end
+        end
+        @src.pos = orig_pos and return false if !pipe_on_line
+
         add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
 
-        if !table.children.any? {|c| c.type == :tbody}
+        if !table.children.any? {|el| el.type == :tbody}
           warning("Found table without body - ignoring it")
           @src.pos = orig_pos
           return false
@@ -114,7 +154,6 @@ module Kramdown
             (columns - row.children.length).times do
               row.children << Element.new(:td)
             end
-            row.children.each {|el| el.type = :th} if kind.type == :thead
           end
         end
         if table.options[:alignment].length > columns

data/lib/kramdown/parser/markdown.rb

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+#--
+# Copyright (C) 2009-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'
+
+module Kramdown
+
+  module Parser
+
+    # Used for parsing a document in Markdown format.
+    #
+    # This parser is based on the kramdown parser and removes the parser methods for the additional
+    # non-Markdown features. However, since some things are handled differently by the kramdown
+    # parser methods (like deciding when a list item contains just text), this parser differs from
+    # real Markdown parsers in some respects.
+    #
+    # Note, though, that the parser basically fails just one of the Markdown test cases (some others
+    # also fail but those failures are negligible).
+    class Markdown < Kramdown
+
+      # Array with all the parsing methods that should be removed from the standard kramdown parser.
+      EXTENDED = [:codeblock_fenced, :table, :definition_list, :footnote_definition, :abbrev_definition, :block_math,
+                  :block_extensions,
+                  :footnote_marker, :smart_quotes, :inline_math, :span_extensions, :typographic_syms]
+
+      def initialize(source, options) # :nodoc:
+        super
+        @block_parsers.delete_if {|i| EXTENDED.include?(i)}
+        @span_parsers.delete_if {|i| EXTENDED.include?(i)}
+      end
+
+      # :stopdoc:
+
+      BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|\Z/
+      BLOCKQUOTE_MATCH = /(^.*\n)+?(?=#{BLANK_LINE}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z)/
+      CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+)*/
+      PARAGRAPH_MATCH = BLOCKQUOTE_MATCH
+
+      IAL_RAND_CHARS = (('a'..'z').to_a + ('0'..'9').to_a)
+      IAL_RAND_STRING = (1..20).collect {|a| IAL_RAND_CHARS[rand(IAL_RAND_CHARS.size)]}.join
+      LIST_ITEM_IAL = /^\s*(#{IAL_RAND_STRING})?\s*\n/
+      IAL_SPAN_START = LIST_ITEM_IAL
+
+      # :startdoc:
+
+    end
+
+  end
+
+end

data/lib/kramdown/utils.rb

@@ -22,14 +22,14 @@
 
 module Kramdown
 
-  # == Utils Module
+  # == \Utils Module
   #
   # This module contains utility class/modules/methods that can be used by both parsers and
   # converters.
   module Utils
 
     autoload :Entities, 'kramdown/utils/entities'
-    autoload :HTML, 'kramdown/utils/html'
+    autoload :Html, 'kramdown/utils/html'
     autoload :OrderedHash, 'kramdown/utils/ordered_hash'
 
   end

data/lib/kramdown/utils/entities.rb

@@ -24,16 +24,23 @@ module Kramdown
 
   module Utils
 
+    # Provides convenience methods for handling named and numeric entities.
     module Entities
 
+      # Represents an entity that has a +code_point+ and +name+.
       class Entity < Struct.new(:code_point, :name)
 
+        # Return the UTF8 representation of the entity.
         def char
           [code_point].pack('U*') rescue nil
         end
 
       end
 
+      # Array of arrays. Each sub-array specifies a code point and the associated name.
+      #
+      # This table is not used directly -- Entity objects are automatically created from it and put
+      # into a Hash map when this file is loaded.
       ENTITY_TABLE = [
                       [913, 'Alpha'],
                       [914, 'Beta'],
@@ -304,6 +311,8 @@ module Kramdown
                       [158, 382],
                       [159, 376],
                      ]
+
+      # Contains the mapping of code point (or name) to the actual Entity object.
       ENTITY_MAP = Hash.new do |h,k|
         if k.kind_of?(Integer)
           h[k] = Entity.new(k, nil)
@@ -320,7 +329,7 @@ module Kramdown
         end
       end
 
-      # Return the entity for the given +point_or_name+.
+      # Return the entity for the given code point or name +point_or_name+.
       def entity(point_or_name)
         ENTITY_MAP[point_or_name]
       end

data/lib/kramdown/utils/html.rb

@@ -24,27 +24,36 @@ module Kramdown
 
   module Utils
 
-    module HTML
+    # Provides convenience methods for HTML related tasks.
+    #
+    # *Note* that this module has to be mixed into a class that has a <tt>@root</tt> (containing an
+    # element of type :root) and an <tt>@options</tt> (containing an options hash) instance variable
+    # so that some of the methods can work correctly.
+    module Html
 
-      # Convert the +entity+ to a string.
+      # Convert the entity +e+ to a string. The optional parameter +original+ may contain the
+      # original representation of the entity.
+      #
+      # This method uses the option +entity_output+ to determine the output form for the entity.
       def entity_to_str(e, original = nil)
-        if RUBY_VERSION >= '1.9' && @doc.options[:entity_output] == :as_char &&
-            (c = e.char.encode(@doc.parse_infos[:encoding]) rescue nil) && !ESCAPE_MAP.has_key?(c)
+        if RUBY_VERSION >= '1.9' && @options[:entity_output] == :as_char &&
+            (c = e.char.encode(@root.options[:encoding]) rescue nil) && !ESCAPE_MAP.has_key?(c)
           c
-        elsif (@doc.options[:entity_output] == :as_input || @doc.options[:entity_output] == :as_char) && original
+        elsif (@options[:entity_output] == :as_input || @options[:entity_output] == :as_char) && original
           original
-        elsif @doc.options[:entity_output] == :numeric || e.name.nil?
+        elsif @options[:entity_output] == :numeric || e.name.nil?
           "&##{e.code_point};"
         else
           "&#{e.name};"
         end
       end
 
-      # Return the string with the attributes of the element +el+.
-      def html_attributes(el)
-        el.attr.map {|k,v| v.nil? ? '' : " #{k}=\"#{escape_html(v.to_s, :attribute)}\"" }.join('')
+      # Return the HTML representation of the attributes +attr+.
+      def html_attributes(attr)
+        attr.map {|k,v| v.nil? ? '' : " #{k}=\"#{escape_html(v.to_s, :attribute)}\"" }.join('')
       end
 
+      # :stopdoc:
       ESCAPE_MAP = {
         '<' => '&lt;',
         '>' => '&gt;',
@@ -59,11 +68,13 @@ module Kramdown
         :text => ESCAPE_TEXT_RE,
         :attribute => ESCAPE_ATTRIBUTE_RE
       }
+      # :startdoc:
 
       # Escape the special HTML characters in the string +str+. The parameter +type+ specifies what
       # is escaped: <tt>:all</tt> - all special HTML characters as well as entities, <tt>:text</tt>
-      # - all special HTML characters except the quotation mark but no entities and
-      # <tt>:attribute</tt> - all special HTML characters including the quotation mark but no entities.
+      # \- all special HTML characters except the quotation mark but no entities and
+      # <tt>:attribute</tt> - all special HTML characters including the quotation mark but no
+      # entities.
       def escape_html(str, type = :all)
         str.gsub(ESCAPE_RE_FROM_TYPE[type]) {|m| ESCAPE_MAP[m] || m}
       end

data/lib/kramdown/utils/ordered_hash.rb

@@ -24,54 +24,58 @@ module Kramdown
 
   module Utils
 
-    # A very simple class mimicking the most used methods of a Hash. The difference to a normal Hash
-    # is that a OrderedHash retains the insertion order of the keys.
-    class OrderedHash
-
-      include Enumerable
-
-      # Direct access to the hash with the key-value pairs. May not be used to modify the data!
-      attr_reader :data
-
-      # Initialize the OrderedHash object, optionally with an +hash+. If the optional +hash+ is
-      # used, there is no special order imposed on the keys (additionally set keys will be stored in
-      # insertion order). An OrderedHash object may be used instead of a hash to provide the initial
-      # data.
-      def initialize(hash = {})
-        if hash.kind_of?(OrderedHash)
-          @data, @order = hash.instance_eval { [@data.dup, @order.dup] }
-        else
-          @data = hash || {}
-          @order = @data.keys
+    if RUBY_VERSION < '1.9'
+
+      # A partial hash implementation which preserves the insertion order of the keys.
+      #
+      # *Note* that this class is only used on Ruby 1.8 since the built-in Hash on Ruby 1.9
+      # automatically preserves the insertion order. However, to remain compatibility only the
+      # methods defined in this class may be used when working with OrderedHash on Ruby 1.9.
+      class OrderedHash
+
+        include Enumerable
+
+        # Initialize the OrderedHash object.
+        def initialize
+          @data =  {}
+          @order = []
         end
-      end
 
-      # Iterate over the stored keys in insertion order.
-      def each
-        @order.each {|k| yield(k, @data[k])}
-      end
+        # Iterate over the stored keys in insertion order.
+        def each
+          @order.each {|k| yield(k, @data[k])}
+        end
 
-      # Return the value for the +key+.
-      def [](key)
-        @data[key]
-      end
+        # Return the value for the +key+.
+        def [](key)
+          @data[key]
+        end
 
-      # Set the value for the +key+ to +val+.
-      def []=(key, val)
-        @order << key if !@data.has_key?(key)
-        @data[key] = val
-      end
+        # Set the value for the +key+ to +val+.
+        def []=(key, val)
+          @order << key if !@data.has_key?(key)
+          @data[key] = val
+        end
 
-      # Delete the +key+.
-      def delete(key)
-        @order.delete(key)
-        @data.delete(key)
-      end
+        # Delete the +key+.
+        def delete(key)
+          @order.delete(key)
+          @data.delete(key)
+        end
+
+        def merge!(other)
+          other.each {|k,v| self[k] = v}
+          self
+        end
+
+        def inspect #:nodoc:
+          "{" + map {|k,v| "#{k.inspect}=>#{v.inspect}"}.join(" ") + "}"
+        end
 
-      def inspect #:nodoc:
-        "{" + map {|k,v| "#{k.inspect}=>#{v.inspect}"}.join(" ") + "}"
       end
 
+    else
+      OrderedHash = Hash
     end
 
   end

data/lib/kramdown/version.rb

@@ -23,6 +23,6 @@
 module Kramdown
 
   # The kramdown version.
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
 
 end

data/man/man1/kramdown.1

@@ -88,7 +88,7 @@ Used by: HTML/Latex converter
 Process kramdown syntax in block HTML tags
 
 If this option is `true`, the kramdown parser processes the content of
-block HTML tags as text containing block level elements. Since this is
+block HTML tags as text containing block-level elements. Since this is
 not wanted normally, the default is `false`. It is normally better to
 selectively enable kramdown processing via the markdown attribute.
 
@@ -102,7 +102,7 @@ Used by: kramdown parser
 Process kramdown syntax in span HTML tags
 
 If this option is `true`, the kramdown parser processes the content of
-span HTML tags as text containing span level elements.
+span HTML tags as text containing span-level elements.
 
 Default: true
 Used by: kramdown parser
@@ -217,11 +217,26 @@ Used by: HTML converter, kramdown converter
 .TP
 .B \-\-toc-depth ARG
 
-Defines the maximum level of headers which will be used to generate the table of
+DEPRECATED: Defines the maximum level of headers which will be used to generate the table of
 contents. For instance, with a value of 2, toc entries will be generated for h1
 and h2 headers but not for h3, h4, etc. A value of 0 uses all header levels.
 
-Default: 0
+Use option toc_levels instead!
+
+Default: -1
+Used by: HTML/Latex converter
+
+
+.TP
+.B \-\-toc-levels ARG
+
+Defines the levels that are used for the table of contents
+
+The individual levels can be specified by separating them with commas
+(e.g. 1,2,3) or by using the range syntax (e.g. 1..3). Only the
+specified levels are used for the table of contents.
+
+Default: 1..6
 Used by: HTML/Latex converter
 
 
@@ -234,6 +249,18 @@ Default: 72
 Used by: kramdown converter
 
 
+.TP
+.B \-\-latex-headers ARG
+
+Defines the LaTeX commands for different header levels
+
+The commands for the header levels one to six can be specified by
+separating them with commas.
+
+Default: section,subsection,subsubsection,paragraph,subparagraph,subsubparagraph
+Used by: Latex converter
+
+
 .SH EXIT STATUS
 The exit status is 0 if no error happened. Otherwise it is 1.
 .SH SEE ALSO