kramdown 0.11.0 → 0.12.0

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

@@ -20,7 +20,7 @@
 #++
 #
 
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 require 'kramdown/parser/kramdown/blank_line'
 require 'kramdown/parser/kramdown/codeblock'
 
@@ -36,8 +36,8 @@ module Kramdown
 
         el = Element.new(:footnote_def)
         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
+        warning("Duplicate footnote name '#{@src[1]}' - overwriting") if @footnotes[@src[1]]
+        (@footnotes[@src[1]] = {})[:content] = el
         @tree.children << Element.new(:eob, :footnote_def)
         true
       end
@@ -49,14 +49,14 @@ module Kramdown
       # Parse the footnote marker at the current location.
       def parse_footnote_marker
         @src.pos += @src.matched_size
-        fn_def = @doc.parse_infos[:footnotes][@src[1]]
+        fn_def = @footnotes[@src[1]]
         if fn_def
-          valid = fn_def[:marker] && fn_def[:marker].options[:stack][0..-2].zip(fn_def[:marker].options[:stack][1..-1]).all? do |par, child|
+          valid = fn_def[:marker] && fn_def[:stack][0..-2].zip(fn_def[:stack][1..-1]).all? do |par, child|
             par.children.include?(child)
           end
           if !fn_def[:marker] || !valid
-            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
+            fn_def[:marker] = Element.new(:footnote, fn_def[:content], nil, :name => @src[1])
+            fn_def[:stack] = [@stack.map {|s| s.first}, @tree, fn_def[:marker]].flatten.compact
             @tree.children << fn_def[:marker]
           else
             warning("Footnote marker '#{@src[1]}' already appeared in document, ignoring newly found marker")

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

@@ -34,7 +34,8 @@ module Kramdown
         return false if !after_block_boundary?
 
         @src.pos += @src.matched_size
-        text, id, level = @src[1].strip, @src[2], @src[3]
+        text, id, level = @src[1], @src[2], @src[3]
+        text.strip!
         el = new_block_el(:header, nil, nil, :level => (level == '-' ? 2 : 1), :raw_text => text)
         add_text(text, el)
         el.attr['id'] = id if id
@@ -52,7 +53,8 @@ module Kramdown
         return false if !after_block_boundary?
 
         result = @src.scan(ATX_HEADER_MATCH)
-        level, text, id = @src[1], @src[2].strip, @src[3]
+        level, text, id = @src[1], @src[2], @src[3]
+        text.strip!
         el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text)
         add_text(text, el)
         el.attr['id'] = id if id

data/lib/kramdown/parser/kramdown/horizontal_rule.rb

@@ -24,7 +24,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1[ \t]*(\1|[ \t])*\n/
+      HR_START = /^#{OPT_SPACE}(\*|-|_)[ \t]*\1[ \t]*\1(\1|[ \t])*\n/
 
       # Parse the horizontal rule at the current location.
       def parse_horizontal_rule

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

@@ -28,75 +28,68 @@ module Kramdown
 
       include Kramdown::Parser::Html::Parser
 
+      # Mapping of markdown attribute value to content model. I.e. :raw when "0", :default when "1"
+      # (use default content model for the HTML element), :span when "span", :block when block and
+      # for everything else +nil+ is returned.
+      HTML_MARKDOWN_ATTR_MAP = {"0" => :raw, "1" => :default, "span" => :span, "block" => :block}
+
+      TRAILING_WHITESPACE = /[ \t]*\n/
+
       def handle_kramdown_html_tag(el, closed)
-        parse_type = if @tree.type != :html_element || @tree.options[:parse_type] != :raw
-                       (@doc.options[:parse_block_html] ? HTML_PARSE_AS[el.value] : :raw)
-                     else
-                       :raw
-                     end
-        if val = html_parse_type(el.attr.delete('markdown'))
-          parse_type = (val == :default ? HTML_PARSE_AS[el.value] : val)
+        el.options[:ial] = @block_ial if @block_ial
+
+        content_model = if @tree.type != :html_element || @tree.options[:content_model] != :raw
+                          (@options[:parse_block_html] ? HTML_CONTENT_MODEL[el.value] : :raw)
+                        else
+                          :raw
+                        end
+        if val = HTML_MARKDOWN_ATTR_MAP[el.attr.delete('markdown')]
+          content_model = (val == :default ? HTML_CONTENT_MODEL[el.value] : val)
         end
 
-        @src.scan(/[ \t]*\n/) if parse_type == :block
-        el.options[:parse_type] = parse_type
+        @src.scan(TRAILING_WHITESPACE) if content_model == :block
+        el.options[:content_model] = content_model
 
         if !closed
-          if parse_type == :block
-            end_tag_found = parse_blocks(el)
-            if !end_tag_found
+          if content_model == :block
+            if !parse_blocks(el)
               warning("Found no end tag for '#{el.value}' - auto-closing it")
             end
-          elsif parse_type == :span
+          elsif content_model == :span
             curpos = @src.pos
             if result = @src.scan_until(/(?=<\/#{el.value}\s*>)/m)
               add_text(extract_string(curpos...@src.pos, @src), el)
               @src.scan(HTML_TAG_CLOSE_RE)
             else
-              add_text(@src.scan(/.*/m), el)
+              add_text(@src.rest, el)
+              @src.terminate
               warning("Found no end tag for '#{el.value}' - auto-closing it")
             end
           else
             parse_raw_html(el, &method(:handle_kramdown_html_tag))
           end
-          @src.scan(/[ \t]*\n/) unless (@tree.type == :html_element && @tree.options[:parse_type] == :raw)
-        end
-      end
-
-      # Return the HTML parse type defined by the string +val+, i.e. raw when "0", default parsing
-      # (return value +nil+) when "1", span parsing when "span" and block parsing when "block". If
-      # +val+ is nil, then the default parsing mode is used.
-      def html_parse_type(val)
-        case val
-        when "0" then :raw
-        when "1" then :default
-        when "span" then :span
-        when "block" then :block
-        when NilClass then nil
-        else
-          warning("Invalid markdown attribute val '#{val}', using default")
-          nil
+          @src.scan(TRAILING_WHITESPACE) unless (@tree.type == :html_element && @tree.options[:content_model] == :raw)
         end
       end
 
 
       HTML_BLOCK_START = /^#{OPT_SPACE}<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
 
-      # Parse the HTML at the current position as block level HTML.
+      # 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, nil, :category => :block)
-          @src.scan(/[ \t]*\n/)
+          @src.scan(TRAILING_WHITESPACE)
           true
         elsif result = @src.scan(HTML_INSTRUCTION_RE)
           @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
-          @src.scan(/[ \t]*\n/)
+          @src.scan(TRAILING_WHITESPACE)
           true
         else
           if result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
             @src.pos += @src.matched_size
             handle_html_start_tag(&method(:handle_kramdown_html_tag))
-            Kramdown::Parser::Html::ElementConverter.new(@doc).process(@tree.children.last) if @doc.options[:html_to_native]
+            Kramdown::Parser::Html::ElementConverter.convert(@root, @tree.children.last) if @options[:html_to_native]
             true
           elsif result = @src.check(/^#{OPT_SPACE}#{HTML_TAG_CLOSE_RE}/) && !HTML_SPAN_ELEMENTS.include?(@src[1])
             name = @src[1]
@@ -117,7 +110,7 @@ module Kramdown
 
       HTML_SPAN_START = /<(#{REXML::Parsers::BaseParser::UNAME_STR}|\?|!--|\/)/
 
-      # Parse the HTML at the current position as span level HTML.
+      # 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, nil, :category => :span)
@@ -128,7 +121,7 @@ module Kramdown
           add_text(result)
         elsif result = @src.scan(HTML_TAG_RE)
           if HTML_BLOCK_ELEMENTS.include?(@src[1])
-            warning("Found block HTML tag '#{@src[1]}' in span level text")
+            warning("Found block HTML tag '#{@src[1]}' in span-level text")
             add_text(result)
             return
           end
@@ -137,20 +130,20 @@ module Kramdown
           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])
-          if val = html_parse_type(attrs.delete('markdown'))
+          do_parsing = (HTML_CONTENT_MODEL[@src[1]] == :raw || @tree.options[:content_model] == :raw ? false : @options[:parse_span_html])
+          if val = HTML_MARKDOWN_ATTR_MAP[attrs.delete('markdown')]
             if val == :block
-              warning("Cannot use block level parsing in span level HTML tag - using default mode")
+              warning("Cannot use block-level parsing in span-level HTML tag - using default mode")
             elsif val == :span
               do_parsing = true
             elsif val == :default
-              do_parsing = !HTML_PARSE_AS_RAW.include?(@src[1])
+              do_parsing = HTML_CONTENT_MODEL[@src[1]] != :raw
             elsif val == :raw
               do_parsing = false
             end
           end
 
-          el = Element.new(:html_element, @src[1], attrs, :category => :span, :parse_type => (do_parsing ? :span : :raw))
+          el = Element.new(:html_element, @src[1], attrs, :category => :span, :content_model => (do_parsing ? :span : :raw))
           @tree.children << el
           stop_re = /<\/#{Regexp.escape(@src[1])}\s*>/
           if !@src[4] && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
@@ -160,12 +153,13 @@ module Kramdown
               @src.scan(stop_re)
             else
               warning("Found no end tag for '#{el.value}' - auto-closing it")
-              add_text(@src.scan(/.*/m), el)
+              add_text(@src.rest, el)
+              @src.terminate
             end
           end
-          Kramdown::Parser::Html::ElementConverter.new(@doc).process(el) if @doc.options[:html_to_native]
+          Kramdown::Parser::Html::ElementConverter.convert(@root, el) if @options[:html_to_native]
         else
-          add_text(@src.scan(/./))
+          add_text(@src.getch)
         end
       end
       define_parser(:span_html, HTML_SPAN_START, '<')

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

@@ -33,8 +33,8 @@ module Kramdown
       def parse_link_definition
         @src.pos += @src.matched_size
         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]
+        warning("Duplicate link ID '#{link_id}' - overwriting") if @link_defs[link_id]
+        @link_defs[link_id] = [link_url, link_title]
         @tree.children << Element.new(:eob, :link_def)
         true
       end
@@ -55,7 +55,8 @@ module Kramdown
         @tree.children << el
       end
 
-      LINK_TEXT_BRACKET_RE = /\\\[|\\\]|\[|\]/
+      LINK_BRACKET_STOP_RE = /(\])|!?\[/
+      LINK_PAREN_STOP_RE = /(\()|(\))|\s(?=['"])/
       LINK_INLINE_ID_RE = /\s*?\[(#{LINK_ID_CHARS}+)?\]/
       LINK_INLINE_TITLE_RE = /\s*?(["'])(.+?)\1\s*?\)/
       LINK_START = /!?\[(?=[^^])/
@@ -75,15 +76,9 @@ module Kramdown
         end
         el = Element.new(link_type)
 
-        stop_re = /\]|!?\[/
         count = 1
-        found = parse_spans(el, stop_re) do
-          case @src.matched
-          when "[", "!["
-            count += 1
-          when "]"
-            count -= 1
-          end
+        found = parse_spans(el, LINK_BRACKET_STOP_RE) do
+          count = count + (@src[1] ? -1 : 1)
           count - el.children.select {|c| c.type == :img}.size == 0
         end
         if !found || (link_type == :a && el.children.empty?)
@@ -92,17 +87,13 @@ module Kramdown
           return
         end
         alt_text = extract_string(reset_pos...@src.pos, @src)
-        conv_link_id = alt_text.gsub(/(\s|\n)+/m, ' ').gsub(LINK_ID_NON_CHARS, '').downcase
-        @src.scan(stop_re)
+        @src.scan(LINK_BRACKET_STOP_RE)
 
         # reference style link or no link url
         if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
-          link_id = (@src[1] || conv_link_id).downcase
-          if link_id.empty?
-            @src.pos = reset_pos
-            add_text(result)
-          elsif @doc.parse_infos[:link_defs].has_key?(link_id)
-            add_link(el, @doc.parse_infos[:link_defs][link_id].first, @doc.parse_infos[:link_defs][link_id].last, alt_text)
+          link_id = (@src[1] || alt_text.gsub(/(\s|\n)+/, ' ').gsub(LINK_ID_NON_CHARS, '')).downcase
+          if @link_defs.has_key?(link_id)
+            add_link(el, @link_defs[link_id].first, @link_defs[link_id].last, alt_text)
           else
             warning("No link definition for link ID '#{link_id}' found")
             @src.pos = reset_pos
@@ -120,21 +111,20 @@ module Kramdown
           end
         else
           link_url = ''
-          re = /\(|\)|\s(?=['"])/
           nr_of_brackets = 0
-          while temp = @src.scan_until(re)
-            link_url += temp
-            case @src.matched
-            when /\s/
-              break
-            when '('
-              nr_of_brackets += 1
-            when ')'
+          while temp = @src.scan_until(LINK_PAREN_STOP_RE)
+            link_url << temp
+            if @src[2]
               nr_of_brackets -= 1
               break if nr_of_brackets == 0
+            elsif @src[1]
+              nr_of_brackets += 1
+            else
+              break
             end
           end
-          link_url = link_url[1..-2].strip
+          link_url = link_url[1..-2]
+          link_url.strip!
 
           if nr_of_brackets == 0
             add_link(el, link_url, nil, alt_text)

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

@@ -23,7 +23,7 @@
 require 'kramdown/parser/kramdown/blank_line'
 require 'kramdown/parser/kramdown/eob'
 require 'kramdown/parser/kramdown/horizontal_rule'
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 
 module Kramdown
   module Parser
@@ -34,12 +34,12 @@ module Kramdown
       # 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 =~ LIST_ITEM_IAL
+        if content =~ self.class::LIST_ITEM_IAL
           indentation = 4
         else
           while content =~ /^ *\t/
             temp = content.scan(/^ */).first.length + indentation
-            content.sub!(/^( *)(\t+)/) {$1 + " "*(4 - (temp % 4)) + " "*($2.length - 1)*4}
+            content.sub!(/^( *)(\t+)/) {$1 << " "*(4 - (temp % 4) + ($2.length - 1)*4)}
           end
           indentation += content.scan(/^ */).first.length
         end
@@ -77,8 +77,8 @@ module Kramdown
             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|
-              parse_attribute_list($~[1], item.options[:ial] ||= {})
+            item.value.sub!(/^#{self.class::IAL_SPAN_START}\s*/) do |match|
+              parse_attribute_list($1, item.options[:ial] ||= {})
               ''
             end
 
@@ -87,7 +87,7 @@ module Kramdown
             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!(/^(\t+)/) { " "*($1 ? 4*$1.length : 0) }
             result.sub!(indent_re, '')
             if !nested_list_found && result =~ LIST_START
               item.value << "^\n"
@@ -123,7 +123,7 @@ module Kramdown
                (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
+            it.children.first.children.first.value << "\n" if it.children.size > 1 && it.children[1].type != :blank
             it.children.first.options[:transparent] = true
           end
 
@@ -158,7 +158,7 @@ module Kramdown
           para = @tree.children.pop
           first_as_para = true
         end
-        para.children.first.value.split("\n").each do |term|
+        para.children.first.value.split(/\n/).each do |term|
           el = Element.new(:dt)
           el.children << Element.new(:raw_text, term)
           deflist.children << el
@@ -176,7 +176,7 @@ module Kramdown
             deflist.children << item
 
             item.value.sub!(/^#{IAL_SPAN_START}\s*/) do |match|
-              parse_attribute_list($~[1], item.options[:ial] ||= {})
+              parse_attribute_list($1, item.options[:ial] ||= {})
               ''
             end
 
@@ -186,7 +186,7 @@ module Kramdown
           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!(/^(\t+)/) { " "*($1 ? 4*$1.length : 0) }
             result.sub!(indent_re, '')
             item.value << result
             first_as_para = false
@@ -214,16 +214,16 @@ module Kramdown
             last = nil
           end
           if it.children.first.type == :p && !it.options.delete(:first_as_para)
-            it.children.first.children.first.value += "\n" if it.children.size > 1
+            it.children.first.children.first.value << "\n" if it.children.size > 1
             it.children.first.options[:transparent] = true
           end
         end
 
         if @tree.children.length >= 1 && @tree.children.last.type == :dl
-          @tree.children[-1].children += deflist.children
+          @tree.children[-1].children.concat(deflist.children)
         elsif @tree.children.length >= 2 && @tree.children[-1].type == :blank && @tree.children[-2].type == :dl
           @tree.children.pop
-          @tree.children[-1].children += deflist.children
+          @tree.children[-1].children.concat(deflist.children)
         else
           @tree.children << deflist
         end

data/lib/kramdown/parser/kramdown/math.rb

@@ -40,7 +40,7 @@ module Kramdown
         @src.pos += @src.matched_size
         data = @src[2]
         if before_block_boundary?
-          @tree.children << new_block_el(:math, data)
+          @tree.children << new_block_el(:math, data, nil, :category => :block)
           true
         else
           @src.pos = orig_pos

data/lib/kramdown/parser/kramdown/paragraph.rb

@@ -21,7 +21,7 @@
 #
 
 require 'kramdown/parser/kramdown/blank_line'
-require 'kramdown/parser/kramdown/attribute_list'
+require 'kramdown/parser/kramdown/extensions'
 require 'kramdown/parser/kramdown/eob'
 require 'kramdown/parser/kramdown/list'
 require 'kramdown/parser/kramdown/html'
@@ -39,12 +39,13 @@ module Kramdown
 
       # Parse the paragraph at the current location.
       def parse_paragraph
-        result = @src.scan(PARAGRAPH_MATCH)
+        result = @src.scan(self.class::PARAGRAPH_MATCH).chomp!
         if @tree.children.last && @tree.children.last.type == :p
-          @tree.children.last.children.first.value << "\n" << result.chomp
+          @tree.children.last.children.first.value << "\n" << result
         else
           @tree.children << new_block_el(:p)
-          @tree.children.last.children << Element.new(@text_type, result.lstrip.chomp)
+          result.lstrip!
+          @tree.children.last.children << Element.new(@text_type, result)
         end
         true
       end