xenia/kakoune
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b9c60e2578
kakoune/rc/filetype/markdown.kak

131 lines
5.6 KiB
Plaintext
Raw Normal View History

add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# http://daringfireball.net/projects/markdown
# ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
# Detection
# ‾‾‾‾‾‾‾‾‾
rc/markdown: add another markdown extension (.mkd)
2015-08-13 21:06:55 +02:00
hook global BufCreate .*[.](markdown|md|mkd) %{
rc: Don't use command aliases to highlight keywords properly
2017-11-03 08:34:41 +01:00
set-option buffer filetype markdown
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
}
Update remaining files to new provide/require format
2019-04-12 00:54:58 +02:00
# Initialization
# ‾‾‾‾‾‾‾‾‾‾‾‾‾‾
hook global WinSetOption filetype=markdown %{
Modified a bunch of language support files to use modules
2019-03-13 06:24:33 +01:00
require-module markdown
Update remaining files to new provide/require format
2019-04-12 00:54:58 +02:00
rc filetype: add trim-indent hooks to all languages that have indent hooks An indent hook automatically adds whitespace, so it seems prudent to add the hook to remove unwanted whitespace again. This is what we do in most languages already.
2022-05-08 15:01:25 +02:00
hook window ModeChange pop:insert:.* -group markdown-trim-indent markdown-trim-indent
rc markdown: Add -insert hook
2021-04-02 02:18:11 +02:00
hook window InsertChar \n -group markdown-insert markdown-insert-on-new-line
Update remaining files to new provide/require format
2019-04-12 00:54:58 +02:00
hook window InsertChar \n -group markdown-indent markdown-indent-on-new-line
hook -once -always window WinSetOption filetype=.* %{ remove-hooks window markdown-.+ }
Modified a bunch of language support files to use modules
2019-03-13 06:24:33 +01:00
}
Use module alias pattern for markdown dynamic loading
2019-07-23 04:01:40 +02:00
hook -group markdown-load-languages global WinSetOption filetype=markdown %{
rc markdown: only add language highlighters for actual code blocks in buffer There have been proposals to add more language aliases to markdown.kak (#4592) and allow users to add their own aliases (#4489). To recap: various markdown implementations allow specifying aliases for languages. For example, here is a code block that should be highlighted as filetype "haskell" but isn't: ```hs -- highlight as haskell ``` There are lots of aliases out in the wild - "pygmentize -L" lists some but I don't think there is a canonical list. Today we have a hardcoded list of supported filetypes. This is hard to mainta, extend, and it can impact performance. This patch simply attempts to load the module "hs" and the shared highlighter "hs". This means that users can use this (obvious?) snippet to add their own aliases: provide-module hs %{ require-module haskell add-highlighter shared/hs ref haskell } Untrusted Markdown files can load arbitrary modules, but that was already true before, and modules are assumed to be trusted anyway. Since language highlighters are now loaded *after* the generic code-block highlighter, we need to make sure the language highlighters take precedence. Do this by making them sub-regions of the generic one. Closes #4489 This improves performance on the [5MB Markdown file](https://github.com/mawww/kakoune/issues/4685#issuecomment-1208129806). $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 3.225 s ± 0.074 s [User: 3.199 s, System: 0.027 s] Range (min … max): 3.099 s … 3.362 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.181 s ± 0.030 s [User: 1.162 s, System: 0.021 s] Range (min … max): 1.149 s … 1.234 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 2.73 ± 0.09 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' (These numbers depend on another optimization.)
2022-08-16 19:47:23 +02:00
markdown-load-languages '%'
}
hook -group markdown-load-languages global WinSetOption filetype=markdown %{
hook -group markdown-load-languages window NormalIdle .* %{markdown-load-languages gtGbGl}
hook -group markdown-load-languages window InsertIdle .* %{markdown-load-languages gtGbGl}
Modified a bunch of language support files to use modules
2019-03-13 06:24:33 +01:00
}
Use module alias pattern for markdown dynamic loading
2019-07-23 04:01:40 +02:00
Update remaining files to new provide/require format
2019-04-12 00:54:58 +02:00
hook -group markdown-highlight global WinSetOption filetype=markdown %{
add-highlighter window/markdown ref markdown
hook -once -always window WinSetOption filetype=.* %{ remove-highlighter window/markdown }
}
Modified a bunch of language support files to use modules
2019-03-13 06:24:33 +01:00
provide-module markdown %{
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# Highlighters
# ‾‾‾‾‾‾‾‾‾‾‾‾
Fix tests and required scripts to get back to green make test
2018-06-28 14:10:22 +02:00
add-highlighter shared/markdown regions
Make list items match as regions
2018-11-08 18:44:03 +01:00
add-highlighter shared/markdown/inline default-region regions
add-highlighter shared/markdown/inline/text default-region group
Fix tests and required scripts to get back to green make test
2018-06-28 14:10:22 +02:00
rc markdown: use language highlighting also for indented code blocks inside lists
2022-08-16 19:44:08 +02:00
add-highlighter shared/markdown/listblock region ^\h*[-*]\s ^(?=\S) regions
add-highlighter shared/markdown/listblock/g default-region group
add-highlighter shared/markdown/listblock/g/ ref markdown/inline
add-highlighter shared/markdown/listblock/g/marker regex ^\h*([-*])\s 1:bullet
rc markdown: Fix fenced code blocks The closing ``` in the following example was not detected because the indented code block highlighter was higher up in the hierarchy than the fenced code block highlighter: ``` indented ``` The codeblock highlighter used to be inline so that it has an effect inside listblocks. This commits adds a listblock/codeblock highlighter as a replacement. Fixes #4351
2021-09-23 16:42:53 +02:00
add-highlighter shared/markdown/codeblock region -match-capture \
^(\h*)```\h* \
^(\h*)```\h*$ \
rc markdown: only add language highlighters for actual code blocks in buffer There have been proposals to add more language aliases to markdown.kak (#4592) and allow users to add their own aliases (#4489). To recap: various markdown implementations allow specifying aliases for languages. For example, here is a code block that should be highlighted as filetype "haskell" but isn't: ```hs -- highlight as haskell ``` There are lots of aliases out in the wild - "pygmentize -L" lists some but I don't think there is a canonical list. Today we have a hardcoded list of supported filetypes. This is hard to mainta, extend, and it can impact performance. This patch simply attempts to load the module "hs" and the shared highlighter "hs". This means that users can use this (obvious?) snippet to add their own aliases: provide-module hs %{ require-module haskell add-highlighter shared/hs ref haskell } Untrusted Markdown files can load arbitrary modules, but that was already true before, and modules are assumed to be trusted anyway. Since language highlighters are now loaded *after* the generic code-block highlighter, we need to make sure the language highlighters take precedence. Do this by making them sub-regions of the generic one. Closes #4489 This improves performance on the [5MB Markdown file](https://github.com/mawww/kakoune/issues/4685#issuecomment-1208129806). $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 3.225 s ± 0.074 s [User: 3.199 s, System: 0.027 s] Range (min … max): 3.099 s … 3.362 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.181 s ± 0.030 s [User: 1.162 s, System: 0.021 s] Range (min … max): 1.149 s … 1.234 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 2.73 ± 0.09 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' (These numbers depend on another optimization.)
2022-08-16 19:47:23 +02:00
regions
add-highlighter shared/markdown/codeblock/ default-region fill meta
rc markdown: Fix fenced code blocks The closing ``` in the following example was not detected because the indented code block highlighter was higher up in the hierarchy than the fenced code block highlighter: ``` indented ``` The codeblock highlighter used to be inline so that it has an effect inside listblocks. This commits adds a listblock/codeblock highlighter as a replacement. Fixes #4351
2021-09-23 16:42:53 +02:00
add-highlighter shared/markdown/listblock/codeblock region -match-capture \
^(\h*)```\h* \
^(\h*)```\h*$ \
rc markdown: only add language highlighters for actual code blocks in buffer There have been proposals to add more language aliases to markdown.kak (#4592) and allow users to add their own aliases (#4489). To recap: various markdown implementations allow specifying aliases for languages. For example, here is a code block that should be highlighted as filetype "haskell" but isn't: ```hs -- highlight as haskell ``` There are lots of aliases out in the wild - "pygmentize -L" lists some but I don't think there is a canonical list. Today we have a hardcoded list of supported filetypes. This is hard to mainta, extend, and it can impact performance. This patch simply attempts to load the module "hs" and the shared highlighter "hs". This means that users can use this (obvious?) snippet to add their own aliases: provide-module hs %{ require-module haskell add-highlighter shared/hs ref haskell } Untrusted Markdown files can load arbitrary modules, but that was already true before, and modules are assumed to be trusted anyway. Since language highlighters are now loaded *after* the generic code-block highlighter, we need to make sure the language highlighters take precedence. Do this by making them sub-regions of the generic one. Closes #4489 This improves performance on the [5MB Markdown file](https://github.com/mawww/kakoune/issues/4685#issuecomment-1208129806). $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 3.225 s ± 0.074 s [User: 3.199 s, System: 0.027 s] Range (min … max): 3.099 s … 3.362 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.181 s ± 0.030 s [User: 1.162 s, System: 0.021 s] Range (min … max): 1.149 s … 1.234 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 2.73 ± 0.09 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' (These numbers depend on another optimization.)
2022-08-16 19:47:23 +02:00
regions
add-highlighter shared/markdown/listblock/codeblock/ default-region fill meta
rc markdown: Fix fenced code blocks The closing ``` in the following example was not detected because the indented code block highlighter was higher up in the hierarchy than the fenced code block highlighter: ``` indented ``` The codeblock highlighter used to be inline so that it has an effect inside listblocks. This commits adds a listblock/codeblock highlighter as a replacement. Fixes #4351
2021-09-23 16:42:53 +02:00
add-highlighter shared/markdown/codeline region "^( {4}|\t)" "$" fill meta
rc markdown: Prevent underscores in URLs cause italic highlighting Create regions to achieve that. Add support for inline links.
2021-01-05 18:51:37 +01:00
# https://spec.commonmark.org/0.29/#link-destination
add-highlighter shared/markdown/angle_bracket_url region (?<=<)([a-z]+://|(mailto|magnet|xmpp):) (?!\\).(?=>)|\n fill link
rc markdown taskpaper: require bare URL to start at word boundary I can't think of a case where a URL would not start at a word boundary. Let's add that to the regex. In addition to correctness, this also slightly improves performance because matching can stop earlier. $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.123 s ± 0.022 s [User: 1.100 s, System: 0.027 s] Range (min … max): 1.093 s … 1.174 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.019 s ± 0.026 s [User: 1.001 s, System: 0.021 s] Range (min … max): 0.984 s … 1.051 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 1.10 ± 0.04 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy'
2022-08-15 22:22:23 +02:00
add-highlighter shared/markdown/inline/url region -recurse \( (\b[a-z]+://|(mailto|magnet|xmpp):) (?!\\).(?=\))|\s fill link
add-highlighter shared/markdown/listblock/angle_bracket_url region (?<=<)(\b[a-z]+://|(mailto|magnet|xmpp):) (?!\\).(?=>)|\n fill link
Make list items match as regions
2018-11-08 18:44:03 +01:00
rc markdown: Highlight HTML tags
2021-01-05 19:09:33 +01:00
try %{
require-module html
rc markdown: Fix HTML highlighting in inline code Because the HTML highlighter was higher up in the hierarchy than the code highlighter, it took precedence. I fixed it by making it an inline region. Using my new knowledge of "inline" I was able to remove one line of code. Fixes #4091
2021-03-21 09:52:00 +01:00
add-highlighter shared/markdown/inline/tag region (?i)</?[a-z][a-z0-9-]*\s*([a-z_:]|(?=>)) > ref html/tag
rc markdown: Highlight HTML tags
2021-01-05 19:09:33 +01:00
}
Make list items match as regions
2018-11-08 18:44:03 +01:00
add-highlighter shared/markdown/inline/code region -match-capture (`+) (`+) fill mono
markdown.kak: Clean up code-block and code-span formatting. Previously, a code block was anything between triple-backtics, including inline blocks: some text ``` not a codeblock, but highlighted as one ``` other text and even if the closing backticks had the wrong indent: ``` this is a code block containing a triple backtick ``` this is still a code block, but Kakoune thinks otherwise ``` Now we use the -match-capture flag to ensure the start and end fences have exactly the same indent. Previously, the generic code-block region was defined first, which meant that it took priority over all the language-specific highlighters. Now we define the generic code-block highlighting *after* the others, which fixes #2304. Previously, code-spans were defined as ordinary inline markup, but in Markdown ordinary formatting doesn't work inside code-spans. Therefore, they are now regions unto themselves, defined according to section 6.3 of the CommonMark spec <https://spec.commonmark.org/0.28/#code-spans>, which addresses a comment on #2111.
2018-09-18 10:55:24 +02:00
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# Setext-style header
Fix regression on setext-style markdown header Reproduce: header1 header2 -------
2020-05-28 08:33:00 +02:00
add-highlighter shared/markdown/inline/text/ regex (\A|^\n)[^\n]+\n={2,}\h*\n\h*$ 0:title
add-highlighter shared/markdown/inline/text/ regex (\A|^\n)[^\n]+\n-{2,}\h*\n\h*$ 0:header
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# Atx-style header
Merge remote-tracking branch 'lePerdu/markdown_highlighter'
2018-11-27 08:22:21 +01:00
add-highlighter shared/markdown/inline/text/ regex ^#[^\n]* 0:header
Make list items match as regions
2018-11-08 18:44:03 +01:00
colors: Retire the `bold` and `italic` faces This commit removes declarations and mentions to the built-in `bold` and `italic` faces. While they could be a user-friendly way of customising how tokens are emphasised in Markdown documents (similarly to the `$LESS_TERMCAP_*` environment variables for `man` pagers), most other markup languages do not have the concept of "strong" and "emphasis" but refer directly to the font style/weight. The faces were also not even set by default to highlight as their names implied, so having markup language support scripts directly use the +b and +i face attributes is more consistent.
2020-05-15 10:56:38 +02:00
add-highlighter shared/markdown/inline/text/ regex (?<!\*)(\*([^\s*]|([^\s*](\n?[^\n*])*[^\s*]))\*)(?!\*) 1:+i
add-highlighter shared/markdown/inline/text/ regex (?<!_)(_([^\s_]|([^\s_](\n?[^\n_])*[^\s_]))_)(?!_) 1:+i
add-highlighter shared/markdown/inline/text/ regex (?<!\*)(\*\*([^\s*]|([^\s*](\n?[^\n*])*[^\s*]))\*\*)(?!\*) 1:+b
add-highlighter shared/markdown/inline/text/ regex (?<!_)(__([^\s_]|([^\s_](\n?[^\n_])*[^\s_]))__)(?!_) 1:+b
Make list items match as regions
2018-11-08 18:44:03 +01:00
add-highlighter shared/markdown/inline/text/ regex ^\h*(>\h*)+ 0:comment
rc markdown: Highlight trailing spaces properly This commit addresses the following issues: * highlight trailing space characters with the `meta` face, instead of `PrimarySelection` * make the regex more readable by using a capture group in stead of `\K` * specifically match space characters, not other horizontal whitespace characters * match two or more space characters Reference[1]: > When you do want to insert a <br /> break tag using Markdown, you > end a line with two or more spaces, then type return. [1] https://daringfireball.net/projects/markdown/syntax#p Note that the original reproducer doesn't seem to work anymore, probably because of changes made to how lists are highlighted. Fixes #911
2020-09-01 12:11:36 +02:00
add-highlighter shared/markdown/inline/text/ regex "\H( {2,})$" 1:+r@meta
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# Commands
# ‾‾‾‾‾‾‾‾
rc markdown: only add language highlighters for actual code blocks in buffer There have been proposals to add more language aliases to markdown.kak (#4592) and allow users to add their own aliases (#4489). To recap: various markdown implementations allow specifying aliases for languages. For example, here is a code block that should be highlighted as filetype "haskell" but isn't: ```hs -- highlight as haskell ``` There are lots of aliases out in the wild - "pygmentize -L" lists some but I don't think there is a canonical list. Today we have a hardcoded list of supported filetypes. This is hard to mainta, extend, and it can impact performance. This patch simply attempts to load the module "hs" and the shared highlighter "hs". This means that users can use this (obvious?) snippet to add their own aliases: provide-module hs %{ require-module haskell add-highlighter shared/hs ref haskell } Untrusted Markdown files can load arbitrary modules, but that was already true before, and modules are assumed to be trusted anyway. Since language highlighters are now loaded *after* the generic code-block highlighter, we need to make sure the language highlighters take precedence. Do this by making them sub-regions of the generic one. Closes #4489 This improves performance on the [5MB Markdown file](https://github.com/mawww/kakoune/issues/4685#issuecomment-1208129806). $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 3.225 s ± 0.074 s [User: 3.199 s, System: 0.027 s] Range (min … max): 3.099 s … 3.362 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.181 s ± 0.030 s [User: 1.162 s, System: 0.021 s] Range (min … max): 1.149 s … 1.234 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 2.73 ± 0.09 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' (These numbers depend on another optimization.)
2022-08-16 19:47:23 +02:00
define-command markdown-load-languages -params 1 %{
evaluate-commands -draft %{ try %{
Avoid semantically significant comments in kak files Kakoune's balanced strings require that delimiter characters nested inside them are also paired, so for example in %{ }, each nested { must occur before a corresponding } to balance it out. In general this will automatically be the case for code in common scripting languages, but sometimes regular expressions used for syntax highlighting do end up containing an unbalanced bracket of one type or another. This problem is easily solved because there is a free choice of balanced delimiter characters. However, it can also be worked around by adding a comment which itself contains an unbalanced delimiter character, to 'balance out' the unpaired one in the regular expression. These unbalanced comments are not ideal as the semantic role they perform is easy for a casual reader to overlook. A good example is catch %{ # indent after lines with an unclosed { or ( try %< execute-keys -draft [c[({],[)}] <ret> <a-k> \A[({][^\n]*\n[^\n]*\n?\z <ret> j<a- gt> > # indent after a switch's case/default statements try %[ execute-keys -draft kx <a-k> ^\h*(case|default).*:$ <ret> j<a-gt> ] # deindent closing brace(s) when after cursor try %[ execute-keys -draft x <a-k> ^\h*[})] <ret> gh / [})] <ret> m <a-S> 1<a-&> ] } in rc/filetype/go/kak. Here, it is not instantly obvious that the comment containing an unmatched { is required for correctness. If you change the comment, delete it or rearrange the contents of the catch block, go.kak will fail to load, and if you cut-and-paste this code as the basis for a new filetype, it is a loaded gun pointing at your feet. Luckily, a careful audit of the standard kakoune library turned up only three such instances, in go.kak, hare.kak and markdown.kak. The examples in go.kak and hare.kak are easily made robust by replacing a %{ } with %< > or %[ ] respectively. The example in markdown.kak is least-intrusively fixed by rewriting the affected regular expression slightly so it has balanced { and } anyway.
2023-12-13 17:40:48 +01:00
execute-keys "%arg{1}1s```\h*\{?[.=]?(\w+)\}?<ret>"
rc markdown: only add language highlighters for actual code blocks in buffer There have been proposals to add more language aliases to markdown.kak (#4592) and allow users to add their own aliases (#4489). To recap: various markdown implementations allow specifying aliases for languages. For example, here is a code block that should be highlighted as filetype "haskell" but isn't: ```hs -- highlight as haskell ``` There are lots of aliases out in the wild - "pygmentize -L" lists some but I don't think there is a canonical list. Today we have a hardcoded list of supported filetypes. This is hard to mainta, extend, and it can impact performance. This patch simply attempts to load the module "hs" and the shared highlighter "hs". This means that users can use this (obvious?) snippet to add their own aliases: provide-module hs %{ require-module haskell add-highlighter shared/hs ref haskell } Untrusted Markdown files can load arbitrary modules, but that was already true before, and modules are assumed to be trusted anyway. Since language highlighters are now loaded *after* the generic code-block highlighter, we need to make sure the language highlighters take precedence. Do this by making them sub-regions of the generic one. Closes #4489 This improves performance on the [5MB Markdown file](https://github.com/mawww/kakoune/issues/4685#issuecomment-1208129806). $ HOME=$PWD hyperfine -w 1 'git checkout HEAD'{~,}' -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' Benchmark 1: git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 3.225 s ± 0.074 s [User: 3.199 s, System: 0.027 s] Range (min … max): 3.099 s … 3.362 s 10 runs Benchmark 2: git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy Time (mean ± σ): 1.181 s ± 0.030 s [User: 1.162 s, System: 0.021 s] Range (min … max): 1.149 s … 1.234 s 10 runs Summary 'git checkout HEAD -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' ran 2.73 ± 0.09 times faster than 'git checkout HEAD~ -- :/rc/filetype/markdown.kak && ./kak.opt big_markdown.md -e "hook global NormalIdle .* quit" -ui dummy' (These numbers depend on another optimization.)
2022-08-16 19:47:23 +02:00
evaluate-commands -itersel %{ try %{
require-module %val{selection}
add-highlighter "shared/markdown/codeblock/%val{selection}" region -match-capture "^(\h*)```\h*(%val{selection}\b|\{[.=]?%val{selection}\})" ^(\h*)``` regions
add-highlighter "shared/markdown/codeblock/%val{selection}/" default-region fill meta
add-highlighter "shared/markdown/codeblock/%val{selection}/inner" region \A\h*```[^\n]*\K (?=```) ref %val{selection}
add-highlighter "shared/markdown/listblock/codeblock/%val{selection}" region -match-capture "^(\h*)```\h*(%val{selection}\b|\{[.=]?%val{selection}\})" ^(\h*)``` regions
add-highlighter "shared/markdown/listblock/codeblock/%val{selection}/" default-region fill meta
add-highlighter "shared/markdown/listblock/codeblock/%val{selection}/inner" region \A\h*```[^\n]*\K (?=```) ref %val{selection}
}}
}}
}
rc filetype: add trim-indent hooks to all languages that have indent hooks An indent hook automatically adds whitespace, so it seems prudent to add the hook to remove unwanted whitespace again. This is what we do in most languages already.
2022-05-08 15:01:25 +02:00
define-command -hidden markdown-trim-indent %{
evaluate-commands -no-hooks -draft -itersel %{
Make `x` just select the full lines `x` is often criticized as hard to predict due to its slightly complex behaviour of selecting next line if the current one is fully selected. Change `x` to use the previous `<a-x>` behaviour, and change `<a-x>` to trim to fully selected lines as `<a-X>` did. Adapt existing indentation script to the new behaviour
2022-03-16 23:20:07 +01:00
execute-keys x
rc filetype: add trim-indent hooks to all languages that have indent hooks An indent hook automatically adds whitespace, so it seems prudent to add the hook to remove unwanted whitespace again. This is what we do in most languages already.
2022-05-08 15:01:25 +02:00
# remove trailing white spaces
try %{ execute-keys -draft s \h + $ <ret> d }
}
}
rc markdown: Add -insert hook
2021-04-02 02:18:11 +02:00
define-command -hidden markdown-insert-on-new-line %{
Make `x` just select the full lines `x` is often criticized as hard to predict due to its slightly complex behaviour of selecting next line if the current one is fully selected. Change `x` to use the previous `<a-x>` behaviour, and change `<a-x>` to trim to fully selected lines as `<a-X>` did. Adapt existing indentation script to the new behaviour
2022-03-16 23:20:07 +01:00
try %{ execute-keys -draft -itersel k x s ^\h*\K((>\h*)+([*+-]\h)?|(>\h*)*[*+-]\h)\h* <ret> y gh j P }
rc markdown: Add -insert hook
2021-04-02 02:18:11 +02:00
}
rc: Don't use command aliases to highlight keywords properly
2017-11-03 08:34:41 +01:00
define-command -hidden markdown-indent-on-new-line %{
src rc: Rename `exec`/`eval` into `execute-keys`/`evaluate-commands`
2017-11-03 09:09:45 +01:00
evaluate-commands -draft -itersel %{
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
# preserve previous line indent
src: Create a <semicolon> named key This commit allows using the <semicolon> expansion in commands, instead of `\;`. It makes commands look more elegant, and prevents new-comers from falling into the trap of using <a-;> without escaping the semicolon.
2019-10-22 11:02:06 +02:00
try %{ execute-keys -draft <semicolon> K <a-&> }
Cleanup the various trailing space removal hooks
2015-11-04 10:48:47 +01:00
# remove trailing white spaces
Make `x` just select the full lines `x` is often criticized as hard to predict due to its slightly complex behaviour of selecting next line if the current one is fully selected. Change `x` to use the previous `<a-x>` behaviour, and change `<a-x>` to trim to fully selected lines as `<a-X>` did. Adapt existing indentation script to the new behaviour
2022-03-16 23:20:07 +01:00
try %{ execute-keys -draft k x s \h+$ <ret> d }
add rc/markdown.kak
2014-07-14 22:51:33 +02:00
}
}
Modified a bunch of language support files to use modules
2019-03-13 06:24:33 +01:00
}
Reference in New Issue Copy Permalink