motion-kramdown 0.6.0 → 1.16.2

data/lib/kramdown/element.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -98,6 +98,10 @@ module Kramdown
   #
   # The +value+ field has to contain the content of the code block.
   #
+  # The option :lang specifies a highlighting language with possible HTML style options (e.g.
+  # php?start_inline=1) and should be used instead of a possibly also available language embedded in
+  # a class name of the form 'language-LANG'.
+  #
   #
   # === :ul
   #

data/lib/kramdown/error.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++

data/lib/kramdown/options.rb

@@ -1,13 +1,13 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
-# RM equire 'yaml'
+require 'yaml'
 
 module Kramdown
 
@@ -133,14 +133,14 @@ module Kramdown
     # - a comma separated string which is split into an array of values
     # - or an array.
     #
-    # Additionally, the array is checked for the correct size.
-    def self.simple_array_validator(val, name, size)
+    # Optionally, the array is checked for the correct size.
+    def self.simple_array_validator(val, name, size = nil)
       if String === val
         val = val.split(/,/)
       elsif !(Array === val)
         raise Kramdown::Error, "Invalid type #{val.class} for option #{name}"
       end
-      if val.size != size
+      if size && val.size != size
         raise Kramdown::Error, "Option #{name} needs exactly #{size} values"
       end
       val
@@ -473,6 +473,37 @@ EOF
       val
     end
 
+    define(:typographic_symbols, Object, {}, <<EOF) do |val|
+Defines a mapping from typographical symbol to output characters
+
+Typographical symbols are normally output using their equivalent Unicode
+codepoint. However, sometimes one wants to change the output, mostly to
+fallback to a sequence of ASCII characters.
+
+This option allows this by specifying a mapping from typographical
+symbol to its output string. For example, the mapping {hellip: ...} would
+output the standard ASCII representation of an ellipsis.
+
+The available typographical symbol names are:
+
+* hellip: ellipsis
+* mdash: em-dash
+* ndash: en-dash
+* laquo: left guillemet
+* raquo: right guillemet
+* laquo_space: left guillemet followed by a space
+* raquo_space: right guillemet preceeded by a space
+
+Default: {}
+Used by: HTML/Latex converter
+EOF
+      val = simple_hash_validator(val, :typographic_symbols)
+      val.keys.each do |k|
+        val[k.kind_of?(String) ? str_to_sym(k) : k] = val.delete(k).to_s
+      end
+      val
+    end
+
     define(:remove_block_html_tags, Boolean, true, <<EOF)
 Remove block HTML tags
 
@@ -525,7 +556,7 @@ Options for the syntax highlighter can be set with the
 syntax_highlighter_opts configuration option.
 
 Default: coderay
-Used by: HTML converter
+Used by: HTML/Latex converter
 EOF
 
     define(:syntax_highlighter_opts, Object, {}, <<EOF) do |val|
@@ -538,7 +569,7 @@ The value needs to be a hash with key-value pairs that are understood by
 the used syntax highlighter.
 
 Default: {}
-Used by: HTML converter
+Used by: HTML/Latex converter
 EOF
       val = simple_hash_validator(val, :syntax_highlighter_opts)
       val.keys.each do |k|
@@ -580,6 +611,71 @@ EOF
       val
     end
 
+    define(:footnote_backlink, String, '&#8617;', <<EOF)
+Defines the text that should be used for the footnote backlinks
+
+The footnote backlink is just text, so any special HTML characters will
+be escaped.
+
+If the footnote backlint text is an empty string, no footnote backlinks
+will be generated.
+
+Default: '&8617;'
+Used by: HTML converter
+EOF
+
+    define(:footnote_backlink_inline, Boolean, false, <<EOF)
+Specifies whether the footnote backlink should always be inline
+
+With the default of false the footnote backlink is placed at the end of
+the last paragraph if there is one, or an extra paragraph with only the
+footnote backlink is created.
+
+Setting this option to true tries to place the footnote backlink in the
+last, possibly nested paragraph or header. If this fails (e.g. in the
+case of a table), an extra paragraph with only the footnote backlink is
+created.
+
+Default: false
+Used by: HTML converter
+EOF
+
+    define(:gfm_quirks, Object, [:paragraph_end], <<EOF) do |val|
+Enables a set of GFM specific quirks
+
+The way how GFM is transformed on Github often differs from the way
+kramdown does things. Many of these differences are negligible but
+others are not.
+
+This option allows one to enable/disable certain GFM quirks, i.e. ways
+in which GFM parsing differs from kramdown parsing.
+
+The value has to be a list of quirk names that should be enabled,
+separated by commas. Possible names are:
+
+* paragraph_end
+
+  Disables the kramdown restriction that at least one blank line has to
+  be used after a paragraph before a new block element can be started.
+
+  Note that if this quirk is used, lazy line wrapping does not fully
+  work anymore!
+
+* no_auto_typographic
+
+  Disables automatic conversion of some characters into their
+  corresponding typographic symbols (like `--` to em-dash etc).
+  This helps to achieve results closer to what GitHub Flavored
+  Markdown produces.
+
+Default: paragraph_end
+Used by: GFM parser
+EOF
+      val = simple_array_validator(val, :gfm_quirks)
+      val.map! {|v| str_to_sym(v.to_s)}
+      val
+    end
+
   end
 
 end

data/lib/kramdown/parser.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++

data/lib/kramdown/parser/base.rb

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
-# RM require 'kramdown/utils'
-# RM require 'kramdown/parser'
+require 'kramdown/utils'
+require 'kramdown/parser'
 
 module Kramdown
 
@@ -89,12 +89,10 @@ module Kramdown
       # Modify the string +source+ to be usable by the parser (unifies line ending characters to
       # +\n+ and makes sure +source+ ends with a new line character).
       def adapt_source(source)
-        if source.respond_to?(:encode)
-          if !source.valid_encoding?
-            raise "The source text contains invalid characters for the used encoding #{source.encoding}"
-          end
-          source = source.encode('UTF-8')
+        unless source.valid_encoding?
+          raise "The source text contains invalid characters for the used encoding #{source.encoding}"
         end
+        source = source.encode('UTF-8')
         source.gsub(/\r\n?/, "\n").chomp + "\n"
       end
 
@@ -113,16 +111,12 @@ module Kramdown
       # method works correctly under Ruby 1.8 and Ruby 1.9.
       def extract_string(range, strscan)
         result = nil
-        if strscan.string.respond_to?(:encoding)
-          begin
-            enc = strscan.string.encoding
-            strscan.string.force_encoding('ASCII-8BIT')
-            result = strscan.string[range].force_encoding(enc)
-          ensure
-            strscan.string.force_encoding(enc)
-          end
-        else
-          result = strscan.string[range]
+        begin
+          enc = strscan.string.encoding
+          strscan.string.force_encoding('ASCII-8BIT')
+          result = strscan.string[range].force_encoding(enc)
+        ensure
+          strscan.string.force_encoding(enc)
         end
         result
       end

data/lib/kramdown/parser/gfm.rb

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 #
 #--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
 
-# RM require 'kramdown/parser'
+require 'kramdown/parser'
 
 module Kramdown
   module Parser
@@ -16,47 +16,178 @@ module Kramdown
 
       def initialize(source, options)
         super
+        @options[:auto_id_stripping] = true
+        @id_counter = Hash.new(-1)
+
         @span_parsers.delete(:line_break) if @options[:hard_wrap]
+        @span_parsers.delete(:typographic_syms) if @options[:gfm_quirks].include?(:no_auto_typographic)
+        if @options[:gfm_quirks].include?(:paragraph_end)
+          atx_header_parser = :atx_header_gfm_quirk
+          @paragraph_end = self.class::PARAGRAPH_END_GFM
+        else
+          atx_header_parser = :atx_header_gfm
+          @paragraph_end = self.class::PARAGRAPH_END
+        end
+
         {:codeblock_fenced => :codeblock_fenced_gfm,
-          :atx_header => :atx_header_gfm}.each do |current, replacement|
+          :atx_header => atx_header_parser}.each do |current, replacement|
           i = @block_parsers.index(current)
           @block_parsers.delete(current)
           @block_parsers.insert(i, replacement)
         end
+
+        i = @span_parsers.index(:escaped_chars)
+        @span_parsers[i] = :escaped_chars_gfm if i
+        @span_parsers << :strikethrough_gfm
       end
 
       def parse
         super
-        add_hard_line_breaks(@root) if @options[:hard_wrap]
+        update_elements(@root)
       end
 
-      def add_hard_line_breaks(element)
+      def update_elements(element)
         element.children.map! do |child|
-          if child.type == :text && child.value =~ /\n/
+          if child.type == :text && @options[:hard_wrap] && child.value =~ /\n/
             children = []
             lines = child.value.split(/\n/, -1)
             omit_trailing_br = (Kramdown::Element.category(element) == :block && element.children[-1] == child &&
                                 lines[-1].empty?)
             lines.each_with_index do |line, index|
-              children << Element.new(:text, (index > 0 ? "\n#{line}" : line))
-              children << Element.new(:br) if index < lines.size - 2 ||
+              new_element_options = { :location => child.options[:location] + index }
+
+              children << Element.new(:text, (index > 0 ? "\n#{line}" : line), nil, new_element_options)
+              children << Element.new(:br, nil, nil, new_element_options) if index < lines.size - 2 ||
                 (index == lines.size - 2 && !omit_trailing_br)
             end
             children
           elsif child.type == :html_element
             child
+          elsif child.type == :header && @options[:auto_ids] && !child.attr.has_key?('id')
+            child.attr['id'] = generate_gfm_header_id(child.options[:raw_text])
+            child
           else
-            add_hard_line_breaks(child)
+            update_elements(child)
             child
           end
         end.flatten!
       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 || child.type == :codespan || child.type ==:math
+            raw_text << child.value
+          elsif child.type == :entity
+            raw_text << child.value.char
+          elsif child.type == :smart_quote
+            raw_text << ::Kramdown::Utils::Entities.entity(child.value.to_s).char
+          elsif child.type == :typographic_sym
+            if child.value == :laquo_space
+              raw_text << "« "
+            elsif child.value == :raquo_space
+              raw_text << " »"
+            else
+              raw_text << ::Kramdown::Utils::Entities.entity(child.value.to_s).char
+            end
+          else
+            child.children.each {|c| append_text.call(c)}
+          end
+        end
+
+        append_text.call(item)
+        item.options[:raw_text] = raw_text
+      end
+
+      NON_WORD_RE = (RUBY_VERSION > "1.9" ? /[^\p{Word}\- \t]/ : /[^\w\- \t]/)
+
+      def generate_gfm_header_id(text)
+        result = text.downcase
+        result.gsub!(NON_WORD_RE, '')
+        result.tr!(" \t", '-')
+        @id_counter[result] += 1
+        result << (@id_counter[result] > 0 ? "-#{@id_counter[result]}" : '')
+        @options[:auto_id_prefix] + result
+      end
+
       ATX_HEADER_START = /^\#{1,6}\s/
       define_parser(:atx_header_gfm, ATX_HEADER_START, nil, 'parse_atx_header')
+      define_parser(:atx_header_gfm_quirk, ATX_HEADER_START)
+
+      # Copied from kramdown/parser/kramdown/header.rb, removed the first line
+      def parse_atx_header_gfm_quirk
+        start_line_number = @src.current_line_number
+        @src.check(ATX_HEADER_MATCH)
+        level, text, id = @src[1], @src[2].to_s.strip, @src[3]
+        return false if text.empty?
+
+        @src.pos += @src.matched_size
+        el = new_block_el(:header, nil, nil, :level => level.length, :raw_text => text, :location => start_line_number)
+        add_text(text, el)
+        el.attr['id'] = id if id
+        @tree.children << el
+        true
+      end
 
-      FENCED_CODEBLOCK_MATCH = /^(([~`]){3,})\s*?(\w+)?\s*?\n(.*?)^\1\2*\s*?\n/m
-      define_parser(:codeblock_fenced_gfm, /^[~`]{3,}/, nil, 'parse_codeblock_fenced')
+      FENCED_CODEBLOCK_START = /^[ ]{0,3}[~`]{3,}/
+      FENCED_CODEBLOCK_MATCH = /^[ ]{0,3}(([~`]){3,})\s*?((\S+?)(?:\?\S*)?)?\s*?\n(.*?)^[ ]{0,3}\1\2*\s*?\n/m
+      define_parser(:codeblock_fenced_gfm, FENCED_CODEBLOCK_START, nil, 'parse_codeblock_fenced')
+
+      STRIKETHROUGH_DELIM = /~~/
+      STRIKETHROUGH_MATCH = /#{STRIKETHROUGH_DELIM}[^\s~](.*?)[^\s~]#{STRIKETHROUGH_DELIM}/m
+      define_parser(:strikethrough_gfm, STRIKETHROUGH_MATCH, '~~')
+
+      def parse_strikethrough_gfm
+        line_number = @src.current_line_number
+
+        @src.pos += @src.matched_size
+        el = Element.new(:html_element, 'del', {}, :category => :span, :line => line_number)
+        @tree.children << el
+
+        env = save_env
+        reset_env(:src => Kramdown::Utils::StringScanner.new(@src.matched[2..-3], line_number),
+                  :text_type => :text)
+        parse_spans(el)
+        restore_env(env)
+
+        el
+      end
+
+      # To handle task-lists we override the parse method for lists, converting matching text into checkbox input
+      # elements where necessary (as well as applying classes to the ul/ol and li elements).
+      def parse_list
+        super
+        current_list = @tree.children.select{ |element| [:ul, :ol].include?(element.type) }.last
+
+        is_tasklist = false
+        box_unchecked = '<input type="checkbox" class="task-list-item-checkbox" disabled="disabled" />'
+        box_checked = '<input type="checkbox" class="task-list-item-checkbox" disabled="disabled" checked="checked" />'
+
+        current_list.children.each do |li|
+          next unless li.children.size > 0 && li.children[0].type == :p
+          # li -> p -> raw_text
+          checked = li.children[0].children[0].value.gsub!(/\A\s*\[ \]\s+/, box_unchecked)
+          unchecked = li.children[0].children[0].value.gsub!(/\A\s*\[x\]\s+/i, box_checked)
+          is_tasklist ||= (!checked.nil? || !unchecked.nil?)
+
+          li.attr['class'] = 'task-list-item' if is_tasklist
+        end
+
+        current_list.attr['class'] = 'task-list' if is_tasklist
+
+        true
+      end
+
+      ESCAPED_CHARS_GFM = /\\([\\.*_+`<>()\[\]{}#!:\|"'\$=\-~])/
+      define_parser(:escaped_chars_gfm, ESCAPED_CHARS_GFM, '\\\\', :parse_escaped_chars)
+
+      PARAGRAPH_END_GFM = /#{LAZY_END}|#{LIST_START}|#{ATX_HEADER_START}|#{DEFINITION_LIST_START}|#{BLOCKQUOTE_START}|#{FENCED_CODEBLOCK_START}/
+
+      def paragraph_end
+        @paragraph_end
+      end
 
     end
   end