motion-markdown-it 0.4.0.3.0 → 4.1.0.1

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

@@ -9,6 +9,8 @@ module MarkdownIt
     include MarkdownIt::Common::Utils
     extend  MarkdownIt::Common::Utils
 
+    attr_accessor   :rules
+    
     # Default Rules
     #------------------------------------------------------------------------------
     def self.code_inline(tokens, idx)

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

@@ -5,7 +5,8 @@
 module MarkdownIt
   module RulesCore
     class Linkify
-
+      MAILTO_RE  = /^mailto\:/
+      
       #------------------------------------------------------------------------------
       def self.isLinkOpen(str)
         return !(/^<a[>\s]/i =~ str).nil?
@@ -18,119 +19,116 @@ module MarkdownIt
       def self.linkify(state)
         blockTokens = state.tokens
 
-          return if (!state.md.options[:linkify])
+        return if (!state.md.options[:linkify])
 
-          (0...blockTokens.length).each do |j|
-            if (blockTokens[j].type != 'inline' || !state.md.linkify.pretest(blockTokens[j].content))
-              next
-            end
+        (0...blockTokens.length).each do |j|
+          if (blockTokens[j].type != 'inline' || !state.md.linkify.pretest(blockTokens[j].content))
+            next
+          end
 
-            tokens = blockTokens[j].children
+          tokens = blockTokens[j].children
 
-            htmlLinkLevel = 0
+          htmlLinkLevel = 0
 
-            # We scan from the end, to keep position when new tags added.
-            # Use reversed logic in links start/end match
-            i = tokens.length - 1
-            while i >= 0
-              currentToken = tokens[i]
+          # We scan from the end, to keep position when new tags added.
+          # Use reversed logic in links start/end match
+          i = tokens.length - 1
+          while i >= 0
+            currentToken = tokens[i]
 
-              # Skip content of markdown links
-              if (currentToken.type == 'link_close')
+            # Skip content of markdown links
+            if (currentToken.type == 'link_close')
+              i -= 1
+              while (tokens[i].level != currentToken.level && tokens[i].type != 'link_open')
                 i -= 1
-                while (tokens[i].level != currentToken.level && tokens[i].type != 'link_open')
-                  i -= 1
-                end
-                next
               end
+              i -= 1 and next
+            end
 
-              # Skip content of html tag links
-              if (currentToken.type == 'html_inline')
-                if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0)
-                  htmlLinkLevel -= 1
-                end
-                if (isLinkClose(currentToken.content))
-                  htmlLinkLevel -= 1
-                end
+            # Skip content of html tag links
+            if (currentToken.type == 'html_inline')
+              if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0)
+                htmlLinkLevel -= 1
               end
-              next if (htmlLinkLevel > 0)
-
-              if (currentToken.type == 'text' && state.md.linkify =~ currentToken.content)
-
-                text = currentToken.content
-                links = state.md.linkify.match(text)
-
-                # Now split string to nodes
-                nodes   = []
-                level   = currentToken.level
-                lastPos = 0
-                
-                (0...links.length).each do |ln|
-                  url = links[ln].url
-                  fullUrl = state.md.normalizeLink.call(url)
-                  next if (!state.md.validateLink.call(fullUrl))
-
-                  urlText = links[ln].text
-
-                  # Linkifier might send raw hostnames like "example.com", where url
-                  # starts with domain name. So we prepend http:// in those cases,
-                  # and remove it afterwards.
-                  #
-
-# TODO work on this when clearer
-puts "Linkify requires work"
-                  # if (!links[ln].schema)
-                  #   urlText = state.md.normalizeLinkText.call('http://' + urlText).replace(/^http:\/\//, '')
-                  # elsif (links[ln].schema == 'mailto:' && !Regexp.new('^mailto:/i') =~ urlText)
-                  #   urlText = state.md.normalizeLinkText.call('mailto:' + urlText).replace(/^mailto:/, '');
-                  # } else {
-                  #   urlText = state.md.normalizeLinkText.call(urlText);
-                  # }
-
-                  pos = links[ln].index
-
-                  if (pos > lastPos)
-                    token         = Token.new('text', '', 0)
-                    token.content = text.slice(lastPos...pos)
-                    token.level   = level
-                    nodes.push(token)
-                  end
-
-                  token         = Token.new('link_open', 'a', 1)
-                  token.attrs   = [ [ 'href', fullUrl ] ]
-                  token.level   = level
-                  level        += 1
-                  token.markup  = 'linkify'
-                  token.info    = 'auto'
-                  nodes.push(token)
-
-                  token         = Token.new('text', '', 0)
-                  token.content = urlText
-                  token.level   = level
-                  nodes.push(token)
+              if (isLinkClose(currentToken.content))
+                htmlLinkLevel += 1
+              end
+            end
+            i -= 1 and next if (htmlLinkLevel > 0)
+
+            if (currentToken.type == 'text' && state.md.linkify.test(currentToken.content))
+
+              text = currentToken.content
+              links = state.md.linkify.match(text)
+
+              # Now split string to nodes
+              nodes   = []
+              level   = currentToken.level
+              lastPos = 0
+              
+              (0...links.length).each do |ln|
+                url = links[ln].url
+                fullUrl = state.md.normalizeLink.call(url)
+                next if (!state.md.validateLink.call(fullUrl))
+
+                urlText = links[ln].text
+
+                # Linkifier might send raw hostnames like "example.com", where url
+                # starts with domain name. So we prepend http:// in those cases,
+                # and remove it afterwards.
+                if links[ln].schema.empty?
+                  urlText = state.md.normalizeLinkText.call("http://#{urlText}").sub(/^http:\/\//, '')
+                elsif (links[ln].schema == 'mailto:' && !(MAILTO_RE =~ urlText))
+                  urlText = state.md.normalizeLinkText.call("mailto:#{urlText}").sub(MAILTO_RE, '')
+                else
+                  urlText = state.md.normalizeLinkText.call(urlText)
+                end
 
-                  token         = Token.new('link_close', 'a', -1)
-                  level        -= 1
-                  token.level   = level
-                  token.markup  = 'linkify'
-                  token.info    = 'auto'
-                  nodes.push(token)
+                pos = links[ln].index
 
-                  lastPos = links[ln].lastIndex
-                end
-                if (lastPos < text.length)
+                if (pos > lastPos)
                   token         = Token.new('text', '', 0)
-                  token.content = text.slice_to_end(lastPos)
+                  token.content = text.slice(lastPos...pos)
                   token.level   = level
                   nodes.push(token)
                 end
 
-                # replace current node
-                blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes)
+                token         = Token.new('link_open', 'a', 1)
+                token.attrs   = [ [ 'href', fullUrl ] ]
+                token.level   = level
+                level        += 1
+                token.markup  = 'linkify'
+                token.info    = 'auto'
+                nodes.push(token)
+
+                token         = Token.new('text', '', 0)
+                token.content = urlText
+                token.level   = level
+                nodes.push(token)
+
+                token         = Token.new('link_close', 'a', -1)
+                level        -= 1
+                token.level   = level
+                token.markup  = 'linkify'
+                token.info    = 'auto'
+                nodes.push(token)
+
+                lastPos = links[ln].lastIndex
               end
-              i -= 1
+              if (lastPos < text.length)
+                token         = Token.new('text', '', 0)
+                token.content = text.slice_to_end(lastPos)
+                token.level   = level
+                nodes.push(token)
+              end
+
+              # replace current node
+              tokens[i] = nodes
+              blockTokens[j].children = (tokens.flatten!(1))
             end
+            i -= 1
           end
+        end
       end
 
     end

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

@@ -15,7 +15,7 @@ module MarkdownIt
   module RulesCore
     class Replacements
 
-      # TODO:
+      # TODO (from original)
       # - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
       # - miltiplication 2 x 4 -> 2 × 4
 

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

@@ -54,8 +54,8 @@ module MarkdownIt
             lastChar = t.begin(0) - 1 >= 0 ? text.charCodeAt(t.begin(0) - 1) : 0x20
             nextChar = pos < max ? text.charCodeAt(pos) : 0x20
 
-            isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr)
-            isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr)
+            isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr(Encoding::UTF_8))
+            isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr(Encoding::UTF_8))
 
             isLastWhiteSpace = isWhiteSpace(lastChar)
             isNextWhiteSpace = isWhiteSpace(nextChar)

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

@@ -30,8 +30,8 @@ module MarkdownIt
         # treat end of the line as a whitespace
         nextChar = pos < max ? state.src.charCodeAt(pos) : 0x20
 
-        isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr)
-        isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr)
+        isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(lastChar.chr(Encoding::UTF_8))
+        isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(nextChar.chr(Encoding::UTF_8))
 
         isLastWhiteSpace = isWhiteSpace(lastChar)
         isNextWhiteSpace = isWhiteSpace(nextChar)

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

@@ -1,5 +1,5 @@
 module MotionMarkdownIt
 
-  VERSION = '0.4.0.3.0'
+  VERSION = '4.1.0.1'
 
 end

data/lib/motion-markdown-it.rb

@@ -16,6 +16,7 @@ else
   require 'mdurl-rb'
   require 'uc.micro-rb'
   require 'linkify-it-rb'
+  require 'motion-markdown-it/version'
   require 'motion-markdown-it/presets/default'
   require 'motion-markdown-it/presets/zero'
   require 'motion-markdown-it/presets/commonmark'
@@ -25,6 +26,7 @@ else
   require 'motion-markdown-it/common/url_schemas'
   require 'motion-markdown-it/common/html_re'
   require 'motion-markdown-it/common/string'
+  require 'motion-markdown-it/common/simpleidn'
   require 'motion-markdown-it/helpers/parse_link_destination'
   require 'motion-markdown-it/helpers/parse_link_label'
   require 'motion-markdown-it/helpers/parse_link_title'

data/spec/motion-markdown-it/bench_mark_spec.rb

@@ -1,5 +1,6 @@
-=begin
-runs          = 1 #50
+require 'kramdown'
+
+runs          = 50
 files         = ['mdsyntax.text', 'mdbasics.text']
 benchmark_dir = File.join(File.dirname(__FILE__), '../../benchmark')
 
@@ -14,10 +15,10 @@ files.each do |file|
   # results = Benchmark.bmbm do |b|
   results = Benchmark.bm do |b|
     b.report("motion-markdown-it 0.1.0") do
-      parser = MarkdownIt::Parser.new(:commonmark, { html: false })
+      parser = MarkdownIt::Parser.new({ html: true, linkify: true, typographer: true })
       runs.times { parser.render(data) }
     end
-    # b.report("kramdown #{Kramdown::VERSION}") { runs.times { Kramdown::Document.new(data).to_html } }
+    b.report("kramdown #{Kramdown::VERSION}") { runs.times { Kramdown::Document.new(data).to_html } }
     # b.report("markdown-it 4.0.1 JS") { runs.times { NSApplication.sharedApplication.delegate.markdown_it(data) } }
     # b.report(" hoedown 3.0.1") do
     #   runs.times do
@@ -41,4 +42,3 @@ describe "Benchmark Test" do
     expect(true).to eq true
   end
 end
-=end

data/spec/motion-markdown-it/misc_spec.rb

@@ -26,40 +26,39 @@ describe 'API' do
     }.to raise_error
   end
 
-  # TODO #------------------------------------------------------------------------------
-  # it 'plugin' do
-  #   plugin[0] = false
-  #
-  #   plugin[1] = lambda {|plugin, opts| plugin[0] = true if (opts == 'bar') }
-  #
-  #   md = MarkdownIt::Parser.new
-  #
-  #   md.use(plugin, 'foo');
-  #   expect(@succeeded).to eq false
-  #   md.use(plugin, 'bar')
-  #   expect(@succeeded).to eq true
-  # end
+  #------------------------------------------------------------------------------
+  it 'plugin' do
+    @success = false
+    plugin = lambda {|plugin, opts| @success = true if (opts == 'bar') }
+
+    md = MarkdownIt::Parser.new
+
+    md.use(plugin, 'foo')
+    expect(@success).to eq false
+    md.use(plugin, 'bar')
+    expect(@success).to eq true
+  end
+
+  #------------------------------------------------------------------------------
+  it 'highlight' do
+    md = MarkdownIt::Parser.new({
+      highlight: lambda do |str, obj|
+        return '==' + str + '=='
+      end
+    })
+
+    expect(md.render("```\nhl\n```")).to eq  "<pre><code>==hl\n==</code></pre>\n"
+  end
 
-#   it('highlight', function () {
-#     var md = markdownit({
-#       highlight: function (str) {
-#         return '==' + str + '==';
-#       }
-#     });
-#
-#     assert.strictEqual(md.render("```\nhl\n```"), "<pre><code>==hl\n==</code></pre>\n");
-#   });
-#
-#   it('highlight escape by default', function () {
-#     var md = markdownit({
-#       highlight: function () {
-#         return '';
-#       }
-#     });
-#
-#     assert.strictEqual(md.render("```\n&\n```"), "<pre><code>&amp;\n</code></pre>\n");
-#   });
+  #------------------------------------------------------------------------------
+  it 'highlight escape by default' do
+    md = MarkdownIt::Parser.new({highlight: lambda {|value, obj| return nil }})
+    
+    # assert.strictEqual(md.render("```\n&\n```"), "<pre><code>&amp;\n</code></pre>\n");
+    expect(md.render("```\n&\n```")).to eq "<pre><code>&amp;\n</code></pre>\n"
+  end
 
+  #------------------------------------------------------------------------------
   it 'force hardbreaks' do
     md = MarkdownIt::Parser.new({ breaks: false })
     expect(md.render("a\nb")).to eq "<p>a\nb</p>\n"
@@ -70,208 +69,229 @@ describe 'API' do
     expect(md.render("a\nb")).to eq "<p>a<br />\nb</p>\n"
   end
 
+  #------------------------------------------------------------------------------
   it 'xhtmlOut enabled' do
     md = MarkdownIt::Parser.new({ xhtmlOut: true })
 
     expect(md.render('---')).to eq "<hr />\n"
-    # TODO expect(md.render('![]()')).to eq "<p><img src=\"\" alt=\"\" /></p>\n"
+    expect(md.render('![]()')).to eq "<p><img src=\"\" alt=\"\" /></p>\n"
     expect(md.render("a  \\\nb")).to eq "<p>a  <br />\nb</p>\n"
   end
 
+  #------------------------------------------------------------------------------
   it 'xhtmlOut disabled' do
     md = MarkdownIt::Parser.new
 
     expect(md.render('---')).to eq "<hr>\n"
-    # TODO expect(md.render('![]()')).to eq "<p><img src=\"\" alt=\"\"></p>\n"
+    expect(md.render('![]()')).to eq "<p><img src=\"\" alt=\"\"></p>\n"
     expect(md.render("a  \\\nb")).to eq "<p>a  <br>\nb</p>\n"
   end
 
-#   it('bulk enable/disable rules in different chains', function () {
-#     var md = markdownit();
-#
-#     var was = {
-#       core: md.core.ruler.getRules('').length,
-#       block: md.block.ruler.getRules('').length,
-#       inline: md.inline.ruler.getRules('').length
-#     };
-#
-#     // Disable 2 rule in each chain & compare result
-#     md.disable([ 'block', 'inline', 'code', 'fence', 'emphasis', 'entity' ]);
-#
-#     var now = {
-#       core: md.core.ruler.getRules('').length + 2,
-#       block: md.block.ruler.getRules('').length + 2,
-#       inline: md.inline.ruler.getRules('').length + 2
-#     };
-#
-#     assert.deepEqual(was, now);
-#
-#     // Enable the same rules back
-#     md.enable([ 'block', 'inline', 'code', 'fence', 'emphasis', 'entity' ]);
-#
-#     var back = {
-#       core: md.core.ruler.getRules('').length,
-#       block: md.block.ruler.getRules('').length,
-#       inline: md.inline.ruler.getRules('').length
-#     };
-#
-#     assert.deepEqual(was, back);
-#   });
-#
-#   it('bulk enable/disable with errors control', function () {
-#     var md = markdownit();
-#
-#     assert.throws(function () {
-#       md.enable([ 'link', 'code', 'invalid' ]);
-#     });
-#     assert.throws(function () {
-#       md.disable([ 'link', 'code', 'invalid' ]);
-#     });
-#     assert.doesNotThrow(function () {
-#       md.enable([ 'link', 'code' ]);
-#     });
-#     assert.doesNotThrow(function () {
-#       md.disable([ 'link', 'code' ]);
-#     });
-#   });
-#
-#   it('bulk enable/disable should understand strings', function () {
-#     var md = markdownit();
-#
-#     md.disable('emphasis');
-#     assert(md.renderInline('_foo_'), '_foo_');
-#
-#     md.enable('emphasis');
-#     assert(md.renderInline('_foo_'), '<em>foo</em>');
-#   });
-#
-# });
-#
-#
-# describe('Misc', function () {
-#
-#   it('Should replace NULL characters', function () {
-#     var md = markdownit();
-#
-#     assert.strictEqual(md.render('foo\u0000bar'), '<p>foo\uFFFDbar</p>\n');
-#   });
-#
-#   it('Should correctly parse strings without tailing \\n', function () {
-#     var md = markdownit();
-#
-#     assert.strictEqual(md.render('123'), '<p>123</p>\n');
-#     assert.strictEqual(md.render('123\n'), '<p>123</p>\n');
-#   });
-#
-#   it('Should quickly exit on empty string', function () {
-#     var md = markdownit();
-#
-#     assert.strictEqual(md.render(''), '');
-#   });
-#
-#   it('Should parse inlines only', function () {
-#     var md = markdownit();
-#
-#     assert.strictEqual(md.renderInline('a *b* c'), 'a <em>b</em> c');
-#   });
-#
-#   it('Renderer should have pluggable inline and block rules', function () {
-#     var md = markdownit();
-#
-#     md.renderer.rules.em_open = function () { return '<it>'; };
-#     md.renderer.rules.em_close = function () { return '</it>'; };
-#     md.renderer.rules.paragraph_open = function () { return '<par>'; };
-#     md.renderer.rules.paragraph_close = function () { return '</par>'; };
-#
-#     assert.strictEqual(md.render('*b*'), '<par><it>b</it></par>');
-#   });
-#
-#   it('Zero preset should disable everything', function () {
-#     var md = markdownit('zero');
-#
-#     assert.strictEqual(md.render('___foo___'), '<p>___foo___</p>\n');
-#     assert.strictEqual(md.renderInline('___foo___'), '___foo___');
-#
-#     md.enable('emphasis');
-#
-#     assert.strictEqual(md.render('___foo___'), '<p><strong><em>foo</em></strong></p>\n');
-#     assert.strictEqual(md.renderInline('___foo___'), '<strong><em>foo</em></strong>');
-#   });
-#
-#   it('Should correctly check block termination rules when those are disabled (#13)', function () {
-#     var md = markdownit('zero');
-#
-#     assert.strictEqual(md.render('foo\nbar'), '<p>foo\nbar</p>\n');
-#   });
-#
-#   it('Should render link target attr', function () {
-#     var md = markdownit()
-#                 .use(require('markdown-it-for-inline'), 'target', 'link_open', function (tokens, idx) {
-#                   tokens[idx].attrs.push([ 'target', '_blank' ]);
-#                 });
-#
-#     assert.strictEqual(md.render('[foo](bar)'), '<p><a href="bar" target="_blank">foo</a></p>\n');
-#   });
-#
-# });
-#
-#
-# describe('Url normalization', function () {
-#
-#   it('Should be overridable', function () {
-#     var md = markdownit({ linkify: true });
-#
-#     md.normalizeLink = function (url) {
-#       assert(url.match(/example\.com/), 'wrong url passed');
-#       return 'LINK';
-#     };
-#     md.normalizeLinkText = function (url) {
-#       assert(url.match(/example\.com/), 'wrong url passed');
-#       return 'TEXT';
-#     };
-#
-#     assert.strictEqual(md.render('foo@example.com'), '<p><a href="LINK">TEXT</a></p>\n');
-#     assert.strictEqual(md.render('http://example.com'), '<p><a href="LINK">TEXT</a></p>\n');
-#     assert.strictEqual(md.render('<foo@example.com>'), '<p><a href="LINK">TEXT</a></p>\n');
-#     assert.strictEqual(md.render('<http://example.com>'), '<p><a href="LINK">TEXT</a></p>\n');
-#     assert.strictEqual(md.render('[test](http://example.com)'), '<p><a href="LINK">test</a></p>\n');
-#     assert.strictEqual(md.render('![test](http://example.com)'), '<p><img src="LINK" alt="test"></p>\n');
-#   });
-#
-# });
-#
-#
-# describe('Links validation', function () {
-#
-#   it('Override validator, disable everything', function () {
-#     var md = markdownit({ linkify: true });
-#
-#     md.validateLink = function () { return false; };
-#
-#     assert.strictEqual(md.render('foo@example.com'), '<p>foo@example.com</p>\n');
-#     assert.strictEqual(md.render('http://example.com'), '<p>http://example.com</p>\n');
-#     assert.strictEqual(md.render('<foo@example.com>'), '<p>&lt;foo@example.com&gt;</p>\n');
-#     assert.strictEqual(md.render('<http://example.com>'), '<p>&lt;http://example.com&gt;</p>\n');
-#     assert.strictEqual(md.render('[test](http://example.com)'), '<p>[test](http://example.com)</p>\n');
-#     assert.strictEqual(md.render('![test](http://example.com)'), '<p>![test](http://example.com)</p>\n');
-#   });
-#
-# });
-#
-#
-# describe('maxNesting', function () {
-#
-#   it('Inline parser should not nest above limit', function () {
-#     var md = markdownit({ maxNesting: 2 });
-#     assert.strictEqual(md.render('*foo *bar *baz* bar* foo*'), '<p><em>foo <em>bar *baz* bar</em> foo</em></p>\n');
-#   });
-#
-#   it('Block parser should not nest above limit', function () {
-#     var md = markdownit({ maxNesting: 2 });
-#     assert.strictEqual(
-#       md.render('>foo\n>>bar\n>>>baz'),
-#       '<blockquote>\n<p>foo</p>\n<blockquote></blockquote>\n</blockquote>\n'
-#     );
-#   });
+  #------------------------------------------------------------------------------
+  it 'bulk enable/disable rules in different chains' do
+    md = MarkdownIt::Parser.new
+
+    was = {
+      core:   md.core.ruler.getRules('').length,
+      block:  md.block.ruler.getRules('').length,
+      inline: md.inline.ruler.getRules('').length
+    }
+
+    # Disable 2 rule in each chain & compare result
+    md.disable([ 'block', 'inline', 'code', 'fence', 'emphasis', 'entity' ])
+
+    now = {
+      core:   md.core.ruler.getRules('').length + 2,
+      block:  md.block.ruler.getRules('').length + 2,
+      inline: md.inline.ruler.getRules('').length + 2
+    }
+
+    expect(was).to eq now
+
+    # Enable the same rules back
+    md.enable([ 'block', 'inline', 'code', 'fence', 'emphasis', 'entity' ])
+
+    back = {
+      core:   md.core.ruler.getRules('').length,
+      block:  md.block.ruler.getRules('').length,
+      inline: md.inline.ruler.getRules('').length
+    }
+
+    expect(was).to eq back
+  end
+
+  #------------------------------------------------------------------------------
+  it 'bulk enable/disable with errors control' do
+    md = MarkdownIt::Parser.new
+    expect {
+      md.enable([ 'link', 'code', 'invalid' ])
+    }.to raise_error
+
+    expect {
+      md.disable([ 'link', 'code', 'invalid' ])
+    }.to raise_error
+
+    expect {
+      md.enable([ 'link', 'code' ])
+    }.to_not raise_error
+
+    expect {
+      md.disable([ 'link', 'code' ])
+    }.to_not raise_error
+  end
+
+  #------------------------------------------------------------------------------
+  it 'bulk enable/disable should understand strings' do
+    md = MarkdownIt::Parser.new
+
+    md.disable('emphasis')
+    expect(md.renderInline('_foo_')).to eq '_foo_'
+
+    md.enable('emphasis')
+    expect(md.renderInline('_foo_')).to eq '<em>foo</em>'
+  end
+
+end
+
+
+#------------------------------------------------------------------------------
+describe 'Misc' do
+
+  #------------------------------------------------------------------------------
+  it 'Should replace NULL characters' do
+    md = MarkdownIt::Parser.new
+
+    expect(md.render("foo\u0000bar")).to eq "<p>foo\\uFFFDbar</p>\n"
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Should correctly parse strings without tailing \\n' do
+    md = MarkdownIt::Parser.new
+
+    expect(md.render('123')).to eq "<p>123</p>\n"
+    expect(md.render("123\n")).to eq "<p>123</p>\n"
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Should quickly exit on empty string' do
+    md = MarkdownIt::Parser.new
+
+    expect(md.render('')).to eq ''
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Should parse inlines only' do
+    md = MarkdownIt::Parser.new
+
+    expect(md.renderInline('a *b* c')).to eq 'a <em>b</em> c'
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Renderer should have pluggable inline and block rules' do
+    md = MarkdownIt::Parser.new
+
+    md.renderer.rules['em_open']         = lambda {|tokens, idx, options, env, renderer| return '<it>' }
+    md.renderer.rules['em_close']        = lambda {|tokens, idx, options, env, renderer| return '</it>' }
+    md.renderer.rules['paragraph_open']  = lambda {|tokens, idx, options, env, renderer| return '<par>' }
+    md.renderer.rules['paragraph_close'] = lambda {|tokens, idx, options, env, renderer| return '</par>' }
+
+    expect(md.render('*b*')).to eq '<par><it>b</it></par>'
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Zero preset should disable everything' do
+    md = MarkdownIt::Parser.new(:zero)
+
+    expect(md.render('___foo___')).to eq "<p>___foo___</p>\n"
+    expect(md.renderInline('___foo___')).to eq '___foo___'
+
+    md.enable('emphasis')
+
+    expect(md.render('___foo___')).to eq "<p><strong><em>foo</em></strong></p>\n"
+    expect(md.renderInline('___foo___')).to eq '<strong><em>foo</em></strong>'
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Should correctly check block termination rules when those are disabled (#13)' do
+    md = MarkdownIt::Parser.new(:zero)
+
+    expect(md.render("foo\nbar")).to eq "<p>foo\nbar</p>\n"
+  end
+
+  # TODO ------------------------------------------------------------------------------
+  # it 'Should render link target attr' do
+  #   md = MarkdownIt::Parser.new.
+  #               use(require('markdown-it-for-inline'), 'target', 'link_open', function (tokens, idx) {
+  #                 tokens[idx].attrs.push([ 'target', '_blank' ]);
+  #               });
+  #
+  #   assert.strictEqual(md.render('[foo](bar)'), '<p><a href="bar" target="_blank">foo</a></p>\n');
+  # end
+
+end
+
+
+#------------------------------------------------------------------------------
+describe 'Url normalization' do
+
+  #------------------------------------------------------------------------------
+  it 'Should be overridable' do
+    md = MarkdownIt::Parser.new({ linkify: true })
+
+    md.normalizeLink = lambda do |url|
+      expect(/example\.com/ =~ url).to_not eq nil
+      return 'LINK'
+    end
+    
+    md.normalizeLinkText = lambda do |url|
+      expect(/example\.com/ =~ url).to_not eq nil
+      return 'TEXT'
+    end
+
+    expect(md.render('foo@example.com')).to eq "<p><a href=\"LINK\">TEXT</a></p>\n"
+    expect(md.render('http://example.com')).to eq "<p><a href=\"LINK\">TEXT</a></p>\n"
+    expect(md.render('<foo@example.com>')).to eq "<p><a href=\"LINK\">TEXT</a></p>\n"
+    expect(md.render('<http://example.com>')).to eq "<p><a href=\"LINK\">TEXT</a></p>\n"
+    expect(md.render('[test](http://example.com)')).to eq "<p><a href=\"LINK\">test</a></p>\n"
+    expect(md.render('![test](http://example.com)')).to eq "<p><img src=\"LINK\" alt=\"test\"></p>\n"
+  end
+
+end
+
+
+#------------------------------------------------------------------------------
+describe 'Links validation' do
+
+  #------------------------------------------------------------------------------
+  it 'Override validator, disable everything' do
+    md = MarkdownIt::Parser.new({ linkify: true })
+
+    md.validateLink = lambda { |url| return false }
+
+    expect(md.render('foo@example.com')).to eq "<p>foo@example.com</p>\n"
+    expect(md.render('http://example.com')).to eq "<p>http://example.com</p>\n"
+    expect(md.render('<foo@example.com>')).to eq "<p>&lt;foo@example.com&gt;</p>\n"
+    expect(md.render('<http://example.com>')).to eq "<p>&lt;http://example.com&gt;</p>\n"
+    expect(md.render('[test](http://example.com)')).to eq "<p>[test](http://example.com)</p>\n"
+    expect(md.render('![test](http://example.com)')).to eq "<p>![test](http://example.com)</p>\n"
+  end
+
+end
+
+
+#------------------------------------------------------------------------------
+describe 'maxNesting' do
+
+  #------------------------------------------------------------------------------
+  it 'Inline parser should not nest above limit' do
+    md = MarkdownIt::Parser.new({ maxNesting: 2 })
+    expect(md.render('*foo *bar *baz* bar* foo*')).to eq "<p><em>foo <em>bar *baz* bar</em> foo</em></p>\n"
+  end
+
+  #------------------------------------------------------------------------------
+  it 'Block parser should not nest above limit' do
+    md = MarkdownIt::Parser.new({ maxNesting: 2 })
+    expect(md.render(">foo\n>>bar\n>>>baz")).to eq "<blockquote>\n<p>foo</p>\n<blockquote></blockquote>\n</blockquote>\n"
+  end
 
 end