kramdown 0.14.2 → 2.3.0

data/lib/kramdown/parser/kramdown.rb

@@ -1,30 +1,18 @@
-# -*- 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 'strscan'
 require 'stringio'
+require 'kramdown/parser'
 
-#TODO: use [[:alpha:]] in all regexp to allow parsing of international values in 1.9.1
-#NOTE: use @src.pre_match only before other check/match?/... operations, otherwise the content is changed
+# TODO: use [[:alpha:]] in all regexp to allow parsing of international values in 1.9.1
+# NOTE: use @src.pre_match only before other check/match?/... operations, otherwise the content is changed
 
 module Kramdown
 
@@ -79,35 +67,55 @@ module Kramdown
 
         reset_env
 
-        @root.options[:abbrev_defs] = {}
         @alds = {}
-        @link_defs = {}
-        @options[:link_defs].each {|k,v| @link_defs[normalize_link_id(k)] = v}
         @footnotes = {}
+        @link_defs = {}
+        update_link_definitions(@options[:link_defs])
 
         @block_parsers = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :atx_header,
                           :horizontal_rule, :list, :definition_list, :block_html, :setext_header,
-                          :table, :footnote_definition, :link_definition, :abbrev_definition,
-                          :block_extensions, :block_math, :eob_marker, :paragraph]
-        @span_parsers =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link, :smart_quotes, :inline_math,
-                         :span_extensions, :html_entity, :typographic_syms, :line_break, :escaped_chars]
+                          :block_math, :table, :footnote_definition, :link_definition,
+                          :abbrev_definition, :block_extensions, :eob_marker, :paragraph]
+        @span_parsers =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link,
+                          :smart_quotes, :inline_math, :span_extensions, :html_entity,
+                          :typographic_syms, :line_break, :escaped_chars]
 
+        @span_pattern_cache ||= Hash.new { |h, k| h[k] = {} }
       end
       private_class_method(:new, :allocate)
 
-
       # The source string provided on initialization is parsed into the @root element.
       def parse
         configure_parser
         parse_blocks(@root, adapt_source(source))
         update_tree(@root)
+        correct_abbreviations_attributes
         replace_abbreviations(@root)
-        @footnotes.each {|name,data| update_tree(data[:marker].value) if data[:marker]}
+        @footnotes.each do |_name, data|
+          update_tree(data[:content])
+          replace_abbreviations(data[:content])
+        end
+        footnote_count = 0
+        @footnotes.each do |name, data|
+          (footnote_count += 1; next) if data.key?(:marker)
+          line = data[:content].options[:location]
+          warning("Footnote definition for '#{name}' on line #{line} is unreferenced - ignoring")
+        end
+        @root.options[:footnote_count] = footnote_count
       end
 
-      #######
       protected
-      #######
+
+      # :doc:
+      #
+      # Update the parser specific link definitions with the data from +link_defs+ (the value of the
+      # :link_defs option).
+      #
+      # The parameter +link_defs+ is a hash where the keys are possibly unnormalized link IDs and
+      # the values are two element arrays consisting of the link target and a title (can be +nil+).
+      def update_link_definitions(link_defs)
+        link_defs.each {|k, v| @link_defs[normalize_link_id(k)] = v }
+      end
 
       # Adapt the object to allow parsing like specified in the options.
       def configure_parser
@@ -124,18 +132,18 @@ module Kramdown
 
       # Create the needed span parser regexps.
       def span_parser_regexps(parsers = @span_parsers)
-        span_start = /#{parsers.map {|name| @parsers[name].span_start}.join('|')}/
+        span_start = /#{parsers.map {|name| @parsers[name].span_start }.join('|')}/
         [span_start, /(?=#{span_start})/]
       end
 
       # Parse all block-level elements in +text+ into the element +el+.
       def parse_blocks(el, text = nil)
         @stack.push([@tree, @src, @block_ial])
-        @tree, @src, @block_ial = el, (text.nil? ? @src : StringScanner.new(text)), nil
+        @tree, @block_ial = el, nil
+        @src = (text.nil? ? @src : ::Kramdown::Utils::StringScanner.new(text, el.options[:location]))
 
         status = catch(:stop_block_parsing) do
-          while !@src.eos?
-            block_ial_set = @block_ial
+          until @src.eos?
             @block_parsers.any? do |name|
               if @src.check(@parsers[name].start_re)
                 send(@parsers[name].method)
@@ -146,7 +154,6 @@ module Kramdown
               warning('Warning: this should not occur - no block parser handled the line')
               add_text(@src.scan(/.*\n/))
             end
-            @block_ial = nil if block_ial_set
           end
         end
 
@@ -161,10 +168,12 @@ module Kramdown
         element.children.map! do |child|
           if child.type == :raw_text
             last_blank = nil
-            reset_env(:src => StringScanner.new(child.value), :text_type => :text)
+            reset_env(src: ::Kramdown::Utils::StringScanner.new(child.value, element.options[:location]),
+                      text_type: :text)
             parse_spans(child)
             child.children
           elsif child.type == :eob
+            update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
             []
           elsif child.type == :blank
             if last_blank
@@ -178,11 +187,21 @@ module Kramdown
             last_blank = nil
             update_tree(child)
             update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
+            # DEPRECATED: option auto_id_stripping will be removed in 2.0 because then this will be
+            # the default behaviour
+            if child.type == :dt || (child.type == :header && @options[:auto_id_stripping])
+              update_raw_text(child)
+            end
             child
           end
         end.flatten!
       end
 
+      def span_pattern_cache(stop_re, span_start)
+        @span_pattern_cache[stop_re][span_start] ||= /(?=#{Regexp.union(stop_re, span_start)})/
+      end
+      private :span_pattern_cache
+
       # Parse all span-level elements in the source string of @src into +el+.
       #
       # If the parameter +stop_re+ (a regexp) is used, parsing is immediately stopped if the regexp
@@ -199,12 +218,12 @@ module Kramdown
         span_start = @span_start
         span_start_re = @span_start_re
         span_start, span_start_re = span_parser_regexps(parsers) if parsers
-        parsers = parsers || @span_parsers
+        parsers ||= @span_parsers
 
-        used_re = (stop_re.nil? ? span_start_re : /(?=#{Regexp.union(stop_re, span_start)})/)
+        used_re = (stop_re.nil? ? span_start_re : span_pattern_cache(stop_re, span_start))
         stop_re_found = false
         while !@src.eos? && !stop_re_found
-          if result = @src.scan_until(used_re)
+          if (result = @src.scan_until(used_re))
             add_text(result)
             if stop_re && @src.check(stop_re)
               stop_re_found = (block_given? ? yield : true)
@@ -232,7 +251,7 @@ module Kramdown
       # Reset the current parsing environment. The parameter +env+ can be used to set initial
       # values for one or more environment variables.
       def reset_env(opts = {})
-        opts = {:text_type => :raw_text, :stack => []}.merge(opts)
+        opts = {text_type: :raw_text, stack: []}.merge(opts)
         @src = opts[:src]
         @tree = opts[:tree]
         @block_ial = opts[:block_ial]
@@ -242,35 +261,53 @@ module Kramdown
 
       # Return the current parsing environment.
       def save_env
-        [@src, @tree, @block_ial, @stack,  @text_type]
+        [@src, @tree, @block_ial, @stack, @text_type]
       end
 
       # Restore the current parsing environment.
       def restore_env(env)
-        @src, @tree, @block_ial, @stack,  @text_type = *env
+        @src, @tree, @block_ial, @stack, @text_type = *env
       end
 
       # Update the given attributes hash +attr+ with the information from the inline attribute list
       # +ial+ and all referenced ALDs.
       def update_attr_with_ial(attr, ial)
-        ial[:refs].each do |ref|
-          update_attr_with_ial(attr, ref) if ref = @alds[ref]
-        end if ial[:refs]
-        ial.each do |k,v|
+        ial[:refs]&.each do |ref|
+          update_attr_with_ial(attr, ref) if (ref = @alds[ref])
+        end
+        ial.each do |k, v|
           if k == IAL_CLASS_ATTR
-            attr[k] = (attr[k] || '') << " #{v}"
-            attr[k].lstrip!
+            attr[k] = "#{attr[k]} #{v}".lstrip
           elsif k.kind_of?(String)
             attr[k] = v
           end
         end
       end
 
+      # Update the raw text for automatic ID generation.
+      def update_raw_text(item)
+        raw_text = +''
+
+        append_text = lambda do |child|
+          if child.type == :text
+            raw_text << child.value
+          else
+            child.children.each {|c| append_text.call(c) }
+          end
+        end
+
+        append_text.call(item)
+        item.options[:raw_text] = raw_text
+      end
+
       # Create a new block-level element, taking care of applying a preceding block IAL if it
       # exists. This method should always be used for creating a block-level element!
       def new_block_el(*args)
         el = Element.new(*args)
-        el.options[:ial] = @block_ial if @block_ial && el.type != :blank && el.type != :eob
+        if @block_ial
+          el.options[:ial] = @block_ial
+          @block_ial = nil
+        end
         el
       end
 
@@ -289,7 +326,7 @@ module Kramdown
       # to the registry. The method name is automatically derived from the +name+ or can explicitly
       # be set by using the +meth_name+ parameter.
       def self.define_parser(name, start_re, span_start = nil, meth_name = "parse_#{name}")
-        raise "A parser with the name #{name} already exists!" if @@parsers.has_key?(name)
+        raise "A parser with the name #{name} already exists!" if @@parsers.key?(name)
         @@parsers[name] = Data.new(name, start_re, span_start, meth_name)
       end
 
@@ -300,7 +337,7 @@ module Kramdown
 
       # Return +true+ if there is a parser called +name+.
       def self.has_parser?(name)
-        @@parsers.has_key?(name)
+        @@parsers.key?(name)
       end
 
       # Regexp for matching indentation (one tab or four spaces)

data/lib/kramdown/parser/kramdown/abbreviation.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,35 +15,54 @@ module Kramdown
 
       # Parse the link definition at the current location.
       def parse_abbrev_definition
+        start_line_number = @src.current_line_number
         @src.pos += @src.matched_size
         abbrev_id, abbrev_text = @src[1], @src[2]
         abbrev_text.strip!
-        warning("Duplicate abbreviation ID '#{abbrev_id}' - overwriting") if @root.options[:abbrev_defs][abbrev_id]
+        if @root.options[:abbrev_defs][abbrev_id]
+          warning("Duplicate abbreviation ID '#{abbrev_id}' on line #{start_line_number} " \
+                  "- overwriting")
+        end
+        @tree.children << new_block_el(:eob, :abbrev_def)
         @root.options[:abbrev_defs][abbrev_id] = abbrev_text
-        @tree.children << Element.new(:eob, :abbrev_def)
+        @root.options[:abbrev_attr][abbrev_id] = @tree.children.last
         true
       end
       define_parser(:abbrev_definition, ABBREV_DEFINITION_START)
 
+      # Correct abbreviation attributes.
+      def correct_abbreviations_attributes
+        @root.options[:abbrev_attr].keys.each do |k|
+          @root.options[:abbrev_attr][k] = @root.options[:abbrev_attr][k].attr
+        end
+      end
+
       # Replace the abbreviation text with elements.
       def replace_abbreviations(el, regexps = nil)
         return if @root.options[:abbrev_defs].empty?
-        if !regexps
-          sorted_abbrevs = @root.options[:abbrev_defs].keys.sort {|a,b| b.length <=> a.length}
-          regexps = [Regexp.union(*sorted_abbrevs.map {|k| /#{Regexp.escape(k)}/})]
+        unless regexps
+          sorted_abbrevs = @root.options[:abbrev_defs].keys.sort {|a, b| b.length <=> a.length }
+          regexps = [Regexp.union(*sorted_abbrevs.map {|k| /#{Regexp.escape(k)}/ })]
           regexps << /(?=(?:\W|^)#{regexps.first}(?!\w))/ # regexp should only match on word boundaries
         end
         el.children.map! do |child|
           if child.type == :text
             if child.value =~ regexps.first
               result = []
-              strscan = StringScanner.new(child.value)
-              while temp = strscan.scan_until(regexps.last)
-                temp << strscan.scan(/\W|^/)
-                abbr = strscan.scan(regexps.first)
-                result << Element.new(:text, temp) << Element.new(:abbreviation, abbr)
+              strscan = Kramdown::Utils::StringScanner.new(child.value, child.options[:location])
+              text_lineno = strscan.current_line_number
+              while (temp = strscan.scan_until(regexps.last))
+                abbr_lineno = strscan.current_line_number
+                abbr = strscan.scan(regexps.first) # begin of line case of abbr with \W char as first one
+                if abbr.nil?
+                  temp << strscan.scan(/\W|^/)
+                  abbr = strscan.scan(regexps.first)
+                end
+                result << Element.new(:text, temp, nil, location: text_lineno)
+                result << Element.new(:abbreviation, abbr, nil, location: abbr_lineno)
+                text_lineno = strscan.current_line_number
               end
-              result << Element.new(:text, strscan.rest)
+              result << Element.new(:text, strscan.rest, nil, location: text_lineno)
             else
               child
             end

data/lib/kramdown/parser/kramdown/autolink.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.
 #++
 #
 
@@ -24,21 +11,16 @@ module Kramdown
   module Parser
     class Kramdown
 
-      if RUBY_VERSION == '1.8.5'
-        ACHARS = '\w\x80-\xFF'
-      elsif RUBY_VERSION < '1.9.0'
-        ACHARS = '\w'
-      else
-        ACHARS = '[[:alnum:]]'
-      end
-      AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[-.#{ACHARS}]+@[-#{ACHARS}]+(?:\.[-#{ACHARS}]+)*\.[a-z]+)>"
+      ACHARS = '[[:alnum:]]-_.'
+      AUTOLINK_START_STR = "<((mailto|https?|ftps?):.+?|[#{ACHARS}]+?@[#{ACHARS}]+?)>"
       AUTOLINK_START = /#{AUTOLINK_START_STR}/u
 
       # Parse the autolink at the current location.
       def parse_autolink
+        start_line_number = @src.current_line_number
         @src.pos += @src.matched_size
         href = (@src[2].nil? ? "mailto:#{@src[1]}" : @src[1])
-        el = Element.new(:a, nil, {'href' => href})
+        el = Element.new(:a, nil, {'href' => href}, location: start_line_number)
         add_text(@src[1].sub(/^mailto:/, ''), el)
         @tree.children << el
       end

data/lib/kramdown/parser/kramdown/blank_line.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.
 #++
 #
 
@@ -24,13 +11,13 @@ module Kramdown
   module Parser
     class Kramdown
 
-      BLANK_LINE = /(?:^\s*\n)+/
+      BLANK_LINE = /(?>^\s*\n)+/
 
       # Parse the blank line at the current postition.
       def parse_blank_line
         @src.pos += @src.matched_size
-        if @tree.children.last && @tree.children.last.type == :blank
-          @tree.children.last.value << @src.matched
+        if (last_child = @tree.children.last) && last_child.type == :blank
+          last_child.value << @src.matched
         else
           @tree.children << new_block_el(:blank, @src.matched)
         end