motion-markdown-it 0.4.0.3.0

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

@@ -0,0 +1,54 @@
+# lheading (---, ===)
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Lheading
+
+      #------------------------------------------------------------------------------
+      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]
+
+        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.map      = [ startLine, state.line - 1 ]
+        token.children = []
+
+        token          = state.push('heading_close', "h#{level.to_s}", -1)
+        token.markup   = marker.chr
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,242 @@
+# Lists
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class List
+
+      # Search `[-+*][\n ]`, returns next pos arter marker on success
+      # or -1 on fail.
+      #------------------------------------------------------------------------------
+      def self.skipBulletListMarker(state, startLine)
+        pos = state.bMarks[startLine] + state.tShift[startLine]
+        max = state.eMarks[startLine]
+
+        marker = state.src.charCodeAt(pos)
+        pos   += 1
+        # Check bullet
+        if (marker != 0x2A && # *
+            marker != 0x2D && # -
+            marker != 0x2B)   # +
+          return -1
+        end
+
+        if (pos < max && state.src.charCodeAt(pos) != 0x20)
+          # " 1.test " - is not a list item
+          return -1
+        end
+
+        return pos
+      end
+
+      # Search `\d+[.)][\n ]`, returns next pos after marker on success
+      # or -1 on fail.
+      #------------------------------------------------------------------------------
+      def self.skipOrderedListMarker(state, startLine)
+        pos = state.bMarks[startLine] + state.tShift[startLine]
+        max = state.eMarks[startLine]
+
+        # List marker should have at least 2 chars (digit + dot)
+        return -1 if (pos + 1 >= max)
+
+        ch   = state.src.charCodeAt(pos)
+        pos += 1
+
+        return -1 if ch.nil?
+        return -1 if (ch < 0x30 || ch > 0x39) # < 0 || > 9
+
+        while true
+          # EOL -> fail
+          return -1 if (pos >= max)
+
+          ch   = state.src.charCodeAt(pos)
+          pos += 1
+
+          if (ch >= 0x30 && ch <= 0x39) #  >= 0 && <= 9
+            next
+          end
+
+          # found valid marker
+          if (ch === 0x29 || ch === 0x2e) # ')' || '.'
+            break
+          end
+
+          return -1
+        end
+
+
+        if (pos < max && state.src.charCodeAt(pos) != 0x20) # space
+          # " 1.test " - is not a list item
+          return -1
+        end
+        return pos
+      end
+
+      #------------------------------------------------------------------------------
+      def self.markTightParagraphs(state, idx)
+        level = state.level + 2
+        
+        i = idx + 2
+        l =  state.tokens.length
+        while i < l
+          if (state.tokens[i].level == level && state.tokens[i].type == 'paragraph_open')
+            state.tokens[i + 2].hidden = true
+            state.tokens[i].hidden     = true
+            i += 2
+          end
+          i += 1
+        end
+      end
+
+
+      #------------------------------------------------------------------------------
+      def self.list(state, startLine, endLine, silent)
+        tight = true
+
+        # Detect list type and position after marker
+        if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0)
+          isOrdered = true
+        elsif ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0)
+          isOrdered = false
+        else
+          return false
+        end
+
+        # We should terminate list on style change. Remember first one to compare.
+        markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
+
+        # For validation mode we can terminate immediately
+        return true if (silent)
+
+        # Start list
+        listTokIdx = state.tokens.length
+
+        if (isOrdered)
+          start       = state.bMarks[startLine] + state.tShift[startLine]
+          markerValue = state.src[start, posAfterMarker - start - 1].to_i
+          token       = state.push('ordered_list_open', 'ol', 1)
+          if (markerValue > 1)
+            token.attrs = [ [ 'start', markerValue ] ]
+          end
+
+        else
+          token       = state.push('bullet_list_open', 'ul', 1)
+        end
+
+        token.map    = listLines = [ startLine, 0 ]
+        token.markup = markerCharCode.chr
+
+        #
+        # Iterate list items
+        #
+
+        nextLine        = startLine
+        prevEmptyEnd    = false
+        terminatorRules = state.md.block.ruler.getRules('list')
+
+        while (nextLine < endLine)
+          contentStart = state.skipSpaces(posAfterMarker)
+          max          = state.eMarks[nextLine]
+
+          if (contentStart >= max)
+            # trimming space in "-    \n  3" case, indent is 1 here
+            indentAfterMarker = 1
+          else
+            indentAfterMarker = contentStart - posAfterMarker
+          end
+
+          # If we have more than 4 spaces, the indent is 1
+          # (the rest is just indented code block)
+          indentAfterMarker = 1 if (indentAfterMarker > 4)
+
+          # "  -  test"
+          #  ^^^^^ - calculating total length of this thing
+          indent = (posAfterMarker - state.bMarks[nextLine]) + indentAfterMarker
+
+          # Run subparser & write tokens
+          token        = state.push('list_item_open', 'li', 1)
+          token.markup = markerCharCode.chr
+          token.map    = itemLines = [ startLine, 0 ]
+
+          oldIndent               = state.blkIndent
+          oldTight                = state.tight
+          oldTShift               = state.tShift[startLine]
+          oldParentType           = state.parentType
+          state.tShift[startLine] = contentStart - state.bMarks[startLine]
+          state.blkIndent         = indent
+          state.tight             = true
+          state.parentType        = 'list'
+
+          state.md.block.tokenize(state, startLine, endLine, true)
+
+          # If any of list item is tight, mark list as tight
+          if (!state.tight || prevEmptyEnd)
+            tight = false
+          end
+          # Item become loose if finish with empty line,
+          # but we should filter last element, because it means list finish
+          prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1)
+
+          state.blkIndent         = oldIndent
+          state.tShift[startLine] = oldTShift
+          state.tight             = oldTight
+          state.parentType        = oldParentType
+
+          token                   = state.push('list_item_close', 'li', -1)
+          token.markup            = markerCharCode.chr
+
+          nextLine                = startLine = state.line
+          itemLines[1]            = nextLine
+          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)
+
+          # fail if terminating block found
+          terminate = false
+          (0...terminatorRules.length).each do |i|
+            if (terminatorRules[i].call(state, nextLine, endLine, true))
+              terminate = true
+              break
+            end
+          end
+          break if (terminate)
+
+          # fail if list has another type
+          if (isOrdered)
+            posAfterMarker = skipOrderedListMarker(state, nextLine)
+            break if (posAfterMarker < 0)
+          else
+            posAfterMarker = skipBulletListMarker(state, nextLine)
+            break if (posAfterMarker < 0)
+          end
+
+          break if (markerCharCode != state.src.charCodeAt(posAfterMarker - 1))
+        end
+
+        # Finilize list
+        if (isOrdered)
+          token = state.push('ordered_list_close', 'ol', -1)
+        else
+          token = state.push('bullet_list_close', 'ul', -1)
+        end
+        token.markup = markerCharCode.chr
+
+        listLines[1] = nextLine
+        state.line   = nextLine
+
+        # mark paragraphs tight if needed
+        if (tight)
+          markTightParagraphs(state, listTokIdx)
+        end
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# Paragraph
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Paragraph
+
+      #------------------------------------------------------------------------------
+      def self.paragraph(state, startLine)
+        nextLine        = startLine + 1
+        terminatorRules = state.md.block.ruler.getRules('paragraph')
+        endLine         = state.lineMax
+
+        # 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)
+
+          # Some tags can terminate paragraph without empty line.
+          terminate = false
+          0.upto(terminatorRules.length - 1) do |i|
+            if terminatorRules[i].call(state, nextLine, endLine, true)
+              terminate = true
+              break
+            end
+          end
+          break if terminate
+          nextLine += 1
+        end
+
+        content = state.getLines(startLine, nextLine, state.blkIndent, false).strip
+
+        state.line = nextLine
+
+        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('paragraph_close', 'p', -1)
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+module MarkdownIt
+  module RulesBlock
+    class Reference
+      extend Helpers::ParseLinkDestination
+      extend Helpers::ParseLinkTitle
+      extend Common::Utils
+      
+      #------------------------------------------------------------------------------
+      def self.reference(state, startLine, _endLine, silent)
+        lines    = 0
+        pos      = state.bMarks[startLine] + state.tShift[startLine]
+        max      = state.eMarks[startLine]
+        nextLine = startLine + 1
+
+        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
+        pos += 1
+        while (pos < max)
+          if (state.src.charCodeAt(pos) == 0x5D &&    # ]
+              state.src.charCodeAt(pos - 1) != 0x5C)  # \
+            return false if (pos + 1 === max)
+            return false if (state.src.charCodeAt(pos + 1) != 0x3A)  # :
+            break
+          end
+          pos += 1
+        end
+
+        endLine = state.lineMax
+
+        # jump line-by-line until empty one or EOF
+        terminatorRules = state.md.block.ruler.getRules('reference')
+
+        while nextLine < endLine && !state.isEmpty(nextLine)
+          nextLine += 1
+          # this would be a code block normally, but after paragraph
+          # it's considered a lazy continuation regardless of what's there
+          next if (state.tShift[nextLine] - state.blkIndent > 3)
+
+          # Some tags can terminate paragraph without empty line.
+          terminate = false
+          (0...terminatorRules.length).each do |i|
+            if (terminatorRules[i].call(state, nextLine, endLine, true))
+              terminate = true
+              break
+            end
+          end
+          break if (terminate)
+        end
+
+        str      = state.getLines(startLine, nextLine, state.blkIndent, false).strip
+        max      = str.length
+        labelEnd = -1
+
+        pos = 1
+        while pos < max
+          ch = str.charCodeAt(pos)
+          if (ch == 0x5B ) # [ 
+            return false
+          elsif (ch == 0x5D) # ]
+            labelEnd = pos
+            break
+          elsif (ch == 0x0A) # \n
+            lines += 1
+          elsif (ch == 0x5C) # \
+            pos += 1
+            if (pos < max && str.charCodeAt(pos) == 0x0A)
+              lines += 1
+            end
+          end
+          pos += 1
+        end
+
+        return false if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) != 0x3A) # :
+
+        # [label]:   destination   'title'
+        #         ^^^ skip optional whitespace here
+        pos = labelEnd + 2
+        while pos < max
+          ch = str.charCodeAt(pos)
+          if (ch == 0x0A)
+            lines += 1
+          elsif (ch == 0x20)
+          else
+            break
+          end
+          pos += 1
+        end
+
+        # [label]:   destination   'title'
+        #            ^^^^^^^^^^^ parse this
+        res = parseLinkDestination(str, pos, max)
+        return false if (!res[:ok])
+
+        href = state.md.normalizeLink.call(res[:str])
+        return false if (!state.md.validateLink.call(href))
+
+        pos    = res[:pos]
+        lines += res[:lines]
+
+        # save cursor state, we could require to rollback later
+        destEndPos    = pos
+        destEndLineNo = lines
+
+        # [label]:   destination   'title'
+        #                       ^^^ skipping those spaces
+        start = pos
+        while (pos < max)
+          ch = str.charCodeAt(pos)
+          if (ch == 0x0A)
+            lines += 1
+          elsif (ch == 0x20)
+          else
+            break
+          end
+          pos += 1
+        end
+
+        # [label]:   destination   'title'
+        #                          ^^^^^^^ parse this
+        res = parseLinkTitle(str, pos, max)
+        if (pos < max && start != pos && res[:ok])
+          title  = res[:str]
+          pos    = res[:pos]
+          lines += res[:lines]
+        else
+          title = ''
+          pos   = destEndPos
+          lines = destEndLineNo
+        end
+
+        # skip trailing spaces until the rest of the line
+        while (pos < max && str.charCodeAt(pos) == 0x20)  # space
+          pos += 1
+        end
+
+        if (pos < max && str.charCodeAt(pos) != 0x0A)
+          # garbage at the end of the line
+          return false
+        end
+
+        # Reference can not terminate anything. This check is for safety only.
+        # istanbul ignore if
+        return true if (silent)
+
+        label = normalizeReference(str.slice(1...labelEnd))
+        if (state.env[:references].nil?)
+          state.env[:references] = {}
+        end
+        if state.env[:references][label].nil?
+          state.env[:references][label] = { title: title, href: href }
+        end
+
+        state.line = startLine + lines + 1
+        return true
+      end
+
+    end
+  end
+end