motion-markdown-it-plugins 1.0.10 → 8.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94704fbe5fa8a967bf999b985367ab32dba0486e
-  data.tar.gz: f839bf41bb8c37eb15c4ac327e9e607172d75333
+  metadata.gz: 90ee7c9cfe812b3c3a61238f5b26e77ca7675968
+  data.tar.gz: d34cc85f6c5b9c11cd7d00d252cfaacca693b071
 SHA512:
-  metadata.gz: ee8f65ccb731bde283c02f26432607e83c65b6bef7cf64b4f4f3599a81b57931ff5cc4103b7e7db38b3f339cad733ba21f69adb60650b8e2d1adcfc53fe7515e
-  data.tar.gz: 20dc882df2b9cc935df9ee03d4f1f4d10e4197a48f39ed7f183fa8b817aa5e8f290890da967f2d3377fb1efe6a5dc253d0999d13b4a1e12205647ea29ec62e85
+  metadata.gz: 702e8cf07a3a85b8a01ae2ca222041c4ba84165755017c21cb290137e38ca4bab00e9c6c9e9c88dfcc836c855d2d78486bfaae7bdb40da707263355b23dd83a6
+  data.tar.gz: 5eaa10dbde3ec0b172d3c357ecd2e1db17f87f2af1deb9e0b08c63393e2a73ab3b943d0de5e8d9b151c62c2da48113252b3676057df58958197853e611401c0f

data/README.md

@@ -1,6 +1,7 @@
 # motion-markdown-it-plugins
 
 [![Gem Version](https://badge.fury.io/rb/motion-markdown-it-plugins.svg)](http://badge.fury.io/rb/motion-markdown-it-plugins)
+[![Build Status](https://travis-ci.org/digitalmoksha/motion-markdown-it-plugins.svg?branch=master)](https://travis-ci.org/digitalmoksha/motion-markdown-it-plugins)
 
 Various useful plugins for use with `motion-markdown-it`. Works with Ruby and RubyMotion.
 

data/lib/motion-markdown-it-plugins/abbr/abbr.rb

@@ -6,15 +6,21 @@ include MarkdownIt::Common::Utils
 
 module MotionMarkdownItPlugins
   class Abbr
-    PUNCT_CHARS         = ' \n()[]\'".,!?-'
-    PUNCT_CAHRS_ESCAPED = PUNCT_CHARS.chars.map {|c| escapeRE(c)}.join
-    
+    # ASCII characters in Cc, Sc, Sm, Sk categories we should terminate on;
+    # you can check character classes here:
+    # http://www.unicode.org/Public/UNIDATA/UnicodeData.txt
+    OTHER_CHARS         = ' \r\n$+<=>^`|~'
+    OTHER_CHARS_ESCAPED = OTHER_CHARS.chars.map {|c| escapeRE(c)}.join
+
+    UNICODE_PUNCT_RE = UCMicro::Categories::P::REGEX
+    UNICODE_SPACE_RE = UCMicro::Categories::Z::REGEX
+
     #------------------------------------------------------------------------------
     def self.init_plugin(md)
-      md.block.ruler.before('reference', 'abbr_def', 
+      md.block.ruler.before('reference', 'abbr_def',
           lambda { |state, startLine, endLine, silent| Abbr.abbr_def(state, startLine, endLine, silent) },
           {alt: ['', 'paragraph', 'reference']})
-      md.core.ruler.after('inline', 'abbr_replace', lambda { |state| Abbr.abbr_replace(state) })
+      md.core.ruler.after('linkify', 'abbr_replace', lambda { |state| Abbr.abbr_replace(state) })
     end
 
     #------------------------------------------------------------------------------
@@ -43,12 +49,13 @@ module MotionMarkdownItPlugins
         pos += 1
       end
 
-      return false if (labelEnd < 0 || state.src.charCodeAt(labelEnd + 1) != 0x3A)  # ':'
+      return false if (labelEnd.nil? || state.src.charCodeAt(labelEnd + 1) != 0x3A)  # ':'
       return true  if (silent)
 
       label = state.src.slice(labelStart...labelEnd).gsub(/\\(.)/, '\1')
       title = state.src.slice((labelEnd + 2)...max).strip
-      return false if (title.length == 0)
+      return false if label.length == 0
+      return false if title.length == 0
 
       state.env[:abbreviations] = {} if (!state.env[:abbreviations])
       state.env[:abbreviations][label] = title if state.env[:abbreviations][label].nil?
@@ -62,14 +69,19 @@ module MotionMarkdownItPlugins
       blockTokens = state.tokens
 
       return if (!state.env[:abbreviations])
-      if (!state.env[:abbrRegExp])
-        regText = "(^|[#{PUNCT_CAHRS_ESCAPED}])("
-        regText << state.env[:abbreviations].keys.sort {|a, b| b.length <=> a.length}.map {|x| escapeRE(x)}.join('|')
-        regText << ")($|[#{PUNCT_CAHRS_ESCAPED}])"
 
-        state.env[:abbrRegExp] = Regexp.new(regText)
-      end
-      reg = state.env[:abbrRegExp]
+      regSimpleText  = '(?:'
+      regSimpleText << state.env[:abbreviations].keys.sort {|a, b| b.length <=> a.length}.map {|x| escapeRE(x)}.join('|')
+      regSimpleText << ')'
+      regSimple      = Regexp.new(regSimpleText)
+
+      regText  = "(^|#{UNICODE_PUNCT_RE}|#{UNICODE_SPACE_RE}" +
+                 "|[#{OTHER_CHARS_ESCAPED}])"
+      regText << '(' + state.env[:abbreviations].keys.sort {|a, b| b.length <=> a.length}.map {|x| escapeRE(x)}.join('|') + ')'
+      regText << "($|#{UNICODE_PUNCT_RE}|#{UNICODE_SPACE_RE}" +
+                 "|[#{OTHER_CHARS_ESCAPED}])"
+
+      reg = Regexp.new(regText)
 
       j = 0
       l = blockTokens.length
@@ -88,9 +100,13 @@ module MotionMarkdownItPlugins
           lastIndex = 0
           nodes     = []
 
+          # fast regexp run to determine whether there are any abbreviated words
+          # in the current token
+          i -= 1 and next if !(regSimple =~ text)
+
           while ((m = reg.match(text, lastIndex)))
             lastIndex = m.end(0)
-            if (lastIndex > pos)
+            if m.begin(0) > 0 || m[1]
               token         = MarkdownIt::Token.new('text', '', 0)
               token.content = text.slice(pos...(m.begin(0) + m[1].length))
               nodes.push(token)
@@ -107,7 +123,8 @@ module MotionMarkdownItPlugins
             token         = MarkdownIt::Token.new('abbr_close', 'abbr', -1)
             nodes.push(token)
 
-            pos = lastIndex - m[3].length
+            lastIndex -= m[3].length
+            pos        = lastIndex
           end
 
           i -= 1 and next if nodes.empty?

data/lib/motion-markdown-it-plugins/container/container.rb

@@ -8,11 +8,11 @@ module MotionMarkdownItPlugins
     extend MarkdownIt::Common::Utils
 
     attr_accessor   :render
-    
+
     #------------------------------------------------------------------------------
     def self.init_plugin(md, name, options = {})
       container_obj = Container.new(md, name, options)
-      md.block.ruler.before('fence', "container_#{name}", 
+      md.block.ruler.before('fence', "container_#{name}",
           lambda { |state, startLine, endLine, silent| container_obj.container(state, startLine, endLine, silent) },
           {alt: [ '', 'paragraph', 'reference', 'blockquote', 'list' ]})
 
@@ -71,6 +71,7 @@ module MotionMarkdownItPlugins
 
       markup = state.src.slice(start...pos)
       params = state.src.slice(pos...max)
+
       return false if (!@validate.call(params))
 
       # Since start is found, we can report success here in validation mode
@@ -90,7 +91,7 @@ module MotionMarkdownItPlugins
         start = state.bMarks[nextLine] + state.tShift[nextLine]
         max   = state.eMarks[nextLine]
 
-        if (start < max && state.tShift[nextLine] < state.blkIndent)
+        if (start < max && state.sCount[nextLine] < state.blkIndent)
           # non-empty line with negative indent should stop the list:
           # - ```
           #  test
@@ -99,7 +100,7 @@ module MotionMarkdownItPlugins
 
         next if (@marker_char != state.src.charCodeAt(start))
 
-        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

data/lib/motion-markdown-it-plugins/deflist/deflist.rb

@@ -9,7 +9,7 @@ module MotionMarkdownItPlugins
 
     #------------------------------------------------------------------------------
     def self.init_plugin(md)
-      md.block.ruler.before('paragraph', 'deflist', 
+      md.block.ruler.before('paragraph', 'deflist',
           lambda { |state, startLine, endLine, silent| Deflist.deflist(state, startLine, endLine, silent) },
           {alt: ['', 'paragraph', 'reference']})
     end
@@ -36,7 +36,7 @@ module MotionMarkdownItPlugins
       # no empty definitions, e.g. "  : "
       return -1 if (pos >= max)
 
-      return pos
+      return start
     end
 
     #------------------------------------------------------------------------------
@@ -63,21 +63,27 @@ module MotionMarkdownItPlugins
       end
 
       nextLine = startLine + 1
-      if (state.isEmpty(nextLine))
+      return false if nextLine >= endLine
+
+      if state.isEmpty(nextLine)
         nextLine += 1
-        return false if (nextLine > endLine)
+        return false if nextLine >= endLine
       end
 
-      return false if (state.tShift[nextLine] < state.blkIndent)
+      return false if (state.sCount[nextLine] < state.blkIndent)
       contentStart = skipMarker(state, nextLine)
       return false if (contentStart < 0)
 
       # Start list
       listTokIdx = state.tokens.length
+      tight      = true
+
       token      = state.push('dl_open', 'dl', 1)
       token.map  = listLines = [ startLine, 0 ]
 
-      #--- Iterate list items
+      #
+      # Iterate list items
+      #
 
       dtLine = startLine
       ddLine = nextLine
@@ -90,7 +96,6 @@ module MotionMarkdownItPlugins
       # OUTER:
       while true
         break_outer    = false
-        tight          = true
         prevEmptyEnd   = false
 
         token          = state.push('dt_open', 'dt', 1)
@@ -107,13 +112,37 @@ module MotionMarkdownItPlugins
           token     = state.push('dd_open', 'dd', 1)
           token.map = itemLines = [ nextLine, 0 ]
 
+          pos    = contentStart
+          max    = state.eMarks[ddLine]
+          offset = state.sCount[ddLine] + contentStart - (state.bMarks[ddLine] + state.tShift[ddLine])
+
+          while pos < max
+            ch = state.src.charCodeAt(pos)
+
+            if isSpace(ch)
+              if ch == 0x09
+                offset += 4 - offset % 4
+              else
+                offset += 1
+              end
+            else
+              break
+            end
+
+            pos += 1
+          end
+
+          contentStart = pos
+
           oldTight             = state.tight
           oldDDIndent          = state.ddIndent
           oldIndent            = state.blkIndent
           oldTShift            = state.tShift[ddLine]
+          oldSCount            = state.sCount[ddLine]
           oldParentType        = state.parentType
-          state.blkIndent      = state.ddIndent = state.tShift[ddLine] + 2
+          state.blkIndent      = state.ddIndent = state.sCount[ddLine] + 2
           state.tShift[ddLine] = contentStart - state.bMarks[ddLine]
+          state.sCount[ddLine] = offset
           state.tight          = true
           state.parentType     = 'deflist'
 
@@ -128,6 +157,7 @@ module MotionMarkdownItPlugins
           prevEmptyEnd = (state.line - ddLine) > 1 && state.isEmpty(state.line - 1)
 
           state.tShift[ddLine] = oldTShift
+          state.sCount[ddLine] = oldSCount
           state.tight          = oldTight
           state.parentType     = oldParentType
           state.blkIndent      = oldIndent
@@ -138,7 +168,7 @@ module MotionMarkdownItPlugins
           itemLines[1] = nextLine = state.line
 
           break_outer = true and break if (nextLine >= endLine)
-          break_outer = true and break if (state.tShift[nextLine] < state.blkIndent)
+          break_outer = true and break if (state.sCount[nextLine] < state.blkIndent)
           contentStart = skipMarker(state, nextLine)
           break if (contentStart < 0)
 
@@ -148,19 +178,19 @@ module MotionMarkdownItPlugins
           # insert DD tag and repeat checking
         end
         break if break_outer
-        
+
         break if (nextLine >= endLine)
         dtLine = nextLine
 
         break if (state.isEmpty(dtLine))
-        break if (state.tShift[dtLine] < state.blkIndent)
+        break if (state.sCount[dtLine] < state.blkIndent)
 
         ddLine = dtLine + 1
         break if (ddLine >= endLine)
         ddLine += 1 if (state.isEmpty(ddLine))
         break if (ddLine >= endLine)
 
-        break if (state.tShift[ddLine] < state.blkIndent)
+        break if (state.sCount[ddLine] < state.blkIndent)
         contentStart = skipMarker(state, ddLine)
         break if (contentStart < 0)
 
@@ -168,7 +198,7 @@ module MotionMarkdownItPlugins
         # insert DT and DD tags and repeat checking
       end
 
-      # Finilize list
+      # Finalize list
       token        = state.push('dl_close', 'dl', -1)
       listLines[1] = nextLine
       state.line   = nextLine

data/lib/motion-markdown-it-plugins/ins/ins.rb

@@ -7,130 +7,117 @@ module MotionMarkdownItPlugins
 
     #------------------------------------------------------------------------------
     def self.init_plugin(md)
-      md.inline.ruler.before('emphasis', 'ins', lambda { |state, silent| Ins.insert(state, silent) })
+      md.inline.ruler.before('emphasis',  'ins', lambda { |state, silent| Ins.tokenize(state, silent) })
+      md.inline.ruler2.before('emphasis', 'ins', lambda { |state| Ins.postProcess(state) })
     end
 
-    # 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 != 0x2B # +
 
-      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      = fromCharCode(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
 
-    #------------------------------------------------------------------------------
-    def self.insert(state, silent)
-      max    = state.posMax
-      start  = state.pos
-      marker = state.src.charCodeAt(start)
+    # Walk through delimiter list and replace text tokens with tags
+    #
+    def self.postProcess(state)
+      loneMarkers = []
+      delimiters  = state.delimiters
+      max         = state.delimiters.length
 
-      return false if (marker != 0x2B) # '+'
-      return false if (silent)  # don't run any pairs in validation mode
+      i = 0
+      while i < max
+        startDelim = delimiters[i]
 
-      res        = scanDelims(state, start)
-      startCount = res[:delims]
+        (i += 1) and next if startDelim[:marker] != 0x2B # +
 
-      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
+        (i += 1) and next if startDelim[:end] == -1
 
-      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
+        endDelim      = delimiters[startDelim[:end]]
 
-        state.md.inline.skipToken(state)
-      end
+        token         = state.tokens[startDelim[:token]]
+        token.type    = 'ins_open'
+        token.tag     = 'ins'
+        token.nesting = 1
+        token.markup  = '++'
+        token.content = ''
 
-      if (!found)
-        # parser failed to find ending tag, so it's not valid emphasis
-        state.pos = start
-        return false
-      end
+        token         = state.tokens[endDelim[:token]]
+        token.type    = 'ins_close'
+        token.tag     = 'ins'
+        token.nesting = -1
+        token.markup  = '++'
+        token.content = ''
 
-      # found!
-      state.posMax = state.pos
-      state.pos    = start + 2
+        if (state.tokens[endDelim[:token] - 1].type == 'text' &&
+            state.tokens[endDelim[:token] - 1].content == '+')
+          loneMarkers.push(endDelim[:token] - 1)
+        end
 
-      # Earlier we checked !silent, but this implementation does not need it
-      token        = state.push('ins_open', 'ins', 1)
-      token.markup = marker.chr * 2
+        i += 1
+      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 == 'ins_close'
+          j += 1
+        end
 
-      token        = state.push('ins_close', 'ins', -1);
-      token.markup = marker.chr * 2
+        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

data/lib/motion-markdown-it-plugins/mark/mark.rb

@@ -7,130 +7,117 @@ module MotionMarkdownItPlugins
 
     #------------------------------------------------------------------------------
     def self.init_plugin(md)
-      md.inline.ruler.before('emphasis', 'mark', lambda { |state, silent| Mark.mark(state, silent) })
+      md.inline.ruler.before('emphasis', 'mark', lambda { |state, silent| Mark.tokenize(state, silent) })
+      md.inline.ruler2.before('emphasis', 'mark', lambda { |state| Mark.postProcess(state) })
     end
 
-    # parse sequence of markers,
-    # "start" should point at a valid marker
+    # Insert each marker as a separate text token, and add it to delimiter list
     #------------------------------------------------------------------------------
-    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
+    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 != 0x3D # =
 
-      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  = fromCharCode(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.mark(state, silent)
-      max    = state.posMax
-      start  = state.pos
-      marker = state.src.charCodeAt(start)
-
-      return false if (marker != 0x3D) #  '='
-      return false if (silent) # don't run any pairs in validation mode
-
-      res = scanDelims(state, start)
-      startCount = res[:delims]
+    def self.postProcess(state)
+      loneMarkers = []
+      delimiters  = state.delimiters
+      max         = state.delimiters.length
+
+      i = 0
+      while i < max
+        startDelim = delimiters[i]
+
+        (i += 1) and next if startDelim[:marker] != 0x3D # =
+
+        (i += 1) and next if startDelim[:end] == -1
+
+        endDelim = delimiters[startDelim[:end]]
+
+        token         = state.tokens[startDelim[:token]]
+        token.type    = 'mark_open'
+        token.tag     = 'mark'
+        token.nesting = 1
+        token.markup  = '=='
+        token.content = ''
+
+        token         = state.tokens[endDelim[:token]]
+        token.type    = 'mark_close'
+        token.tag     = 'mark'
+        token.nesting = -1
+        token.markup  = '=='
+        token.content = ''
+
+        if (state.tokens[endDelim[:token] - 1].type == 'text' &&
+            state.tokens[endDelim[:token] - 1].content == '=')
+          loneMarkers.push(endDelim[:token] - 1)
+        end
 
-      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
+        i += 1
       end
 
-      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
+      # 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 === 'mark_close'
+          j += 1
         end
 
-        state.md.inline.skipToken(state)
-      end
+        j -= 1
 
-      if (!found)
-        # parser failed to find ending tag, so it's not valid emphasis
-        state.pos = start
-        return false
+        if i != j
+          token = state.tokens[j]
+          state.tokens[j] = state.tokens[i]
+          state.tokens[i] = token
+        end
       end
-
-      # found!
-      state.posMax = state.pos
-      state.pos    = start + 2
-
-      # Earlier we checked !silent, but this implementation does not need it
-      token        = state.push('mark_open', 'mark', 1)
-      token.markup = marker.chr * 2
-
-      state.md.inline.tokenize(state)
-
-      token        = state.push('mark_close', 'mark', -1)
-      token.markup = marker.chr * 2
-
-      state.pos    = state.posMax + 2
-      state.posMax = max
-      return true
     end
-
   end
-end
+end

data/lib/motion-markdown-it-plugins/version.rb

@@ -1,5 +1,5 @@
 module MotionMarkdownItPlugins
 
-  VERSION = '1.0.10'
+  VERSION = '8.4.1'
 
 end

data/spec/abbr/abbr_spec.rb

@@ -2,7 +2,7 @@ fixture_dir  = fixture_path('abbr/fixtures')
 
 #------------------------------------------------------------------------------
 describe 'markdown-it-abbr' do
-  md = MarkdownIt::Parser.new
+  md = MarkdownIt::Parser.new(linkify: true)
   md.use(MotionMarkdownItPlugins::Abbr)
   generate(File.join(fixture_dir, 'abbr.txt'), md)
 end

data/spec/container/api_spec.rb

@@ -1,11 +1,11 @@
 #------------------------------------------------------------------------------
 describe 'api' do
-  
+
   #------------------------------------------------------------------------------
   it 'renderer' do
     md = MarkdownIt::Parser.new
     md.use(MotionMarkdownItPlugins::Container, 'spoiler',
-      { render: lambda {|tokens, idx, _options, env, renderer| 
+      { render: lambda {|tokens, idx, _options, env, renderer|
                   tokens[idx].nesting == 1 ? "<details><summary>click me</summary>\n" : "</details>\n" }})
     res = md.render("::: spoiler\n*content*\n:::\n")
     expect(res).to eq "<details><summary>click me</summary>\n<p><em>content</em></p>\n</details>\n"
@@ -61,14 +61,21 @@ describe 'api' do
       md = MarkdownIt::Parser.new
       md.use(MotionMarkdownItPlugins::Container, 'name', {validate: lambda {|params| count += 1} })
       md.parse(":\n::\n:::\n::::\n:::::\n", {})
-      expect(count).to eq 3
+
+      # called by paragraph and lheading 3 times each
+      expect(count).to be > 0
+      expect(count % 3).to eq 0
     end
 
     #------------------------------------------------------------------------------
     it 'should not trim params' do
       md = MarkdownIt::Parser.new
-      md.use(MotionMarkdownItPlugins::Container, 'name', 
-           {validate: lambda {|params| expect(params).to eq '     name '; return 1  } })
+      md.use(MotionMarkdownItPlugins::Container, 'name',
+           {validate: lambda do |params|
+                        expect(params).to eq " \tname "
+                        return 1
+                      end
+            })
       md.parse("::: \tname \ncontent\n:::\n", {})
      end
   end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 # make sure to have `--require spec_helper` in `.rspec` to have the
 # spec_helper.rb included automatically in spec files
-require 'byebug'
-require 'benchmark'
+require 'pry-byebug'
 require 'motion-markdown-it-plugins'
 require 'testgen_helper'

data/spec/sub/sub_spec.rb

@@ -1,5 +1,10 @@
 fixture_dir  = fixture_path('sub/fixtures')
 
+# TODO: these are parsed incorrectly:
+#
+# ~~~foo~~~
+# ~~~foo~ bar~~
+
 #------------------------------------------------------------------------------
 describe 'markdown-it-sub' do
   md = MarkdownIt::Parser.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-markdown-it-plugins
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 8.4.1
 platform: ruby
 authors:
 - Brett Walker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-04 00:00:00.000000000 Z
+date: 2018-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: motion-markdown-it
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: bacon-expect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: Plugins for use with motion-markdown-it
 email: github@digitalmoksha.com
 executables: []