motion-markdown-it 4.4.0 → 8.4.1

data/lib/motion-markdown-it/rules_block/paragraph.rb

@@ -10,15 +10,18 @@ module MarkdownIt
         terminatorRules = state.md.block.ruler.getRules('paragraph')
         endLine         = state.lineMax
 
+        oldParentType     = state.parentType
+        state.parentType  = 'paragraph'
+
         # jump line-by-line until empty one or EOF
         # for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
         while nextLine < endLine && !state.isEmpty(nextLine)
           # this would be a code block normally, but after paragraph
           # it's considered a lazy continuation regardless of what's there
-          (nextLine += 1) && next if (state.tShift[nextLine] - state.blkIndent > 3)
+          (nextLine += 1) and next if (state.sCount[nextLine] - state.blkIndent > 3)
 
           # quirk for blockquotes, this line should already be checked by that rule
-          (nextLine += 1) && next if state.tShift[nextLine] < 0
+          (nextLine += 1) and next if state.sCount[nextLine] < 0
 
           # Some tags can terminate paragraph without empty line.
           terminate = false
@@ -36,15 +39,17 @@ module MarkdownIt
 
         state.line = nextLine
 
-        token          = state.push('paragraph_open', 'p', 1)
-        token.map      = [ startLine, state.line ]
+        token             = state.push('paragraph_open', 'p', 1)
+        token.map         = [ startLine, state.line ]
+
+        token             = state.push('inline', '', 0)
+        token.content     = content
+        token.map         = [ startLine, state.line ]
+        token.children    = []
 
-        token          = state.push('inline', '', 0)
-        token.content  = content
-        token.map      = [ startLine, state.line ]
-        token.children = []
+        token             = state.push('paragraph_close', 'p', -1)
 
-        token          = state.push('paragraph_close', 'p', -1)
+        state.parentType  = oldParentType
 
         return true
       end

data/lib/motion-markdown-it/rules_block/reference.rb

@@ -1,10 +1,8 @@
 module MarkdownIt
   module RulesBlock
     class Reference
-      extend Helpers::ParseLinkDestination
-      extend Helpers::ParseLinkTitle
       extend Common::Utils
-      
+
       #------------------------------------------------------------------------------
       def self.reference(state, startLine, _endLine, silent)
         lines    = 0
@@ -12,7 +10,10 @@ module MarkdownIt
         max      = state.eMarks[startLine]
         nextLine = startLine + 1
 
-        return false if (state.src.charCodeAt(pos) != 0x5B) # [
+         # if it's indented more than 3 spaces, it should be a code block
+        return false if state.sCount[startLine] - state.blkIndent >= 4
+
+        return false if state.src.charCodeAt(pos) != 0x5B # [
 
         # Simple check to quickly interrupt scan on [link](url) at the start of line.
         # Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54
@@ -30,15 +31,18 @@ module MarkdownIt
         endLine = state.lineMax
 
         # jump line-by-line until empty one or EOF
-        terminatorRules = state.md.block.ruler.getRules('reference')
+        terminatorRules   = state.md.block.ruler.getRules('reference')
+
+        oldParentType     = state.parentType
+        state.parentType  = 'reference'
 
         while nextLine < endLine && !state.isEmpty(nextLine)
           # this would be a code block normally, but after paragraph
           # it's considered a lazy continuation regardless of what's there
-          (nextLine += 1) && next if (state.tShift[nextLine] - state.blkIndent > 3)
+          (nextLine += 1) and next if (state.sCount[nextLine] - state.blkIndent > 3)
 
           # quirk for blockquotes, this line should already be checked by that rule
-          (nextLine += 1) && next if state.tShift[nextLine] < 0
+          (nextLine += 1) and next if state.sCount[nextLine] < 0
 
           # Some tags can terminate paragraph without empty line.
           terminate = false
@@ -59,7 +63,7 @@ module MarkdownIt
         pos = 1
         while pos < max
           ch = str.charCodeAt(pos)
-          if (ch == 0x5B ) # [ 
+          if (ch == 0x5B ) # [
             return false
           elsif (ch == 0x5D) # ]
             labelEnd = pos
@@ -84,7 +88,7 @@ module MarkdownIt
           ch = str.charCodeAt(pos)
           if (ch == 0x0A)
             lines += 1
-          elsif (ch == 0x20)
+          elsif isSpace(ch)
           else
             break
           end
@@ -93,7 +97,7 @@ module MarkdownIt
 
         # [label]:   destination   'title'
         #            ^^^^^^^^^^^ parse this
-        res = parseLinkDestination(str, pos, max)
+        res = state.md.helpers.parseLinkDestination(str, pos, max)
         return false if (!res[:ok])
 
         href = state.md.normalizeLink.call(res[:str])
@@ -113,7 +117,7 @@ module MarkdownIt
           ch = str.charCodeAt(pos)
           if (ch == 0x0A)
             lines += 1
-          elsif (ch == 0x20)
+          elsif isSpace(ch)
           else
             break
           end
@@ -122,7 +126,7 @@ module MarkdownIt
 
         # [label]:   destination   'title'
         #                          ^^^^^^^ parse this
-        res = parseLinkTitle(str, pos, max)
+        res = state.md.helpers.parseLinkTitle(str, pos, max)
         if (pos < max && start != pos && res[:ok])
           title  = res[:str]
           pos    = res[:pos]
@@ -134,7 +138,9 @@ module MarkdownIt
         end
 
         # skip trailing spaces until the rest of the line
-        while (pos < max && str.charCodeAt(pos) == 0x20)  # space
+        while pos < max
+          ch = str.charCodeAt(pos)
+          break if !isSpace(ch)
           pos += 1
         end
 
@@ -145,7 +151,9 @@ module MarkdownIt
             title = ''
             pos = destEndPos
             lines = destEndLineNo
-            while (pos < max && str.charCodeAt(pos) == 0x20)  # space
+            while pos < max
+              ch = str.charCodeAt(pos)
+              break if !isSpace(ch)
               pos += 1
             end
           end
@@ -173,6 +181,8 @@ module MarkdownIt
           state.env[:references][label] = { title: title, href: href }
         end
 
+        state.parentType = oldParentType
+
         state.line = startLine + lines + 1
         return true
       end

data/lib/motion-markdown-it/rules_block/state_block.rb

@@ -3,11 +3,12 @@
 module MarkdownIt
   module RulesBlock
     class StateBlock
+      include MarkdownIt::Common::Utils
 
-      attr_accessor     :src, :md, :env, :tokens, :bMarks, :eMarks, :tShift
+      attr_accessor     :src, :md, :env, :tokens, :bMarks, :eMarks, :tShift, :sCount, :bsCount
       attr_accessor     :blkIndent, :line, :lineMax, :tight, :parentType, :ddIndent
       attr_accessor     :level, :result
-      
+
       #------------------------------------------------------------------------------
       def initialize(src, md, env, tokens)
         @src = src
@@ -22,7 +23,20 @@ module MarkdownIt
 
         @bMarks = []  # line begin offsets for fast jumps
         @eMarks = []  # line end offsets for fast jumps
-        @tShift = []  # indent for each line
+        @tShift = []  # offsets of the first non-space characters (tabs not expanded)
+        @sCount = []  # indents for each line (tabs expanded)
+
+        # An amount of virtual spaces (tabs expanded) between beginning
+        # of each line (bMarks) and real beginning of that line.
+        #
+        # It exists only as a hack because blockquotes override bMarks
+        # losing information in the process.
+        #
+        # It's used only when expanding tabs, you can think about it as
+        # an initial tab length, e.g. bsCount=21 applied to string `\t123`
+        # means first tab should be expanded to 4-21%4 === 3 spaces.
+        #
+        @bsCount    = []
 
         # block parser variables
         @blkIndent  = 0       # required block content indent (for example, if we are in list)
@@ -32,6 +46,10 @@ module MarkdownIt
         @parentType = 'root'  # if `list`, block parser stops on two newlines
         @ddIndent   = -1      # indent of the current dd block (-1 if there isn't any)
 
+        # can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'
+        # used in lists to determine if they interrupt a paragraph
+        @parentType = 'root'
+
         @level = 0
 
         # renderer
@@ -40,20 +58,23 @@ module MarkdownIt
         # Create caches
         # Generate markers.
         s            = @src
-        indent       = 0
         indent_found = false
 
-        start = pos = indent = 0
+        start = pos = indent = offset = 0
         len = s.length
-        start.upto(len - 1) do |pos|
-        # !!!!!!
-        # for (start = pos = indent = 0, len = s.length pos < len pos++) {
+        while pos < len
           ch = s.charCodeAt(pos)
 
           if !indent_found
-            if ch == 0x20  # space
+            if isSpace(ch)
               indent += 1
-              next
+
+              if ch == 0x09
+                offset += 4 - offset % 4
+              else
+                offset += 1
+              end
+              (pos += 1) and next
             else
               indent_found = true
             end
@@ -64,17 +85,24 @@ module MarkdownIt
             @bMarks.push(start)
             @eMarks.push(pos)
             @tShift.push(indent)
+            @sCount.push(offset)
+            @bsCount.push(0)
 
             indent_found = false
             indent       = 0
+            offset       = 0
             start        = pos + 1
           end
+
+          pos += 1
         end
 
         # Push fake entry to simplify cache bounds checks
         @bMarks.push(s.length)
         @eMarks.push(s.length)
         @tShift.push(0)
+        @sCount.push(0)
+        @bsCount.push(0)
 
         @lineMax = @bMarks.length - 1 # don't count last fake line
       end
@@ -112,12 +140,24 @@ module MarkdownIt
       def skipSpaces(pos)
         max = @src.length
         while pos < max
-          break if @src.charCodeAt(pos) != 0x20 # space
+          ch = @src.charCodeAt(pos)
+          break if !isSpace(ch)
           pos += 1
         end
         return pos
       end
 
+      # Skip spaces from given position in reverse.
+      #------------------------------------------------------------------------------
+      def skipSpacesBack(pos, min)
+        return pos if pos <= min
+
+        while (pos > min)
+          return pos + 1 if !isSpace(@src.charCodeAt(pos -= 1))
+        end
+        return pos
+      end
+
       # Skip char codes from given position
       #------------------------------------------------------------------------------
       def skipChars(pos, code)
@@ -147,22 +187,12 @@ module MarkdownIt
 
         return '' if line_begin >= line_end
 
-        # Opt: don't use push queue for single line
-        if (line + 1) == line_end
-          first = @bMarks[line] + [@tShift[line], indent].min
-          last  = @eMarks[line_end - 1] + (keepLastLF ? 1 : 0)
-          return @src.slice(first...last)
-        end
-
         queue = Array.new(line_end - line_begin)
 
         i = 0
         while line < line_end
-          shift = @tShift[line]
-          shift = indent if shift > indent
-          shift = 0 if shift < 0
-
-          first = @bMarks[line] + shift
+          lineIndent = 0
+          lineStart = first = @bMarks[line]
 
           if line + 1 < line_end || keepLastLF
             # No need for bounds check because we have fake entry on tail.
@@ -171,7 +201,32 @@ module MarkdownIt
             last = @eMarks[line]
           end
 
-          queue[i] = @src.slice(first...last)
+          while first < last && lineIndent < indent
+            ch = @src.charCodeAt(first)
+
+            if isSpace(ch)
+              if ch === 0x09
+                lineIndent += 4 - (lineIndent + @bsCount[line]) % 4
+              else
+                lineIndent += 1
+              end
+            elsif first - lineStart < @tShift[line]
+              # patched tShift masked characters to look like spaces (blockquotes, list markers)
+              lineIndent += 1
+            else
+              break
+            end
+
+            first += 1
+          end
+
+          if lineIndent > indent
+            # partially expanding tabs in code blocks, e.g '\t\tfoobar'
+            # with indent=2 becomes '  \tfoobar'
+            queue[i] = (' ' * (lineIndent - indent)) + @src.slice(first...last)
+          else
+            queue[i] = @src.slice(first...last)
+          end
           line += 1
           i    += 1
         end

data/lib/motion-markdown-it/rules_block/table.rb

@@ -3,6 +3,7 @@
 module MarkdownIt
   module RulesBlock
     class Table
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.getLine(state, line)
@@ -21,17 +22,26 @@ module MarkdownIt
         lastPos      = 0
         backTicked   = false
         lastBackTick = 0
-        
+
         ch           = str.charCodeAt(pos)
 
         while (pos < max)
-          if (ch == 0x60 && (escapes % 2 == 0))  # `
-            backTicked   = !backTicked
-            lastBackTick = pos
+          if ch == 0x60  # `
+            if (backTicked)
+              # make \` close code sequence, but not open it;
+              # the reason is: `\` is correct code block
+              backTicked = false
+              lastBackTick = pos
+            elsif escapes % 2 == 0
+              backTicked   = !backTicked
+              lastBackTick = pos
+            end
           elsif (ch == 0x7c && (escapes % 2 == 0) && !backTicked)     # '|'
             result.push(str[lastPos...pos])
             lastPos = pos + 1
-          elsif (ch == 0x5c)   # '\'
+          end
+
+          if ch == 0x5c   # '\'
             escapes += 1
           else
             escapes = 0
@@ -55,32 +65,44 @@ module MarkdownIt
 
       #------------------------------------------------------------------------------
       def self.table(state, startLine, endLine, silent)
-        # should have at least three lines
+        # should have at least two lines
         return false if (startLine + 2 > endLine)
 
         nextLine = startLine + 1
 
-        return false if (state.tShift[nextLine] < state.blkIndent)
+        return false if (state.sCount[nextLine] < state.blkIndent)
+
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if state.sCount[nextLine] - state.blkIndent >= 4
+
+        # first character of the second line should be '|', '-', ':',
+        # and no other characters are allowed but spaces;
+        # basically, this is the equivalent of /^[-:|][-:|\s]*$/ regexp
 
-        # first character of the second line should be '|' or '-'
         pos = state.bMarks[nextLine] + state.tShift[nextLine]
         return false if (pos >= state.eMarks[nextLine])
 
         ch = state.src.charCodeAt(pos)
-        return false if (ch != 0x7C && ch != 0x2D && ch != 0x3A) # != '|' && '-' && ':'
+        pos += 1
+        return false if (ch != 0x7C && ch != 0x2D && ch != 0x3A) # | or  - or :
+
+        while pos < state.eMarks[nextLine]
+          ch = state.src.charCodeAt(pos)
+          return false if (ch != 0x7C && ch != 0x2D && ch != 0x3A && !isSpace(ch)) # | or - or :
+
+          pos += 1
+        end
 
         lineText = getLine(state, startLine + 1)
-        return false if (/^[-:| ]+$/ =~ lineText).nil?
 
-        rows = lineText.split('|')
-        return false if (rows.length < 2)
+        columns = lineText.split('|')
         aligns = []
-        (0...rows.length).each do |i|
-          t = rows[i].strip
+        (0...columns.length).each do |i|
+          t = columns[i].strip
           if t.empty?
             # allow empty columns before and after table, but not in between columns
             # e.g. allow ` |---| `, disallow ` ---||--- `
-            if (i == 0 || i == rows.length - 1)
+            if (i == 0 || i == columns.length - 1)
               next
             else
               return false
@@ -99,8 +121,14 @@ module MarkdownIt
 
         lineText = getLine(state, startLine).strip
         return false if !lineText.include?('|')
-        rows = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
-        return false if (aligns.length != rows.length)
+        return false if state.sCount[startLine] - state.blkIndent >= 4
+        columns = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
+
+        # header row will define an amount of columns in the entire table,
+        # and align row shouldn't be smaller than that (the rest of the rows can)
+        columnCount = columns.length
+        return false if columnCount > aligns.length
+
         return true  if silent
 
         token     = state.push('table_open', 'table', 1)
@@ -112,7 +140,7 @@ module MarkdownIt
         token     = state.push('tr_open', 'tr', 1)
         token.map = [ startLine, startLine + 1 ]
 
-        (0...rows.length).each do |i|
+        (0...columns.length).each do |i|
           token          = state.push('th_open', 'th', 1)
           token.map      = [ startLine, startLine + 1 ]
           unless aligns[i].empty?
@@ -120,7 +148,7 @@ module MarkdownIt
           end
 
           token          = state.push('inline', '', 0)
-          token.content  = rows[i].strip
+          token.content  = columns[i].strip
           token.map      = [ startLine, startLine + 1 ]
           token.children = []
 
@@ -135,24 +163,22 @@ module MarkdownIt
 
         nextLine = startLine + 2
         while nextLine < endLine
-          break if (state.tShift[nextLine] < state.blkIndent)
+          break if (state.sCount[nextLine] < state.blkIndent)
 
           lineText = getLine(state, nextLine).strip
           break if !lineText.include?('|')
-          rows = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
-
-          # set number of columns to number of columns in header row
-          rows_length = aligns.length
+          break if state.sCount[nextLine] - state.blkIndent >= 4
+          columns = self.escapedSplit(lineText.gsub(/^\||\|$/, ''))
 
           token = state.push('tr_open', 'tr', 1)
-          (0...rows_length).each do |i|
+          (0...columnCount).each do |i|
             token          = state.push('td_open', 'td', 1)
             unless aligns[i].empty?
               token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ]
             end
 
             token          = state.push('inline', '', 0)
-            token.content  = rows[i] ? rows[i].strip : ''
+            token.content  = columns[i] ? columns[i].strip : ''
             token.children = []
 
             token          = state.push('td_close', 'td', -1)