motion-markdown-it 4.4.0 → 8.4.1

data/lib/motion-markdown-it/rules_inline/entity.rb

@@ -4,7 +4,7 @@ module MarkdownIt
   module RulesInline
     class Entity
       extend Common::Utils
-      
+
       DIGITAL_RE = /^&#((?:x[a-f0-9]{1,8}|[0-9]{1,8}));/i
       NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i
 
@@ -33,7 +33,7 @@ module MarkdownIt
             match = state.src.slice_to_end(pos).match(NAMED_RE)
             if match
               if HTMLEntities::MAPPINGS[match[1]]
-                state.pending += HTMLEntities::MAPPINGS[match[1]].chr(Encoding::UTF_8) if !silent
+                state.pending += fromCodePoint(HTMLEntities::MAPPINGS[match[1]]) if !silent
                 state.pos     += match[0].length
                 return true
               end

data/lib/motion-markdown-it/rules_inline/escape.rb

@@ -1,8 +1,9 @@
-# Proceess escaped chars and hardbreaks
+# Process escaped chars and hardbreaks
 #------------------------------------------------------------------------------
 module MarkdownIt
   module RulesInline
     class Escape
+      extend Common::Utils
 
       ESCAPED = []
 
@@ -36,7 +37,9 @@ module MarkdownIt
 
             pos += 1
             # skip leading whitespaces from next line
-            while (pos < max && state.src.charCodeAt(pos) == 0x20)
+            while pos < max
+              ch = state.src.charCodeAt(pos)
+              break if !isSpace(ch)
               pos += 1
             end
 
@@ -49,7 +52,6 @@ module MarkdownIt
         state.pos += 1
         return true
       end
-
     end
   end
 end

data/lib/motion-markdown-it/rules_inline/image.rb

@@ -3,9 +3,6 @@
 module MarkdownIt
   module RulesInline
     class Image
-      extend Helpers::ParseLinkDestination
-      extend Helpers::ParseLinkLabel
-      extend Helpers::ParseLinkTitle
       extend Common::Utils
 
       #------------------------------------------------------------------------------
@@ -18,7 +15,7 @@ module MarkdownIt
         return false if (state.src.charCodeAt(state.pos + 1) != 0x5B) # [
 
         labelStart  = state.pos + 2
-        labelEnd    = parseLinkLabel(state, state.pos + 1, false)
+        labelEnd    = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)
 
         # parser failed to find ']', so it's not a valid link
         return false if (labelEnd < 0)
@@ -34,7 +31,7 @@ module MarkdownIt
           pos += 1
           while pos < max
             code = state.src.charCodeAt(pos)
-            break if (code != 0x20 && code != 0x0A)
+            break if (!isSpace(code) && code != 0x0A)
             pos += 1
           end
           return false if (pos >= max)
@@ -42,7 +39,7 @@ module MarkdownIt
           # [link](  <href>  "title"  )
           #          ^^^^^^ parsing link destination
           start = pos
-          res   = parseLinkDestination(state.src, pos, state.posMax)
+          res   = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
           if (res[:ok])
             href = state.md.normalizeLink.call(res[:str])
             if (state.md.validateLink.call(href))
@@ -57,13 +54,13 @@ module MarkdownIt
           start = pos
           while pos < max
             code = state.src.charCodeAt(pos)
-            break if (code != 0x20 && code != 0x0A)
+            break if (!isSpace(code) && code != 0x0A)
             pos += 1
           end
 
           # [link](  <href>  "title"  )
           #                  ^^^^^^^ parsing link title
-          res = parseLinkTitle(state.src, pos, state.posMax)
+          res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
           if (pos < max && start != pos && res[:ok])
             title = res[:str]
             pos   = res[:pos]
@@ -72,7 +69,7 @@ module MarkdownIt
             #                         ^^ skipping these spaces
             while pos < max
               code = state.src.charCodeAt(pos);
-              break if (code != 0x20 && code != 0x0A)
+              break if (!isSpace(code) && code != 0x0A)
               pos += 1
             end
           else
@@ -90,17 +87,9 @@ module MarkdownIt
           #
           return false if state.env[:references].nil?
 
-          # [foo]  [bar]
-          #      ^^ optional whitespace (can include newlines)
-          while pos < max
-            code = state.src.charCodeAt(pos)
-            break if (code != 0x20 && code != 0x0A)
-            pos += 1
-          end
-
           if (pos < max && state.src.charCodeAt(pos) == 0x5B) # [
             start = pos + 1
-            pos   = parseLinkLabel(state, pos)
+            pos   = state.md.helpers.parseLinkLabel(state, pos)
             if (pos >= 0)
               label = state.src.slice(start...pos)
               pos += 1
@@ -129,20 +118,20 @@ module MarkdownIt
         # so all that's left to do is to call tokenizer.
         #
         if (!silent)
-          state.pos    = labelStart
-          state.posMax = labelEnd
+          content = state.src.slice(labelStart...labelEnd)
 
-          newState = RulesInline::StateInline.new(
-            state.src.slice(labelStart...labelEnd),
+          state.md.inline.parse(
+            content,
             state.md,
             state.env,
             tokens = []
           )
-          newState.md.inline.tokenize(newState)
 
           token          = state.push('image', 'img', 0)
           token.attrs    = attrs = [ [ 'src', href ], [ 'alt', '' ] ]
           token.children = tokens
+          token.content  = content;
+
           unless (title.nil? || title.empty?)
             attrs.push([ 'title', title ])
           end

data/lib/motion-markdown-it/rules_inline/link.rb

@@ -3,22 +3,20 @@
 module MarkdownIt
   module RulesInline
     class Link
-      extend Helpers::ParseLinkDestination
-      extend Helpers::ParseLinkLabel
-      extend Helpers::ParseLinkTitle
       extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.link(state, silent)
-        href   = ''
-        oldPos = state.pos
-        max    = state.posMax
-        start  = state.pos
+        href            = ''
+        oldPos          = state.pos
+        max             = state.posMax
+        start           = state.pos
+        parseReference  = true
 
         return false if (state.src.charCodeAt(state.pos) != 0x5B) # [
 
         labelStart = state.pos + 1
-        labelEnd   = parseLinkLabel(state, state.pos, true)
+        labelEnd   = state.md.helpers.parseLinkLabel(state, state.pos, true)
 
         # parser failed to find ']', so it's not a valid link
         return false if (labelEnd < 0)
@@ -29,12 +27,15 @@ module MarkdownIt
           # Inline link
           #
 
+          # might have found a valid shortcut link, disable reference parsing
+          parseReference = false
+
           # [link](  <href>  "title"  )
           #        ^^ skipping these spaces
           pos += 1
           while pos < max
             code = state.src.charCodeAt(pos)
-            break if (code != 0x20 && code != 0x0A)
+            break if (!isSpace(code) && code != 0x0A)
             pos += 1
           end
           return false if (pos >= max)
@@ -42,7 +43,7 @@ module MarkdownIt
           # [link](  <href>  "title"  )
           #          ^^^^^^ parsing link destination
           start = pos
-          res   = parseLinkDestination(state.src, pos, state.posMax)
+          res   = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
           if (res[:ok])
             href = state.md.normalizeLink.call(res[:str])
             if (state.md.validateLink.call(href))
@@ -57,13 +58,13 @@ module MarkdownIt
           start = pos
           while pos < max
             code = state.src.charCodeAt(pos)
-            break if (code != 0x20 && code != 0x0A)
+            break if (!isSpace(code) && code != 0x0A)
             pos += 1
           end
 
           # [link](  <href>  "title"  )
           #                  ^^^^^^^ parsing link title
-          res = parseLinkTitle(state.src, pos, state.posMax)
+          res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
           if (pos < max && start != pos && res[:ok])
             title = res[:str]
             pos   = res[:pos]
@@ -72,7 +73,7 @@ module MarkdownIt
             #                         ^^ skipping these spaces
             while pos < max
               code = state.src.charCodeAt(pos)
-              break if (code != 0x20 && code != 0x0A)
+              break if (!isSpace(code) && code != 0x0A)
               pos += 1
             end
           else
@@ -80,27 +81,21 @@ module MarkdownIt
           end
 
           if (pos >= max || state.src.charCodeAt(pos) != 0x29) # )
-            state.pos = oldPos
-            return false
+            # parsing a valid shortcut link failed, fallback to reference
+            parseReference = true
           end
           pos += 1
-        else
+        end
+
+        if parseReference
           #
           # Link reference
           #
           return false if state.env[:references].nil?
 
-          # [foo]  [bar]
-          #      ^^ optional whitespace (can include newlines)
-          while pos < max
-            code = state.src.charCodeAt(pos);
-            break if (code != 0x20 && code != 0x0A)
-            pos += 1
-          end
-
           if (pos < max && state.src.charCodeAt(pos) == 0x5B)  # [
             start = pos + 1
-            pos   = parseLinkLabel(state, pos)
+            pos   = state.md.helpers.parseLinkLabel(state, pos)
             if (pos >= 0)
               label = state.src.slice(start...pos)
               pos += 1

data/lib/motion-markdown-it/rules_inline/newline.rb

@@ -3,6 +3,7 @@
 module MarkdownIt
   module RulesInline
     class Newline
+      extend Common::Utils
 
       #------------------------------------------------------------------------------
       def self.newline(state, silent)
@@ -34,7 +35,7 @@ module MarkdownIt
         pos += 1
 
         # skip heading spaces for next line
-        while pos < max && state.src.charCodeAt(pos) == 0x20
+        while pos < max && isSpace(state.src.charCodeAt(pos))
           pos += 1
         end
 

data/lib/motion-markdown-it/rules_inline/state_inline.rb

@@ -3,9 +3,10 @@
 module MarkdownIt
   module RulesInline
     class StateInline
+      include MarkdownIt::Common::Utils
 
       attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level
-      attr_accessor   :pending, :pendingLevel, :cache
+      attr_accessor   :pending, :pendingLevel, :cache, :delimiters
 
       #------------------------------------------------------------------------------
       def initialize(src, md, env, outTokens)
@@ -22,6 +23,7 @@ module MarkdownIt
 
         @cache        = {}      # Stores { start: end } pairs. Useful for backtrack
                                 # optimization of pairs parse (emphasis, strikes).
+        @delimiters   = []
       end
 
 
@@ -52,6 +54,63 @@ module MarkdownIt
         return token
       end
 
+      # Scan a sequence of emphasis-like markers, and determine whether
+      # it can start an emphasis sequence or end an emphasis sequence.
+      #
+      #  - start - position to scan from (it should point at a valid marker);
+      #  - canSplitWord - determine if these markers can be found inside a word
+      #------------------------------------------------------------------------------
+      def scanDelims(start, canSplitWord)
+        pos            = start
+        left_flanking  = true
+        right_flanking = true
+        max            = @posMax
+        marker         = @src.charCodeAt(start)
+
+        # treat beginning of the line as a whitespace
+        lastChar = start > 0 ? @src.charCodeAt(start - 1) : 0x20
+
+        while (pos < max && @src.charCodeAt(pos) == marker)
+          pos += 1
+        end
+
+        count = pos - start
+
+        # treat end of the line as a whitespace
+        nextChar = pos < max ? @src.charCodeAt(pos) : 0x20
+
+        isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(fromCodePoint(lastChar))
+        isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(fromCodePoint(nextChar))
+
+        isLastWhiteSpace = isWhiteSpace(lastChar)
+        isNextWhiteSpace = isWhiteSpace(nextChar)
+
+        if (isNextWhiteSpace)
+          left_flanking = false
+        elsif (isNextPunctChar)
+          if (!(isLastWhiteSpace || isLastPunctChar))
+            left_flanking = false
+          end
+        end
+
+        if isLastWhiteSpace
+          right_flanking = false
+        elsif isLastPunctChar
+          if !(isNextWhiteSpace || isNextPunctChar)
+            right_flanking = false
+          end
+        end
+
+        if !canSplitWord
+          can_open  = left_flanking  && (!right_flanking || isLastPunctChar)
+          can_close = right_flanking && (!left_flanking  || isNextPunctChar)
+        else
+          can_open  = left_flanking
+          can_close = right_flanking
+        end
+
+        return { can_open: can_open, can_close: can_close, length: count }
+      end
     end
   end
 end

data/lib/motion-markdown-it/rules_inline/strikethrough.rb

@@ -4,127 +4,111 @@ module MarkdownIt
   module RulesInline
     class Strikethrough
       extend Common::Utils
-      
-      # parse sequence of markers,
-      # "start" should point at a valid marker
-      def self.scanDelims(state, start)
-        pos       = start
-        can_open  = true
-        can_close = true
-        max       = state.posMax
-        marker    = state.src.charCodeAt(start)
-
-        # treat beginning of the line as a whitespace
-        lastChar = start > 0 ? state.src.charCodeAt(start - 1) : 0x20
-
-        while (pos < max && state.src.charCodeAt(pos) == marker)
-          pos += 1
-        end
 
-        if (pos >= max)
-          can_open = false
-        end
+      # Insert each marker as a separate text token, and add it to delimiter list
+      #------------------------------------------------------------------------------
+      def self.tokenize(state, silent)
+        start = state.pos
+        marker = state.src.charCodeAt(start)
 
-        count = pos - start
+        return false if silent
 
-        # treat end of the line as a whitespace
-        nextChar = pos < max ? state.src.charCodeAt(pos) : 0x20
+        return false if marker != 0x7E # ~
 
-        isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr(Encoding::UTF_8))
-        isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr(Encoding::UTF_8))
+        scanned = state.scanDelims(state.pos, true)
+        len     = scanned[:length]
+        ch      = fromCodePoint(marker)
 
-        isLastWhiteSpace = isWhiteSpace(lastChar)
-        isNextWhiteSpace = isWhiteSpace(nextChar)
+        return false if len < 2
 
-        if (isNextWhiteSpace)
-          can_open = false
-        elsif (isNextPunctChar)
-          if (!(isLastWhiteSpace || isLastPunctChar))
-            can_open = false
-          end
+        if len % 2 > 0
+          token         = state.push('text', '', 0)
+          token.content = ch
+          len          -= 1
         end
 
-        if (isLastWhiteSpace)
-          can_close = false
-        elsif (isLastPunctChar)
-          if (!(isNextWhiteSpace || isNextPunctChar))
-            can_close = false
-          end
+        i = 0
+        while i < len
+          token         = state.push('text', '', 0)
+          token.content = ch + ch
+
+          state.delimiters.push({
+            marker: marker,
+            length: scanned[:length],
+            jump:   i,
+            token:  state.tokens.length - 1,
+            level:  state.level,
+            end:    -1,
+            open:   scanned[:can_open],
+            close:  scanned[:can_close]
+          })
+          i += 2
         end
 
-        return { can_open: can_open, can_close: can_close, delims: count }
+        state.pos += scanned[:length]
+
+        return true
       end
 
+      # Walk through delimiter list and replace text tokens with tags
       #------------------------------------------------------------------------------
-      def self.strikethrough(state, silent)
-        max    = state.posMax
-        start  = state.pos
-        marker = state.src.charCodeAt(start)
+      def self.postProcess(state)
+        loneMarkers = []
+        delimiters  = state.delimiters
+        max         = state.delimiters.length
 
-        return false if (marker != 0x7E) # ~
-        return false if (silent)  # don't run any pairs in validation mode
+        0.upto(max - 1) do |i|
+          startDelim = delimiters[i]
 
-        res        = scanDelims(state, start)
-        startCount = res[:delims]
-        if (!res[:can_open])
-          state.pos += startCount
-          # Earlier we checked !silent, but this implementation does not need it
-          state.pending += state.src.slice(start...state.pos)
-          return true
-        end
+          next if startDelim[:marker] != 0x7E # ~
 
-        stack = (startCount / 2).floor
-        return false if (stack <= 0)
-        state.pos = start + startCount
-
-        while (state.pos < max)
-          if (state.src.charCodeAt(state.pos) == marker)
-            res      = scanDelims(state, state.pos)
-            count    = res[:delims]
-            tagCount = (count / 2).floor
-            if (res[:can_close])
-              if (tagCount >= stack)
-                state.pos += count - 2
-                found = true
-                break
-              end
-              stack     -= tagCount
-              state.pos += count
-              next
-            end
-
-            stack += tagCount if (res[:can_open])
-            state.pos += count
-            next
-          end
+          next if startDelim[:end] == -1
 
-          state.md.inline.skipToken(state)
-        end
+          endDelim = delimiters[startDelim[:end]]
 
-        if (!found)
-          # parser failed to find ending tag, so it's not valid emphasis
-          state.pos = start
-          return false
-        end
+          token         = state.tokens[startDelim[:token]]
+          token.type    = 's_open'
+          token.tag     = 's'
+          token.nesting = 1
+          token.markup  = '~~'
+          token.content = ''
 
-        # found!
-        state.posMax = state.pos
-        state.pos    = start + 2
+          token         = state.tokens[endDelim[:token]]
+          token.type    = 's_close'
+          token.tag     = 's'
+          token.nesting = -1
+          token.markup  = '~~'
+          token.content = ''
 
-        # Earlier we checked !silent, but this implementation does not need it
-        token        = state.push('s_open', 's', 1)
-        token.markup = '~~'
+          if (state.tokens[endDelim[:token] - 1].type == 'text' &&
+              state.tokens[endDelim[:token] - 1].content == '~')
+            loneMarkers.push(endDelim[:token] - 1)
+          end
+        end
 
-        state.md.inline.tokenize(state)
+        # If a marker sequence has an odd number of characters, it's splitted
+        # like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the
+        # start of the sequence.
+        #
+        # So, we have to move all those markers after subsequent s_close tags.
+        #
+        while loneMarkers.length > 0
+          i = loneMarkers.pop
+          j = i + 1
+
+          while j < state.tokens.length && state.tokens[j].type == 's_close'
+            j += 1
+          end
 
-        token        = state.push('s_close', 's', -1)
-        token.markup = '~~'
+          j -= 1
 
-        state.pos    = state.posMax + 2
-        state.posMax = max
-        return true
+          if i != j
+            token = state.tokens[j]
+            state.tokens[j] = state.tokens[i]
+            state.tokens[i] = token
+          end
+        end
       end
-
     end
   end
 end