kramdown 0.10.0 → 0.11.0

data/lib/kramdown/parser/kramdown/block_boundary.rb

@@ -0,0 +1,46 @@
+# -*- 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/attribute_list'
+require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/eob'
+
+module Kramdown
+  module Parser
+    class Kramdown
+
+      BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|#{IAL_BLOCK_START}|\Z/
+
+      # Return +true+ if we are after a block boundary.
+      def after_block_boundary?
+        !@tree.children.last || @tree.children.last.type == :blank ||
+          (@tree.children.last.type == :eob && @tree.children.last.value.nil?) || @block_ial
+      end
+
+      # Return +true+ if we are before a block boundary.
+      def before_block_boundary?
+        @src.check(BLOCK_BOUNDARY)
+      end
+
+    end
+  end
+end

data/lib/kramdown/parser/kramdown/blockquote.rb

@@ -20,23 +20,27 @@
 #++
 #
 
+require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/eob'
+
 module Kramdown
   module Parser
     class Kramdown
 
       BLOCKQUOTE_START = /^#{OPT_SPACE}> ?/
-      BLOCKQUOTE_MATCH = /(^#{OPT_SPACE}>.*?\n)+/
+      BLOCKQUOTE_MATCH = /(^.*\n)+?(?=#{BLANK_LINE}|#{IAL_BLOCK_START}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z)/
 
       # Parse the blockquote at the current location.
       def parse_blockquote
-        result = @src.scan(BLOCKQUOTE_MATCH).gsub(BLOCKQUOTE_START, '')
         el = new_block_el(:blockquote)
         @tree.children << el
-        parse_blocks(el, result)
+        parse_blocks(el, @src.scan(BLOCKQUOTE_MATCH).gsub!(BLOCKQUOTE_START, ''))
         true
       end
       define_parser(:blockquote, BLOCKQUOTE_START)
 
+
     end
   end
 end

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

@@ -21,18 +21,20 @@
 #
 
 require 'kramdown/parser/kramdown/blank_line'
+require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/eob'
+require 'kramdown/parser/kramdown/paragraph'
 
 module Kramdown
   module Parser
     class Kramdown
 
       CODEBLOCK_START = INDENT
-      CODEBLOCK_LINE =  /(?:#{INDENT}.*?\S.*?\n)+/
-      CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?#{CODEBLOCK_LINE})*/
+      CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+(?:(?!#{BLANK_LINE} {0,3}\S|#{IAL_BLOCK_START}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START})^[ \t]*\S.*\n)*)*/
 
       # Parse the indented codeblock at the current location.
       def parse_codeblock
-        @tree.children << new_block_el(:codeblock, @src.scan(CODEBLOCK_MATCH).gsub!(INDENT, ''))
+        @tree.children << new_block_el(:codeblock, @src.scan(CODEBLOCK_MATCH).gsub(/\n( {0,3}\S)/, ' \\1').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/extension.rb

@@ -27,12 +27,19 @@ module Kramdown
     class Kramdown
 
       def parse_extension_start_tag(type)
+        orig_pos = @src.pos
         @src.pos += @src.matched_size
 
+        error_block = lambda do |msg|
+          warning(msg)
+          @src.pos = orig_pos
+          add_text(@src.scan(/./)) if type == :span
+          false
+        end
+
         if @src[4] || @src.matched == '{:/}'
           name = (@src[4] ? "for '#{@src[4]}' " : '')
-          warning("Invalid extension stop tag #{name}found - ignoring it")
-          return
+          return error_block.call("Invalid extension stop tag #{name}found - ignoring it")
         end
 
         ext = @src[1]
@@ -46,19 +53,25 @@ module Kramdown
             body = result.sub!(stop_re, '')
             body.chomp! if type == :block
           else
-            warning("No stop tag for extension '#{ext}' found - treating it as extension without body")
+            return error_block.call("No stop tag for extension '#{ext}' found - ignoring it")
           end
         end
 
-        handle_extension(ext, opts, body, type)
+        if !handle_extension(ext, opts, body, type)
+          error_block.call("Invalid extension with name '#{ext}' specified - ignoring it")
+        else
+          true
+        end
       end
 
       def handle_extension(name, opts, body, type)
         case name
         when 'comment'
-          @tree.children << Element.new(:comment, body, :category => type) if body.kind_of?(String)
+          @tree.children << Element.new(:comment, body, nil, :category => type) if body.kind_of?(String)
+          true
         when 'nomarkdown'
-          @tree.children << Element.new(:raw, body, :category => type) if body.kind_of?(String)
+          @tree.children << Element.new(:raw, body, nil, :category => type, :type => opts['type'].to_s.split(/\s+/)) if body.kind_of?(String)
+          true
         when 'options'
           opts.select do |k,v|
             k = k.to_sym
@@ -71,8 +84,10 @@ module Kramdown
           end.each do |k,v|
             warning("Unknown kramdown option '#{k}'")
           end
+          @tree.children << Element.new(:eob, :extension) if type == :block
+          true
         else
-          warning("Invalid extension name '#{name}' specified - ignoring extension")
+          false
         end
       end
 
@@ -86,7 +101,6 @@ module Kramdown
       # Parse the extension block at the current location.
       def parse_block_extension
         parse_extension_start_tag(:block)
-        true
       end
       define_parser(:block_extension, EXT_BLOCK_START)
 

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_LINE})*)/
+      FOOTNOTE_DEFINITION_START = /^#{OPT_SPACE}\[\^(#{ALD_ID_NAME})\]:\s*?(.*?\n#{CODEBLOCK_MATCH})/
 
       # 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
+        @tree.children << Element.new(:eob, :footnote_def)
         true
       end
       define_parser(:footnote_definition, FOOTNOTE_DEFINITION_START)
@@ -54,7 +55,7 @@ module Kramdown
             par.children.include?(child)
           end
           if !fn_def[:marker] || !valid
-            fn_def[:marker] = Element.new(:footnote, nil, :name => @src[1])
+            fn_def[:marker] = Element.new(:footnote, nil, nil, :name => @src[1])
             fn_def[:marker].options[:stack] = [@stack.map {|s| s.first}, @tree, fn_def[:marker]].flatten.compact
             @tree.children << fn_def[:marker]
           else

data/lib/kramdown/parser/kramdown/header.rb

@@ -20,6 +20,8 @@
 #++
 #
 
+require 'kramdown/parser/kramdown/block_boundary'
+
 module Kramdown
   module Parser
     class Kramdown
@@ -29,14 +31,13 @@ module Kramdown
 
       # Parse the Setext header at the current location.
       def parse_setext_header
-        if @tree.children.last && @tree.children.last.type != :blank
-          return false
-        end
+        return false if !after_block_boundary?
+
         @src.pos += @src.matched_size
         text, id, level = @src[1].strip, @src[2], @src[3]
-        el = new_block_el(:header, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
+        el = new_block_el(:header, nil, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
         add_text(text, el)
-        el.options[:attr] = {'id' => id} if id
+        el.attr['id'] = id if id
         @tree.children << el
         true
       end
@@ -48,14 +49,13 @@ module Kramdown
 
       # Parse the Atx header at the current location.
       def parse_atx_header
-        if @tree.children.last && @tree.children.last.type != :blank
-          return false
-        end
+        return false if !after_block_boundary?
+
         result = @src.scan(ATX_HEADER_MATCH)
         level, text, id = @src[1], @src[2].strip, @src[3]
-        el = new_block_el(:header, nil, :level => level.length, :raw_text => text)
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text)
         add_text(text, el)
-        el.options[:attr] = {'id' => id} if id
+        el.attr['id'] = id if id
         @tree.children << el
         true
       end

data/lib/kramdown/parser/kramdown/html.rb

@@ -34,13 +34,11 @@ module Kramdown
                      else
                        :raw
                      end
-        if val = html_parse_type(el.options[:attr].delete('markdown'))
+        if val = html_parse_type(el.attr.delete('markdown'))
           parse_type = (val == :default ? HTML_PARSE_AS[el.value] : val)
         end
 
         @src.scan(/[ \t]*\n/) if parse_type == :block
-        el.options[:outer_element] = true if @tree.type != :html_element
-        el.options[:parent_is_raw] = true if @tree.type == :html_element && @tree.options[:parse_type] == :raw
         el.options[:parse_type] = parse_type
 
         if !closed
@@ -87,11 +85,11 @@ module Kramdown
       # Parse the HTML at the current position as block level HTML.
       def parse_block_html
         if result = @src.scan(HTML_COMMENT_RE)
-          @tree.children << Element.new(:xml_comment, result, :category => :block)
+          @tree.children << Element.new(:xml_comment, result, nil, :category => :block)
           @src.scan(/[ \t]*\n/)
           true
         elsif result = @src.scan(HTML_INSTRUCTION_RE)
-          @tree.children << Element.new(:xml_pi, result, :category => :block)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
           @src.scan(/[ \t]*\n/)
           true
         else
@@ -101,14 +99,13 @@ module Kramdown
             Kramdown::Parser::Html::ElementConverter.new(@doc).process(@tree.children.last) if @doc.options[:html_to_native]
             true
           elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
-            @src.pos += @src.matched_size
             name = @src[1]
 
             if @tree.type == :html_element && @tree.value == name
+              @src.pos += @src.matched_size
               throw :stop_block_parsing, :found
             else
-              warning("Found invalidly used HTML closing tag for '#{name}' - ignoring it")
-              true
+              false
             end
           else
             false
@@ -123,16 +120,21 @@ module Kramdown
       # Parse the HTML at the current position as span level HTML.
       def parse_span_html
         if result = @src.scan(HTML_COMMENT_RE)
-          @tree.children << Element.new(:xml_comment, result, :category => :span)
+          @tree.children << Element.new(:xml_comment, result, nil, :category => :span)
         elsif result = @src.scan(HTML_INSTRUCTION_RE)
-          @tree.children << Element.new(:xml_pi, result, :category => :span)
+          @tree.children << Element.new(:xml_pi, result, nil, :category => :span)
         elsif result = @src.scan(HTML_TAG_CLOSE_RE)
-          warning("Found invalidly used HTML closing tag for '#{@src[1]}' - ignoring it")
+          warning("Found invalidly used HTML closing tag for '#{@src[1]}'")
+          add_text(result)
         elsif result = @src.scan(HTML_TAG_RE)
-          return if HTML_BLOCK_ELEMENTS.include?(@src[1])
+          if HTML_BLOCK_ELEMENTS.include?(@src[1])
+            warning("Found block HTML tag '#{@src[1]}' in span level text")
+            add_text(result)
+            return
+          end
 
           reset_pos = @src.pos
-          attrs = {}
+          attrs = Utils::OrderedHash.new
           @src[2].scan(HTML_ATTRIBUTE_RE).each {|name,sep,val| attrs[name] = val.gsub(/\n+/, ' ')}
 
           do_parsing = (HTML_PARSE_AS_RAW.include?(@src[1]) || @tree.options[:parse_type] == :raw ? false : @doc.options[:parse_span_html])
@@ -148,7 +150,7 @@ module Kramdown
             end
           end
 
-          el = Element.new(:html_element, @src[1], :attr => attrs, :category => :span, :parse_type => (do_parsing ? :span : :raw))
+          el = Element.new(:html_element, @src[1], attrs, :category => :span, :parse_type => (do_parsing ? :span : :raw))
           @tree.children << el
           stop_re = /<\/#{Regexp.escape(@src[1])}\s*>/
           if !@src[4] && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)

data/lib/kramdown/parser/kramdown/html_entity.rb

@@ -30,7 +30,7 @@ module Kramdown
       def parse_html_entity
         @src.pos += @src.matched_size
         @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity(@src[1] || (@src[2] && @src[2].to_i) || @src[3].hex),
-                                      :original => @src.matched)
+                                      nil, :original => @src.matched)
       end
       define_parser(:html_entity, Kramdown::Parser::Html::Constants::HTML_ENTITY_RE, '&')
 

data/lib/kramdown/parser/kramdown/link.rb

@@ -27,7 +27,7 @@ module Kramdown
       PUNCTUATION_CHARS = "_.:,;!?-"
       LINK_ID_CHARS = /[a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
       LINK_ID_NON_CHARS = /[^a-zA-Z0-9 #{PUNCTUATION_CHARS}]/
-      LINK_DEFINITION_START = /^#{OPT_SPACE}\[(#{LINK_ID_CHARS}+)\]:[ \t]*(?:<(.*?)>|([^\s]+))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
+      LINK_DEFINITION_START = /^#{OPT_SPACE}\[(#{LINK_ID_CHARS}+)\]:[ \t]*(?:<(.*?)>|([^'"\n]*?\S[^'"\n]*?))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
 
       # Parse the link definition at the current location.
       def parse_link_definition
@@ -35,6 +35,7 @@ module Kramdown
         link_id, link_url, link_title = @src[1].downcase, @src[2] || @src[3], @src[5]
         warning("Duplicate link ID '#{link_id}' - overwriting") if @doc.parse_infos[:link_defs][link_id]
         @doc.parse_infos[:link_defs][link_id] = [link_url, link_title]
+        @tree.children << Element.new(:eob, :link_def)
         true
       end
       define_parser(:link_definition, LINK_DEFINITION_START)
@@ -43,15 +44,14 @@ module Kramdown
       # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
       # and the element itself to the <tt>@tree</tt>.
       def add_link(el, href, title, alt_text = nil)
-        el.options[:attr] ||= {}
-        el.options[:attr]['title'] = title if title
         if el.type == :a
-          el.options[:attr]['href'] = href
+          el.attr['href'] = href
         else
-          el.options[:attr]['src'] = href
-          el.options[:attr]['alt'] = alt_text
+          el.attr['src'] = href
+          el.attr['alt'] = alt_text
           el.children.clear
         end
+        el.attr['title'] = title if title
         @tree.children << el
       end
 
@@ -120,7 +120,7 @@ module Kramdown
           end
         else
           link_url = ''
-          re = /\(|\)|\s/
+          re = /\(|\)|\s(?=['"])/
           nr_of_brackets = 0
           while temp = @src.scan_until(re)
             link_url += temp
@@ -134,7 +134,7 @@ module Kramdown
               break if nr_of_brackets == 0
             end
           end
-          link_url = link_url[1..-2]
+          link_url = link_url[1..-2].strip
 
           if nr_of_brackets == 0
             add_link(el, link_url, nil, alt_text)

data/lib/kramdown/parser/kramdown/list.rb

@@ -29,10 +29,12 @@ module Kramdown
   module Parser
     class Kramdown
 
+      LIST_ITEM_IAL = /^\s*(#{IAL_SPAN_START})?\s*\n/
+
       # Used for parsing the first line of a list item or a definition, i.e. the line with list item
       # marker or the definition marker.
       def parse_first_list_line(indentation, content)
-        if content =~ /^\s*(#{IAL_SPAN_START})?\s*\n/
+        if content =~ LIST_ITEM_IAL
           indentation = 4
         else
           while content =~ /^ *\t/
@@ -44,8 +46,9 @@ module Kramdown
         content.sub!(/^\s*/, '')
 
         indent_re = /^ {#{indentation}}/
-        content_re = /^(?:(?:\t| {4}){#{indentation / 4}} {#{indentation % 4}}|(?:\t| {4}){#{indentation / 4 + 1}}).*?\n/
-        [content, indentation, content_re, indent_re]
+        content_re = /^(?:(?:\t| {4}){#{indentation / 4}} {#{indentation % 4}}|(?:\t| {4}){#{indentation / 4 + 1}}).*\S.*\n/
+        lazy_re = /(?!^ {0,#{[indentation, 3].min}}(?:#{IAL_BLOCK}|#{LAZY_END_HTML_STOP}|#{LAZY_END_HTML_START})).*\S.*\n/
+        [content, indentation, content_re, lazy_re, indent_re]
       end
 
 
@@ -55,24 +58,23 @@ module Kramdown
 
       # Parse the ordered or unordered list at the current location.
       def parse_list
-        if @tree.children.last && @tree.children.last.type == :p # last element must not be a paragraph
-          return false
-        end
-
         type, list_start_re = (@src.check(LIST_START_UL) ? [:ul, LIST_START_UL] : [:ol, LIST_START_OL])
         list = new_block_el(type)
 
         item = nil
-        indent_re = nil
-        content_re = nil
+        content_re, lazy_re, indent_re = nil
         eob_found = false
         nested_list_found = false
+        last_is_blank = false
         while !@src.eos?
-          if @src.check(HR_START)
+          if last_is_blank && @src.check(HR_START)
+            break
+          elsif @src.scan(EOB_MARKER)
+            eob_found = true
             break
           elsif @src.scan(list_start_re)
             item = Element.new(:li)
-            item.value, indentation, content_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
+            item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
             list.children << item
 
             item.value.sub!(/^#{IAL_SPAN_START}\s*/) do |match|
@@ -82,26 +84,21 @@ module Kramdown
 
             list_start_re = (type == :ul ? /^( {0,#{[3, indentation - 1].min}}[+*-])([\t| ].*?\n)/ :
                              /^( {0,#{[3, indentation - 1].min}}\d+\.)([\t| ].*?\n)/)
-            nested_list_found = false
-          elsif result = @src.scan(content_re)
+            nested_list_found = (item.value =~ LIST_START)
+            last_is_blank = false
+          elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
             result.sub!(/^(\t+)/) { " "*4*($1 ? $1.length : 0) }
             result.sub!(indent_re, '')
             if !nested_list_found && result =~ LIST_START
-              parse_blocks(item, item.value)
-              if item.children.length == 1 && item.children.first.type == :p
-                item.value = ''
-              else
-                item.children.clear
-              end
+              item.value << "^\n"
               nested_list_found = true
             end
             item.value << result
+            last_is_blank = false
           elsif result = @src.scan(BLANK_LINE)
             nested_list_found = true
+            last_is_blank = true
             item.value << result
-          elsif @src.scan(EOB_MARKER)
-            eob_found = true
-            break
           else
             break
           end
@@ -113,12 +110,17 @@ module Kramdown
         list.children.each do |it|
           temp = Element.new(:temp)
           parse_blocks(temp, it.value)
-          it.children += temp.children
+          it.children = temp.children
           it.value = nil
           next if it.children.size == 0
 
-          if it.children.first.type == :p && (it.children.length < 2 || it.children[1].type != :blank ||
-                                              (it == list.children.last && it.children.length == 2 && !eob_found)) &&
+          # Handle the case where an EOB marker is inserted by a block IAL for the first paragraph
+          it.children.delete_at(1) if it.children.first.type == :p &&
+            it.children.length >= 2 && it.children[1].type == :eob && it.children.first.options[:ial]
+
+          if it.children.first.type == :p &&
+              (it.children.length < 2 || it.children[1].type != :blank ||
+               (it == list.children.last && it.children.length == 2 && !eob_found)) &&
               (list.children.last != it || list.children.size == 1 ||
                list.children[0..-2].any? {|cit| cit.children.first.type != :p || cit.children.first.options[:transparent]})
             it.children.first.children.first.value += "\n" if it.children.size > 1 && it.children[1].type != :blank
@@ -163,14 +165,14 @@ module Kramdown
         end
 
         item = nil
-        indent_re = nil
-        content_re = nil
+        content_re, lazy_re, indent_re = nil
         def_start_re = DEFINITION_LIST_START
+        last_is_blank = false
         while !@src.eos?
           if @src.scan(def_start_re)
             item = Element.new(:dd)
             item.options[:first_as_para] = first_as_para
-            item.value, indentation, content_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
+            item.value, indentation, content_re, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
             deflist.children << item
 
             item.value.sub!(/^#{IAL_SPAN_START}\s*/) do |match|
@@ -180,14 +182,19 @@ module Kramdown
 
             def_start_re = /^( {0,#{[3, indentation - 1].min}}:)([\t| ].*?\n)/
             first_as_para = false
-          elsif result = @src.scan(content_re)
+            last_is_blank = false
+          elsif @src.check(EOB_MARKER)
+            break
+          elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
             result.sub!(/^(\t+)/) { " "*4*($1 ? $1.length : 0) }
             result.sub!(indent_re, '')
             item.value << result
             first_as_para = false
+            last_is_blank = false
           elsif result = @src.scan(BLANK_LINE)
             first_as_para = true
             item.value << result
+            last_is_blank = true
           else
             break
           end