motion-markdown-it 0.4.0.3.0 → 4.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2a9d7a4a0faddb89435b89e6fbd600ae4e515ba
-  data.tar.gz: 37bdb57d017e7ea1694134a593f8f1d8134c721b
+  metadata.gz: ff09df2d99031e399da64902f3d11648574bd646
+  data.tar.gz: f6f52c3479c1805ec267503ff12f567d7539df61
 SHA512:
-  metadata.gz: 7537b3cbd241aba33b314f8e8704d8ee6f2b6ecdf1aabd864bba0bc0ce79a478a314505771e48aaf06bf55e242ec2aded7ebec339b1badb5e93e5df0789e3f8e
-  data.tar.gz: a12889a2301c2f349378a163378b1e8e606e112233bc00b3df829a4ee0bb2cd5a101d2b3890f56d237e7dcf29def96c31bf217cc94877a9ccdc5f440b940fef0
+  metadata.gz: c145910ac522f1e62985bce82e1509fb79f6ab803d52d35886ac1c370d3e84d3bc495c4c9592b501bd25775146a505471422ff17875ac78f97ebb7f25c5518fd
+  data.tar.gz: 2d20509844c9f7d40b2702a0cb366dca3a65e8a0b2ed693b3c3c3e79b953004a460c6843a4e5d88ce415669c674d3cb3d4191302af5bd9965ae2077960700749

data/README.md

@@ -1,8 +1,10 @@
 # motion-markdown-it
 
-Markdown parser done right. Fast and easy to extend.  For use with **Ruby** and **RubyMotion**.
+[![Gem Version](https://badge.fury.io/rb/motion-markdown-it.svg)](http://badge.fury.io/rb/motion-markdown-it)
 
-This gem is a port of the [markdown-it Javascript package](https://github.com/markdown-it/markdown-it) by Vitaly Puzrin and Alex Kocharin.
+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 4.0.3
 
 __[Javascript Live demo](https://markdown-it.github.io)__
 
@@ -11,14 +13,14 @@ __[Javascript Live demo](https://markdown-it.github.io)__
 - High speed
 - Community-written plugins
 
-## Beta
-
-The gem is still a work in progress.  There are several areas to get working better, including plugins and performance.  It will track as closely as possible to fixes and enhancements in the main _markdown-it_ implementation. Currently synced with markdown-it 4.0.3
-
 ## Benefit
 
 The benefit of this project, for me at least, is to have a standardized CommonMark compliant, fast, and extendable, Markdown parser which can be used from Javascript, Ruby, and/or RubyMotion, as the development situation warrants.
 
+## Performance
+
+Performance is still an issue.  While it performs reasonably well with small to medium files, it degrades for large files.  Work in progres...
+
 ## Table of content
 
 - [Install](#install)
@@ -61,20 +63,19 @@ and run `bundle install`
 
 ```ruby
 parser = MarkdownIt::Parser.new(:commonmark, { html: false })
-parser.render('# markdown-it rulezz!')
+parser.render('# markdown-it in **Ruby**')
 ```
 
 Single line rendering, without paragraph wrap:
 
 ```ruby
-result = MarkdownIt::Parser.new.renderInline('__markdown-it__ rulezz!')
+result = MarkdownIt::Parser.new.renderInline('__markdown-it__ in Ruby')
 ```
 
 ### Init with presets and options
 
-(*) preset define combination of active rules and options. Can be
-`:commonmark`, `:zero` or `:default` (if skipped). You can refer to the 
-[markdown-it Javascript API docs](https://markdown-it.github.io/markdown-it/#MarkdownIt.new) for more details.
+(*) presets define combinations of active rules and options. Can be
+`:commonmark`, `:zero` or `:default` (if skipped).
 
 ```ruby
 #--- commonmark mode
@@ -104,8 +105,8 @@ parser = MarkdownIt::Parser.new({
   quotes: '“”‘’',
 
   # Highlighter function. Should return escaped HTML,
-  # or '' if the source string is not changed and should be escaped externaly.
-  highlight: lambda {|str, lang| return ''}
+  # or nil if the source string is not changed and should be escaped externaly.
+  highlight: lambda {|str, lang| return nil}
 })
 ```
 

data/lib/motion-markdown-it/common/simpleidn.rb

@@ -0,0 +1,268 @@
+# encoding: UTF-8
+# Borrowed from https://github.com/mmriis/simpleidn
+#------------------------------------------------------------------------------
+class Integer
+  def to_utf8_character
+    [self].pack("U*")
+  end
+end
+
+module SimpleIDN
+    
+  module Punycode
+    
+    INITIAL_N = 0x80
+    INITIAL_BIAS = 72
+    DELIMITER = 0x2D
+    BASE = 36
+    DAMP = 700
+    TMIN = 1
+    TMAX = 26
+    SKEW = 38
+    MAXINT = 0x7FFFFFFF
+
+    module_function  
+    
+    # decode_digit(cp) returns the numeric value of a basic code 
+    # point (for use in representing integers) in the range 0 to
+    # base-1, or base if cp is does not represent a value. 
+    def decode_digit(cp)
+      cp - 48 < 10 ? cp - 22 : cp - 65 < 26 ? cp - 65 : cp - 97 < 26 ? cp - 97 : BASE
+    end
+  
+    # encode_digit(d,flag) returns the basic code point whose value
+    # (when used for representing integers) is d, which needs to be in
+    # the range 0 to base-1. The lowercase form is used unless flag is
+    # nonzero, in which case the uppercase form is used. The behavior
+    # is undefined if flag is nonzero and digit d has no uppercase form. 
+    def encode_digit(d)
+      d + 22 + 75 * (d < 26 ? 1 : 0)
+      #  0..25 map to ASCII a..z or A..Z 
+      # 26..35 map to ASCII 0..9
+    end
+  
+    # Bias adaptation function
+    def adapt(delta, numpoints, firsttime)
+      delta = firsttime ? (delta / DAMP) : (delta >> 1)
+      delta += (delta / numpoints)
+
+      k = 0
+      while delta > (((BASE - TMIN) * TMAX) / 2) do
+        delta /= BASE - TMIN
+        k += BASE
+      end
+      return k + (BASE - TMIN + 1) * delta / (delta + SKEW)
+    end
+  
+    # encode_basic(bcp,flag) forces a basic code point to lowercase if flag is zero,
+    # uppercase if flag is nonzero, and returns the resulting code point.
+    # The code point is unchanged if it is caseless.
+    # The behavior is undefined if bcp is not a basic code point.
+    def encode_basic(bcp, flag)
+      bcp -= (bcp - 97 < 26 ? 1 : 0) << 5
+      return bcp + ((!flag && (bcp - 65 < 26 ? 1 : 0)) << 5)
+    end
+  
+    # Main decode
+    def decode(input)
+      output = []
+
+      # Initialize the state: 
+      n = INITIAL_N
+      i = 0
+      bias = INITIAL_BIAS
+
+      # Handle the basic code points: Let basic be the number of input code 
+      # points before the last delimiter, or 0 if there is none, then
+      # copy the first basic code points to the output.
+      basic = input.rindex(DELIMITER.to_utf8_character) || 0
+
+      input.unpack("U*")[0, basic].each do |char|
+        raise(RangeError, "Illegal input >= 0x80") if char >= 0x80
+        output << char.chr # to_utf8_character not needed her because ord < 0x80 (128) which is within US-ASCII.
+      end
+
+      # Main decoding loop: Start just after the last delimiter if any
+      # basic code points were copied; start at the beginning otherwise. 
+
+      ic = basic > 0 ? basic + 1 : 0
+      while ic < input.length do
+        # ic is the index of the next character to be consumed,
+
+        # Decode a generalized variable-length integer into delta,
+        # which gets added to i. The overflow checking is easier
+        # if we increase i as we go, then subtract off its starting 
+        # value at the end to obtain delta.
+        oldi = i
+        w = 1
+        k = BASE
+        while true do
+          raise(RangeError, "punycode_bad_input(1)") if ic >= input.length
+
+          digit = decode_digit(input[ic].ord)
+          ic += 1
+
+          raise(RangeError, "punycode_bad_input(2)") if digit >= BASE
+        
+          raise(RangeError, "punycode_overflow(1)") if digit > (MAXINT - i) / w
+
+          i += digit * w
+          t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias
+          break if digit < t
+          raise(RangeError, "punycode_overflow(2)") if w > MAXINT / (BASE - t)
+        
+          w *= BASE - t
+          k += BASE
+        end
+
+        out = output.length + 1
+        bias = adapt(i - oldi, out, oldi == 0)
+
+        # i was supposed to wrap around from out to 0,
+        # incrementing n each time, so we'll fix that now: 
+        raise(RangeError, "punycode_overflow(3)") if (i / out) > MAXINT - n
+
+        n += (i / out)
+        i %= out
+
+        # Insert n at position i of the output: 
+        output.insert(i, n.to_utf8_character)
+        i += 1
+      end
+    
+      return output.join
+    end
+
+    # Main encode function
+    def encode(input)
+
+      input = input.downcase.unpack("U*")
+      output = []
+
+      # Initialize the state: 
+      n = INITIAL_N
+      delta = 0
+      bias = INITIAL_BIAS
+
+      # Handle the basic code points: 
+      output = input.select do |char|
+        char if char < 0x80
+      end
+    
+      h = b = output.length
+
+      # h is the number of code points that have been handled, b is the
+      # number of basic code points 
+
+      output << DELIMITER if b > 0
+
+      # Main encoding loop:
+      while h < input.length do
+        # All non-basic code points < n have been
+        # handled already. Find the next larger one: 
+
+        m = MAXINT
+        
+        input.each do |char|
+          m = char if char >= n && char < m
+        end
+
+        # Increase delta enough to advance the decoder's
+        # <n,i> state to <m,0>, but guard against overflow: 
+
+        raise(RangeError, "punycode_overflow (1)") if m - n > ((MAXINT - delta) / (h + 1)).floor
+
+        delta += (m - n) * (h + 1)
+        n = m
+
+        input.each_with_index do |char, j|
+          if char < n
+            delta += 1
+            raise(StandardError,"punycode_overflow(2)") if delta > MAXINT
+          end
+
+          if (char == n)
+              # Represent delta as a generalized variable-length integer: 
+              q = delta
+              k = BASE
+              while true do
+                  t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias
+                  break if q < t
+                  output << encode_digit(t + (q - t) % (BASE - t))
+                  q = ( (q - t) / (BASE - t) ).floor
+                  k += BASE
+              end
+              output << encode_digit(q)
+              bias = adapt(delta, h + 1, h == b)
+              delta = 0
+              h += 1
+          end
+        end
+
+        delta += 1
+        n += 1
+      end
+      return output.collect {|c| c.to_utf8_character}.join
+    end
+
+  end
+  
+  module_function
+  
+  # Converts a UTF-8 unicode string to a punycode ACE string.
+  # == Example
+  #   SimpleIDN.to_ascii("møllerriis.com")
+  #    => "xn--mllerriis-l8a.com" 
+  def to_ascii(domain)
+    domain_array = domain.split(".") rescue []
+    return domain if domain_array.length == 0
+    out = []
+    i = 0
+    while i < domain_array.length
+      s = domain_array[i]
+      out << (s =~ /[^A-Z0-9\-*_]/i ? "xn--" + Punycode.encode(s) : s)
+      i += 1
+    end
+    return out.join(".")
+  end
+
+  # Converts a punycode ACE string to a UTF-8 unicode string.
+  # == Example
+  #   SimpleIDN.to_unicode("xn--mllerriis-l8a.com")
+  #    => "møllerriis.com" 
+  def to_unicode(domain)
+    domain_array = domain.split(".") rescue []
+    return domain if domain_array.length == 0
+    out = []
+    i = 0
+    while i < domain_array.length
+      s = domain_array[i]
+      out << (s =~ /^xn\-\-/i ? Punycode.decode(s.gsub('xn--','')) : s)
+      i += 1
+    end
+    return out.join(".")
+  end
+end
+
+#------------------------------------------------------------------------------
+# The MIT License
+#
+# Copyright (c) 2011-2013 Morten Møller Riis
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.

data/lib/motion-markdown-it/common/utils.rb

@@ -20,7 +20,9 @@ module MarkdownIt
       # Useful for some operations with tokens
       #------------------------------------------------------------------------------
       def arrayReplaceAt(src, pos, newElements)
-        return [].concat([src.slice(0...pos), newElements, src.slice_to_end(pos + 1)])
+        src[pos] = newElements
+        src.flatten!(1)
+        return src
       end
 
       #------------------------------------------------------------------------------
@@ -73,13 +75,6 @@ module MarkdownIt
         return match
       end
 
-      # not used
-      #------------------------------------------------------------------------------
-      # def replaceEntities(str)
-      #   return str if str.index('&').nil?
-      #   return str.gsub(ENTITY_RE, replaceEntityPattern)
-      # end
-
       #------------------------------------------------------------------------------
       def unescapeMd(str)
         return str if !str.include?('\\')
@@ -143,11 +138,7 @@ module MarkdownIt
         return false
       end
 
-      # from file uc.micro/categories/P/regex in github project
-      # https://github.com/markdown-it/uc.micro
-      # UNICODE_PUNCT_RE = /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E42\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDE38-\uDE3D]|\uD805[\uDCC6\uDDC1-\uDDC9\uDE41-\uDE43]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD82F\uDC9F/
-      # was unable to get abouve to work TODO
-      UNICODE_PUNCT_RE = /[!-#%-\*,-\/:;\?@\[-\]_\{\}]/
+      UNICODE_PUNCT_RE = UCMicro::Categories::P::REGEX
 
       # Currently without astral characters support.
       #------------------------------------------------------------------------------

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

@@ -7,18 +7,21 @@ CONFIG = {
   commonmark: MarkdownIt::Presets::Commonmark.options
 }
 
+#------------------------------------------------------------------------------
+# This validator does not pretend to functionality of full weight sanitizers.
+# It's a tradeoff between default security, simplicity and usability.
+# If you need different setup - override validator method as you wish. Or
+# replace it with dummy function and use external sanitizer.
 
-BAD_PROTOCOLS    = [ 'vbscript', 'javascript', 'file' ]
+BAD_PROTO_RE = /^(vbscript|javascript|file|data):/
+GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/
 
 VALIDATE_LINK = lambda do |url|
   # url should be normalized at this point, and existing entities are decoded
   #
   str = url.strip.downcase
 
-  if str.include?(':') && BAD_PROTOCOLS.include?(str.split(':')[0])
-    return false
-  end
-  return true
+  return !!(BAD_PROTO_RE =~ str) ? (!!(GOOD_DATA_RE =~ str) ? true : false) : true
 end
 
 RECODE_HOSTNAME_FOR = [ 'http:', 'https:', 'mailto:' ]
@@ -26,40 +29,44 @@ RECODE_HOSTNAME_FOR = [ 'http:', 'https:', 'mailto:' ]
 # mdurl comes from https://github.com/markdown-it/mdurl
 NORMALIZE_LINK = lambda do |url|
   parsed = MDUrl::Url.urlParse(url, true)
+  if parsed.hostname
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    if !parsed.protocol || RECODE_HOSTNAME_FOR.include?(parsed.protocol)
+      begin
+        trailing_dot    = parsed.hostname[-1] == '.'
+        parsed.hostname = SimpleIDN.to_ascii(parsed.hostname)
+        parsed.hostname << '.' if trailing_dot
+      rescue
+        # then use what we already have
+      end
+    end
+  end
  
-  # if parsed[:hostname]
-  #   # Encode hostnames in urls like:
-  #   # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-  #   #
-  #   # We don't encode unknown schemas, because it's likely that we encode
-  #   # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-  #   if !parsed[:protocol] || RECODE_HOSTNAME_FOR.include?(parsed[:protocol])
-  #     # TODO is punycode really needed?
-  #     # try {
-  #     #   parsed.hostname = punycode.toASCII(parsed.hostname);
-  #     # } catch(er) {}
-  #   end
-  # end
- 
-  return MDUrl::Encode.encode(MDUrl::Format.format(parsed)); 
+  return MDUrl::Encode.encode(MDUrl::Format.format(parsed))
 end
 
 NORMALIZE_LINK_TEXT = lambda do |url|
   parsed = MDUrl::Url.urlParse(url, true)
-
-  # if parsed[:hostname]
-  #   # Encode hostnames in urls like:
-  #   # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
-  #   #
-  #   # We don't encode unknown schemas, because it's likely that we encode
-  #   # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
-  #   if !parsed[:protocol] || RECODE_HOSTNAME_FOR.include?(parsed[:protocol])
-  #     # TODO is punycode really needed?
-  #     # try {
-  #     #   parsed.hostname = punycode.toUnicode(parsed.hostname);
-  #     # } catch(er) {}
-  #   end
-  # end
+  if parsed.hostname
+    # Encode hostnames in urls like:
+    # `http://host/`, `https://host/`, `mailto:user@host`, `//host/`
+    #
+    # We don't encode unknown schemas, because it's likely that we encode
+    # something we shouldn't (e.g. `skype:name` treated as `skype:host`)
+    if !parsed.protocol || RECODE_HOSTNAME_FOR.include?(parsed.protocol)
+      begin
+        trailing_dot    = parsed.hostname[-1] == '.'
+        parsed.hostname = SimpleIDN.to_unicode(parsed.hostname)
+        parsed.hostname << '.' if trailing_dot
+      rescue
+        # then use what we already have
+      end
+    end
+  end
 
   return MDUrl::Decode.decode(MDUrl::Format.format(parsed))
 end
@@ -147,9 +154,9 @@ module MarkdownIt
     # - __quotes__ - `“”‘’`, string. Double + single quotes replacement pairs, when
     #   typographer enabled and smartquotes on. Set doubles to '«»' for Russian,
     #   '„“' for German.
-    # - __highlight__ - `null`. Highlighter function for fenced code blocks.
+    # - __highlight__ - `nil`. Highlighter function for fenced code blocks.
     #   Highlighter `function (str, lang)` should return escaped HTML. It can also
-    #   return empty string if the source was not changed and should be escaped externaly.
+    #   return nil if the source was not changed and should be escaped externaly.
     #
     # ##### Example
     #
@@ -273,20 +280,6 @@ module MarkdownIt
 
       #  Expose utils & helpers for easy acces from plugins
 
-      # TODO I don't know if these (utils and helpers) are really needed
-      # MarkdownIt#utils -> utils
-      #
-      # Assorted utility functions, useful to write plugins. See details
-      # [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).
-      # this.utils = utils;
-
-      # MarkdownIt#helpers -> helpers
-      #
-      # Link components parser functions, useful to write plugins. See details
-      # [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).
-      # this.helpers = helpers;
-
-
       @options = {}
       configure(presetName)
       set(options) if options
@@ -366,7 +359,7 @@ module MarkdownIt
     #             .disable('smartquotes');
     # ```
     #------------------------------------------------------------------------------
-    def enable(list, ignoreInvalid)
+    def enable(list, ignoreInvalid = false)
       result = []
 
       list = [ list ] if !list.is_a? Array
@@ -374,10 +367,10 @@ module MarkdownIt
       result << @core.ruler.enable(list, true)
       result << @block.ruler.enable(list, true)
       result << @inline.ruler.enable(list, true)
-
-      missed = list.select {|name| result.include?(name) }
-
-      if missed.length && !ignoreInvalid
+      result.flatten!
+      
+      missed = list.select {|name| !result.include?(name) }
+      if !(missed.empty? || ignoreInvalid)
         raise StandardError, "MarkdownIt. Failed to enable unknown rule(s): #{missed}"
       end
 
@@ -391,7 +384,8 @@ module MarkdownIt
     # - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
     #
     # The same as [[MarkdownIt.enable]], but turn specified rules off.
-    def disable(list, ignoreInvalid)
+    #------------------------------------------------------------------------------
+    def disable(list, ignoreInvalid = false)
       result = []
 
       list = [ list ] if !list.is_a? Array
@@ -399,10 +393,10 @@ module MarkdownIt
       result << @core.ruler.disable(list, true)
       result << @block.ruler.disable(list, true)
       result << @inline.ruler.disable(list, true)
+      result.flatten!
 
-      missed = list.select {|name| result.include?(name) }
-
-      if missed.length && !ignoreInvalid
+      missed = list.select {|name| !result.include?(name) }
+      if !(missed.empty? || ignoreInvalid)
         raise StandardError, "MarkdownIt. Failed to disable unknown rule(s): #{missed}"
       end
 
@@ -426,10 +420,8 @@ module MarkdownIt
     #             });
     # ```
     def use(plugin, *args)
-      puts "Implement: Parser.use"
-      # var args = [ this ].concat(Array.prototype.slice.call(arguments, 1));
-      # plugin.call(plugin, args)
-      # return self
+      plugin.call(plugin, *args)
+      return self
     end