motion-markdown-it 0.4.0.3.0

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

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

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

@@ -0,0 +1,44 @@
+=begin
+runs          = 1 #50
+files         = ['mdsyntax.text', 'mdbasics.text']
+benchmark_dir = File.join(File.dirname(__FILE__), '../../benchmark')
+
+puts
+puts "Running tests on #{Time.now.strftime("%Y-%m-%d")} under #{RUBY_DESCRIPTION}"
+
+files.each do |file|
+  data = File.read(File.join(benchmark_dir, file))
+  puts
+  puts "==> Test using file #{file} and #{runs} runs"
+
+  # 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 })
+      runs.times { parser.render(data) }
+    end
+    # 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
+    #     document = HoedownDocument.new
+    #     document.initWithHtmlRendererWithFlags(FLAGS)
+    #     html = document.renderMarkdownString(data)
+    #   end
+    # end
+  end
+
+  # puts
+  # puts "Real time of X divided by real time of kramdown"
+  # kd = results.shift.real
+  # %w[hoedown].each do |name|
+  #   puts name.ljust(19) << (results.shift.real/kd).round(4).to_s
+  # end
+end
+
+describe "Benchmark Test" do
+  it "benchmarks with mdsyntax.text and mdbasics.text" do
+    expect(true).to eq true
+  end
+end
+=end

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

@@ -0,0 +1,16 @@
+#------------------------------------------------------------------------------
+describe "CommonMark Specs" do 
+
+  parser    = MarkdownIt::Parser.new(:commonmark)
+  specfile  = File.join(File.dirname(__FILE__), 'fixtures', 'commonmark', 'good.txt')
+  tests     = get_tests(specfile)
+  
+  if ENV['example']
+    define_test(tests[ENV['example'].to_i - 1], parser, true)
+  else
+    tests.each do |t|
+      define_test(t, parser)
+    end
+  end
+  
+end

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

@@ -0,0 +1,18 @@
+#------------------------------------------------------------------------------
+describe "markdown-it" do 
+
+  parser    = MarkdownIt::Parser.new({ html: true, langPrefix: '', typographer: true, linkify: true })
+  datadir   = File.join(File.dirname(__FILE__), 'fixtures', 'markdown-it')
+  datafiles = (ENV['datafile'] ? [ File.join(datadir, ENV['datafile']) ] : Dir[File.join(datadir, '**/*')])
+
+  datafiles.each do |data_file|
+    tests = get_tests(data_file)
+    if ENV['example'] && !tests[ENV['example'].to_i - 1].nil?
+      define_test(tests[ENV['example'].to_i - 1], parser, true)
+    else
+      tests.each do |t|
+        define_test(t, parser)
+      end
+    end
+  end  
+end

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

@@ -0,0 +1,277 @@
+describe 'API' do
+
+  #------------------------------------------------------------------------------
+  it 'constructor' do
+    expect {
+      MarkdownIt::Parser.new('bad preset')
+    }.to raise_error
+
+    # options should override preset
+    md = MarkdownIt::Parser.new(:commonmark, { html: false })
+    expect(md).not_to eq nil
+    expect(md.render('one')).to eq "<p>one</p>\n"
+    expect(md.render('<!-- -->')).to eq "<p>&lt;!-- --&gt;</p>\n"
+  end
+
+  #------------------------------------------------------------------------------
+  it 'configure coverage' do
+    md = MarkdownIt::Parser.new
+
+    # conditions coverage
+    md.configure({})
+    expect(md.render('123')).to eq "<p>123</p>\n"
+
+    expect {
+      md.configure
+    }.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('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 'force hardbreaks' do
+    md = MarkdownIt::Parser.new({ breaks: false })
+    expect(md.render("a\nb")).to eq "<p>a\nb</p>\n"
+    
+    md.set({ breaks: true })
+    expect(md.render("a\nb")).to eq "<p>a<br>\nb</p>\n"
+    md.set({ xhtmlOut: true })
+    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("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("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'
+#     );
+#   });
+
+end

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

@@ -0,0 +1,153 @@
+describe 'Ruler' do
+
+  #------------------------------------------------------------------------------
+  it 'should replace rule (.at)' do
+    ruler = MarkdownIt::Ruler.new
+    res = 0
+
+    ruler.push('test', lambda { res = 1 })
+    ruler.at('test', lambda { res = 2 })
+
+    rules = ruler.getRules('')
+
+    expect(rules.length).to eq 1
+    rules[0].call
+    expect(res).to eq 2
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should inject before/after rule' do
+    ruler = MarkdownIt::Ruler.new
+    res = 0
+
+    ruler.push('test', lambda { res = 1 })
+    ruler.before('test', 'before_test', lambda { res = -10; })
+    ruler.after('test', 'after_test', lambda { res = 10; })
+
+    rules = ruler.getRules('');
+
+    expect(rules.length).to eq 3
+    rules[0].call
+    expect(res).to eq -10
+    rules[1].call
+    expect(res).to eq 1
+    rules[2].call
+    expect(res).to eq 10
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should enable/disable rule' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+    ruler.push('test2', lambda {})
+
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 2
+
+    ruler.disable('test')
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 1
+    ruler.disable('test2')
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 0
+
+    ruler.enable('test')
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 1
+    ruler.enable('test2')
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 2
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should enable/disable multiple rule' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+    ruler.push('test2', lambda {})
+
+    ruler.disable([ 'test', 'test2' ])
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 0
+    ruler.enable([ 'test', 'test2' ])
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 2
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should enable rules by whitelist' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+    ruler.push('test2', lambda {})
+
+    ruler.enableOnly('test')
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 1
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should support multiple chains' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+    ruler.push('test2', lambda {}, { alt: [ 'alt1' ] })
+    ruler.push('test2', lambda {}, { alt: [ 'alt1', 'alt2' ] })
+
+    rules = ruler.getRules('')
+    expect(rules.length).to eq 3
+    rules = ruler.getRules('alt1')
+    expect(rules.length).to eq 2
+    rules = ruler.getRules('alt2');
+    expect(rules.length).to eq 1
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should fail on invalid rule name' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+
+    expect {
+      ruler.at('invalid name', lambda {})
+    }.to raise_error(StandardError)
+    expect {
+      ruler.before('invalid name', lambda {})
+    }.to raise_error(StandardError)
+    expect {
+      ruler.after('invalid name', lambda {})
+    }.to raise_error(StandardError)
+    expect {
+      ruler.enable('invalid name')
+    }.to raise_error(StandardError)
+    expect {
+      ruler.disable('invalid name')
+    }.to raise_error(StandardError)
+  end
+
+
+  #------------------------------------------------------------------------------
+  it 'should not fail on invalid rule name in silent mode' do
+    ruler = MarkdownIt::Ruler.new
+
+    ruler.push('test', lambda {})
+
+    expect {
+      ruler.enable('invalid name', true)
+    }.not_to raise_error
+    expect {
+      ruler.enableOnly('invalid name', true)
+    }.not_to raise_error
+    expect {
+      ruler.disable('invalid name', true)
+    }.not_to raise_error
+  end
+
+end