motion-markdown-it 9.0.1 → 10.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2731c7d392eb70c89a0b583ff854d85ea277e299f86a6a3f02502427b4effdda
-  data.tar.gz: 25c49dfc9916421e4ea44878dd499c4e535e26d106f2663a594911002dd6cb21
+  metadata.gz: a7f2ac0d111cfc878b1017c5e3c32d1e9a6b9468176051937bac57f0378e5ac8
+  data.tar.gz: 13b8f19a17c53fca0f8ae6c8e373f219bb90b9e6152e7d3a9a0b1ad54c3f7c63
 SHA512:
-  metadata.gz: f8a8d408d9a62779180b1176404c6f0e2f0616e0fd45e95e068eadec6780b1eb68268cda6a4339cd188e442e276f757d5cc54faa6f94eeb18ed5ac8992cbe410
-  data.tar.gz: f6b204daacb84fb2bd888d1246aab6882810d1c85bf5444bc92a2bc1dc837f750ec42f2df6a806550ae7822f516e2ebfddecbd386ae512f57ebf6105afb53edd
+  metadata.gz: d632e566f5280d655dac450d8e5c9532dc17829ec8c40aee01c1b35df2909f55e467940e2598bf557aa8c4ee85285a0d6bb1801a28ed1ddd3c1a1767a306c9eb
+  data.tar.gz: f669a717a5d9f56c2f9d9d7669bd329610b0120a2dceeca3334eb72411184b371448d71a03ad04e4ff9d4f7c7d499750f98b091bd1415ba709011193b0fd385b

data/README.md

@@ -7,7 +7,7 @@ Ruby/RubyMotion version of Markdown-it (CommonMark compliant and extendable)
 
 This gem is a port of the [markdown-it Javascript package](https://github.com/markdown-it/markdown-it) by Vitaly Puzrin and Alex Kocharin. 
 
-_Currently synced with markdown-it 9.0.1_
+_Currently synced with markdown-it 10.0.0_
 
 ---
 
@@ -54,12 +54,15 @@ redcarpet 3.4.0             0.0065
 
 ## Table of content
 
-- [Install](#install)
-- [Usage examples](#usage-examples)
-- [Plugins](#plugins)
-- [Upgrading](#upgrading)
-- [References / Thanks](#references--thanks)
-- [License](#license)
+- [markdown-it](#markdown-it)
+  - [Install](#install)
+  - [Usage examples](#usage-examples)
+    - [Simple](#simple)
+    - [Init with presets and options](#init-with-presets-and-options)
+  - [Plugins](#plugins)
+  - [Upgrading](#upgrading)
+  - [References / Thanks](#references--thanks)
+  - [License](#license)
 
 <!--
 - [API](#api)

data/lib/motion-markdown-it/rules_core/normalize.rb

@@ -4,8 +4,9 @@ module MarkdownIt
   module RulesCore
     class Normalize
 
-      NEWLINES_RE  = /\r[\n\u0085]?|[\u2424\u2028\u0085]/
-      NULL_RE      = /\u0000/
+      # https://spec.commonmark.org/0.29/#line-ending
+      NEWLINES_RE  = /\r\n?|\n/
+      NULL_RE      = /\0/
 
       #------------------------------------------------------------------------------
       def self.normalize(state)

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

@@ -5,51 +5,104 @@ module MarkdownIt
     class BalancePairs
 
       #------------------------------------------------------------------------------
-      def self.link_pairs(state)
-        delimiters = state.delimiters
-        max = state.delimiters.length
-
-        0.upto(max - 1) do |i|
-          lastDelim = delimiters[i]
-
-          next if !lastDelim[:close]
-
-          j = i - lastDelim[:jump] - 1
-
-          while j >= 0
-            currDelim = delimiters[j]
-
-            if currDelim[:open] &&
-               currDelim[:marker] == lastDelim[:marker] &&
-               currDelim[:end] < 0 &&
-               currDelim[:level] == lastDelim[:level]
-
-              odd_match = false
-
-              # typeofs are for backward compatibility with plugins
-              # not needed:  typeof currDelim.length !== 'undefined' &&
-              #              typeof lastDelim.length !== 'undefined' &&
-              if (currDelim[:close] || lastDelim[:open])
-                # from spec:
-                # sum of the lengths [...] must not be a multiple of 3
-                # unless both lengths are multiples of 3
-                if ((currDelim[:length] + lastDelim[:length]) % 3) == 0
-                  if (currDelim[:length] % 3 != 0 || lastDelim[:length] % 3 != 0)
-                    odd_match = true
+      def self.processDelimiters(state, delimiters)
+        openersBottom = {}
+        max = delimiters.length
+        
+        0.upto(max - 1) do |closerIdx|
+          closer = delimiters[closerIdx]
+      
+          # Length is only used for emphasis-specific "rule of 3",
+          # if it's not defined (in strikethrough or 3rd party plugins),
+          # we can default it to 0 to disable those checks.
+          #
+          closer[:length] = closer[:length] || 0
+      
+          next if (!closer[:close])
+      
+          # Previously calculated lower bounds (previous fails)
+          # for each marker and each delimiter length modulo 3.
+          unless openersBottom[closer[:marker]]
+            openersBottom[closer[:marker]] = [ -1, -1, -1 ]
+          end
+      
+          minOpenerIdx = openersBottom[closer[:marker]][closer[:length] % 3]
+          newMinOpenerIdx = -1
+      
+          openerIdx = closerIdx - closer[:jump] - 1
+      
+          while openerIdx > minOpenerIdx
+            opener = delimiters[openerIdx]
+      
+            (openerIdx -= opener[:jump] + 1) && next if (opener[:marker] != closer[:marker])
+      
+            newMinOpenerIdx = openerIdx if (newMinOpenerIdx == -1)
+      
+            if (opener[:open] &&
+                opener[:end] < 0 &&
+                opener[:level] == closer[:level])
+      
+              isOddMatch = false
+      
+              # from spec:
+              #
+              # If one of the delimiters can both open and close emphasis, then the
+              # sum of the lengths of the delimiter runs containing the opening and
+              # closing delimiters must not be a multiple of 3 unless both lengths
+              # are multiples of 3.
+              #
+              if (opener[:close] || closer[:open])
+                if ((opener[:length] + closer[:length]) % 3 == 0)
+                  if (opener[:length] % 3 != 0 || closer[:length] % 3 != 0)
+                    isOddMatch = true
                   end
                 end
               end
-
-              if !odd_match
-                lastDelim[:jump] = i - j
-                lastDelim[:open] = false
-                currDelim[:end]  = i
-                currDelim[:jump] = 0
+      
+              if (!isOddMatch)
+                # If previous delimiter cannot be an opener, we can safely skip
+                # the entire sequence in future checks. This is required to make
+                # sure algorithm has linear complexity (see *_*_*_*_*_... case).
+                #
+                lastJump = openerIdx > 0 && !delimiters[openerIdx - 1][:open] ?
+                  delimiters[openerIdx - 1][:jump] + 1 : 0
+      
+                closer[:jump]  = closerIdx - openerIdx + lastJump
+                closer[:open]  = false
+                opener[:end]   = closerIdx
+                opener[:jump]  = lastJump
+                opener[:close] = false
+                newMinOpenerIdx = -1
                 break
               end
             end
+            
+            openerIdx -= opener[:jump] + 1
+          end
+      
+          if (newMinOpenerIdx != -1)
+            # If match for this delimiter run failed, we want to set lower bound for
+            # future lookups. This is required to make sure algorithm has linear
+            # complexity.
+            #
+            # See details here:
+            # https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
+            #
+            openersBottom[closer[:marker]][(closer[:length] || 0) % 3] = newMinOpenerIdx
+          end
+        end
+      end
+
+      #------------------------------------------------------------------------------
+      def self.link_pairs(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
 
-            j -= currDelim[:jump] + 1
+        processDelimiters(state, state.delimiters)
+      
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            processDelimiters(state, tokens_meta[curr][:delimiters])
           end
         end
       end

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

@@ -43,10 +43,6 @@ module MarkdownIt
             #
             token:  state.tokens.length - 1,
 
-            # Token level.
-            #
-            level:  state.level,
-
             # If this delimiter is matched as a valid opener, `end` will be
             # equal to its position, otherwise it's `-1`.
             #
@@ -65,12 +61,8 @@ module MarkdownIt
         return true
       end
 
-
-      # Walk through delimiter list and replace text tokens with tags
-      #
-      def self.postProcess(state)
-        delimiters = state.delimiters
-        max = state.delimiters.length
+      def self.private_postProcess(state, delimiters)
+        max = delimiters.length
 
         i = max - 1
         while i >= 0
@@ -119,6 +111,21 @@ module MarkdownIt
           i -= 1
         end
       end
+      
+      # Walk through delimiter list and replace text tokens with tags
+      #
+      def self.postProcess(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
+      
+        private_postProcess(state, state.delimiters)
+
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            private_postProcess(state, tokens_meta[curr][:delimiters])
+          end
+        end
+      end
     end
   end
 end

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

@@ -5,7 +5,7 @@ module MarkdownIt
     class StateInline
       include MarkdownIt::Common::Utils
 
-      attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level
+      attr_accessor   :src, :env, :md, :tokens, :pos, :posMax, :level, :tokens_meta
       attr_accessor   :pending, :pendingLevel, :cache, :delimiters
 
       #------------------------------------------------------------------------------
@@ -14,6 +14,7 @@ module MarkdownIt
         @env          = env
         @md           = md
         @tokens       = outTokens
+        @tokens_meta  = Array.new(outTokens.length)
 
         @pos          = 0
         @posMax       = @src.length
@@ -21,9 +22,15 @@ module MarkdownIt
         @pending      = ''
         @pendingLevel = 0
 
-        @cache        = {}      # Stores { start: end } pairs. Useful for backtrack
-                                # optimization of pairs parse (emphasis, strikes).
-        @delimiters   = []
+        # Stores { start: end } pairs. Useful for backtrack
+        # optimization of pairs parse (emphasis, strikes).
+        @cache = {}
+                          
+        # List of emphasis-like delimiters for current tag
+        @delimiters = []
+
+        # Stack of delimiter lists for upper level tags
+        @_prev_delimiters = [];
       end
 
 
@@ -44,13 +51,29 @@ module MarkdownIt
       def push(type, tag, nesting)
         pushPending unless @pending.empty?
 
-        token       = Token.new(type, tag, nesting);
-        @level     -= 1 if nesting < 0 # closing tag
+        token      = Token.new(type, tag, nesting)
+        token_meta = nil
+
+        if nesting < 0
+          # closing tag
+          @level -= 1 
+          @delimiters = @_prev_delimiters.pop
+        end
+
         token.level = @level
-        @level     += 1 if nesting > 0 # opening tag
+
+        if nesting > 0
+          # opening tag
+          @level += 1
+          @_prev_delimiters.push(@delimiters)
+          @delimiters = []
+          token_meta = { delimiters: @delimiters }
+        end
 
         @pendingLevel = @level
         @tokens.push(token)
+        @tokens_meta.push(token_meta)
+
         return token
       end
 

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

@@ -34,10 +34,9 @@ module MarkdownIt
 
           state.delimiters.push({
             marker: marker,
-            length: scanned[:length],
+            length: 0, # disable "rule of 3" length checks meant for emphasis
             jump:   i,
             token:  state.tokens.length - 1,
-            level:  state.level,
             end:    -1,
             open:   scanned[:can_open],
             close:  scanned[:can_close]
@@ -50,12 +49,9 @@ module MarkdownIt
         return true
       end
 
-      # Walk through delimiter list and replace text tokens with tags
-      #------------------------------------------------------------------------------
-      def self.postProcess(state)
+      def self.private_postProcess(state, delimiters)
         loneMarkers = []
-        delimiters  = state.delimiters
-        max         = state.delimiters.length
+        max         = delimiters.length
 
         0.upto(max - 1) do |i|
           startDelim = delimiters[i]
@@ -109,6 +105,21 @@ module MarkdownIt
           end
         end
       end
+
+      # Walk through delimiter list and replace text tokens with tags
+      #
+      def self.postProcess(state)
+        tokens_meta = state.tokens_meta
+        max = state.tokens_meta.length
+      
+        private_postProcess(state, state.delimiters)
+
+        0.upto(max - 1) do |curr|
+          if (tokens_meta[curr] && tokens_meta[curr][:delimiters])
+            private_postProcess(state, tokens_meta[curr][:delimiters])
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,3 +1,3 @@
 module MotionMarkdownIt
-  VERSION = '9.0.1'
+  VERSION = '10.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion-markdown-it
 version: !ruby/object:Gem::Version
-  version: 9.0.1
+  version: 10.0.0
 platform: ruby
 authors:
 - Brett Walker