motion-markdown-it 9.0.1 → 11.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2731c7d392eb70c89a0b583ff854d85ea277e299f86a6a3f02502427b4effdda
-  data.tar.gz: 25c49dfc9916421e4ea44878dd499c4e535e26d106f2663a594911002dd6cb21
+  metadata.gz: '0489d301352f960adaa9978744f1dd22181b74149760ba53056a63dc2822eb71'
+  data.tar.gz: 0267606372ae4d745d218301a5f18302ea58b7c2339439aeb79201421d203a31
 SHA512:
-  metadata.gz: f8a8d408d9a62779180b1176404c6f0e2f0616e0fd45e95e068eadec6780b1eb68268cda6a4339cd188e442e276f757d5cc54faa6f94eeb18ed5ac8992cbe410
-  data.tar.gz: f6b204daacb84fb2bd888d1246aab6882810d1c85bf5444bc92a2bc1dc837f750ec42f2df6a806550ae7822f516e2ebfddecbd386ae512f57ebf6105afb53edd
+  metadata.gz: b594bb031e89f3f422603096fbf8abc678f7fc065b69c8d8b854f4c8e8e134c38337f5d662daff09e14010951fdf056a96d5467717406e64399378087b1441c7
+  data.tar.gz: d247938869b5d43dfd772dbfb5bcf10307f404befce83dba8da65559353d22891e59b8ca811e46e6cdd1748d422de6d0c60ed18034be11af2b7d4bae58278253

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 11.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)
@@ -271,6 +274,10 @@ md = require('markdown-it')({
 });
 ```
 
+You can find all rules in sources:
+[parser_core.js](lib/parser_core.js), [parser_block](lib/parser_block.js),
+[parser_inline](lib/parser_inline.js).
+
 
 ## Benchmark
 

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

@@ -352,7 +352,7 @@ module MarkdownIt
     # MarkdownIt.configure(presets)
     #
     # Batch load of all options and compenent settings. This is internal method,
-    # and you probably will not need it. But if you with - see available presets
+    # and you probably will not need it. But if you will - see available presets
     # and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
     #
     # We strongly recommend to use presets instead of direct config loads. That
@@ -474,7 +474,7 @@ module MarkdownIt
     # - src (String): source string
     # - env (Object): environment sandbox
     #
-    # Parse input string and returns list of block tokens (special token type
+    # Parse input string and return list of block tokens (special token type
     # "inline" will contain list of inline tokens). You should not call this
     # method directly, until you write custom renderer (for example, to produce
     # AST).
@@ -542,4 +542,4 @@ module MarkdownIt
     end
 
   end
-end
+end

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_core/replacements.rb

@@ -67,10 +67,10 @@ module MarkdownIt
                           gsub(/\.{2,}/, '…').gsub(/([?!])…/, "\\1..").
                           gsub(/([?!]){4,}/, '\\1\\1\\1').gsub(/,{2,}/, ',').
                           # em-dash
-                          gsub(/(^|[^-])---([^-]|$)/m, "\\1\u2014\\2").
+                          gsub(/(^|[^-])---(?=[^-]|$)/m, "\\1\u2014").
                           # en-dash
-                          gsub(/(^|\s)--(\s|$)/m, "\\1\u2013\\2").
-                          gsub(/(^|[^-\s])--([^-\s]|$)/m, "\\1\u2013\\2")
+                          gsub(/(^|\s)--(?=\s|$)/m, "\\1\u2013").
+                          gsub(/(^|[^-\s])--(?=[^-\s]|$)/m, "\\1\u2013")
             end
           end
 

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

@@ -113,8 +113,14 @@ module MarkdownIt
             end
 
             if (canOpen && canClose)
-              # treat this as the middle of the word
-              canOpen  = false
+              # Replace quotes in the middle of punctuation sequence, but not
+              # in the middle of the words, i.e.:
+              #
+              # 1. foo " bar " baz - not replaced
+              # 2. foo-"-bar-"-baz - replaced
+              # 3. foo"bar"baz     - not replaced
+              #
+              canOpen  = isLastPunctChar
               canClose = isNextPunctChar
             end
 

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 = '11.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: 11.0.0
 platform: ruby
 authors:
 - Brett Walker