motion-markdown-it 4.4.0 → 8.4.1

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

@@ -6,7 +6,7 @@ module MarkdownIt
 
       #------------------------------------------------------------------------------
       def self.code(state, startLine, endLine, silent = true)
-        return false if (state.tShift[startLine] - state.blkIndent < 4)
+        return false if (state.sCount[startLine] - state.blkIndent < 4)
 
         last = nextLine = startLine + 1
         while nextLine < endLine
@@ -14,7 +14,8 @@ module MarkdownIt
             nextLine += 1
             next
           end
-          if (state.tShift[nextLine] - state.blkIndent >= 4)
+
+          if (state.sCount[nextLine] - state.blkIndent >= 4)
             nextLine += 1
             last = nextLine
             next
@@ -22,7 +23,7 @@ module MarkdownIt
           break
         end
 
-        state.line    = nextLine
+        state.line    = last
 
         token         = state.push('code_block', 'code', 0)
         token.content = state.getLines(startLine, last, 4 + state.blkIndent, true)

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

@@ -3,6 +3,7 @@
 module MarkdownIt
   module RulesBlock
     class Fence
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.fence(state, startLine, endLine, silent)
@@ -10,6 +11,9 @@ module MarkdownIt
         pos           = state.bMarks[startLine] + state.tShift[startLine]
         max           = state.eMarks[startLine]
 
+        # 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 pos + 3 > max
 
         marker = state.src.charCodeAt(pos)
@@ -28,7 +32,7 @@ module MarkdownIt
         markup = state.src.slice(mem...pos)
         params = state.src.slice(pos...max)
 
-        return false if params.include?('`')
+        return false if params.include?(fromCharCode(marker))
 
         # Since start is found, we can report success here in validation mode
         return true if silent
@@ -47,7 +51,7 @@ module MarkdownIt
           pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]
           max = state.eMarks[nextLine];
 
-          if pos < max && state.tShift[nextLine] < state.blkIndent
+          if pos < max && state.sCount[nextLine] < state.blkIndent
             # non-empty line with negative indent should stop the list:
             # - ```
             #  test
@@ -56,7 +60,7 @@ module MarkdownIt
 
           next if state.src.charCodeAt(pos) != marker
 
-          if state.tShift[nextLine] - state.blkIndent >= 4
+          if state.sCount[nextLine] - state.blkIndent >= 4
             # closing fence should be indented less than 4 spaces
             next
           end
@@ -77,7 +81,8 @@ module MarkdownIt
         end
 
         # If a fence has heading spaces, they should be removed from its inner block
-        len           = state.tShift[startLine]
+        len           = state.sCount[startLine]
+
         state.line    = nextLine + (haveEndMarker ? 1 : 0)
 
         token         = state.push('fence', 'code', 0)

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

@@ -3,11 +3,16 @@
 module MarkdownIt
   module RulesBlock
     class Heading
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.heading(state, startLine, endLine, silent)
         pos = state.bMarks[startLine] + state.tShift[startLine]
         max = state.eMarks[startLine]
+
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if state.sCount[startLine] - state.blkIndent >= 4
+
         ch  = state.src.charCodeAt(pos)
 
         return false if (ch != 0x23 || pos >= max)
@@ -22,15 +27,15 @@ module MarkdownIt
           ch = state.src.charCodeAt(pos)
         end
 
-        return false if (level > 6 || (pos < max && ch != 0x20))  # space
+        return false if (level > 6 || (pos < max && !isSpace(ch)))
 
         return true if (silent)
 
         # Let's cut tails like '    ###  ' from the end of string
 
-        max = state.skipCharsBack(max, 0x20, pos) # space
+        max = state.skipSpacesBack(max, pos)
         tmp = state.skipCharsBack(max, 0x23, pos) # '#'
-        if (tmp > pos && state.src.charCodeAt(tmp - 1) == 0x20)   # space
+        if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1)))
           max = tmp
         end
 

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

@@ -3,11 +3,16 @@
 module MarkdownIt
   module RulesBlock
     class Hr
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.hr(state, startLine, endLine, silent)
         pos    = state.bMarks[startLine] + state.tShift[startLine]
         max    = state.eMarks[startLine]
+
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if (state.sCount[startLine] - state.blkIndent >= 4)
+
         marker = state.src.charCodeAt(pos)
         pos   += 1
 
@@ -18,18 +23,18 @@ module MarkdownIt
           return false
         end
 
-        # markers can be mixed with spaces, but there should be at least 3 one
+        # markers can be mixed with spaces, but there should be at least 3 of them
 
         cnt = 1
         while (pos < max)
           ch   = state.src.charCodeAt(pos)
           pos += 1
-          return false if (ch != marker && ch != 0x20) # space
-          cnt += 1 if (ch == marker)
+          return false if ch != marker && !isSpace(ch)
+          cnt += 1 if ch == marker
         end
 
-        return false if (cnt < 3)
-        return true if (silent)
+        return false if cnt < 3
+        return true if silent
 
         state.line = startLine + 1
 

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

@@ -24,8 +24,11 @@ module MarkdownIt
         pos   = state.bMarks[startLine] + state.tShift[startLine]
         max   = state.eMarks[startLine]
 
+        # 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.md.options[:html]
-        return false if state.src.charCodeAt(pos) != 0x3C    # < 
+        return false if state.src.charCodeAt(pos) != 0x3C    # <
 
         lineText = state.src.slice(pos...max)
 
@@ -34,7 +37,7 @@ module MarkdownIt
           break if HTML_SEQUENCES[i][0].match(lineText)
           i += 1
         end
-        
+
         return false if i == HTML_SEQUENCES.length
 
         if silent
@@ -48,7 +51,7 @@ module MarkdownIt
         # Let's roll down till block end.
         if !HTML_SEQUENCES[i][1].match(lineText)
           while nextLine < endLine
-            break if state.tShift[nextLine] < state.blkIndent
+            break if state.sCount[nextLine] < state.blkIndent
 
             pos = state.bMarks[nextLine] + state.tShift[nextLine]
             max = state.eMarks[nextLine]

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

@@ -6,46 +6,84 @@ module MarkdownIt
 
       #------------------------------------------------------------------------------
       def self.lheading(state, startLine, endLine, silent = true)
-        nextLine = startLine + 1
-
-        return false if (nextLine >= endLine)
-        return false if (state.tShift[nextLine] < state.blkIndent)
-
-        # Scan next line
-
-        return false if (state.tShift[nextLine] - state.blkIndent > 3)
-
-        pos = state.bMarks[nextLine] + state.tShift[nextLine]
-        max = state.eMarks[nextLine]
-
-        return false if (pos >= max)
-
-        marker = state.src.charCodeAt(pos)
-
-        return false if (marker != 0x2D && marker != 0x3D) # != '-' && != '='
-
-        pos = state.skipChars(pos, marker)
-        pos = state.skipSpaces(pos)
-
-        return false if (pos < max)
-
-        pos = state.bMarks[startLine] + state.tShift[startLine]
+        nextLine        = startLine + 1
+        terminatorRules = state.md.block.ruler.getRules('paragraph')
+
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if state.sCount[startLine] - state.blkIndent >= 4
+
+        oldParentType     = state.parentType
+        state.parentType  = 'paragraph' # use paragraph to match terminatorRules
+
+        # jump line-by-line until empty one or EOF
+        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) and next if (state.sCount[nextLine] - state.blkIndent > 3)
+
+          #
+          # Check for underline in setext header
+          #
+          if state.sCount[nextLine] >= state.blkIndent
+            pos = state.bMarks[nextLine] + state.tShift[nextLine]
+            max = state.eMarks[nextLine]
+
+            if pos < max
+              marker = state.src.charCodeAt(pos)
+
+              if marker == 0x2D || marker == 0x3D # - or =
+                pos = state.skipChars(pos, marker)
+                pos = state.skipSpaces(pos)
+
+                if pos >= max
+                  level = (marker == 0x3D ? 1 : 2) # =
+                  break
+                end
+              end
+            end
+          end
+
+          # quirk for blockquotes, this line should already be checked by that rule
+          (nextLine += 1) and next if state.sCount[nextLine] < 0
+
+          # Some tags can terminate paragraph without empty line.
+          terminate = false
+          l = terminatorRules.length
+          0.upto(l - 1) do |i|
+            if terminatorRules[i].call(state, nextLine, endLine, true)
+              terminate = true
+              break
+            end
+          end
+          break if terminate
+
+          nextLine += 1
+        end
+
+        if !level
+          # Didn't find valid underline
+          return false
+        end
+
+        content = state.getLines(startLine, nextLine, state.blkIndent, false).strip
 
         state.line = nextLine + 1
-        level = (marker == 0x3D ? 1 : 2) # =
 
         token          = state.push('heading_open', "h#{level.to_s}", 1)
         token.markup   = marker.chr
         token.map      = [ startLine, state.line ]
 
         token          = state.push('inline', '', 0)
-        token.content  = state.src.slice(pos...state.eMarks[startLine]).strip
+        # token.content  = state.src.slice(pos...state.eMarks[startLine]).strip
+        token.content  = content
         token.map      = [ startLine, state.line - 1 ]
         token.children = []
 
         token          = state.push('heading_close', "h#{level.to_s}", -1)
         token.markup   = marker.chr
 
+        state.parentType = oldParentType
+
         return true
       end
 

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

@@ -3,8 +3,9 @@
 module MarkdownIt
   module RulesBlock
     class List
+      extend Common::Utils
 
-      # Search `[-+*][\n ]`, returns next pos arter marker on success
+      # Search `[-+*][\n ]`, returns next pos after marker on success
       # or -1 on fail.
       #------------------------------------------------------------------------------
       def self.skipBulletListMarker(state, startLine)
@@ -20,9 +21,13 @@ module MarkdownIt
           return -1
         end
 
-        if (pos < max && state.src.charCodeAt(pos) != 0x20)
-          # " 1.test " - is not a list item
-          return -1
+        if pos < max
+          ch = state.src.charCodeAt(pos)
+
+          if !isSpace(ch)
+            # " -test " - is not a list item
+            return -1
+          end
         end
 
         return pos
@@ -69,10 +74,13 @@ module MarkdownIt
           return -1
         end
 
+        if pos < max
+          ch = state.src.charCodeAt(pos)
 
-        if (pos < max && state.src.charCodeAt(pos) != 0x20) # space
-          # " 1.test " - is not a list item
-          return -1
+          if !isSpace(ch)
+            # " 1.test " - is not a list item
+            return -1
+          end
         end
         return pos
       end
@@ -80,7 +88,7 @@ module MarkdownIt
       #------------------------------------------------------------------------------
       def self.markTightParagraphs(state, idx)
         level = state.level + 2
-        
+
         i = idx + 2
         l =  state.tokens.length
         while i < l
@@ -93,20 +101,48 @@ module MarkdownIt
         end
       end
 
-
       #------------------------------------------------------------------------------
       def self.list(state, startLine, endLine, silent)
+        isTerminatingParagraph = false
         tight = true
 
+        # if it's indented more than 3 spaces, it should be a code block
+        return false if (state.sCount[startLine] - state.blkIndent >= 4)
+
+        # limit conditions when list can interrupt
+        # a paragraph (validation mode only)
+        if silent && state.parentType == 'paragraph'
+          # Next list item should still terminate previous list item;
+          #
+          # This code can fail if plugins use blkIndent as well as lists,
+          # but I hope the spec gets fixed long before that happens.
+          #
+          if state.tShift[startLine] >= state.blkIndent
+            isTerminatingParagraph = true
+          end
+        end
+
         # Detect list type and position after marker
         if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0)
-          isOrdered = true
+          isOrdered   = true
+          start       = state.bMarks[startLine] + state.tShift[startLine]
+          markerValue = state.src[start, posAfterMarker - start - 1].to_i
+
+          # If we're starting a new ordered list right after
+          # a paragraph, it should start with 1.
+          return false if isTerminatingParagraph && markerValue != 1
         elsif ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0)
           isOrdered = false
         else
           return false
         end
 
+        # If we're starting a new unordered list right after
+        # a paragraph, first line should not be empty.
+        if isTerminatingParagraph
+          return false if state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]
+        end
+
         # We should terminate list on style change. Remember first one to compare.
         markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
 
@@ -139,15 +175,36 @@ module MarkdownIt
         prevEmptyEnd    = false
         terminatorRules = state.md.block.ruler.getRules('list')
 
+        oldParentType    = state.parentType
+        state.parentType = 'list'
+
         while (nextLine < endLine)
-          contentStart = state.skipSpaces(posAfterMarker)
+          pos          = posAfterMarker
           max          = state.eMarks[nextLine]
 
+          initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine])
+
+          while pos < max
+            ch = state.src.charCodeAt(pos)
+
+            if ch == 0x09
+              offset += 4 - (offset + state.bsCount[nextLine]) % 4
+            elsif ch == 0x20
+              offset += 1
+            else
+              break
+            end
+
+            pos += 1
+          end
+
+          contentStart = pos
+
           if (contentStart >= max)
             # trimming space in "-    \n  3" case, indent is 1 here
             indentAfterMarker = 1
           else
-            indentAfterMarker = contentStart - posAfterMarker
+            indentAfterMarker = offset - initial
           end
 
           # If we have more than 4 spaces, the indent is 1
@@ -156,7 +213,7 @@ module MarkdownIt
 
           # "  -  test"
           #  ^^^^^ - calculating total length of this thing
-          indent = (posAfterMarker - state.bMarks[nextLine]) + indentAfterMarker
+          indent = initial + indentAfterMarker
 
           # Run subparser & write tokens
           token        = state.push('list_item_open', 'li', 1)
@@ -166,13 +223,24 @@ module MarkdownIt
           oldIndent               = state.blkIndent
           oldTight                = state.tight
           oldTShift               = state.tShift[startLine]
-          oldParentType           = state.parentType
-          state.tShift[startLine] = contentStart - state.bMarks[startLine]
+          oldLIndent              = state.sCount[startLine]
           state.blkIndent         = indent
           state.tight             = true
-          state.parentType        = 'list'
-
-          state.md.block.tokenize(state, startLine, endLine, true)
+          state.tShift[startLine] = contentStart - state.bMarks[startLine]
+          state.sCount[startLine] = offset
+
+          if contentStart >= max && state.isEmpty(startLine + 1)
+            # workaround for this case
+            # (list item is empty, list terminates before "foo"):
+            # ~~~~~~~~
+            #   -
+            #
+            #     foo
+            # ~~~~~~~~
+            state.line = [state.line + 2, endLine].min
+          else
+            state.md.block.tokenize(state, startLine, endLine, true)
+          end
 
           # If any of list item is tight, mark list as tight
           if (!state.tight || prevEmptyEnd)
@@ -184,8 +252,8 @@ module MarkdownIt
 
           state.blkIndent         = oldIndent
           state.tShift[startLine] = oldTShift
+          state.sCount[startLine] = oldLIndent
           state.tight             = oldTight
-          state.parentType        = oldParentType
 
           token                   = state.push('list_item_close', 'li', -1)
           token.markup            = markerCharCode.chr
@@ -195,12 +263,11 @@ module MarkdownIt
           contentStart            = state.bMarks[startLine]
 
           break if (nextLine >= endLine)
-          break if (state.isEmpty(nextLine))
 
           #
           # Try to check if list is terminated or continued.
           #
-          break if (state.tShift[nextLine] < state.blkIndent)
+          break if (state.sCount[nextLine] < state.blkIndent)
 
           # fail if terminating block found
           terminate = false
@@ -224,7 +291,7 @@ module MarkdownIt
           break if (markerCharCode != state.src.charCodeAt(posAfterMarker - 1))
         end
 
-        # Finilize list
+        # Finalize list
         if (isOrdered)
           token = state.push('ordered_list_close', 'ol', -1)
         else
@@ -235,6 +302,8 @@ module MarkdownIt
         listLines[1] = nextLine
         state.line   = nextLine
 
+        state.parentType = oldParentType
+
         # mark paragraphs tight if needed
         if (tight)
           markTightParagraphs(state, listTokIdx)