forked from forgejo/forgejo
Server-side syntax highlighting for all code (#12047)
* Server-side syntax hilighting for all code This PR does a few things: * Remove all traces of highlight.js * Use chroma library to provide fast syntax hilighting directly on the server * Provide syntax hilighting for diffs * Re-style both unified and split diffs views * Add custom syntax hilighting styling for both regular and arc-green Fixes #7729 Fixes #10157 Fixes #11825 Fixes #7728 Fixes #3872 Fixes #3682 And perhaps gets closer to #9553 * fix line marker * fix repo search * Fix single line select * properly load settings * npm uninstall highlight.js * review suggestion * code review * forgot to call function * fix test * Apply suggestions from code review suggestions from @silverwind thanks Co-authored-by: silverwind <me@silverwind.io> * code review * copy/paste error * Use const for highlight size limit * Update web_src/less/_repository.less Co-authored-by: Lauris BH <lauris@nix.lv> * update size limit to 1MB and other styling tweaks * fix highlighting for certain diff sections * fix test * add worker back as suggested Co-authored-by: silverwind <me@silverwind.io> Co-authored-by: Lauris BH <lauris@nix.lv>
This commit is contained in:
mrsdizzie
GitHub
parent
ce5f2b9845
commit
af7ffaa279
336 changed files with 37293 additions and 769 deletions
66
vendor/github.com/alecthomas/chroma/lexers/r/r.go
generated
vendored
Normal file
66
vendor/github.com/alecthomas/chroma/lexers/r/r.go
generated
vendored
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// R/S lexer.
|
||||
var R = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "R",
|
||||
Aliases: []string{"splus", "s", "r"},
|
||||
Filenames: []string{"*.S", "*.R", "*.r", ".Rhistory", ".Rprofile", ".Renviron"},
|
||||
MimeTypes: []string{"text/S-plus", "text/S", "text/x-r-source", "text/x-r", "text/x-R", "text/x-r-history", "text/x-r-profile"},
|
||||
},
|
||||
Rules{
|
||||
"comments": {
|
||||
{`#.*$`, CommentSingle, nil},
|
||||
},
|
||||
"valid_name": {
|
||||
{"(?:`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)|(?:(?:[a-zA-z]|[_.][^0-9])[\\w_.]*)", Name, nil},
|
||||
},
|
||||
"punctuation": {
|
||||
{`\[{1,2}|\]{1,2}|\(|\)|;|,`, Punctuation, nil},
|
||||
},
|
||||
"keywords": {
|
||||
{`(if|else|for|while|repeat|in|next|break|return|switch|function)(?![\w.])`, KeywordReserved, nil},
|
||||
},
|
||||
"operators": {
|
||||
{`<<?-|->>?|-|==|<=|>=|<|>|&&?|!=|\|\|?|\?`, Operator, nil},
|
||||
{`\*|\+|\^|/|!|%[^%]*%|=|~|\$|@|:{1,3}`, Operator, nil},
|
||||
},
|
||||
"builtin_symbols": {
|
||||
{`(NULL|NA(_(integer|real|complex|character)_)?|letters|LETTERS|Inf|TRUE|FALSE|NaN|pi|\.\.(\.|[0-9]+))(?![\w.])`, KeywordConstant, nil},
|
||||
{`(T|F)\b`, NameBuiltinPseudo, nil},
|
||||
},
|
||||
"numbers": {
|
||||
{`0[xX][a-fA-F0-9]+([pP][0-9]+)?[Li]?`, LiteralNumberHex, nil},
|
||||
{`[+-]?([0-9]+(\.[0-9]+)?|\.[0-9]+|\.)([eE][+-]?[0-9]+)?[Li]?`, LiteralNumber, nil},
|
||||
},
|
||||
"statements": {
|
||||
Include("comments"),
|
||||
{`\s+`, Text, nil},
|
||||
{`\'`, LiteralString, Push("string_squote")},
|
||||
{`\"`, LiteralString, Push("string_dquote")},
|
||||
Include("builtin_symbols"),
|
||||
Include("valid_name"),
|
||||
Include("numbers"),
|
||||
Include("keywords"),
|
||||
Include("punctuation"),
|
||||
Include("operators"),
|
||||
},
|
||||
"root": {
|
||||
{"((?:`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)|(?:(?:[a-zA-z]|[_.][^0-9])[\\w_.]*))\\s*(?=\\()", NameFunction, nil},
|
||||
Include("statements"),
|
||||
{`\{|\}`, Punctuation, nil},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
"string_squote": {
|
||||
{`([^\'\\]|\\.)*\'`, LiteralString, Pop(1)},
|
||||
},
|
||||
"string_dquote": {
|
||||
{`([^"\\]|\\.)*"`, LiteralString, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
102
vendor/github.com/alecthomas/chroma/lexers/r/racket.go
generated
vendored
Normal file
102
vendor/github.com/alecthomas/chroma/lexers/r/racket.go
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
76
vendor/github.com/alecthomas/chroma/lexers/r/ragel.go
generated
vendored
Normal file
76
vendor/github.com/alecthomas/chroma/lexers/r/ragel.go
generated
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Ragel lexer.
|
||||
var Ragel = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "Ragel",
|
||||
Aliases: []string{"ragel"},
|
||||
Filenames: []string{},
|
||||
MimeTypes: []string{},
|
||||
},
|
||||
Rules{
|
||||
"whitespace": {
|
||||
{`\s+`, TextWhitespace, nil},
|
||||
},
|
||||
"comments": {
|
||||
{`\#.*$`, Comment, nil},
|
||||
},
|
||||
"keywords": {
|
||||
{`(access|action|alphtype)\b`, Keyword, nil},
|
||||
{`(getkey|write|machine|include)\b`, Keyword, nil},
|
||||
{`(any|ascii|extend|alpha|digit|alnum|lower|upper)\b`, Keyword, nil},
|
||||
{`(xdigit|cntrl|graph|print|punct|space|zlen|empty)\b`, Keyword, nil},
|
||||
},
|
||||
"numbers": {
|
||||
{`0x[0-9A-Fa-f]+`, LiteralNumberHex, nil},
|
||||
{`[+-]?[0-9]+`, LiteralNumberInteger, nil},
|
||||
},
|
||||
"literals": {
|
||||
{`"(\\\\|\\"|[^"])*"`, LiteralString, nil},
|
||||
{`'(\\\\|\\'|[^'])*'`, LiteralString, nil},
|
||||
{`\[(\\\\|\\\]|[^\]])*\]`, LiteralString, nil},
|
||||
{`/(?!\*)(\\\\|\\/|[^/])*/`, LiteralStringRegex, nil},
|
||||
},
|
||||
"identifiers": {
|
||||
{`[a-zA-Z_]\w*`, NameVariable, nil},
|
||||
},
|
||||
"operators": {
|
||||
{`,`, Operator, nil},
|
||||
{`\||&|--?`, Operator, nil},
|
||||
{`\.|<:|:>>?`, Operator, nil},
|
||||
{`:`, Operator, nil},
|
||||
{`->`, Operator, nil},
|
||||
{`(>|\$|%|<|@|<>)(/|eof\b)`, Operator, nil},
|
||||
{`(>|\$|%|<|@|<>)(!|err\b)`, Operator, nil},
|
||||
{`(>|\$|%|<|@|<>)(\^|lerr\b)`, Operator, nil},
|
||||
{`(>|\$|%|<|@|<>)(~|to\b)`, Operator, nil},
|
||||
{`(>|\$|%|<|@|<>)(\*|from\b)`, Operator, nil},
|
||||
{`>|@|\$|%`, Operator, nil},
|
||||
{`\*|\?|\+|\{[0-9]*,[0-9]*\}`, Operator, nil},
|
||||
{`!|\^`, Operator, nil},
|
||||
{`\(|\)`, Operator, nil},
|
||||
},
|
||||
"root": {
|
||||
Include("literals"),
|
||||
Include("whitespace"),
|
||||
Include("comments"),
|
||||
Include("keywords"),
|
||||
Include("numbers"),
|
||||
Include("identifiers"),
|
||||
Include("operators"),
|
||||
{`\{`, Punctuation, Push("host")},
|
||||
{`=`, Operator, nil},
|
||||
{`;`, Punctuation, nil},
|
||||
},
|
||||
"host": {
|
||||
{`([^{}\'"/#]+|[^\\]\\[{}]|"(\\\\|\\"|[^"])*"|'(\\\\|\\'|[^'])*'|//.*$\n?|/\*(.|\n)*?\*/|\#.*$\n?|/(?!\*)(\\\\|\\/|[^/])*/|/)+`, Other, nil},
|
||||
{`\{`, Punctuation, Push()},
|
||||
{`\}`, Punctuation, Pop(1)},
|
||||
},
|
||||
},
|
||||
))
|
||||
67
vendor/github.com/alecthomas/chroma/lexers/r/reasonml.go
generated
vendored
Normal file
67
vendor/github.com/alecthomas/chroma/lexers/r/reasonml.go
generated
vendored
Normal file
|
|
@ -0,0 +1,67 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Reasonml lexer.
|
||||
var Reasonml = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "ReasonML",
|
||||
Aliases: []string{"reason", "reasonml"},
|
||||
Filenames: []string{"*.re", "*.rei"},
|
||||
MimeTypes: []string{"text/x-reasonml"},
|
||||
},
|
||||
Rules{
|
||||
"escape-sequence": {
|
||||
{`\\[\\"\'ntbr]`, LiteralStringEscape, nil},
|
||||
{`\\[0-9]{3}`, LiteralStringEscape, nil},
|
||||
{`\\x[0-9a-fA-F]{2}`, LiteralStringEscape, nil},
|
||||
},
|
||||
"root": {
|
||||
{`\s+`, Text, nil},
|
||||
{`false|true|\(\)|\[\]`, NameBuiltinPseudo, nil},
|
||||
{`\b([A-Z][\w\']*)(?=\s*\.)`, NameNamespace, Push("dotted")},
|
||||
{`\b([A-Z][\w\']*)`, NameClass, nil},
|
||||
{`//.*?\n`, CommentSingle, nil},
|
||||
{`\/\*(?![\/])`, CommentMultiline, Push("comment")},
|
||||
{`\b(as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|false|for|fun|esfun|function|functor|if|in|include|inherit|initializer|lazy|let|switch|module|pub|mutable|new|nonrec|object|of|open|pri|rec|sig|struct|then|to|true|try|type|val|virtual|when|while|with)\b`, Keyword, nil},
|
||||
{"(~|\\}|\\|]|\\||\\|\\||\\{<|\\{|`|_|]|\\[\\||\\[>|\\[<|\\[|\\?\\?|\\?|>\\}|>]|>|=|<-|<|;;|;|:>|:=|::|:|\\.\\.\\.|\\.\\.|\\.|=>|-\\.|-|,|\\+|\\*|\\)|\\(|&&|&|#|!=)", OperatorWord, nil},
|
||||
{`([=<>@^|&+\*/$%-]|[!?~])?[!$%&*+\./:<=>?@^|~-]`, Operator, nil},
|
||||
{`\b(and|asr|land|lor|lsl|lsr|lxor|mod|or)\b`, OperatorWord, nil},
|
||||
{`\b(unit|int|float|bool|string|char|list|array)\b`, KeywordType, nil},
|
||||
{`[^\W\d][\w']*`, Name, nil},
|
||||
{`-?\d[\d_]*(.[\d_]*)?([eE][+\-]?\d[\d_]*)`, LiteralNumberFloat, nil},
|
||||
{`0[xX][\da-fA-F][\da-fA-F_]*`, LiteralNumberHex, nil},
|
||||
{`0[oO][0-7][0-7_]*`, LiteralNumberOct, nil},
|
||||
{`0[bB][01][01_]*`, LiteralNumberBin, nil},
|
||||
{`\d[\d_]*`, LiteralNumberInteger, nil},
|
||||
{`'(?:(\\[\\\"'ntbr ])|(\\[0-9]{3})|(\\x[0-9a-fA-F]{2}))'`, LiteralStringChar, nil},
|
||||
{`'.'`, LiteralStringChar, nil},
|
||||
{`'`, Keyword, nil},
|
||||
{`"`, LiteralStringDouble, Push("string")},
|
||||
{`[~?][a-z][\w\']*:`, NameVariable, nil},
|
||||
},
|
||||
"comment": {
|
||||
{`[^\/*]+`, CommentMultiline, nil},
|
||||
{`\/\*`, CommentMultiline, Push()},
|
||||
{`\*\/`, CommentMultiline, Pop(1)},
|
||||
{`[\*]`, CommentMultiline, nil},
|
||||
},
|
||||
"string": {
|
||||
{`[^\\"]+`, LiteralStringDouble, nil},
|
||||
Include("escape-sequence"),
|
||||
{`\\\n`, LiteralStringDouble, nil},
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
},
|
||||
"dotted": {
|
||||
{`\s+`, Text, nil},
|
||||
{`\.`, Punctuation, nil},
|
||||
{`[A-Z][\w\']*(?=\s*\.)`, NameNamespace, nil},
|
||||
{`[A-Z][\w\']*`, NameClass, Pop(1)},
|
||||
{`[a-z_][\w\']*`, Name, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
32
vendor/github.com/alecthomas/chroma/lexers/r/regedit.go
generated
vendored
Normal file
32
vendor/github.com/alecthomas/chroma/lexers/r/regedit.go
generated
vendored
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Reg lexer.
|
||||
var Reg = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "reg",
|
||||
Aliases: []string{"registry"},
|
||||
Filenames: []string{"*.reg"},
|
||||
MimeTypes: []string{"text/x-windows-registry"},
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{`Windows Registry Editor.*`, Text, nil},
|
||||
{`\s+`, Text, nil},
|
||||
{`[;#].*`, CommentSingle, nil},
|
||||
{`(\[)(-?)(HKEY_[A-Z_]+)(.*?\])$`, ByGroups(Keyword, Operator, NameBuiltin, Keyword), nil},
|
||||
{`("(?:\\"|\\\\|[^"])+")([ \t]*)(=)([ \t]*)`, ByGroups(NameAttribute, Text, Operator, Text), Push("value")},
|
||||
{`(.*?)([ \t]*)(=)([ \t]*)`, ByGroups(NameAttribute, Text, Operator, Text), Push("value")},
|
||||
},
|
||||
"value": {
|
||||
{`-`, Operator, Pop(1)},
|
||||
{`(dword|hex(?:\([0-9a-fA-F]\))?)(:)([0-9a-fA-F,]+)`, ByGroups(NameVariable, Punctuation, LiteralNumber), Pop(1)},
|
||||
{`.+`, LiteralString, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
},
|
||||
))
|
||||
59
vendor/github.com/alecthomas/chroma/lexers/r/rexx.go
generated
vendored
Normal file
59
vendor/github.com/alecthomas/chroma/lexers/r/rexx.go
generated
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Rexx lexer.
|
||||
var Rexx = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "Rexx",
|
||||
Aliases: []string{"rexx", "arexx"},
|
||||
Filenames: []string{"*.rexx", "*.rex", "*.rx", "*.arexx"},
|
||||
MimeTypes: []string{"text/x-rexx"},
|
||||
NotMultiline: true,
|
||||
CaseInsensitive: true,
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{`\s`, TextWhitespace, nil},
|
||||
{`/\*`, CommentMultiline, Push("comment")},
|
||||
{`"`, LiteralString, Push("string_double")},
|
||||
{`'`, LiteralString, Push("string_single")},
|
||||
{`[0-9]+(\.[0-9]+)?(e[+-]?[0-9])?`, LiteralNumber, nil},
|
||||
{`([a-z_]\w*)(\s*)(:)(\s*)(procedure)\b`, ByGroups(NameFunction, TextWhitespace, Operator, TextWhitespace, KeywordDeclaration), nil},
|
||||
{`([a-z_]\w*)(\s*)(:)`, ByGroups(NameLabel, TextWhitespace, Operator), nil},
|
||||
Include("function"),
|
||||
Include("keyword"),
|
||||
Include("operator"),
|
||||
{`[a-z_]\w*`, Text, nil},
|
||||
},
|
||||
"function": {
|
||||
{Words(``, `(\s*)(\()`, `abbrev`, `abs`, `address`, `arg`, `b2x`, `bitand`, `bitor`, `bitxor`, `c2d`, `c2x`, `center`, `charin`, `charout`, `chars`, `compare`, `condition`, `copies`, `d2c`, `d2x`, `datatype`, `date`, `delstr`, `delword`, `digits`, `errortext`, `form`, `format`, `fuzz`, `insert`, `lastpos`, `left`, `length`, `linein`, `lineout`, `lines`, `max`, `min`, `overlay`, `pos`, `queued`, `random`, `reverse`, `right`, `sign`, `sourceline`, `space`, `stream`, `strip`, `substr`, `subword`, `symbol`, `time`, `trace`, `translate`, `trunc`, `value`, `verify`, `word`, `wordindex`, `wordlength`, `wordpos`, `words`, `x2b`, `x2c`, `x2d`, `xrange`), ByGroups(NameBuiltin, TextWhitespace, Operator), nil},
|
||||
},
|
||||
"keyword": {
|
||||
{`(address|arg|by|call|do|drop|else|end|exit|for|forever|if|interpret|iterate|leave|nop|numeric|off|on|options|parse|pull|push|queue|return|say|select|signal|to|then|trace|until|while)\b`, KeywordReserved, nil},
|
||||
},
|
||||
"operator": {
|
||||
{`(-|//|/|\(|\)|\*\*|\*|\\<<|\\<|\\==|\\=|\\>>|\\>|\\|\|\||\||&&|&|%|\+|<<=|<<|<=|<>|<|==|=|><|>=|>>=|>>|>|¬<<|¬<|¬==|¬=|¬>>|¬>|¬|\.|,)`, Operator, nil},
|
||||
},
|
||||
"string_double": {
|
||||
{`[^"\n]+`, LiteralString, nil},
|
||||
{`""`, LiteralString, nil},
|
||||
{`"`, LiteralString, Pop(1)},
|
||||
{`\n`, Text, Pop(1)},
|
||||
},
|
||||
"string_single": {
|
||||
{`[^\'\n]`, LiteralString, nil},
|
||||
{`\'\'`, LiteralString, nil},
|
||||
{`\'`, LiteralString, Pop(1)},
|
||||
{`\n`, Text, Pop(1)},
|
||||
},
|
||||
"comment": {
|
||||
{`[^*]+`, CommentMultiline, nil},
|
||||
{`\*/`, CommentMultiline, Pop(1)},
|
||||
{`\*`, CommentMultiline, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
86
vendor/github.com/alecthomas/chroma/lexers/r/rst.go
generated
vendored
Normal file
86
vendor/github.com/alecthomas/chroma/lexers/r/rst.go
generated
vendored
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Restructuredtext lexer.
|
||||
var Restructuredtext = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "reStructuredText",
|
||||
Aliases: []string{"rst", "rest", "restructuredtext"},
|
||||
Filenames: []string{"*.rst", "*.rest"},
|
||||
MimeTypes: []string{"text/x-rst", "text/prs.fallenstein.rst"},
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{"^(=+|-+|`+|:+|\\.+|\\'+|\"+|~+|\\^+|_+|\\*+|\\++|#+)([ \\t]*\\n)(.+)(\\n)(\\1)(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text, GenericHeading, Text), nil},
|
||||
{"^(\\S.*)(\\n)(={3,}|-{3,}|`{3,}|:{3,}|\\.{3,}|\\'{3,}|\"{3,}|~{3,}|\\^{3,}|_{3,}|\\*{3,}|\\+{3,}|#{3,})(\\n)", ByGroups(GenericHeading, Text, GenericHeading, Text), nil},
|
||||
{`^(\s*)([-*+])( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil},
|
||||
{`^(\s*)([0-9#ivxlcmIVXLCM]+\.)( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil},
|
||||
{`^(\s*)(\(?[0-9#ivxlcmIVXLCM]+\))( .+\n(?:\1 .+\n)*)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil},
|
||||
{`^(\s*)([A-Z]+\.)( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil},
|
||||
{`^(\s*)(\(?[A-Za-z]+\))( .+\n(?:\1 .+\n)+)`, ByGroups(Text, LiteralNumber, UsingSelf("inline")), nil},
|
||||
{`^(\s*)(\|)( .+\n(?:\| .+\n)*)`, ByGroups(Text, Operator, UsingSelf("inline")), nil},
|
||||
{`^( *\.\.)(\s*)((?:source)?code(?:-block)?)(::)([ \t]*)([^\n]+)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\8.*|)\n)+)`, EmitterFunc(rstCodeBlock), nil},
|
||||
{`^( *\.\.)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil},
|
||||
{`^( *\.\.)(\s*)(_(?:[^:\\]|\\.)+:)(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil},
|
||||
{`^( *\.\.)(\s*)(\[.+\])(.*?)$`, ByGroups(Punctuation, Text, NameTag, UsingSelf("inline")), nil},
|
||||
{`^( *\.\.)(\s*)(\|.+\|)(\s*)([\w:-]+?)(::)(?:([ \t]*)(.*))`, ByGroups(Punctuation, Text, NameTag, Text, OperatorWord, Punctuation, Text, UsingSelf("inline")), nil},
|
||||
{`^ *\.\..*(\n( +.*\n|\n)+)?`, CommentPreproc, nil},
|
||||
{`^( *)(:[a-zA-Z-]+:)(\s*)$`, ByGroups(Text, NameClass, Text), nil},
|
||||
{`^( *)(:.*?:)([ \t]+)(.*?)$`, ByGroups(Text, NameClass, Text, NameFunction), nil},
|
||||
{`^(\S.*(?<!::)\n)((?:(?: +.*)\n)+)`, ByGroups(UsingSelf("inline"), UsingSelf("inline")), nil},
|
||||
{`(::)(\n[ \t]*\n)([ \t]+)(.*)(\n)((?:(?:\3.*|)\n)+)`, ByGroups(LiteralStringEscape, Text, LiteralString, LiteralString, Text, LiteralString), nil},
|
||||
Include("inline"),
|
||||
},
|
||||
"inline": {
|
||||
{`\\.`, Text, nil},
|
||||
{"``", LiteralString, Push("literal")},
|
||||
{"(`.+?)(<.+?>)(`__?)", ByGroups(LiteralString, LiteralStringInterpol, LiteralString), nil},
|
||||
{"`.+?`__?", LiteralString, nil},
|
||||
{"(`.+?`)(:[a-zA-Z0-9:-]+?:)?", ByGroups(NameVariable, NameAttribute), nil},
|
||||
{"(:[a-zA-Z0-9:-]+?:)(`.+?`)", ByGroups(NameAttribute, NameVariable), nil},
|
||||
{`\*\*.+?\*\*`, GenericStrong, nil},
|
||||
{`\*.+?\*`, GenericEmph, nil},
|
||||
{`\[.*?\]_`, LiteralString, nil},
|
||||
{`<.+?>`, NameTag, nil},
|
||||
{"[^\\\\\\n\\[*`:]+", Text, nil},
|
||||
{`.`, Text, nil},
|
||||
},
|
||||
"literal": {
|
||||
{"[^`]+", LiteralString, nil},
|
||||
{"``((?=$)|(?=[-/:.,; \\n\\x00\\\u2010\\\u2011\\\u2012\\\u2013\\\u2014\\\u00a0\\'\\\"\\)\\]\\}\\>\\\u2019\\\u201d\\\u00bb\\!\\?]))", LiteralString, Pop(1)},
|
||||
{"`", LiteralString, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
|
||||
func rstCodeBlock(groups []string, lexer Lexer) Iterator {
|
||||
iterators := []Iterator{}
|
||||
tokens := []Token{
|
||||
{Punctuation, groups[1]},
|
||||
{Text, groups[2]},
|
||||
{OperatorWord, groups[3]},
|
||||
{Punctuation, groups[4]},
|
||||
{Text, groups[5]},
|
||||
{Keyword, groups[6]},
|
||||
{Text, groups[7]},
|
||||
}
|
||||
code := strings.Join(groups[8:], "")
|
||||
lexer = internal.Get(groups[6])
|
||||
if lexer == nil {
|
||||
tokens = append(tokens, Token{String, code})
|
||||
iterators = append(iterators, Literator(tokens...))
|
||||
} else {
|
||||
sub, err := lexer.Tokenise(nil, code)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
iterators = append(iterators, Literator(tokens...), sub)
|
||||
}
|
||||
return Concaterator(iterators...)
|
||||
}
|
||||
250
vendor/github.com/alecthomas/chroma/lexers/r/ruby.go
generated
vendored
Normal file
250
vendor/github.com/alecthomas/chroma/lexers/r/ruby.go
generated
vendored
Normal file
|
|
@ -0,0 +1,250 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Ruby lexer.
|
||||
var Ruby = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "Ruby",
|
||||
Aliases: []string{"rb", "ruby", "duby"},
|
||||
Filenames: []string{"*.rb", "*.rbw", "Rakefile", "*.rake", "*.gemspec", "*.rbx", "*.duby", "Gemfile"},
|
||||
MimeTypes: []string{"text/x-ruby", "application/x-ruby"},
|
||||
DotAll: true,
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{`\A#!.+?$`, CommentHashbang, nil},
|
||||
{`#.*?$`, CommentSingle, nil},
|
||||
{`=begin\s.*?\n=end.*?$`, CommentMultiline, nil},
|
||||
{Words(``, `\b`, `BEGIN`, `END`, `alias`, `begin`, `break`, `case`, `defined?`, `do`, `else`, `elsif`, `end`, `ensure`, `for`, `if`, `in`, `next`, `redo`, `rescue`, `raise`, `retry`, `return`, `super`, `then`, `undef`, `unless`, `until`, `when`, `while`, `yield`), Keyword, nil},
|
||||
{`(module)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)`, ByGroups(Keyword, Text, NameNamespace), nil},
|
||||
{`(def)(\s+)`, ByGroups(Keyword, Text), Push("funcname")},
|
||||
{"def(?=[*%&^`~+-/\\[<>=])", Keyword, Push("funcname")},
|
||||
{`(class)(\s+)`, ByGroups(Keyword, Text), Push("classname")},
|
||||
{Words(``, `\b`, `initialize`, `new`, `loop`, `include`, `extend`, `raise`, `attr_reader`, `attr_writer`, `attr_accessor`, `attr`, `catch`, `throw`, `private`, `module_function`, `public`, `protected`, `true`, `false`, `nil`), KeywordPseudo, nil},
|
||||
{`(not|and|or)\b`, OperatorWord, nil},
|
||||
{Words(``, `\?`, `autoload`, `block_given`, `const_defined`, `eql`, `equal`, `frozen`, `include`, `instance_of`, `is_a`, `iterator`, `kind_of`, `method_defined`, `nil`, `private_method_defined`, `protected_method_defined`, `public_method_defined`, `respond_to`, `tainted`), NameBuiltin, nil},
|
||||
{`(chomp|chop|exit|gsub|sub)!`, NameBuiltin, nil},
|
||||
{Words(`(?<!\.)`, `\b`, `Array`, `Float`, `Integer`, `String`, `__id__`, `__send__`, `abort`, `ancestors`, `at_exit`, `autoload`, `binding`, `callcc`, `caller`, `catch`, `chomp`, `chop`, `class_eval`, `class_variables`, `clone`, `const_defined?`, `const_get`, `const_missing`, `const_set`, `constants`, `display`, `dup`, `eval`, `exec`, `exit`, `extend`, `fail`, `fork`, `format`, `freeze`, `getc`, `gets`, `global_variables`, `gsub`, `hash`, `id`, `included_modules`, `inspect`, `instance_eval`, `instance_method`, `instance_methods`, `instance_variable_get`, `instance_variable_set`, `instance_variables`, `lambda`, `load`, `local_variables`, `loop`, `method`, `method_missing`, `methods`, `module_eval`, `name`, `object_id`, `open`, `p`, `print`, `printf`, `private_class_method`, `private_instance_methods`, `private_methods`, `proc`, `protected_instance_methods`, `protected_methods`, `public_class_method`, `public_instance_methods`, `public_methods`, `putc`, `puts`, `raise`, `rand`, `readline`, `readlines`, `require`, `scan`, `select`, `self`, `send`, `set_trace_func`, `singleton_methods`, `sleep`, `split`, `sprintf`, `srand`, `sub`, `syscall`, `system`, `taint`, `test`, `throw`, `to_a`, `to_s`, `trace_var`, `trap`, `untaint`, `untrace_var`, `warn`), NameBuiltin, nil},
|
||||
{`__(FILE|LINE)__\b`, NameBuiltinPseudo, nil},
|
||||
{"(?<!\\w)(<<-?)([\"`\\']?)([a-zA-Z_]\\w*)(\\2)(.*?\\n)", String, nil},
|
||||
{`(<<-?)("|\')()(\2)(.*?\n)`, String, nil},
|
||||
{`__END__`, CommentPreproc, Push("end-part")},
|
||||
{`(?:^|(?<=[=<>~!:])|(?<=(?:\s|;)when\s)|(?<=(?:\s|;)or\s)|(?<=(?:\s|;)and\s)|(?<=\.index\s)|(?<=\.scan\s)|(?<=\.sub\s)|(?<=\.sub!\s)|(?<=\.gsub\s)|(?<=\.gsub!\s)|(?<=\.match\s)|(?<=(?:\s|;)if\s)|(?<=(?:\s|;)elsif\s)|(?<=^when\s)|(?<=^index\s)|(?<=^scan\s)|(?<=^sub\s)|(?<=^gsub\s)|(?<=^sub!\s)|(?<=^gsub!\s)|(?<=^match\s)|(?<=^if\s)|(?<=^elsif\s))(\s*)(/)`, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")},
|
||||
{`(?<=\(|,|\[)/`, LiteralStringRegex, Push("multiline-regex")},
|
||||
{`(\s+)(/)(?![\s=])`, ByGroups(Text, LiteralStringRegex), Push("multiline-regex")},
|
||||
{`(0_?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberOct, Text, Operator), nil},
|
||||
{`(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberHex, Text, Operator), nil},
|
||||
{`(0b[01]+(?:_[01]+)*)(\s*)([/?])?`, ByGroups(LiteralNumberBin, Text, Operator), nil},
|
||||
{`([\d]+(?:_\d+)*)(\s*)([/?])?`, ByGroups(LiteralNumberInteger, Text, Operator), nil},
|
||||
{`@@[a-zA-Z_]\w*`, NameVariableClass, nil},
|
||||
{`@[a-zA-Z_]\w*`, NameVariableInstance, nil},
|
||||
{`\$\w+`, NameVariableGlobal, nil},
|
||||
{"\\$[!@&`\\'+~=/\\\\,;.<>_*$?:\"^-]", NameVariableGlobal, nil},
|
||||
{`\$-[0adFiIlpvw]`, NameVariableGlobal, nil},
|
||||
{`::`, Operator, nil},
|
||||
Include("strings"),
|
||||
{`\?(\\[MC]-)*(\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)(?!\w)`, LiteralStringChar, nil},
|
||||
{`[A-Z]\w+`, NameConstant, nil},
|
||||
{Words(`(\.|::)`, ``, `*`, `**`, `-`, `+`, `-@`, `+@`, `/`, `%`, `&`, `|`, `^`, "`", `~`, `[]`, `[]=`, `<<`, `>>`, `<`, `<>`, `<=>`, `>`, `>=`, `==`, `===`), ByGroups(Operator, NameOperator), nil},
|
||||
{"(\\.|::)([a-zA-Z_]\\w*[!?]?|[*%&^`~+\\-/\\[<>=])", ByGroups(Operator, Name), nil},
|
||||
{`[a-zA-Z_]\w*[!?]?`, Name, nil},
|
||||
{`(\[|\]|\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3})`, Operator, nil},
|
||||
{`[-+/*%=<>&!^|~]=?`, Operator, nil},
|
||||
{`[(){};,/?:\\]`, Punctuation, nil},
|
||||
{`\s+`, Text, nil},
|
||||
},
|
||||
"funcname": {
|
||||
{`\(`, Punctuation, Push("defexpr")},
|
||||
{"(?:([a-zA-Z_]\\w*)(\\.))?([a-zA-Z_]\\w*[!?]?|\\*\\*?|[-+]@?|[/%&|^`~]|\\[\\]=?|<<|>>|<=?>|>=?|===?)", ByGroups(NameClass, Operator, NameFunction), Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"classname": {
|
||||
{`\(`, Punctuation, Push("defexpr")},
|
||||
{`<<`, Operator, Pop(1)},
|
||||
{`[A-Z_]\w*`, NameClass, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"defexpr": {
|
||||
{`(\))(\.|::)?`, ByGroups(Punctuation, Operator), Pop(1)},
|
||||
{`\(`, Operator, Push()},
|
||||
Include("root"),
|
||||
},
|
||||
"in-intp": {
|
||||
{`\{`, LiteralStringInterpol, Push()},
|
||||
{`\}`, LiteralStringInterpol, Pop(1)},
|
||||
Include("root"),
|
||||
},
|
||||
"string-intp": {
|
||||
{`#\{`, LiteralStringInterpol, Push("in-intp")},
|
||||
{`#@@?[a-zA-Z_]\w*`, LiteralStringInterpol, nil},
|
||||
{`#\$[a-zA-Z_]\w*`, LiteralStringInterpol, nil},
|
||||
},
|
||||
"string-intp-escaped": {
|
||||
Include("string-intp"),
|
||||
{`\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})`, LiteralStringEscape, nil},
|
||||
},
|
||||
"interpolated-regex": {
|
||||
Include("string-intp"),
|
||||
{`[\\#]`, LiteralStringRegex, nil},
|
||||
{`[^\\#]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
"interpolated-string": {
|
||||
Include("string-intp"),
|
||||
{`[\\#]`, LiteralStringOther, nil},
|
||||
{`[^\\#]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"multiline-regex": {
|
||||
Include("string-intp"),
|
||||
{`\\\\`, LiteralStringRegex, nil},
|
||||
{`\\/`, LiteralStringRegex, nil},
|
||||
{`[\\#]`, LiteralStringRegex, nil},
|
||||
{`[^\\/#]+`, LiteralStringRegex, nil},
|
||||
{`/[mixounse]*`, LiteralStringRegex, Pop(1)},
|
||||
},
|
||||
"end-part": {
|
||||
{`.+`, CommentPreproc, Pop(1)},
|
||||
},
|
||||
"strings": {
|
||||
{`\:@{0,2}[a-zA-Z_]\w*[!?]?`, LiteralStringSymbol, nil},
|
||||
{Words(`\:@{0,2}`, ``, `*`, `**`, `-`, `+`, `-@`, `+@`, `/`, `%`, `&`, `|`, `^`, "`", `~`, `[]`, `[]=`, `<<`, `>>`, `<`, `<>`, `<=>`, `>`, `>=`, `==`, `===`), LiteralStringSymbol, nil},
|
||||
{`:'(\\\\|\\'|[^'])*'`, LiteralStringSymbol, nil},
|
||||
{`'(\\\\|\\'|[^'])*'`, LiteralStringSingle, nil},
|
||||
{`:"`, LiteralStringSymbol, Push("simple-sym")},
|
||||
{`([a-zA-Z_]\w*)(:)(?!:)`, ByGroups(LiteralStringSymbol, Punctuation), nil},
|
||||
{`"`, LiteralStringDouble, Push("simple-string")},
|
||||
{"(?<!\\.)`", LiteralStringBacktick, Push("simple-backtick")},
|
||||
{`%[QWx]?\{`, LiteralStringOther, Push("cb-intp-string")},
|
||||
{`%[qsw]\{`, LiteralStringOther, Push("cb-string")},
|
||||
{`%r\{`, LiteralStringRegex, Push("cb-regex")},
|
||||
{`%[QWx]?\[`, LiteralStringOther, Push("sb-intp-string")},
|
||||
{`%[qsw]\[`, LiteralStringOther, Push("sb-string")},
|
||||
{`%r\[`, LiteralStringRegex, Push("sb-regex")},
|
||||
{`%[QWx]?\(`, LiteralStringOther, Push("pa-intp-string")},
|
||||
{`%[qsw]\(`, LiteralStringOther, Push("pa-string")},
|
||||
{`%r\(`, LiteralStringRegex, Push("pa-regex")},
|
||||
{`%[QWx]?<`, LiteralStringOther, Push("ab-intp-string")},
|
||||
{`%[qsw]<`, LiteralStringOther, Push("ab-string")},
|
||||
{`%r<`, LiteralStringRegex, Push("ab-regex")},
|
||||
{`(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[mixounse]*)`, String, nil},
|
||||
{`%[qsw]([\W_])((?:\\\1|(?!\1).)*)\1`, LiteralStringOther, nil},
|
||||
{`(%[QWx]([\W_]))((?:\\\2|(?!\2).)*)(\2)`, String, nil},
|
||||
{`(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil},
|
||||
{`^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)`, ByGroups(Text, LiteralStringOther, None), nil},
|
||||
{`(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)`, String, nil},
|
||||
},
|
||||
"simple-string": {
|
||||
Include("string-intp-escaped"),
|
||||
{`[^\\"#]+`, LiteralStringDouble, nil},
|
||||
{`[\\#]`, LiteralStringDouble, nil},
|
||||
{`"`, LiteralStringDouble, Pop(1)},
|
||||
},
|
||||
"simple-sym": {
|
||||
Include("string-intp-escaped"),
|
||||
{`[^\\"#]+`, LiteralStringSymbol, nil},
|
||||
{`[\\#]`, LiteralStringSymbol, nil},
|
||||
{`"`, LiteralStringSymbol, Pop(1)},
|
||||
},
|
||||
"simple-backtick": {
|
||||
Include("string-intp-escaped"),
|
||||
{"[^\\\\`#]+", LiteralStringBacktick, nil},
|
||||
{`[\\#]`, LiteralStringBacktick, nil},
|
||||
{"`", LiteralStringBacktick, Pop(1)},
|
||||
},
|
||||
"cb-intp-string": {
|
||||
{`\\[\\{}]`, LiteralStringOther, nil},
|
||||
{`\{`, LiteralStringOther, Push()},
|
||||
{`\}`, LiteralStringOther, Pop(1)},
|
||||
Include("string-intp-escaped"),
|
||||
{`[\\#{}]`, LiteralStringOther, nil},
|
||||
{`[^\\#{}]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"cb-string": {
|
||||
{`\\[\\{}]`, LiteralStringOther, nil},
|
||||
{`\{`, LiteralStringOther, Push()},
|
||||
{`\}`, LiteralStringOther, Pop(1)},
|
||||
{`[\\#{}]`, LiteralStringOther, nil},
|
||||
{`[^\\#{}]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"cb-regex": {
|
||||
{`\\[\\{}]`, LiteralStringRegex, nil},
|
||||
{`\{`, LiteralStringRegex, Push()},
|
||||
{`\}[mixounse]*`, LiteralStringRegex, Pop(1)},
|
||||
Include("string-intp"),
|
||||
{`[\\#{}]`, LiteralStringRegex, nil},
|
||||
{`[^\\#{}]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
"sb-intp-string": {
|
||||
{`\\[\\\[\]]`, LiteralStringOther, nil},
|
||||
{`\[`, LiteralStringOther, Push()},
|
||||
{`\]`, LiteralStringOther, Pop(1)},
|
||||
Include("string-intp-escaped"),
|
||||
{`[\\#\[\]]`, LiteralStringOther, nil},
|
||||
{`[^\\#\[\]]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"sb-string": {
|
||||
{`\\[\\\[\]]`, LiteralStringOther, nil},
|
||||
{`\[`, LiteralStringOther, Push()},
|
||||
{`\]`, LiteralStringOther, Pop(1)},
|
||||
{`[\\#\[\]]`, LiteralStringOther, nil},
|
||||
{`[^\\#\[\]]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"sb-regex": {
|
||||
{`\\[\\\[\]]`, LiteralStringRegex, nil},
|
||||
{`\[`, LiteralStringRegex, Push()},
|
||||
{`\][mixounse]*`, LiteralStringRegex, Pop(1)},
|
||||
Include("string-intp"),
|
||||
{`[\\#\[\]]`, LiteralStringRegex, nil},
|
||||
{`[^\\#\[\]]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
"pa-intp-string": {
|
||||
{`\\[\\()]`, LiteralStringOther, nil},
|
||||
{`\(`, LiteralStringOther, Push()},
|
||||
{`\)`, LiteralStringOther, Pop(1)},
|
||||
Include("string-intp-escaped"),
|
||||
{`[\\#()]`, LiteralStringOther, nil},
|
||||
{`[^\\#()]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"pa-string": {
|
||||
{`\\[\\()]`, LiteralStringOther, nil},
|
||||
{`\(`, LiteralStringOther, Push()},
|
||||
{`\)`, LiteralStringOther, Pop(1)},
|
||||
{`[\\#()]`, LiteralStringOther, nil},
|
||||
{`[^\\#()]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"pa-regex": {
|
||||
{`\\[\\()]`, LiteralStringRegex, nil},
|
||||
{`\(`, LiteralStringRegex, Push()},
|
||||
{`\)[mixounse]*`, LiteralStringRegex, Pop(1)},
|
||||
Include("string-intp"),
|
||||
{`[\\#()]`, LiteralStringRegex, nil},
|
||||
{`[^\\#()]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
"ab-intp-string": {
|
||||
{`\\[\\<>]`, LiteralStringOther, nil},
|
||||
{`<`, LiteralStringOther, Push()},
|
||||
{`>`, LiteralStringOther, Pop(1)},
|
||||
Include("string-intp-escaped"),
|
||||
{`[\\#<>]`, LiteralStringOther, nil},
|
||||
{`[^\\#<>]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"ab-string": {
|
||||
{`\\[\\<>]`, LiteralStringOther, nil},
|
||||
{`<`, LiteralStringOther, Push()},
|
||||
{`>`, LiteralStringOther, Pop(1)},
|
||||
{`[\\#<>]`, LiteralStringOther, nil},
|
||||
{`[^\\#<>]+`, LiteralStringOther, nil},
|
||||
},
|
||||
"ab-regex": {
|
||||
{`\\[\\<>]`, LiteralStringRegex, nil},
|
||||
{`<`, LiteralStringRegex, Push()},
|
||||
{`>[mixounse]*`, LiteralStringRegex, Pop(1)},
|
||||
Include("string-intp"),
|
||||
{`[\\#<>]`, LiteralStringRegex, nil},
|
||||
{`[^\\#<>]+`, LiteralStringRegex, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
135
vendor/github.com/alecthomas/chroma/lexers/r/rust.go
generated
vendored
Normal file
135
vendor/github.com/alecthomas/chroma/lexers/r/rust.go
generated
vendored
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
package r
|
||||
|
||||
import (
|
||||
. "github.com/alecthomas/chroma" // nolint
|
||||
"github.com/alecthomas/chroma/lexers/internal"
|
||||
)
|
||||
|
||||
// Rust lexer.
|
||||
var Rust = internal.Register(MustNewLexer(
|
||||
&Config{
|
||||
Name: "Rust",
|
||||
Aliases: []string{"rust"},
|
||||
Filenames: []string{"*.rs", "*.rs.in"},
|
||||
MimeTypes: []string{"text/rust"},
|
||||
EnsureNL: true,
|
||||
},
|
||||
Rules{
|
||||
"root": {
|
||||
{`#![^[\r\n].*$`, CommentPreproc, nil},
|
||||
Default(Push("base")),
|
||||
},
|
||||
"base": {
|
||||
{`\n`, TextWhitespace, nil},
|
||||
{`\s+`, TextWhitespace, nil},
|
||||
{`//!.*?\n`, LiteralStringDoc, nil},
|
||||
{`///(\n|[^/].*?\n)`, LiteralStringDoc, nil},
|
||||
{`//(.*?)\n`, CommentSingle, nil},
|
||||
{`/\*\*(\n|[^/*])`, LiteralStringDoc, Push("doccomment")},
|
||||
{`/\*!`, LiteralStringDoc, Push("doccomment")},
|
||||
{`/\*`, CommentMultiline, Push("comment")},
|
||||
{`r#*"(?:\\.|[^\\\r\n;])*"#*`, LiteralString, nil},
|
||||
{`"(?:\\.|[^\\\r\n"])*"`, LiteralString, nil},
|
||||
{`\$([a-zA-Z_]\w*|\(,?|\),?|,?)`, CommentPreproc, nil},
|
||||
{Words(``, `\b`, `as`, `box`, `const`, `crate`, `else`, `extern`, `for`, `if`, `impl`, `in`, `loop`, `match`, `move`, `mut`, `pub`, `ref`, `return`, `static`, `super`, `trait`, `unsafe`, `use`, `where`, `while`), Keyword, nil},
|
||||
{Words(``, `\b`, `abstract`, `alignof`, `become`, `do`, `final`, `macro`, `offsetof`, `override`, `priv`, `proc`, `pure`, `sizeof`, `typeof`, `unsized`, `virtual`, `yield`), KeywordReserved, nil},
|
||||
{`(true|false)\b`, KeywordConstant, nil},
|
||||
{`mod\b`, Keyword, Push("modname")},
|
||||
{`let\b`, KeywordDeclaration, nil},
|
||||
{`fn\b`, Keyword, Push("funcname")},
|
||||
{`(struct|enum|type|union)\b`, Keyword, Push("typename")},
|
||||
{`(default)(\s+)(type|fn)\b`, ByGroups(Keyword, Text, Keyword), nil},
|
||||
{Words(``, `\b`, `u8`, `u16`, `u32`, `u64`, `i8`, `i16`, `i32`, `i64`, `usize`, `isize`, `f32`, `f64`, `str`, `bool`), KeywordType, nil},
|
||||
{`self\b`, NameBuiltinPseudo, nil},
|
||||
{Words(``, `\b`, `Copy`, `Send`, `Sized`, `Sync`, `Drop`, `Fn`, `FnMut`, `FnOnce`, `Box`, `ToOwned`, `Clone`, `PartialEq`, `PartialOrd`, `Eq`, `Ord`, `AsRef`, `AsMut`, `Into`, `From`, `Default`, `Iterator`, `Extend`, `IntoIterator`, `DoubleEndedIterator`, `ExactSizeIterator`, `Option`, `Some`, `None`, `Result`, `Ok`, `Err`, `SliceConcatExt`, `String`, `ToString`, `Vec`), NameBuiltin, nil},
|
||||
{`::\b`, Text, nil},
|
||||
{`(?::|->)`, Text, Push("typename")},
|
||||
{`(break|continue)(\s*)(\'[A-Za-z_]\w*)?`, ByGroups(Keyword, TextWhitespace, NameLabel), nil},
|
||||
{`'(\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'`, LiteralStringChar, nil},
|
||||
{`b'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\0|\\u\{[0-9a-fA-F]{1,6}\}|.)'`, LiteralStringChar, nil},
|
||||
{`0b[01_]+`, LiteralNumberBin, Push("number_lit")},
|
||||
{`0o[0-7_]+`, LiteralNumberOct, Push("number_lit")},
|
||||
{`0[xX][0-9a-fA-F_]+`, LiteralNumberHex, Push("number_lit")},
|
||||
{`[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|\.[0-9_]*(?!\.)|[eE][+\-]?[0-9_]+)`, LiteralNumberFloat, Push("number_lit")},
|
||||
{`[0-9][0-9_]*`, LiteralNumberInteger, Push("number_lit")},
|
||||
{`b"`, LiteralString, Push("bytestring")},
|
||||
{`b?r(#*)".*?"\1`, LiteralString, nil},
|
||||
{`'static`, NameBuiltin, nil},
|
||||
{`'[a-zA-Z_]\w*`, NameAttribute, nil},
|
||||
{`[{}()\[\],.;]`, Punctuation, nil},
|
||||
{`[+\-*/%&|<>^!~@=:?]`, Operator, nil},
|
||||
{`(r#)?[a-zA-Z_]\w*`, Name, nil},
|
||||
{`#!?\[`, CommentPreproc, Push("attribute[")},
|
||||
{`([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\s*)(\{)`, ByGroups(CommentPreproc, Punctuation, TextWhitespace, Name, TextWhitespace, Punctuation), Push("macro{")},
|
||||
{`([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\()`, ByGroups(CommentPreproc, Punctuation, TextWhitespace, Name, Punctuation), Push("macro(")},
|
||||
},
|
||||
"comment": {
|
||||
{`[^*/]+`, CommentMultiline, nil},
|
||||
{`/\*`, CommentMultiline, Push()},
|
||||
{`\*/`, CommentMultiline, Pop(1)},
|
||||
{`[*/]`, CommentMultiline, nil},
|
||||
},
|
||||
"doccomment": {
|
||||
{`[^*/]+`, LiteralStringDoc, nil},
|
||||
{`/\*`, LiteralStringDoc, Push()},
|
||||
{`\*/`, LiteralStringDoc, Pop(1)},
|
||||
{`[*/]`, LiteralStringDoc, nil},
|
||||
},
|
||||
"modname": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[a-zA-Z_]\w*`, NameNamespace, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"funcname": {
|
||||
{`\s+`, Text, nil},
|
||||
{`[a-zA-Z_]\w*`, NameFunction, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"typename": {
|
||||
{`\s+`, Text, nil},
|
||||
{`&`, KeywordPseudo, nil},
|
||||
{Words(``, `\b`, `Copy`, `Send`, `Sized`, `Sync`, `Drop`, `Fn`, `FnMut`, `FnOnce`, `Box`, `ToOwned`, `Clone`, `PartialEq`, `PartialOrd`, `Eq`, `Ord`, `AsRef`, `AsMut`, `Into`, `From`, `Default`, `Iterator`, `Extend`, `IntoIterator`, `DoubleEndedIterator`, `ExactSizeIterator`, `Option`, `Some`, `None`, `Result`, `Ok`, `Err`, `SliceConcatExt`, `String`, `ToString`, `Vec`), NameBuiltin, nil},
|
||||
{Words(``, `\b`, `u8`, `u16`, `u32`, `u64`, `i8`, `i16`, `i32`, `i64`, `usize`, `isize`, `f32`, `f64`, `str`, `bool`), KeywordType, nil},
|
||||
{`[a-zA-Z_]\w*`, NameClass, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"number_lit": {
|
||||
{`[ui](8|16|32|64|size)`, Keyword, Pop(1)},
|
||||
{`f(32|64)`, Keyword, Pop(1)},
|
||||
Default(Pop(1)),
|
||||
},
|
||||
"string": {
|
||||
{`"`, LiteralString, Pop(1)},
|
||||
{`\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0|\\u\{[0-9a-fA-F]{1,6}\}`, LiteralStringEscape, nil},
|
||||
{`[^\\"]+`, LiteralString, nil},
|
||||
{`\\`, LiteralString, nil},
|
||||
},
|
||||
"bytestring": {
|
||||
{`\\x[89a-fA-F][0-9a-fA-F]`, LiteralStringEscape, nil},
|
||||
Include("string"),
|
||||
},
|
||||
"macro{": {
|
||||
{`\{`, Operator, Push()},
|
||||
{`\}`, Operator, Pop(1)},
|
||||
},
|
||||
"macro(": {
|
||||
{`\(`, Operator, Push()},
|
||||
{`\)`, Operator, Pop(1)},
|
||||
},
|
||||
"attribute_common": {
|
||||
{`"`, LiteralString, Push("string")},
|
||||
{`\[`, CommentPreproc, Push("attribute[")},
|
||||
{`\(`, CommentPreproc, Push("attribute(")},
|
||||
},
|
||||
"attribute[": {
|
||||
Include("attribute_common"),
|
||||
{`\];?`, CommentPreproc, Pop(1)},
|
||||
{`[^"\]]+`, CommentPreproc, nil},
|
||||
},
|
||||
"attribute(": {
|
||||
Include("attribute_common"),
|
||||
{`\);?`, CommentPreproc, Pop(1)},
|
||||
{`[^")]+`, CommentPreproc, nil},
|
||||
},
|
||||
},
|
||||
))
|
||||
Loading…
Add table
Add a link
Reference in a new issue