]> git.madduck.net Git - etc/vim.git/blobdiff - test/syntax.vader

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

projects / etc / vim.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add documentation for foldtext override
[etc/vim.git] / test / syntax.vader
diff --git a/test/syntax.vader b/test/syntax.vader
index e63ce7ef95def80c266dc919b99f724e151be36a..2f5f78c751ff509faa371fcfee1eea02ccf6a24d 100644 (file)
--- a/test/syntax.vader
+++ b/test/syntax.vader
@@ -1,3 +1,8 @@
+Before:
+  unlet! b:mkd_known_filetypes
+  unlet! b:mkd_included_filetypes
+  unlet! g:vim_markdown_math
+
 Given markdown;
 a **b** c
 
 Given markdown;
 a **b** c
 
@@ -30,6 +35,13 @@ Execute (italic):
   AssertEqual SyntaxOf('b'), 'htmlItalic'
   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
 
   AssertEqual SyntaxOf('b'), 'htmlItalic'
   AssertNotEqual SyntaxOf('c'), 'htmlItalic'
 
+Given markdown;
+_a_b_
+
+Execute (italic text has underscores):
+  AssertEqual SyntaxOf('a'), 'htmlItalic'
+  AssertEqual SyntaxOf('b'), 'htmlItalic'
+
 Given markdown;
 a \*b\* c
 
 Given markdown;
 a \*b\* c
 
@@ -55,6 +67,14 @@ Execute (italic with escaped underscores):
   AssertEqual SyntaxOf('c'), 'htmlItalic'
   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 
   AssertEqual SyntaxOf('c'), 'htmlItalic'
   AssertNotEqual SyntaxOf('d'), 'htmlItalic'
 
+Given markdown;
+a_b_c
+
+Execute (not italic underscores within text):
+  AssertNotEqual SyntaxOf('a'), 'htmlItalic'
+  AssertNotEqual SyntaxOf('b'), 'htmlItalic'
+  AssertNotEqual SyntaxOf('c'), 'htmlItalic'
+
 Given markdown;
 a *b\*c* d
 
 Given markdown;
 a *b\*c* d
 
@@ -73,6 +93,80 @@ Execute (bold with escaped underscores):
   AssertEqual SyntaxOf('c'), 'htmlBold'
   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 
   AssertEqual SyntaxOf('c'), 'htmlBold'
   AssertNotEqual SyntaxOf('d'), 'htmlBold'
 
+Given markdown;
+_a b
+c_ d
+
+Execute (italic with underscores in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlItalic'
+  AssertEqual SyntaxOf('b'), 'htmlItalic'
+  AssertEqual SyntaxOf('c'), 'htmlItalic'
+  AssertNotEqual SyntaxOf('d'), 'htmlItalic'
+
+Given markdown;
+__a b
+c__ d
+
+Execute (bold with underscores in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlBold'
+  AssertEqual SyntaxOf('b'), 'htmlBold'
+  AssertEqual SyntaxOf('c'), 'htmlBold'
+  AssertNotEqual SyntaxOf('d'), 'htmlBold'
+
+Given markdown;
+___a b
+c___ d
+
+Execute (bold italic with underscores in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
+  AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
+  AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
+  AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
+
+Given markdown;
+*a b
+c* d
+
+Execute (italic with asterisks in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlItalic'
+  AssertEqual SyntaxOf('b'), 'htmlItalic'
+  AssertEqual SyntaxOf('c'), 'htmlItalic'
+  AssertNotEqual SyntaxOf('d'), 'htmlItalic'
+
+Given markdown;
+**a b
+c** d
+
+Execute (bold with asterisks in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlBold'
+  AssertEqual SyntaxOf('b'), 'htmlBold'
+  AssertEqual SyntaxOf('c'), 'htmlBold'
+  AssertNotEqual SyntaxOf('d'), 'htmlBold'
+
+Given markdown;
+***a b
+c*** d
+
+Execute (bold italic with asterisks in multiple lines):
+  AssertEqual SyntaxOf('a'), 'htmlBoldItalic'
+  AssertEqual SyntaxOf('b'), 'htmlBoldItalic'
+  AssertEqual SyntaxOf('c'), 'htmlBoldItalic'
+  AssertNotEqual SyntaxOf('d'), 'htmlBoldItalic'
+
+Given markdown;
+*a
+
+Execute (not italic with an asterisk):
+  AssertNotEqual SyntaxOf('a'), 'htmlItalic'
+
+Given markdown;
+[__](a) b
+
+Execute (not bold with double underscores):
+  AssertNotEqual SyntaxOf('_'), 'htmlBold'
+  AssertNotEqual SyntaxOf('a'), 'htmlBold'
+  AssertNotEqual SyntaxOf('b'), 'htmlBold'
+
 # Links
 
 Given markdown;
 # Links
 
 Given markdown;
@@ -82,6 +176,15 @@ Execute (link with title):
   AssertEqual SyntaxOf('a'), 'mkdLink'
   AssertEqual SyntaxOf('b'), 'mkdURL'
 
   AssertEqual SyntaxOf('a'), 'mkdLink'
   AssertEqual SyntaxOf('b'), 'mkdURL'
 
+Given markdown;
+[a
+b](c)
+
+Execute (link text with newline):
+  AssertEqual SyntaxOf('a'), 'mkdLink'
+  AssertEqual SyntaxOf('b'), 'mkdLink'
+  AssertEqual SyntaxOf('c'), 'mkdURL'
+
 Given markdown;
 (a)
 
 Given markdown;
 (a)
 
@@ -98,19 +201,56 @@ Execute (multiple links on a line):
   AssertNotEqual SyntaxOf('c'), 'mkdLink'
   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 
   AssertNotEqual SyntaxOf('c'), 'mkdLink'
   AssertNotEqual SyntaxOf('c'), 'mkdURL'
 
+Given markdown;
+[a] (b)
+
+Execute (space is not allowed between link text and parenthesis):
+  AssertNotEqual SyntaxOf('a'), 'mkdLink'
+  AssertNotEqual SyntaxOf('b'), 'mkdURL'
+
 Given markdown;
 [a](b)
 
 Execute (conceal link):
 Given markdown;
 [a](b)
 
 Execute (conceal link):
-  setlocal conceallevel=2
-  AssertEqual synconcealed(1, 1)[0], 1
-  AssertEqual synconcealed(1, 2)[0], 0
-  AssertEqual synconcealed(1, 3)[0], 1
-  AssertEqual synconcealed(1, 4)[0], 1
-  AssertEqual synconcealed(1, 4)[0], 1
-  AssertEqual synconcealed(1, 5)[0], 1
-  AssertEqual synconcealed(1, 6)[0], 1
-  setlocal conceallevel=0
+  if has('conceal')
+    setlocal conceallevel=2
+    AssertEqual synconcealed(1, 1)[0], 1
+    AssertEqual synconcealed(1, 2)[0], 0
+    AssertEqual synconcealed(1, 3)[0], 1
+    AssertEqual synconcealed(1, 4)[0], 1
+    AssertEqual synconcealed(1, 4)[0], 1
+    AssertEqual synconcealed(1, 5)[0], 1
+    AssertEqual synconcealed(1, 6)[0], 1
+    setlocal conceallevel=0
+  endif
+
+Execute (disable conceal):
+  if has('conceal')
+    let g:vim_markdown_conceal=0
+    syn off | syn on
+    setlocal conceallevel=2
+    AssertEqual synconcealed(1, 1)[0], 0
+    AssertEqual synconcealed(1, 2)[0], 0
+    AssertEqual synconcealed(1, 3)[0], 0
+    AssertEqual synconcealed(1, 4)[0], 0
+    AssertEqual synconcealed(1, 4)[0], 0
+    AssertEqual synconcealed(1, 5)[0], 0
+    AssertEqual synconcealed(1, 6)[0], 0
+
+    let g:vim_markdown_conceal=1
+    syn off | syn on
+    AssertEqual synconcealed(1, 1)[0], 1
+    AssertEqual synconcealed(1, 2)[0], 0
+    AssertEqual synconcealed(1, 3)[0], 1
+    AssertEqual synconcealed(1, 4)[0], 1
+    AssertEqual synconcealed(1, 4)[0], 1
+    AssertEqual synconcealed(1, 5)[0], 1
+    AssertEqual synconcealed(1, 6)[0], 1
+
+    setlocal conceallevel=0
+    unlet g:vim_markdown_conceal
+    syn off | syn on
+  endif
 
 # Autolinks
 
 
 # Autolinks
 
@@ -124,6 +264,12 @@ Execute (autolink):
   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 
   AssertEqual SyntaxOf('>'), 'mkdDelimiter'
   AssertNotEqual SyntaxOf('c'), 'mkdInlineURL'
 
+Given markdown;
+http://12monkeys.foo
+
+Execute (autolink with domain starting with a number):
+  AssertEqual SyntaxOf('12monkeys'), 'mkdInlineURL'
+
 Given markdown;
 <HtTp://a>
 
 Given markdown;
 <HtTp://a>
 
@@ -174,6 +320,72 @@ Execute (autolink in link text):
   AssertEqual SyntaxOf('b'), 'mkdURL'
   AssertEqual SyntaxOf('c'), 'mkdURL'
 
   AssertEqual SyntaxOf('b'), 'mkdURL'
   AssertEqual SyntaxOf('c'), 'mkdURL'
 
+Given markdown;
+# [h1link](url)
+
+## [h2link](url)
+
+### [h3link](url)
+
+#### [h4link](url)
+
+##### [h5link](url)
+
+###### [h6link](url)
+
+[h1link_b](url)
+===============
+
+[h2link_b](url)
+---------------
+
+Execute (link in headers):
+  AssertEqual SyntaxOf('h1link'), 'mkdLink'
+  AssertEqual SyntaxOf('h2link'), 'mkdLink'
+  AssertEqual SyntaxOf('h3link'), 'mkdLink'
+  AssertEqual SyntaxOf('h4link'), 'mkdLink'
+  AssertEqual SyntaxOf('h5link'), 'mkdLink'
+  AssertEqual SyntaxOf('h6link'), 'mkdLink'
+  AssertEqual SyntaxOf('h1link_b'), 'mkdLink'
+  AssertEqual SyntaxOf('h2link_b'), 'mkdLink'
+
+Given markdown;
+# http://h1link.foo
+
+## http://h2link.foo
+
+### http://h3link.foo
+
+#### http://h4link.foo
+
+##### http://h5link.foo
+
+###### http://h6link.foo
+
+http://h1link_b.foo
+===================
+
+http://h2link_b.foo
+-------------------
+
+Execute (inline url in headers):
+  AssertEqual SyntaxOf('h1link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h2link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h3link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h4link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h5link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h6link'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h1link_b'), 'mkdInlineURL'
+  AssertEqual SyntaxOf('h2link_b'), 'mkdInlineURL'
+
+Given markdown;
+> [a](b)
+> http://foo.bar
+
+Execute (link in blockquote):
+  AssertEqual SyntaxOf('a'), 'mkdLink'
+  AssertEqual SyntaxOf('foo'), 'mkdInlineURL'
+
 # Code Blocks
 
 Given markdown;
 # Code Blocks
 
 Given markdown;
@@ -256,6 +468,14 @@ Execute (indent code blocks after list):
   AssertNotEqual SyntaxOf('b'), 'mkdCode'
   AssertEqual SyntaxOf('c'), 'mkdCode'
 
   AssertNotEqual SyntaxOf('b'), 'mkdCode'
   AssertEqual SyntaxOf('c'), 'mkdCode'
 
+Given markdown;
+    a
+    b
+
+Execute (indent code block at beginning of file):
+  AssertEqual SyntaxOf('a'), 'mkdCode'
+  AssertEqual SyntaxOf('b'), 'mkdCode'
+
 Given markdown;
 ```c++
 #include <iostream>
 Given markdown;
 ```c++
 #include <iostream>
@@ -274,6 +494,80 @@ Execute (fenced code block syntax with a language specifier):
   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
   AssertEqual SyntaxOf('def'), 'rubyDefine'
 
   AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
   AssertEqual SyntaxOf('def'), 'rubyDefine'
 
+Given markdown;
+``` c++
+#include <iostream>
+code
+```
+
+```  vim
+let g:a = 1
+```
+
+```    ruby
+def a
+end
+```
+
+```
+ruby
+class B
+end
+```
+
+Execute (fenced code block syntax with a language specifier after whitespace):
+  let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
+  call b:func(0)
+  AssertEqual SyntaxOf('include'), 'cInclude'
+  AssertEqual SyntaxOf('code'), 'mkdSnippetCPP'
+  AssertEqual SyntaxOf('g:a'), 'vimVar'
+  AssertEqual SyntaxOf('def'), 'rubyDefine'
+  AssertNotEqual SyntaxOf('class'), 'rubyClass'
+
+Given markdown;
+```vim
+let g:a = 1
+```
+
+```viml
+let g:b = 1
+```
+
+Execute (fenced code block syntax with alias language specifier):
+  let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
+  call b:func(0)
+  AssertEqual SyntaxOf('g:a'), 'vimVar'
+  AssertEqual SyntaxOf('g:b'), 'vimVar'
+
+Given markdown;
+```csharp
+var s = "foo";
+```
+
+Execute (fenced code block languages setting):
+  let g:vim_markdown_fenced_languages = ['csharp=cs']
+  source ../ftplugin/markdown.vim
+  let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
+  call b:func(0)
+  AssertEqual SyntaxOf('foo'), 'csString'
+  unlet g:vim_markdown_fenced_languages
+
+Given markdown;
+```vim
+let g:a = 1
+```
+
+Execute (fenced code block includes language syntax with reopening same buffer):
+  let b:func = Markdown_GetFunc('vim-markdown/ftplugin/markdown.vim', 'MarkdownRefreshSyntax')
+  call b:func(0)
+  split
+  quit
+  edit
+  set filetype=markdown
+  execute "normal! i```vim\<cr>let g:a = 1\<cr>```"
+  call b:func(1)
+  AssertEqual SyntaxOf('g:a'), 'vimVar'
+
 Given markdown;
 ```a+b-
 code
 Given markdown;
 ```a+b-
 code
@@ -284,7 +578,6 @@ Execute (fenced code block syntax with an unknown language specifier):
   call b:func(0)
   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 
   call b:func(0)
   AssertEqual SyntaxOf('code'), 'mkdSnippetA_B_'
 
-
 Given markdown;
 ```
 =
 Given markdown;
 ```
 =
@@ -296,6 +589,48 @@ Execute (first = or - in fenced code block is not setex headers):
   AssertEqual SyntaxOf('='), 'mkdCode'
   AssertEqual SyntaxOf('-'), 'mkdCode'
 
   AssertEqual SyntaxOf('='), 'mkdCode'
   AssertEqual SyntaxOf('-'), 'mkdCode'
 
+Given markdown;
+``` {style=""}
+a
+```
+
+Execute (fenced code block with extended info strings):
+  AssertEqual SyntaxOf('a'), 'mkdCode'
+
+# Code Blocks in pre and code tag
+
+Given markdown;
+<pre>
+a
+</pre>
+
+Execute (code block in pre tag):
+  AssertEqual SyntaxOf('a'), 'mkdCode'
+
+Given markdown;
+<code>
+a
+</code>
+
+Execute (code block in code tag):
+  AssertEqual SyntaxOf('a'), 'mkdCode'
+
+Given markdown;
+\<pre\>
+a
+\</pre\>
+
+Execute (not code block in escaped pre tag):
+  AssertNotEqual SyntaxOf('a'), 'mkdCode'
+
+Given markdown;
+\<code\>
+a
+\</code\>
+
+Execute (not code block in escaped code tag):
+  AssertNotEqual SyntaxOf('a'), 'mkdCode'
+
 # Math
 
 Given markdown;
 # Math
 
 Given markdown;
@@ -305,22 +640,22 @@ c $$y$$ d
 \$\$f\$\$
 
 Execute (math):
 \$\$f\$\$
 
 Execute (math):
-  AssertNotEqual SyntaxOf('x'), 'mkdMath'
-  AssertNotEqual SyntaxOf('y'), 'mkdMath'
+  AssertNotEqual SyntaxOf('x')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('y')[0:2], 'tex'
   let g:vim_markdown_math=1
   syn off | syn on
   let g:vim_markdown_math=1
   syn off | syn on
-  AssertNotEqual SyntaxOf('a'), 'mkdMath'
-  AssertNotEqual SyntaxOf('b'), 'mkdMath'
-  AssertNotEqual SyntaxOf('c'), 'mkdMath'
-  AssertNotEqual SyntaxOf('d'), 'mkdMath'
-  AssertNotEqual SyntaxOf('e'), 'mkdMath'
-  AssertNotEqual SyntaxOf('f'), 'mkdMath'
-  AssertEqual SyntaxOf('x'), 'mkdMath'
-  AssertEqual SyntaxOf('y'), 'mkdMath'
+  AssertNotEqual SyntaxOf('a')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('b')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('c')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('d')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('e')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('f')[0:2], 'tex'
+  AssertEqual SyntaxOf('x')[0:2], 'tex'
+  AssertEqual SyntaxOf('y')[0:2], 'tex'
   let g:vim_markdown_math=0
   syn off | syn on
   let g:vim_markdown_math=0
   syn off | syn on
-  AssertNotEqual SyntaxOf('x'), 'mkdMath'
-  AssertNotEqual SyntaxOf('y'), 'mkdMath'
+  AssertNotEqual SyntaxOf('x')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('y')[0:2], 'tex'
 
 Given markdown;
 a
 
 Given markdown;
 a
@@ -334,9 +669,9 @@ c
 Execute (multiline math):
   let g:vim_markdown_math=1
   syn off | syn on
 Execute (multiline math):
   let g:vim_markdown_math=1
   syn off | syn on
-  AssertNotEqual SyntaxOf('a'), 'mkdMath'
-  AssertEqual SyntaxOf('b'), 'mkdMath'
-  AssertNotEqual SyntaxOf('c'), 'mkdMath'
+  AssertNotEqual SyntaxOf('a')[0:2], 'tex'
+  AssertEqual SyntaxOf('b')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('c')[0:2], 'tex'
 
 Given markdown;
 $ \sqrt{a}{b} $
 
 Given markdown;
 $ \sqrt{a}{b} $
@@ -352,6 +687,68 @@ Execute (math tex highlighting):
   AssertEqual SyntaxOf('sqrt'), 'texStatement'
   AssertEqual SyntaxOf('frac'), 'texStatement'
 
   AssertEqual SyntaxOf('sqrt'), 'texStatement'
   AssertEqual SyntaxOf('frac'), 'texStatement'
 
+Given markdown;
+$a b[$ c
+
+Execute (math ends with $):
+  let g:vim_markdown_math=1
+  syn off | syn on
+  AssertEqual SyntaxOf('a')[0:2], 'tex'
+  AssertEqual SyntaxOf('b')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('c')[0:2], 'tex'
+
+Given markdown;
+$$a b[$$ c
+
+Execute (math ends with $$):
+  let g:vim_markdown_math=1
+  syn off | syn on
+  AssertEqual SyntaxOf('a')[0:2], 'tex'
+  AssertEqual SyntaxOf('b')[0:2], 'tex'
+  AssertNotEqual SyntaxOf('c')[0:2], 'tex'
+
+Given markdown;
+$(0 \le 1)$
+
+Execute (math conceal in $):
+  if has('conceal')
+    setlocal conceallevel=2
+    let g:vim_markdown_math=1
+    syn off | syn on
+    AssertEqual synconcealed(1, 1)[0], 1, '$'
+    AssertEqual synconcealed(1, 2)[0], 0
+    AssertEqual synconcealed(1, 3)[0], 0
+    AssertEqual synconcealed(1, 4)[0], 0
+    AssertEqual synconcealed(1, 5)[0], 1, '\le'
+    AssertEqual synconcealed(1, 6)[0], 1
+    AssertEqual synconcealed(1, 7)[0], 1
+    AssertEqual synconcealed(1, 8)[0], 0
+    AssertEqual synconcealed(1, 9)[0], 0
+    AssertEqual synconcealed(1, 10)[0], 0
+    AssertEqual synconcealed(1, 11)[0], 1, '$'
+    setlocal conceallevel=0
+  endif
+
+Given markdown;
+$$
+\omega
+0 \le 1
+$$
+
+Execute (math conceal in $$):
+  if has('conceal')
+    setlocal conceallevel=2
+    let g:vim_markdown_math=1
+    syn off | syn on
+    AssertEqual synconcealed(1, 1)[0], 1, '$$'
+    AssertEqual synconcealed(2, 1)[0], 1, '\omega'
+    AssertEqual synconcealed(3, 1)[0], 0, '0'
+    AssertEqual synconcealed(3, 3)[0], 1, '\le'
+    AssertEqual synconcealed(3, 7)[0], 0, '1'
+    AssertEqual synconcealed(4, 1)[0], 1, '$$'
+    setlocal conceallevel=0
+  endif
+
 # YAML frontmatter
 
 Given markdown;
 # YAML frontmatter
 
 Given markdown;
@@ -360,13 +757,13 @@ a: b
 ---
 
 Execute (YAML frontmatter is controlled by the option):
 ---
 
 Execute (YAML frontmatter is controlled by the option):
-  AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
+  AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
   let g:vim_markdown_frontmatter=1
   syn off | syn on
   let g:vim_markdown_frontmatter=1
   syn off | syn on
-  AssertEqual SyntaxOf('a'), 'yamlBlockMappingKey'
+  AssertEqual SyntaxOf('a')[0:3], 'yaml'
   let g:vim_markdown_frontmatter=0
   syn off | syn on
   let g:vim_markdown_frontmatter=0
   syn off | syn on
-  AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
+  AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 
 Given markdown;
 
 
 Given markdown;
 
@@ -377,7 +774,7 @@ a: b
 Execute (YAML frontmatter only works if it's the first thing in the file):
   let g:vim_markdown_frontmatter=1
   syn off | syn on
 Execute (YAML frontmatter only works if it's the first thing in the file):
   let g:vim_markdown_frontmatter=1
   syn off | syn on
-  AssertNotEqual SyntaxOf('a'), 'yamlBlockMappingKey'
+  AssertNotEqual SyntaxOf('a')[0:3], 'yaml'
 
 Given markdown;
 ---
 
 Given markdown;
 ---
@@ -390,6 +787,65 @@ Execute (rules are not mistaken by YAML frontmatter delimiters):
   let g:vim_markdown_frontmatter=1
   syn off | syn on
   AssertEqual SyntaxAt(5, 1), 'mkdRule'
   let g:vim_markdown_frontmatter=1
   syn off | syn on
   AssertEqual SyntaxAt(5, 1), 'mkdRule'
+  unlet g:vim_markdown_frontmatter
+
+# TOML frontmatter
+
+Given markdown;
++++
+a = "b"
++++
+
+Execute (TOML frontmatter is controlled by the option):
+  syn off | syn on
+  AssertNotEqual SyntaxOf('b'), 'tomlString'
+  let g:vim_markdown_toml_frontmatter=1
+  syn off | syn on
+  AssertEqual SyntaxOf('b'), 'tomlString'
+  let g:vim_markdown_toml_frontmatter=0
+  syn off | syn on
+  AssertNotEqual SyntaxOf('b'), 'tomlString'
+
+Given markdown;
+
++++
+a = "b"
++++
+
+Execute (TOML frontmatter only works if it's the first thing in the file):
+  let g:vim_markdown_toml_frontmatter=1
+  syn off | syn on
+  AssertNotEqual SyntaxOf('b'), 'tomlString'
+  unlet g:vim_markdown_toml_frontmatter
+
+# JSON frontmatter
+
+Given markdown;
+{
+  "a": "b"
+}
+
+Execute (JSON frontmatter is controlled by the option):
+  syn off | syn on
+  AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
+  let g:vim_markdown_json_frontmatter=1
+  syn off | syn on
+  AssertEqual SyntaxOf('a'), 'jsonKeyword'
+  let g:vim_markdown_json_frontmatter=0
+  syn off | syn on
+  AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
+
+Given markdown;
+
+{
+  "a": "b"
+}
+
+Execute (JSON frontmatter only works if it's the first thing in the file):
+  let g:vim_markdown_json_frontmatter=1
+  syn off | syn on
+  AssertNotEqual SyntaxOf('a'), 'jsonKeyword'
+  unlet g:vim_markdown_json_frontmatter
 
 # Header
 
 
 # Header
 
@@ -525,6 +981,14 @@ Execute (& and > are not marked as htmlError in lists):
   AssertNotEqual SyntaxOf('&'), 'htmlError'
   AssertNotEqual SyntaxOf('>'), 'htmlError'
 
   AssertNotEqual SyntaxOf('&'), 'htmlError'
   AssertNotEqual SyntaxOf('>'), 'htmlError'
 
+Given markdown;
+1. a  
+2. b
+
+Execute (list after line break):
+  AssertEqual SyntaxOf('1'), 'mkdListItem'
+  AssertEqual SyntaxOf('2'), 'mkdListItem'
+
 # HTML
 
 Given markdown;
 # HTML
 
 Given markdown;
vim configuration

Legalese

All content available in this repository is copyright © martin f. krafft, unless otherwise noted.

All files and their content are released under the terms of the Artistic Licence 2.0, unless otherwise noted.

The operator of this repository shall not be held liable for offending content in pages linking to or linked from these page, nor does he endorse their content unless stated otherwise.