second commit
This commit is contained in:
518
env/lib/python3.11/site-packages/pygments/lexers/ruby.py
vendored
Normal file
518
env/lib/python3.11/site-packages/pygments/lexers/ruby.py
vendored
Normal file
@ -0,0 +1,518 @@
|
||||
"""
|
||||
pygments.lexers.ruby
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Lexers for Ruby and related languages.
|
||||
|
||||
:copyright: Copyright 2006-2024 by the Pygments team, see AUTHORS.
|
||||
:license: BSD, see LICENSE for details.
|
||||
"""
|
||||
|
||||
import re
|
||||
|
||||
from pygments.lexer import Lexer, RegexLexer, ExtendedRegexLexer, include, \
|
||||
bygroups, default, LexerContext, do_insertions, words, line_re
|
||||
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
|
||||
Number, Punctuation, Error, Generic, Whitespace
|
||||
from pygments.util import shebang_matches
|
||||
|
||||
__all__ = ['RubyLexer', 'RubyConsoleLexer', 'FancyLexer']
|
||||
|
||||
|
||||
RUBY_OPERATORS = (
|
||||
'*', '**', '-', '+', '-@', '+@', '/', '%', '&', '|', '^', '`', '~',
|
||||
'[]', '[]=', '<<', '>>', '<', '<>', '<=>', '>', '>=', '==', '==='
|
||||
)
|
||||
|
||||
|
||||
class RubyLexer(ExtendedRegexLexer):
|
||||
"""
|
||||
For Ruby source code.
|
||||
"""
|
||||
|
||||
name = 'Ruby'
|
||||
url = 'http://www.ruby-lang.org'
|
||||
aliases = ['ruby', 'rb', 'duby']
|
||||
filenames = ['*.rb', '*.rbw', 'Rakefile', '*.rake', '*.gemspec',
|
||||
'*.rbx', '*.duby', 'Gemfile', 'Vagrantfile']
|
||||
mimetypes = ['text/x-ruby', 'application/x-ruby']
|
||||
version_added = ''
|
||||
|
||||
flags = re.DOTALL | re.MULTILINE
|
||||
|
||||
def heredoc_callback(self, match, ctx):
|
||||
# okay, this is the hardest part of parsing Ruby...
|
||||
# match: 1 = <<[-~]?, 2 = quote? 3 = name 4 = quote? 5 = rest of line
|
||||
|
||||
start = match.start(1)
|
||||
yield start, Operator, match.group(1) # <<[-~]?
|
||||
yield match.start(2), String.Heredoc, match.group(2) # quote ", ', `
|
||||
yield match.start(3), String.Delimiter, match.group(3) # heredoc name
|
||||
yield match.start(4), String.Heredoc, match.group(4) # quote again
|
||||
|
||||
heredocstack = ctx.__dict__.setdefault('heredocstack', [])
|
||||
outermost = not bool(heredocstack)
|
||||
heredocstack.append((match.group(1) in ('<<-', '<<~'), match.group(3)))
|
||||
|
||||
ctx.pos = match.start(5)
|
||||
ctx.end = match.end(5)
|
||||
# this may find other heredocs, so limit the recursion depth
|
||||
if len(heredocstack) < 100:
|
||||
yield from self.get_tokens_unprocessed(context=ctx)
|
||||
else:
|
||||
yield ctx.pos, String.Heredoc, match.group(5)
|
||||
ctx.pos = match.end()
|
||||
|
||||
if outermost:
|
||||
# this is the outer heredoc again, now we can process them all
|
||||
for tolerant, hdname in heredocstack:
|
||||
lines = []
|
||||
for match in line_re.finditer(ctx.text, ctx.pos):
|
||||
if tolerant:
|
||||
check = match.group().strip()
|
||||
else:
|
||||
check = match.group().rstrip()
|
||||
if check == hdname:
|
||||
for amatch in lines:
|
||||
yield amatch.start(), String.Heredoc, amatch.group()
|
||||
yield match.start(), String.Delimiter, match.group()
|
||||
ctx.pos = match.end()
|
||||
break
|
||||
else:
|
||||
lines.append(match)
|
||||
else:
|
||||
# end of heredoc not found -- error!
|
||||
for amatch in lines:
|
||||
yield amatch.start(), Error, amatch.group()
|
||||
ctx.end = len(ctx.text)
|
||||
del heredocstack[:]
|
||||
|
||||
def gen_rubystrings_rules():
|
||||
def intp_regex_callback(self, match, ctx):
|
||||
yield match.start(1), String.Regex, match.group(1) # begin
|
||||
nctx = LexerContext(match.group(3), 0, ['interpolated-regex'])
|
||||
for i, t, v in self.get_tokens_unprocessed(context=nctx):
|
||||
yield match.start(3)+i, t, v
|
||||
yield match.start(4), String.Regex, match.group(4) # end[mixounse]*
|
||||
ctx.pos = match.end()
|
||||
|
||||
def intp_string_callback(self, match, ctx):
|
||||
yield match.start(1), String.Other, match.group(1)
|
||||
nctx = LexerContext(match.group(3), 0, ['interpolated-string'])
|
||||
for i, t, v in self.get_tokens_unprocessed(context=nctx):
|
||||
yield match.start(3)+i, t, v
|
||||
yield match.start(4), String.Other, match.group(4) # end
|
||||
ctx.pos = match.end()
|
||||
|
||||
states = {}
|
||||
states['strings'] = [
|
||||
# easy ones
|
||||
(r'\:@{0,2}[a-zA-Z_]\w*[!?]?', String.Symbol),
|
||||
(words(RUBY_OPERATORS, prefix=r'\:@{0,2}'), String.Symbol),
|
||||
(r":'(\\\\|\\[^\\]|[^'\\])*'", String.Symbol),
|
||||
(r':"', String.Symbol, 'simple-sym'),
|
||||
(r'([a-zA-Z_]\w*)(:)(?!:)',
|
||||
bygroups(String.Symbol, Punctuation)), # Since Ruby 1.9
|
||||
(r'"', String.Double, 'simple-string-double'),
|
||||
(r"'", String.Single, 'simple-string-single'),
|
||||
(r'(?<!\.)`', String.Backtick, 'simple-backtick'),
|
||||
]
|
||||
|
||||
# quoted string and symbol
|
||||
for name, ttype, end in ('string-double', String.Double, '"'), \
|
||||
('string-single', String.Single, "'"),\
|
||||
('sym', String.Symbol, '"'), \
|
||||
('backtick', String.Backtick, '`'):
|
||||
states['simple-'+name] = [
|
||||
include('string-intp-escaped'),
|
||||
(rf'[^\\{end}#]+', ttype),
|
||||
(r'[\\#]', ttype),
|
||||
(end, ttype, '#pop'),
|
||||
]
|
||||
|
||||
# braced quoted strings
|
||||
for lbrace, rbrace, bracecc, name in \
|
||||
('\\{', '\\}', '{}', 'cb'), \
|
||||
('\\[', '\\]', '\\[\\]', 'sb'), \
|
||||
('\\(', '\\)', '()', 'pa'), \
|
||||
('<', '>', '<>', 'ab'):
|
||||
states[name+'-intp-string'] = [
|
||||
(r'\\[\\' + bracecc + ']', String.Other),
|
||||
(lbrace, String.Other, '#push'),
|
||||
(rbrace, String.Other, '#pop'),
|
||||
include('string-intp-escaped'),
|
||||
(r'[\\#' + bracecc + ']', String.Other),
|
||||
(r'[^\\#' + bracecc + ']+', String.Other),
|
||||
]
|
||||
states['strings'].append((r'%[QWx]?' + lbrace, String.Other,
|
||||
name+'-intp-string'))
|
||||
states[name+'-string'] = [
|
||||
(r'\\[\\' + bracecc + ']', String.Other),
|
||||
(lbrace, String.Other, '#push'),
|
||||
(rbrace, String.Other, '#pop'),
|
||||
(r'[\\#' + bracecc + ']', String.Other),
|
||||
(r'[^\\#' + bracecc + ']+', String.Other),
|
||||
]
|
||||
states['strings'].append((r'%[qsw]' + lbrace, String.Other,
|
||||
name+'-string'))
|
||||
states[name+'-regex'] = [
|
||||
(r'\\[\\' + bracecc + ']', String.Regex),
|
||||
(lbrace, String.Regex, '#push'),
|
||||
(rbrace + '[mixounse]*', String.Regex, '#pop'),
|
||||
include('string-intp'),
|
||||
(r'[\\#' + bracecc + ']', String.Regex),
|
||||
(r'[^\\#' + bracecc + ']+', String.Regex),
|
||||
]
|
||||
states['strings'].append((r'%r' + lbrace, String.Regex,
|
||||
name+'-regex'))
|
||||
|
||||
# these must come after %<brace>!
|
||||
states['strings'] += [
|
||||
# %r regex
|
||||
(r'(%r([\W_]))((?:\\\2|(?!\2).)*)(\2[mixounse]*)',
|
||||
intp_regex_callback),
|
||||
# regular fancy strings with qsw
|
||||
(r'%[qsw]([\W_])((?:\\\1|(?!\1).)*)\1', String.Other),
|
||||
(r'(%[QWx]([\W_]))((?:\\\2|(?!\2).)*)(\2)',
|
||||
intp_string_callback),
|
||||
# special forms of fancy strings after operators or
|
||||
# in method calls with braces
|
||||
(r'(?<=[-+/*%=<>&!^|~,(])(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
|
||||
bygroups(Whitespace, String.Other, None)),
|
||||
# and because of fixed width lookbehinds the whole thing a
|
||||
# second time for line startings...
|
||||
(r'^(\s*)(%([\t ])(?:(?:\\\3|(?!\3).)*)\3)',
|
||||
bygroups(Whitespace, String.Other, None)),
|
||||
# all regular fancy strings without qsw
|
||||
(r'(%([^a-zA-Z0-9\s]))((?:\\\2|(?!\2).)*)(\2)',
|
||||
intp_string_callback),
|
||||
]
|
||||
|
||||
return states
|
||||
|
||||
tokens = {
|
||||
'root': [
|
||||
(r'\A#!.+?$', Comment.Hashbang),
|
||||
(r'#.*?$', Comment.Single),
|
||||
(r'=begin\s.*?\n=end.*?$', Comment.Multiline),
|
||||
# keywords
|
||||
(words((
|
||||
'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'), suffix=r'\b'),
|
||||
Keyword),
|
||||
# start of function, class and module names
|
||||
(r'(module)(\s+)([a-zA-Z_]\w*'
|
||||
r'(?:::[a-zA-Z_]\w*)*)',
|
||||
bygroups(Keyword, Whitespace, Name.Namespace)),
|
||||
(r'(def)(\s+)', bygroups(Keyword, Whitespace), 'funcname'),
|
||||
(r'def(?=[*%&^`~+-/\[<>=])', Keyword, 'funcname'),
|
||||
(r'(class)(\s+)', bygroups(Keyword, Whitespace), 'classname'),
|
||||
# special methods
|
||||
(words((
|
||||
'initialize', 'new', 'loop', 'include', 'extend', 'raise', 'attr_reader',
|
||||
'attr_writer', 'attr_accessor', 'attr', 'catch', 'throw', 'private',
|
||||
'module_function', 'public', 'protected', 'true', 'false', 'nil'),
|
||||
suffix=r'\b'),
|
||||
Keyword.Pseudo),
|
||||
(r'(not|and|or)\b', Operator.Word),
|
||||
(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'), suffix=r'\?'),
|
||||
Name.Builtin),
|
||||
(r'(chomp|chop|exit|gsub|sub)!', Name.Builtin),
|
||||
(words((
|
||||
'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'), prefix=r'(?<!\.)', suffix=r'\b'),
|
||||
Name.Builtin),
|
||||
(r'__(FILE|LINE)__\b', Name.Builtin.Pseudo),
|
||||
# normal heredocs
|
||||
(r'(?<!\w)(<<[-~]?)(["`\']?)([a-zA-Z_]\w*)(\2)(.*?\n)',
|
||||
heredoc_callback),
|
||||
# empty string heredocs
|
||||
(r'(<<[-~]?)("|\')()(\2)(.*?\n)', heredoc_callback),
|
||||
(r'__END__', Comment.Preproc, 'end-part'),
|
||||
# multiline regex (after keywords or assignments)
|
||||
(r'(?:^|(?<=[=<>~!:])|'
|
||||
r'(?<=(?:\s|;)when\s)|'
|
||||
r'(?<=(?:\s|;)or\s)|'
|
||||
r'(?<=(?:\s|;)and\s)|'
|
||||
r'(?<=\.index\s)|'
|
||||
r'(?<=\.scan\s)|'
|
||||
r'(?<=\.sub\s)|'
|
||||
r'(?<=\.sub!\s)|'
|
||||
r'(?<=\.gsub\s)|'
|
||||
r'(?<=\.gsub!\s)|'
|
||||
r'(?<=\.match\s)|'
|
||||
r'(?<=(?:\s|;)if\s)|'
|
||||
r'(?<=(?:\s|;)elsif\s)|'
|
||||
r'(?<=^when\s)|'
|
||||
r'(?<=^index\s)|'
|
||||
r'(?<=^scan\s)|'
|
||||
r'(?<=^sub\s)|'
|
||||
r'(?<=^gsub\s)|'
|
||||
r'(?<=^sub!\s)|'
|
||||
r'(?<=^gsub!\s)|'
|
||||
r'(?<=^match\s)|'
|
||||
r'(?<=^if\s)|'
|
||||
r'(?<=^elsif\s)'
|
||||
r')(\s*)(/)', bygroups(Text, String.Regex), 'multiline-regex'),
|
||||
# multiline regex (in method calls or subscripts)
|
||||
(r'(?<=\(|,|\[)/', String.Regex, 'multiline-regex'),
|
||||
# multiline regex (this time the funny no whitespace rule)
|
||||
(r'(\s+)(/)(?![\s=])', bygroups(Whitespace, String.Regex),
|
||||
'multiline-regex'),
|
||||
# lex numbers and ignore following regular expressions which
|
||||
# are division operators in fact (grrrr. i hate that. any
|
||||
# better ideas?)
|
||||
# since pygments 0.7 we also eat a "?" operator after numbers
|
||||
# so that the char operator does not work. Chars are not allowed
|
||||
# there so that you can use the ternary operator.
|
||||
# stupid example:
|
||||
# x>=0?n[x]:""
|
||||
(r'(0_?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Oct, Whitespace, Operator)),
|
||||
(r'(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Hex, Whitespace, Operator)),
|
||||
(r'(0b[01]+(?:_[01]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Bin, Whitespace, Operator)),
|
||||
(r'([\d]+(?:_\d+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Integer, Whitespace, Operator)),
|
||||
# Names
|
||||
(r'@@[a-zA-Z_]\w*', Name.Variable.Class),
|
||||
(r'@[a-zA-Z_]\w*', Name.Variable.Instance),
|
||||
(r'\$\w+', Name.Variable.Global),
|
||||
(r'\$[!@&`\'+~=/\\,;.<>_*$?:"^-]', Name.Variable.Global),
|
||||
(r'\$-[0adFiIlpvw]', Name.Variable.Global),
|
||||
(r'::', Operator),
|
||||
include('strings'),
|
||||
# chars
|
||||
(r'\?(\\[MC]-)*' # modifiers
|
||||
r'(\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)'
|
||||
r'(?!\w)',
|
||||
String.Char),
|
||||
(r'[A-Z]\w+', Name.Constant),
|
||||
# this is needed because ruby attributes can look
|
||||
# like keywords (class) or like this: ` ?!?
|
||||
(words(RUBY_OPERATORS, prefix=r'(\.|::)'),
|
||||
bygroups(Operator, Name.Operator)),
|
||||
(r'(\.|::)([a-zA-Z_]\w*[!?]?|[*%&^`~+\-/\[<>=])',
|
||||
bygroups(Operator, Name)),
|
||||
(r'[a-zA-Z_]\w*[!?]?', Name),
|
||||
(r'(\[|\]|\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|'
|
||||
r'!~|&&?|\|\||\.{1,3})', Operator),
|
||||
(r'[-+/*%=<>&!^|~]=?', Operator),
|
||||
(r'[(){};,/?:\\]', Punctuation),
|
||||
(r'\s+', Whitespace)
|
||||
],
|
||||
'funcname': [
|
||||
(r'\(', Punctuation, 'defexpr'),
|
||||
(r'(?:([a-zA-Z_]\w*)(\.))?' # optional scope name, like "self."
|
||||
r'('
|
||||
r'[a-zA-Z\u0080-\uffff][a-zA-Z0-9_\u0080-\uffff]*[!?=]?' # method name
|
||||
r'|!=|!~|=~|\*\*?|[-+!~]@?|[/%&|^]|<=>|<[<=]?|>[>=]?|===?' # or operator override
|
||||
r'|\[\]=?' # or element reference/assignment override
|
||||
r'|`' # or the undocumented backtick override
|
||||
r')',
|
||||
bygroups(Name.Class, Operator, Name.Function), '#pop'),
|
||||
default('#pop')
|
||||
],
|
||||
'classname': [
|
||||
(r'\(', Punctuation, 'defexpr'),
|
||||
(r'<<', Operator, '#pop'),
|
||||
(r'[A-Z_]\w*', Name.Class, '#pop'),
|
||||
default('#pop')
|
||||
],
|
||||
'defexpr': [
|
||||
(r'(\))(\.|::)?', bygroups(Punctuation, Operator), '#pop'),
|
||||
(r'\(', Operator, '#push'),
|
||||
include('root')
|
||||
],
|
||||
'in-intp': [
|
||||
(r'\{', String.Interpol, '#push'),
|
||||
(r'\}', String.Interpol, '#pop'),
|
||||
include('root'),
|
||||
],
|
||||
'string-intp': [
|
||||
(r'#\{', String.Interpol, 'in-intp'),
|
||||
(r'#@@?[a-zA-Z_]\w*', String.Interpol),
|
||||
(r'#\$[a-zA-Z_]\w*', String.Interpol)
|
||||
],
|
||||
'string-intp-escaped': [
|
||||
include('string-intp'),
|
||||
(r'\\([\\abefnrstv#"\']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})',
|
||||
String.Escape)
|
||||
],
|
||||
'interpolated-regex': [
|
||||
include('string-intp'),
|
||||
(r'[\\#]', String.Regex),
|
||||
(r'[^\\#]+', String.Regex),
|
||||
],
|
||||
'interpolated-string': [
|
||||
include('string-intp'),
|
||||
(r'[\\#]', String.Other),
|
||||
(r'[^\\#]+', String.Other),
|
||||
],
|
||||
'multiline-regex': [
|
||||
include('string-intp'),
|
||||
(r'\\\\', String.Regex),
|
||||
(r'\\/', String.Regex),
|
||||
(r'[\\#]', String.Regex),
|
||||
(r'[^\\/#]+', String.Regex),
|
||||
(r'/[mixounse]*', String.Regex, '#pop'),
|
||||
],
|
||||
'end-part': [
|
||||
(r'.+', Comment.Preproc, '#pop')
|
||||
]
|
||||
}
|
||||
tokens.update(gen_rubystrings_rules())
|
||||
|
||||
def analyse_text(text):
|
||||
return shebang_matches(text, r'ruby(1\.\d)?')
|
||||
|
||||
|
||||
class RubyConsoleLexer(Lexer):
|
||||
"""
|
||||
For Ruby interactive console (**irb**) output.
|
||||
"""
|
||||
name = 'Ruby irb session'
|
||||
aliases = ['rbcon', 'irb']
|
||||
mimetypes = ['text/x-ruby-shellsession']
|
||||
url = 'https://www.ruby-lang.org'
|
||||
version_added = ''
|
||||
_example = 'rbcon/console'
|
||||
|
||||
_prompt_re = re.compile(r'irb\([a-zA-Z_]\w*\):\d{3}:\d+[>*"\'] '
|
||||
r'|>> |\?> ')
|
||||
|
||||
def get_tokens_unprocessed(self, text):
|
||||
rblexer = RubyLexer(**self.options)
|
||||
|
||||
curcode = ''
|
||||
insertions = []
|
||||
for match in line_re.finditer(text):
|
||||
line = match.group()
|
||||
m = self._prompt_re.match(line)
|
||||
if m is not None:
|
||||
end = m.end()
|
||||
insertions.append((len(curcode),
|
||||
[(0, Generic.Prompt, line[:end])]))
|
||||
curcode += line[end:]
|
||||
else:
|
||||
if curcode:
|
||||
yield from do_insertions(
|
||||
insertions, rblexer.get_tokens_unprocessed(curcode))
|
||||
curcode = ''
|
||||
insertions = []
|
||||
yield match.start(), Generic.Output, line
|
||||
if curcode:
|
||||
yield from do_insertions(
|
||||
insertions, rblexer.get_tokens_unprocessed(curcode))
|
||||
|
||||
|
||||
class FancyLexer(RegexLexer):
|
||||
"""
|
||||
Pygments Lexer For Fancy.
|
||||
|
||||
Fancy is a self-hosted, pure object-oriented, dynamic,
|
||||
class-based, concurrent general-purpose programming language
|
||||
running on Rubinius, the Ruby VM.
|
||||
"""
|
||||
name = 'Fancy'
|
||||
url = 'https://github.com/bakkdoor/fancy'
|
||||
filenames = ['*.fy', '*.fancypack']
|
||||
aliases = ['fancy', 'fy']
|
||||
mimetypes = ['text/x-fancysrc']
|
||||
version_added = '1.5'
|
||||
|
||||
tokens = {
|
||||
# copied from PerlLexer:
|
||||
'balanced-regex': [
|
||||
(r'/(\\\\|\\[^\\]|[^/\\])*/[egimosx]*', String.Regex, '#pop'),
|
||||
(r'!(\\\\|\\[^\\]|[^!\\])*![egimosx]*', String.Regex, '#pop'),
|
||||
(r'\\(\\\\|[^\\])*\\[egimosx]*', String.Regex, '#pop'),
|
||||
(r'\{(\\\\|\\[^\\]|[^}\\])*\}[egimosx]*', String.Regex, '#pop'),
|
||||
(r'<(\\\\|\\[^\\]|[^>\\])*>[egimosx]*', String.Regex, '#pop'),
|
||||
(r'\[(\\\\|\\[^\\]|[^\]\\])*\][egimosx]*', String.Regex, '#pop'),
|
||||
(r'\((\\\\|\\[^\\]|[^)\\])*\)[egimosx]*', String.Regex, '#pop'),
|
||||
(r'@(\\\\|\\[^\\]|[^@\\])*@[egimosx]*', String.Regex, '#pop'),
|
||||
(r'%(\\\\|\\[^\\]|[^%\\])*%[egimosx]*', String.Regex, '#pop'),
|
||||
(r'\$(\\\\|\\[^\\]|[^$\\])*\$[egimosx]*', String.Regex, '#pop'),
|
||||
],
|
||||
'root': [
|
||||
(r'\s+', Whitespace),
|
||||
|
||||
# balanced delimiters (copied from PerlLexer):
|
||||
(r's\{(\\\\|\\[^\\]|[^}\\])*\}\s*', String.Regex, 'balanced-regex'),
|
||||
(r's<(\\\\|\\[^\\]|[^>\\])*>\s*', String.Regex, 'balanced-regex'),
|
||||
(r's\[(\\\\|\\[^\\]|[^\]\\])*\]\s*', String.Regex, 'balanced-regex'),
|
||||
(r's\((\\\\|\\[^\\]|[^)\\])*\)\s*', String.Regex, 'balanced-regex'),
|
||||
(r'm?/(\\\\|\\[^\\]|[^///\n])*/[gcimosx]*', String.Regex),
|
||||
(r'm(?=[/!\\{<\[(@%$])', String.Regex, 'balanced-regex'),
|
||||
|
||||
# Comments
|
||||
(r'#(.*?)\n', Comment.Single),
|
||||
# Symbols
|
||||
(r'\'([^\'\s\[\](){}]+|\[\])', String.Symbol),
|
||||
# Multi-line DoubleQuotedString
|
||||
(r'"""(\\\\|\\[^\\]|[^\\])*?"""', String),
|
||||
# DoubleQuotedString
|
||||
(r'"(\\\\|\\[^\\]|[^"\\])*"', String),
|
||||
# keywords
|
||||
(r'(def|class|try|catch|finally|retry|return|return_local|match|'
|
||||
r'case|->|=>)\b', Keyword),
|
||||
# constants
|
||||
(r'(self|super|nil|false|true)\b', Name.Constant),
|
||||
(r'[(){};,/?|:\\]', Punctuation),
|
||||
# names
|
||||
(words((
|
||||
'Object', 'Array', 'Hash', 'Directory', 'File', 'Class', 'String',
|
||||
'Number', 'Enumerable', 'FancyEnumerable', 'Block', 'TrueClass',
|
||||
'NilClass', 'FalseClass', 'Tuple', 'Symbol', 'Stack', 'Set',
|
||||
'FancySpec', 'Method', 'Package', 'Range'), suffix=r'\b'),
|
||||
Name.Builtin),
|
||||
# functions
|
||||
(r'[a-zA-Z](\w|[-+?!=*/^><%])*:', Name.Function),
|
||||
# operators, must be below functions
|
||||
(r'[-+*/~,<>=&!?%^\[\].$]+', Operator),
|
||||
(r'[A-Z]\w*', Name.Constant),
|
||||
(r'@[a-zA-Z_]\w*', Name.Variable.Instance),
|
||||
(r'@@[a-zA-Z_]\w*', Name.Variable.Class),
|
||||
('@@?', Operator),
|
||||
(r'[a-zA-Z_]\w*', Name),
|
||||
# numbers - / checks are necessary to avoid mismarking regexes,
|
||||
# see comment in RubyLexer
|
||||
(r'(0[oO]?[0-7]+(?:_[0-7]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Oct, Whitespace, Operator)),
|
||||
(r'(0[xX][0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Hex, Whitespace, Operator)),
|
||||
(r'(0[bB][01]+(?:_[01]+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Bin, Whitespace, Operator)),
|
||||
(r'([\d]+(?:_\d+)*)(\s*)([/?])?',
|
||||
bygroups(Number.Integer, Whitespace, Operator)),
|
||||
(r'\d+([eE][+-]?[0-9]+)|\d+\.\d+([eE][+-]?[0-9]+)?', Number.Float),
|
||||
(r'\d+', Number.Integer)
|
||||
]
|
||||
}
|
||||
Reference in New Issue
Block a user