kramdown 0.14.2 → 2.3.0

data/lib/kramdown/parser/kramdown/line_break.rb

@@ -1,22 +1,9 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 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/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
@@ -28,8 +15,8 @@ module Kramdown
 
       # Parse the line break at the current location.
       def parse_line_break
+        @tree.children << Element.new(:br, nil, nil, location: @src.current_line_number)
         @src.pos += @src.matched_size
-        @tree.children << Element.new(:br)
       end
       define_parser(:line_break, LINE_BREAK, '(  |\\\\)(?=\n)')
 

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

@@ -1,51 +1,44 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 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/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
+require 'kramdown/parser/kramdown/escaped_chars'
+
 module Kramdown
   module Parser
     class Kramdown
 
       # Normalize the link identifier.
       def normalize_link_id(id)
-        id.gsub(/(\s|\n)+/, ' ').downcase
+        id.gsub(/[\s]+/, ' ').downcase
       end
 
-      LINK_DEFINITION_START = /^#{OPT_SPACE}\[([^\n\]]+)\]:[ \t]*(?:<(.*?)>|([^'"\n]*?\S[^'"\n]*?))[ \t]*?(?:\n?[ \t]*?(["'])(.+?)\4[ \t]*?)?\n/
+      LINK_DEFINITION_START = /^#{OPT_SPACE}\[([^\n\]]+)\]:[ \t]*(?:<(.*?)>|([^\n]*?\S[^\n]*?))(?:(?:[ \t]*?\n|[ \t]+?)[ \t]*?(["'])(.+?)\4)?[ \t]*?\n/
 
       # Parse the link definition at the current location.
       def parse_link_definition
+        return false if @src[3].to_s =~ /[ \t]+["']/
         @src.pos += @src.matched_size
         link_id, link_url, link_title = normalize_link_id(@src[1]), @src[2] || @src[3], @src[5]
-        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)
+        if @link_defs[link_id]
+          warning("Duplicate link ID '#{link_id}' on line #{@src.current_line_number} - overwriting")
+        end
+        @tree.children << new_block_el(:eob, :link_def)
+        @link_defs[link_id] = [link_url, link_title, @tree.children.last]
         true
       end
       define_parser(:link_definition, LINK_DEFINITION_START)
 
-
       # This helper methods adds the approriate attributes to the element +el+ of type +a+ or +img+
       # and the element itself to the @tree.
-      def add_link(el, href, title, alt_text = nil)
+      def add_link(el, href, title, alt_text = nil, ial = nil)
+        el.options[:ial] = ial
+        update_attr_with_ial(el.attr, ial) if ial
         if el.type == :a
           el.attr['href'] = href
         else
@@ -66,39 +59,47 @@ module Kramdown
       # Parse the link at the current scanner position. This method is used to parse normal links as
       # well as image links.
       def parse_link
+        start_line_number = @src.current_line_number
         result = @src.scan(LINK_START)
-        reset_pos = @src.pos
+        cur_pos = @src.pos
+        saved_pos = @src.save_pos
 
         link_type = (result =~ /^!/ ? :img : :a)
 
         # no nested links allowed
-        if link_type == :a && (@tree.type == :img || @tree.type == :a || @stack.any? {|t,s| t && (t.type == :img || t.type == :a)})
+        if link_type == :a && (@tree.type == :img || @tree.type == :a ||
+                               @stack.any? {|t, _| t && (t.type == :img || t.type == :a) })
           add_text(result)
           return
         end
-        el = Element.new(link_type)
+        el = Element.new(link_type, nil, nil, location: start_line_number)
 
         count = 1
         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
+          count += (@src[1] ? -1 : 1)
+          count - el.children.select {|c| c.type == :img }.size == 0
         end
-        if !found || (link_type == :a && el.children.empty?)
-          @src.pos = reset_pos
+        unless found
+          @src.revert_pos(saved_pos)
           add_text(result)
           return
         end
-        alt_text = extract_string(reset_pos...@src.pos, @src)
+        alt_text = extract_string(cur_pos...@src.pos, @src).gsub(ESCAPED_CHARS, '\1')
         @src.scan(LINK_BRACKET_STOP_RE)
 
         # reference style link or no link url
         if @src.scan(LINK_INLINE_ID_RE) || !@src.check(/\(/)
+          emit_warning = !@src[1]
           link_id = normalize_link_id(@src[1] || alt_text)
-          if @link_defs.has_key?(link_id)
-            add_link(el, @link_defs[link_id].first, @link_defs[link_id].last, alt_text)
+          if @link_defs.key?(link_id)
+            link_def = @link_defs[link_id]
+            add_link(el, link_def[0], link_def[1], alt_text,
+                     link_def[2] && link_def[2].options[:ial])
           else
-            warning("No link definition for link ID '#{link_id}' found")
-            @src.pos = reset_pos
+            if emit_warning
+              warning("No link definition for link ID '#{link_id}' found on line #{start_line_number}")
+            end
+            @src.revert_pos(saved_pos)
             add_text(result)
           end
           return
@@ -112,9 +113,9 @@ module Kramdown
             return
           end
         else
-          link_url = ''
+          link_url = +''
           nr_of_brackets = 0
-          while temp = @src.scan_until(LINK_PAREN_STOP_RE)
+          while (temp = @src.scan_until(LINK_PAREN_STOP_RE))
             link_url << temp
             if @src[2]
               nr_of_brackets -= 1
@@ -137,7 +138,7 @@ module Kramdown
         if @src.scan(LINK_INLINE_TITLE_RE)
           add_link(el, link_url, @src[2], alt_text)
         else
-          @src.pos = reset_pos
+          @src.revert_pos(saved_pos)
           add_text(result)
         end
       end

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

@@ -1,22 +1,9 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 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/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
@@ -32,6 +19,14 @@ module Kramdown
       LIST_ITEM_IAL = /^\s*(?:\{:(?!(?:#{ALD_ID_NAME})?:|\/)(#{ALD_ANY_CHARS}+)\})\s*/
       LIST_ITEM_IAL_CHECK = /^#{LIST_ITEM_IAL}?\s*\n/
 
+      PARSE_FIRST_LIST_LINE_REGEXP_CACHE = Hash.new do |h, indentation|
+        indent_re = /^ {#{indentation}}/
+        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/
+
+        h[indentation] = [content_re, lazy_re, indent_re]
+      end
+
       # 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)
@@ -40,66 +35,69 @@ module Kramdown
         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
+          indentation += content[/^ */].length
         end
         content.sub!(/^\s*/, '')
 
-        indent_re = /^ {#{indentation}}/
-        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]
+        [content, indentation, *PARSE_FIRST_LIST_LINE_REGEXP_CACHE[indentation]]
       end
 
+      PATTERN_TAIL = /[\t| ].*?\n/
 
-      LIST_START_UL = /^(#{OPT_SPACE}[+*-])([\t| ].*?\n)/
-      LIST_START_OL = /^(#{OPT_SPACE}\d+\.)([\t| ].*?\n)/
+      LIST_START_UL = /^(#{OPT_SPACE}[+*-])(#{PATTERN_TAIL})/
+      LIST_START_OL = /^(#{OPT_SPACE}\d+\.)(#{PATTERN_TAIL})/
       LIST_START = /#{LIST_START_UL}|#{LIST_START_OL}/
 
       # Parse the ordered or unordered list at the current location.
       def parse_list
+        start_line_number = @src.current_line_number
         type, list_start_re = (@src.check(LIST_START_UL) ? [:ul, LIST_START_UL] : [:ol, LIST_START_OL])
-        list = new_block_el(type)
+        list = new_block_el(type, nil, nil, location: start_line_number)
 
         item = nil
         content_re, lazy_re, indent_re = nil
         eob_found = false
         nested_list_found = false
         last_is_blank = false
-        while !@src.eos?
+        until @src.eos?
+          start_line_number = @src.current_line_number
           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, lazy_re, indent_re = parse_first_list_line(@src[1].length, @src[2])
+            item = Element.new(:li, nil, nil, location: start_line_number)
+            item.value, indentation, content_re, lazy_re, indent_re =
+              parse_first_list_line(@src[1].length, @src[2])
             list.children << item
 
-            item.value.sub!(self.class::LIST_ITEM_IAL) do |match|
+            item.value.sub!(self.class::LIST_ITEM_IAL) do
               parse_attribute_list($1, item.options[:ial] ||= {})
               ''
             end
 
-            list_start_re = (type == :ul ? /^( {0,#{[3, indentation - 1].min}}[+*-])([\t| ].*?\n)/ :
-                             /^( {0,#{[3, indentation - 1].min}}\d+\.)([\t| ].*?\n)/)
+            list_start_re = fetch_pattern(type, indentation)
             nested_list_found = (item.value =~ LIST_START)
             last_is_blank = false
+            item.value = [item.value]
           elsif (result = @src.scan(content_re)) || (!last_is_blank && (result = @src.scan(lazy_re)))
-            result.sub!(/^(\t+)/) { " "*($1 ? 4*$1.length : 0) }
-            result.sub!(indent_re, '')
-            if !nested_list_found && result =~ LIST_START
-              item.value << "^\n"
+            result.sub!(/^(\t+)/) { " " * 4 * $1.length }
+            indentation_found = result.sub!(indent_re, '')
+            if !nested_list_found && indentation_found && result =~ LIST_START
+              item.value << +''
               nested_list_found = true
+            elsif nested_list_found && !indentation_found && result =~ LIST_START
+              result = " " * (indentation + 4) << result
             end
-            item.value << result
+            item.value.last << result
             last_is_blank = false
-          elsif result = @src.scan(BLANK_LINE)
+          elsif (result = @src.scan(BLANK_LINE))
             nested_list_found = true
             last_is_blank = true
-            item.value << result
+            item.value.last << result
           else
             break
           end
@@ -109,30 +107,37 @@ module Kramdown
 
         last = nil
         list.children.each do |it|
-          temp = Element.new(:temp)
-          parse_blocks(temp, it.value)
+          temp = Element.new(:temp, nil, nil, location: it.options[:location])
+
+          env = save_env
+          location = it.options[:location]
+          it.value.each do |val|
+            @src = ::Kramdown::Utils::StringScanner.new(val, location)
+            parse_blocks(temp)
+            location = @src.current_line_number
+          end
+          restore_env(env)
+
           it.children = temp.children
           it.value = nil
-          next if it.children.size == 0
+
+          it_children = it.children
+          next if it_children.empty?
 
           # 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]
+          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)) &&
+          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 || 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.options[:transparent] = true
+              list.children[0..-2].any? {|cit| !cit.children.first || 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.options[:transparent] = true
           end
 
-          if it.children.last.type == :blank
-            last = it.children.pop
-          else
-            last = nil
-          end
+          last = (it_children.last.type == :blank ? it_children.pop : nil)
         end
 
         @tree.children << last if !last.nil? && !eob_found
@@ -141,14 +146,14 @@ module Kramdown
       end
       define_parser(:list, LIST_START)
 
-
-      DEFINITION_LIST_START = /^(#{OPT_SPACE}:)([\t| ].*?\n)/
+      DEFINITION_LIST_START = /^(#{OPT_SPACE}:)(#{PATTERN_TAIL})/
 
       # Parse the ordered or unordered list at the current location.
       def parse_definition_list
         children = @tree.children
-        if !children.last || (children.length == 1 && children.last.type != :p ) ||
-            (children.length >= 2 && children[-1].type != :p && (children[-1].type != :blank || children[-1].value != "\n" || children[-2].type != :p))
+        if !children.last || (children.length == 1 && children.last.type != :p) ||
+            (children.length >= 2 && children[-1].type != :p &&
+             (children[-1].type != :blank || children[-1].value != "\n" || children[-2].type != :p))
           return false
         end
 
@@ -159,8 +164,15 @@ module Kramdown
           para = @tree.children.pop
           first_as_para = true
         end
+        # take location from preceding para which is the first definition term
+        deflist.options[:location] = para.options[:location]
         para.children.first.value.split(/\n/).each do |term|
-          el = Element.new(:dt)
+          el = Element.new(:dt, nil, nil, location: @src.current_line_number)
+          term.sub!(self.class::LIST_ITEM_IAL) do
+            parse_attribute_list($1, el.options[:ial] ||= {})
+            ''
+          end
+          el.options[:raw_text] = term
           el.children << Element.new(:raw_text, term)
           deflist.children << el
         end
@@ -170,30 +182,32 @@ module Kramdown
         content_re, lazy_re, indent_re = nil
         def_start_re = DEFINITION_LIST_START
         last_is_blank = false
-        while !@src.eos?
+        until @src.eos?
+          start_line_number = @src.current_line_number
           if @src.scan(def_start_re)
-            item = Element.new(:dd)
+            item = Element.new(:dd, nil, nil, location: start_line_number)
             item.options[:first_as_para] = first_as_para
-            item.value, indentation, content_re, lazy_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!(self.class::LIST_ITEM_IAL) do |match|
+            item.value.sub!(self.class::LIST_ITEM_IAL) do |_match|
               parse_attribute_list($1, item.options[:ial] ||= {})
               ''
             end
 
-            def_start_re = /^( {0,#{[3, indentation - 1].min}}:)([\t| ].*?\n)/
+            def_start_re = fetch_pattern(:dl, indentation)
             first_as_para = false
             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+)/) { " "*($1 ? 4*$1.length : 0) }
+            result.sub!(/^(\t+)/) { " " * ($1 ? 4 * $1.length : 0) }
             result.sub!(indent_re, '')
             item.value << result
             first_as_para = false
             last_is_blank = false
-          elsif result = @src.scan(BLANK_LINE)
+          elsif (result = @src.scan(BLANK_LINE))
             first_as_para = true
             item.value << result
             last_is_blank = true
@@ -208,35 +222,63 @@ module Kramdown
 
           parse_blocks(it, it.value)
           it.value = nil
-          next if it.children.size == 0
+          it_children = it.children
+          next if it_children.empty?
 
-          if it.children.last.type == :blank
-            last = it.children.pop
-          else
-            last = nil
-          end
+          last = (it_children.last.type == :blank ? it_children.pop : nil)
 
-          if it.children.first && 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.options[:transparent] = true
+          if it_children.first && 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.options[:transparent] = true
           end
         end
 
-        if @tree.children.length >= 1 && @tree.children.last.type == :dl
-          @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.concat(deflist.children)
+        children = @tree.children
+        if children.length >= 1 && children.last.type == :dl
+          children[-1].children.concat(deflist.children)
+        elsif children.length >= 2 && children[-1].type == :blank &&
+            children[-2].type == :dl
+          children.pop
+          children[-1].children.concat(deflist.children)
         else
-          @tree.children << deflist
+          children << deflist
         end
 
-        @tree.children << last if !last.nil?
+        children << last if last
 
         true
       end
       define_parser(:definition_list, DEFINITION_LIST_START)
 
+      private
+
+      # precomputed patterns for indentations 1..4 and fallback expression
+      # to compute pattern when indentation is outside the 1..4 range.
+      def fetch_pattern(type, indentation)
+        if type == :ul
+          case indentation
+          when 1 then %r/^( {0}[+*-])(#{PATTERN_TAIL})/o
+          when 2 then %r/^( {0,1}[+*-])(#{PATTERN_TAIL})/o
+          when 3 then %r/^( {0,2}[+*-])(#{PATTERN_TAIL})/o
+          else %r/^( {0,3}[+*-])(#{PATTERN_TAIL})/o
+          end
+        elsif type == :ol
+          case indentation
+          when 1 then %r/^( {0}\d+\.)(#{PATTERN_TAIL})/o
+          when 2 then %r/^( {0,1}\d+\.)(#{PATTERN_TAIL})/o
+          when 3 then %r/^( {0,2}\d+\.)(#{PATTERN_TAIL})/o
+          else %r/^( {0,3}\d+\.)(#{PATTERN_TAIL})/o
+          end
+        elsif type == :dl
+          case indentation
+          when 1 then %r/^( {0}:)(#{PATTERN_TAIL})/o
+          when 2 then %r/^( {0,1}:)(#{PATTERN_TAIL})/o
+          when 3 then %r/^( {0,2}:)(#{PATTERN_TAIL})/o
+          else %r/^( {0,3}:)(#{PATTERN_TAIL})/o
+          end
+        end
+      end
+
     end
   end
 end