motion-markdown-it 0.4.0.3.0

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

@@ -0,0 +1,138 @@
+# Block quotes
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Blockquote
+
+      #------------------------------------------------------------------------------
+      def self.blockquote(state, startLine, endLine, silent)
+        pos = state.bMarks[startLine] + state.tShift[startLine]
+        max = state.eMarks[startLine]
+
+        # check the block quote marker
+        return false if state.src.charCodeAt(pos) != 0x3E # >
+        pos += 1
+        
+        # we know that it's going to be a valid blockquote,
+        # so no point trying to find the end of it in silent mode
+        return true if silent
+
+        # skip one optional space after '>'
+        pos += 1 if state.src.charCodeAt(pos) == 0x20
+
+        oldIndent               = state.blkIndent
+        state.blkIndent         = 0
+
+        oldBMarks               = [ state.bMarks[startLine] ]
+        state.bMarks[startLine] = pos
+
+        # check if we have an empty blockquote
+        pos                     = pos < max ? state.skipSpaces(pos) : pos
+        lastLineEmpty           = pos >= max
+
+        oldTShift               = [ state.tShift[startLine] ]
+        state.tShift[startLine] = pos - state.bMarks[startLine]
+
+        terminatorRules         = state.md.block.ruler.getRules('blockquote')
+
+        # Search the end of the block
+        #
+        # Block ends with either:
+        #  1. an empty line outside:
+        #     ```
+        #     > test
+        #
+        #     ```
+        #  2. an empty line inside:
+        #     ```
+        #     >
+        #     test
+        #     ```
+        #  3. another tag
+        #     ```
+        #     > test
+        #      - - -
+        #     ```
+        nextLine = startLine + 1
+        while nextLine < endLine
+          pos = state.bMarks[nextLine] + state.tShift[nextLine]
+          max = state.eMarks[nextLine]
+
+          if pos >= max
+            # Case 1: line is not inside the blockquote, and this line is empty.
+            break
+          end
+
+          if state.src.charCodeAt(pos) == 0x3E   # >
+            pos += 1
+            # This line is inside the blockquote.
+
+            # skip one optional space after '>'
+            pos += 1 if state.src.charCodeAt(pos) == 0x20
+
+            oldBMarks.push(state.bMarks[nextLine])
+            state.bMarks[nextLine] = pos
+
+            pos = pos < max ? state.skipSpaces(pos) : pos
+            lastLineEmpty = pos >= max
+
+            oldTShift.push(state.tShift[nextLine])
+            state.tShift[nextLine] = pos - state.bMarks[nextLine]
+            nextLine += 1
+            next
+          else
+            pos += 1
+          end
+
+          # Case 2: line is not inside the blockquote, and the last line was empty.
+          break if lastLineEmpty
+
+          # Case 3: another tag 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
+
+          oldBMarks.push(state.bMarks[nextLine])
+          oldTShift.push(state.tShift[nextLine])
+
+          # A negative number means that this is a paragraph continuation
+          #
+          # Any negative number will do the job here, but it's better for it
+          # to be large enough to make any bugs obvious.
+          state.tShift[nextLine] = -1337
+          nextLine += 1
+        end
+
+        oldParentType    = state.parentType
+        state.parentType = 'blockquote'
+
+        token            = state.push('blockquote_open', 'blockquote', 1)
+        token.markup     = '>'
+        token.map        = lines = [ startLine, 0 ]
+
+        state.md.block.tokenize(state, startLine, nextLine)
+
+        token            = state.push('blockquote_close', 'blockquote', -1)
+        token.markup     = '>'
+
+        state.parentType = oldParentType
+        lines[1]         = state.line
+
+        # Restore original tShift; this might not be necessary since the parser
+        # has already been here, but just to make sure we can do that.
+        (0...oldTShift.length).each do |i|
+          state.bMarks[i + startLine] = oldBMarks[i]
+          state.tShift[i + startLine] = oldTShift[i]
+        end
+        state.blkIndent = oldIndent
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# Code block (4 spaces padded)
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Code
+
+      #------------------------------------------------------------------------------
+      def self.code(state, startLine, endLine, silent = true)
+        return false if (state.tShift[startLine] - state.blkIndent < 4)
+
+        last = nextLine = startLine + 1
+        while nextLine < endLine
+          if state.isEmpty(nextLine)
+            nextLine += 1
+            next
+          end
+          if (state.tShift[nextLine] - state.blkIndent >= 4)
+            nextLine += 1
+            last = nextLine
+            next
+          end
+          break
+        end
+
+        state.line    = nextLine
+
+        token         = state.push('code_block', 'code', 0)
+        token.content = state.getLines(startLine, last, 4 + state.blkIndent, true)
+        token.map     = [ startLine, state.line ]
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# fences (``` lang, ~~~ lang)
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Fence
+
+      #------------------------------------------------------------------------------
+      def self.fence(state, startLine, endLine, silent)
+        haveEndMarker = false
+        pos           = state.bMarks[startLine] + state.tShift[startLine]
+        max           = state.eMarks[startLine]
+
+        return false if pos + 3 > max
+
+        marker = state.src.charCodeAt(pos)
+
+        if marker != 0x7E && marker != 0x60 #  != ~ && != `
+          return false
+        end
+
+        # scan marker length
+        mem = pos;
+        pos = state.skipChars(pos, marker)
+        len = pos - mem
+
+        return false if len < 3
+
+        markup = state.src.slice(mem...pos)
+        params = state.src.slice(pos...max)
+
+        return false if params.include?('`')
+
+        # Since start is found, we can report success here in validation mode
+        return true if silent
+
+        # search end of block
+        nextLine = startLine
+
+        while true
+          nextLine += 1
+          if nextLine >= endLine
+            # unclosed block should be autoclosed by end of document.
+            # also block seems to be autoclosed by end of parent
+            break
+          end
+
+          pos = mem = state.bMarks[nextLine] + state.tShift[nextLine]
+          max = state.eMarks[nextLine];
+
+          if pos < max && state.tShift[nextLine] < state.blkIndent
+            # non-empty line with negative indent should stop the list:
+            # - ```
+            #  test
+            break
+          end
+
+          next if state.src.charCodeAt(pos) != marker
+
+          if state.tShift[nextLine] - state.blkIndent >= 4
+            # closing fence should be indented less than 4 spaces
+            next
+          end
+
+          pos = state.skipChars(pos, marker)
+
+          # closing code fence must be at least as long as the opening one
+          next if pos - mem < len
+
+          # make sure tail has spaces only
+          pos = state.skipSpaces(pos)
+
+          next if pos < max
+
+          haveEndMarker = true
+          # found!
+          break
+        end
+
+        # If a fence has heading spaces, they should be removed from its inner block
+        len           = state.tShift[startLine]
+        state.line    = nextLine + (haveEndMarker ? 1 : 0)
+
+        token         = state.push('fence', 'code', 0)
+        token.info    = params
+        token.content = state.getLines(startLine + 1, nextLine, len, true)
+        token.markup  = markup
+        token.map     = [ startLine, state.line ]
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# heading (#, ##, ...)
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Heading
+
+      #------------------------------------------------------------------------------
+      def self.heading(state, startLine, endLine, silent)
+        pos = state.bMarks[startLine] + state.tShift[startLine]
+        max = state.eMarks[startLine]
+        ch  = state.src.charCodeAt(pos)
+
+        return false if (ch != 0x23 || pos >= max)
+
+        # count heading level
+        level = 1
+        pos  += 1
+        ch = state.src.charCodeAt(pos)
+        while (ch == 0x23 && pos < max && level <= 6)  # '#'
+          level += 1
+          pos   += 1
+          ch = state.src.charCodeAt(pos)
+        end
+
+        return false if (level > 6 || (pos < max && ch != 0x20))  # space
+
+        return true if (silent)
+
+        # Let's cut tails like '    ###  ' from the end of string
+
+        max = state.skipCharsBack(max, 0x20, pos) # space
+        tmp = state.skipCharsBack(max, 0x23, pos) # '#'
+        if (tmp > pos && state.src.charCodeAt(tmp - 1) == 0x20)   # space
+          max = tmp
+        end
+
+        state.line = startLine + 1
+
+        token          = state.push('heading_open', "h#{level.to_s}", 1)
+        token.markup   = '########'.slice(0...level)
+        token.map      = [ startLine, state.line ]
+
+        token          = state.push('inline', '', 0)
+        token.content  = state.src.slice(pos...max).strip
+        token.map      = [ startLine, state.line ]
+        token.children = []
+
+        token        = state.push('heading_close', "h#{level.to_s}", -1)
+        token.markup = '########'.slice(0...level)
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# Horizontal rule
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class Hr
+
+      #------------------------------------------------------------------------------
+      def self.hr(state, startLine, endLine, silent)
+        pos    = state.bMarks[startLine] + state.tShift[startLine]
+        max    = state.eMarks[startLine]
+        marker = state.src.charCodeAt(pos)
+        pos   += 1
+
+        # Check hr marker
+        if (marker != 0x2A &&  # *
+            marker != 0x2D &&  # -
+            marker != 0x5F)    # _
+          return false
+        end
+
+        # markers can be mixed with spaces, but there should be at least 3 one
+
+        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)
+        end
+
+        return false if (cnt < 3)
+        return true if (silent)
+
+        state.line = startLine + 1
+
+        token        = state.push('hr', 'hr', 0)
+        token.map    = [ startLine, state.line ]
+        token.markup = marker.chr * (cnt + 1)
+
+        return true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# HTML block
+#------------------------------------------------------------------------------
+module MarkdownIt
+  module RulesBlock
+    class HtmlBlock
+
+      HTML_TAG_OPEN_RE  = /^<([a-zA-Z][a-zA-Z0-9]{0,14})[\s\/>]/
+      HTML_TAG_CLOSE_RE = /^<\/([a-zA-Z][a-zA-Z0-9]{0,14})[\s>]/
+
+      #------------------------------------------------------------------------------
+      def self.isLetter(ch)
+        lc = ch | 0x20; # to lower case
+        return (lc >= 0x61) && (lc <= 0x7a)  # >= a and <= z
+      end
+
+      #------------------------------------------------------------------------------
+      def self.html_block(state, startLine, endLine, silent)
+        pos   = state.bMarks[startLine]
+        max   = state.eMarks[startLine]
+        shift = state.tShift[startLine]
+
+        pos += shift
+
+        return false if !state.md.options[:html]
+        return false if shift > 3 || (pos + 2) >= max
+        return false if state.src.charCodeAt(pos) != 0x3C    # < 
+
+        ch = state.src.charCodeAt(pos + 1)
+
+        if ch == 0x21 || ch == 0x3F #  ! or ?
+          # Directive start / comment start / processing instruction start
+          return true if silent
+
+        elsif ch == 0x2F || isLetter(ch)  # /
+
+          # Probably start or end of tag
+          if ch == 0x2F   # \
+            # closing tag
+            match = state.src.slice(pos...max).match(HTML_TAG_CLOSE_RE)
+            return false if (!match)
+          else
+            # opening tag
+            match = state.src.slice(pos...max).match(HTML_TAG_OPEN_RE)
+            return false if !match
+          end
+
+          # Make sure tag name is valid
+          return false if HTML_BLOCKS[match[1].downcase] != true
+          return true if silent
+
+        else
+          return false
+        end
+
+        # If we are here - we detected HTML block.
+        # Let's roll down till empty line (block end).
+        nextLine = startLine + 1
+        while nextLine < state.lineMax && !state.isEmpty(nextLine)
+          nextLine += 1
+        end
+
+        state.line = nextLine
+
+        token         = state.push('html_block', '', 0)
+        token.map     = [ startLine, state.line ]
+        token.content = state.getLines(startLine, nextLine, 0, true)
+
+        return true
+      end
+
+    end
+  end
+end