774 lines
32 KiB
Python
774 lines
32 KiB
Python
import os, re, sets, string, sys
|
|
import buffer, color, commands, completer, context, default, method, mode, regex, tab
|
|
from point import Point
|
|
from lex import Grammar, PatternRule, ContextPatternRule, RegionRule, OverridePatternRule, PatternGroupRule
|
|
from method import Argument, Method, WrapParagraph
|
|
|
|
class PodGrammar(Grammar):
|
|
rules = [
|
|
RegionRule(r'entry', r'(?<=^=head[1-4]) +.*$', Grammar, '^\n$'),
|
|
RegionRule(r'entry', r'(?<=^=over) +.*$', Grammar, '^\n$'),
|
|
RegionRule(r'entry', r'(?<=^=item) +.*$', Grammar, '^\n$'),
|
|
RegionRule(r'entry', r'(?:(?<=^=begin)|(?<=^=end)) +.*$', Grammar, '^\n$'),
|
|
RegionRule(r'entry', r'(?<=^=encoding) +.*$', Grammar, '^\n$'),
|
|
]
|
|
|
|
def _make_string_rules(forbidden=None):
|
|
if forbidden:
|
|
rule = PatternRule(r'scalar', r"\$[^A-Za-z0-9 \\%s](?![A-Za-z0-9_])" % forbidden)
|
|
else:
|
|
rule = ContextPatternRule(r'scalar', r"\$[^A-Za-z0-9 %(delim)s](?![A-Za-z0-9_])", r"\$[^A-Za-z0-9 ](?![A-Za-z0-9_])")
|
|
|
|
rules = [
|
|
PatternRule(r'octal', r'\\[0-7]{3}'),
|
|
PatternRule(r'escaped', r'\\.'),
|
|
PatternRule(r'deref', r"\$+[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*(?:(?:->)?{\$?(?:[a-zA-Z_][a-zA-Z_0-9]*|'(?:\\.|[^'\\])*'|\"(\\.|[^\\\"])*\")}|(?:->)?\[\$?[0-9a-zA-Z_]+\])+"),
|
|
PatternRule(r'length', r"\$#[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
|
|
rule,
|
|
PatternRule(r'scalar', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
|
|
PatternRule(r'cast', r"[\$\@\%\&]{.*?}"),
|
|
PatternRule(r'array', r"@\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
|
|
]
|
|
return rules
|
|
|
|
class StrictStringGrammar(Grammar):
|
|
rules = [
|
|
PatternRule(r'escaped', r"\\'"),
|
|
]
|
|
class StringGrammar(Grammar):
|
|
rules = _make_string_rules()
|
|
|
|
class QuotedGrammar1(Grammar):
|
|
rules = _make_string_rules(')')
|
|
class QuotedGrammar2(Grammar):
|
|
rules = _make_string_rules('}')
|
|
class QuotedGrammar3(Grammar):
|
|
rules = _make_string_rules('>')
|
|
class QuotedGrammar4(Grammar):
|
|
rules = _make_string_rules(']')
|
|
|
|
class PerlGrammar(Grammar):
|
|
rules = [
|
|
RegionRule(r'heredoc', r"<<(?P<heredoc>[a-zA-Z_][a-zA-Z0-9_]+)", None, ';\n', StringGrammar, r'^%(heredoc)s$'),
|
|
RegionRule(r'heredoc', r'<< *"(?P<heredoc>[a-zA-Z0-9_]+)" *;', StringGrammar, r'^%(heredoc)s$'),
|
|
RegionRule(r'heredoc', r"<< *'(?P<heredoc>[a-zA-Z0-9_]+)' *;", Grammar, r'^%(heredoc)s$'),
|
|
RegionRule(r'evaldoc', r"<< *`(?P<heredoc>[a-zA-Z0-9_]+)` *;", StringGrammar, r'^%(heredoc)s$'),
|
|
|
|
RegionRule(r'endblock', r"^__END__|__DATA__ *$", Grammar, r''),
|
|
RegionRule(r'pod', r'^=[a-zA-Z0-9_]+', PodGrammar, r'^=cut'),
|
|
|
|
OverridePatternRule(r'comment', r'#@@:(?P<token>[.a-zA-Z0-9_]+):(?P<mode>[.a-zA-Z0-9_]+) *$'),
|
|
|
|
#PatternRule(r'prototype', r'\([\\@$%&*;]+\)'),
|
|
PatternGroupRule(r'prototype', r'delimiter', r'\(', r'prototype', r'[\[\]\\@$%&*;]+', r'delimiter', '\)'),
|
|
|
|
PatternRule(r'comment', r'#.*$'),
|
|
RegionRule(r'perl_string', r'"', StringGrammar, r'"'),
|
|
RegionRule(r'perl_string', r"'", StrictStringGrammar, r"'"),
|
|
RegionRule(r'evalstring', r"`", StringGrammar, r"`"),
|
|
PatternRule(r'number', r'0?\.[0-9]+|[0-9]+(?:\.[0-9]+)?'),
|
|
PatternRule(r'perl_keyword', r"(?<!->)(?:STDIN|STDERR|STDOUT|continue|do|else|elsif|eval|foreach|for|if|last|my|next|our|package|require|return|sub|undef|unless|until|use|while)(?![a-zA-Z0-9_])"),
|
|
PatternRule(r'hash_key', r'(?<={)[A-Za-z0-9_]+(?=})'),
|
|
PatternRule(r'hash_key', r'[A-Za-z0-9_]+(?= *=>)'),
|
|
PatternRule(r'length', r"\$#[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
|
|
PatternRule(r'cast', r'[\$\@\%\^\&](?= *{)'),
|
|
PatternRule(r'scalar', r"\$[\[\]<>ab/'\"_@\?#\$!%^|&*()](?![A-Za-z0-9_])"),
|
|
PatternRule(r'array', r"@_"),
|
|
PatternRule(r'perl_function', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*(?=-> *\()"),
|
|
PatternRule(r'scalar', r"\$\$*[A-Za-z0-9_](?:[A-Za-z0-9_]|::)*"),
|
|
PatternRule(r'array', r"@\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
|
|
PatternRule(r'perl_hash', r"%\$*[A-Za-z_](?:[A-Za-z0-9_]|::)*"),
|
|
PatternRule(r'deref', r"[@%\$&\*](?={)"),
|
|
|
|
# match regexes
|
|
RegionRule(r'match', r'(?:(?<==~)|(?<=!~)|(?<=\()|(?<=split)|(?<=if)|(?<=unless)|(?<=while)|(?<=until)) *(?P<delim>/)', StringGrammar, r'/[a-z]*'),
|
|
RegionRule(r'match', r'm *(?P<delim>[^ #a-zA-Z0-9_])', StringGrammar, r'%(delim)s[a-z]*'),
|
|
RegionRule(r'match', r'm(?P<delim>#)', StringGrammar, r'#[a-z]*'),
|
|
|
|
# replace regexes
|
|
RegionRule(r'replace', r's *(?P<delim>[^ a-zA-Z0-9_])', StringGrammar, r'%(delim)s', StringGrammar, r'%(delim)s[a-z]*'),
|
|
RegionRule(r'replace', r's(?P<delim>#)', StringGrammar, r'#', StringGrammar, r'#[a-z]*'),
|
|
|
|
# translate operator
|
|
RegionRule(r'translate', r'(?:y|tr) *(?P<delim>[^ a-zA-Z0-9_])', Grammar, r'%(delim)s', Grammar, r'%(delim)s[a-z]*'),
|
|
RegionRule(r'translate', r'(?:y|tr)#', Grammar, r'#', Grammar, r'#[a-z]*'),
|
|
|
|
# some more basic stuff
|
|
PatternRule(r'package', r"(?<=package )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'sub', r"(?<=sub )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'use', r"(?<=use )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'require', r"(?<=require )(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'perl_label', r'[a-zA-Z_][a-zA-Z0-9_]*:(?!:)'),
|
|
PatternRule(r'method', r"(?<=->)[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'perl_function', r"&\$*(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*"),
|
|
PatternRule(r'perl_builtin', r"(?<!->)&?(?:write|warn|wantarray|waitpid|wait|vec|values|utime|use|untie|unshift|unpack|unlink|undef|umask|ucfirst|uc|truncate|times|time|tied|tie|telldir|tell|syswrite|system|sysseek|sysread|sysopen|syscall|symlink|substr|sub|study|stat|srand|sqrt|sprintf|split|splice|sort|socketpair|socket|sleep|sin|shutdown|shmwrite|shmread|shmget|shmctl|shift|setsockopt|setservent|setpwent|setprotoent|setpriority|setpgrp|setnetent|sethostent|setgrent|send|semop|semget|semctl|select|seekdir|seek|scalar|rmdir|rindex|rewinddir|reverse|return|reset|require|rename|ref|redo|recv|readpipe|readlink|readline|readdir|read|rand|quotemeta|push|prototype|printf|print|pos|pop|pipe|package|pack|our|ord|opendir|open|oct|no|next|my|msgsnd|msgrcv|msgget|msgctl|mkdir|map|lstat|log|lock|localtime|local|listen|link|length|lcfirst|lc|last|kill|keys|join|ioctl|int|index|import|hex|grep|goto|gmtime|glob|getsockopt|getsockname|getservent|getservbyport|getservbyname|getpwuid|getpwnam|getpwent|getprotoent|getprotobynumber|getprotobyname|getpriority|getppid|getpgrp|getpeername|getnetent|getnetbyname|getnetbyaddr|getlogin|gethostent|gethostbyname|gethostbyaddr|getgrnam|getgrgid|getgrent|getc|formline|format|fork|flock|fileno|fcntl|exp|exit|exists|exec|eval|eof|endservent|endpwent|endprotoent|endnetent|endhostent|endgrent|each|dump|do|die|delete|defined|dbmopen|dbmclose|crypt|cos|continue|connect|closedir|close|chroot|chr|chown|chop|chomp|chmod|chdir|caller|bless|binmode|bind|atan2|alarm|accept|abs)(?![a-zA-Z0-9_])"),
|
|
|
|
# quote operator: qq(), qx() and qr() usually interpolate
|
|
RegionRule(r'quoted', r'q[rqx] *(?P<delim>\()', QuotedGrammar1, r'\)'),
|
|
RegionRule(r'quoted', r'q[rqx] *(?P<delim>{)', QuotedGrammar2, r'}'),
|
|
RegionRule(r'quoted', r'q[rqx] *(?P<delim><)', QuotedGrammar3, r'>'),
|
|
RegionRule(r'quoted', r'q[rqx] *(?P<delim>\[)', QuotedGrammar4, r'\]'),
|
|
RegionRule(r'quoted', r"q[rqx] *(?P<delim>')", Grammar, r"'"),
|
|
RegionRule(r'quoted', r'q[rqx] *(?P<delim>[^ #])', StringGrammar, r'%(delim)s'),
|
|
RegionRule(r'quoted', r'q[rqx](?P<delim>#)', StringGrammar, r'#'),
|
|
|
|
# quote operator: q() and qw() do not interpolate
|
|
RegionRule(r'quoted', r'qw? *\(', Grammar, r'\)'),
|
|
RegionRule(r'quoted', r'qw? *{', Grammar, r'}'),
|
|
RegionRule(r'quoted', r'qw? *<', Grammar, r'>'),
|
|
RegionRule(r'quoted', r'qw? *\[', Grammar, r'\]'),
|
|
RegionRule(r'quoted', r'qw?#', Grammar, r'#'),
|
|
RegionRule(r'quoted', r'qw? *(?P<delim>[^ #])', Grammar, r'%(delim)s'),
|
|
|
|
PatternRule(r'perl_function', r"(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*(?= *\()"),
|
|
PatternRule(r'perl_namespace', r"(?:[a-zA-Z_][a-zA-Z_0-9]*\:\:)+(?:[a-zA-Z_][a-zA-Z_0-9]*)?"),
|
|
PatternRule(r'perl_class', r"(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*(?=->)"),
|
|
|
|
# some basic stuff
|
|
PatternRule(r'delimiter', r"::|->|=>|(?<!:):(?!=:)|[,;=\?(){}\[\]\(\)]"),
|
|
PatternRule(r'operator', r"\+=|-=|\*=|/=|//=|%=|&=\|\^=|>>=|<<=|\*\*="),
|
|
PatternRule(r'operator', r"\+\+|\+|<=>|<>|<<|<=|<|-|>>|>=|>|\*\*|\*|&&|&|\|\||\||/|\^|==|//|~|=~|!~|!=|%|!|\.|x(?![a-zA-Z_])"),
|
|
PatternRule(r'noperator', r"(?:xor|or|not|ne|lt|le|gt|ge|eq|cmp|and)(?![a-zA-Z_])"),
|
|
PatternRule(r'bareword', r'(?:[a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*'),
|
|
|
|
PatternRule(r"eol", r"\n$"),
|
|
]
|
|
|
|
class PerlTabber(tab.StackTabber):
|
|
def is_base(self, y):
|
|
if y == 0:
|
|
return True
|
|
highlighter = self.mode.window.buffer.highlights[self.mode.name()]
|
|
if not highlighter.tokens[y]:
|
|
return False
|
|
t = highlighter.tokens[y][0]
|
|
return t.name == 'perl_keyword' and t.string == 'sub'
|
|
def _handle_open_token(self, currlvl, y, i):
|
|
currlvl = tab.StackTabber._handle_open_token(self, currlvl, y, i)
|
|
return currlvl
|
|
def _handle_close_token(self, currlvl, y, i):
|
|
w = self.mode.tabwidth
|
|
self._opt_pop('cont')
|
|
currlvl = tab.StackTabber._handle_close_token(self, currlvl, y, i)
|
|
token = self.get_token(y, i)
|
|
if self.is_rightmost_token(y, i):
|
|
if token.string == '}':
|
|
self._opt_pop('cont')
|
|
else:
|
|
self._opt_append('cont', currlvl + w)
|
|
return currlvl
|
|
def _handle_other_token(self, currlvl, y, i):
|
|
w = self.mode.tabwidth
|
|
token = self.get_token(y, i)
|
|
fqname = token.fqname()
|
|
if fqname == 'delimiter' and token.string == ';':
|
|
self._opt_pop('cont')
|
|
elif fqname == 'heredoc.start':
|
|
self._opt_append('heredoc', None)
|
|
elif fqname == 'heredoc.end':
|
|
self._opt_pop('heredoc')
|
|
self._opt_pop('cont')
|
|
elif fqname == 'quoted.start':
|
|
self._opt_append('quoted', currlvl + w)
|
|
elif fqname == 'quoted.end':
|
|
self._opt_pop('cont')
|
|
self._opt_pop('quoted')
|
|
elif fqname == 'evaldoc.start':
|
|
self._opt_append('evaldoc', None)
|
|
elif fqname == 'evaldoc.end':
|
|
self._opt_pop('evaldoc')
|
|
self._opt_pop('cont')
|
|
elif fqname == 'pod.start':
|
|
self._opt_append('pod', None)
|
|
elif fqname == 'pod.end':
|
|
self._opt_pop('pod')
|
|
currlvl = 0
|
|
elif fqname == 'perl_string.start':
|
|
self._opt_append('string', None)
|
|
elif fqname == 'perl_string.end':
|
|
self._opt_pop('string')
|
|
if self.is_rightmost_token(y, i):
|
|
self._opt_append('cont', currlvl + w)
|
|
if self.is_rightmost_token(y, i):
|
|
if(not fqname.startswith('pod') and
|
|
not fqname.startswith('heredoc') and
|
|
not fqname.startswith('perl_string') and
|
|
not fqname.startswith('endblock') and
|
|
not fqname == 'eol' and
|
|
not fqname == 'comment' and
|
|
not fqname == 'null' and
|
|
token.string not in ('}', ';', '(', '{', '[', ',')):
|
|
self._opt_append('cont', currlvl + w)
|
|
return currlvl
|
|
|
|
class PerlSetLib(Method):
|
|
'''Set the path(s) to find perl modules'''
|
|
args = [Argument("lib", type=type(""), prompt="Location of lib: ",
|
|
default=default.build_constant("."))]
|
|
def _execute(self, w, **vargs):
|
|
w.application.config['perl.lib'] = vargs['lib']
|
|
|
|
class PerlCheckSyntax(Method):
|
|
'''Check the syntax of a perl file'''
|
|
def _execute(self, w, **vargs):
|
|
app = w.application
|
|
perllib = w.application.config.get('perl.lib')
|
|
if perllib:
|
|
cmd = "perl -c -I '%s' '%s'" % (perllib, w.buffer.path)
|
|
else:
|
|
cmd = "perl -c '%s'" % (w.buffer.path)
|
|
(status, output) = commands.getstatusoutput(cmd)
|
|
if status == 0:
|
|
app.set_error("Syntax OK")
|
|
app.data_buffer("*Perl-Check-Syntax*", output, switch_to=False)
|
|
else:
|
|
app.data_buffer("*Perl-Check-Syntax*", output)
|
|
|
|
class PerlViewModulePerldoc(Method):
|
|
'''View documentation about this file using perldoc'''
|
|
def _execute(self, w, **vargs):
|
|
cmd = "perldoc -t -T '%s'" % w.buffer.path
|
|
(status, output) = commands.getstatusoutput(cmd)
|
|
w.application.data_buffer("*Perldoc*", output, switch_to=True)
|
|
|
|
class PerlViewWordPerldoc(Method):
|
|
'''View documentation about a package or function using perldoc'''
|
|
def _try(self, w, word, asfunc=False):
|
|
if asfunc:
|
|
cmd = "perldoc -t -T -f '%s'" % (word,)
|
|
else:
|
|
cmd = "perldoc -t -T '%s'" % (word,)
|
|
perllib = w.application.config.get('perl.lib')
|
|
if perllib:
|
|
cmd = 'PERL5LIB=%r %s' % (perllib, cmd)
|
|
(status, data) = commands.getstatusoutput(cmd)
|
|
if status == 0:
|
|
return data
|
|
else:
|
|
return None
|
|
def _show(self, w, data, word):
|
|
w.application.data_buffer("*Perldoc*", data, switch_to=True)
|
|
w.application.set_error('displaying documentation for %r' % word)
|
|
def _execute(self, w, **vargs):
|
|
token = w.get_token()
|
|
word = token.string
|
|
|
|
# make sure that the name is (mostly) valid
|
|
if word is None:
|
|
w.application.set_error('no word selected')
|
|
return
|
|
elif ':' in word and '::' not in word:
|
|
w.application.set_error('invalid word: %r' % word)
|
|
return
|
|
|
|
# first try it is a package, unless it's a builtin
|
|
if not token.name == "perl_builtin":
|
|
parts = word.split('::')
|
|
while len(parts) > 0:
|
|
newword = '::'.join(parts)
|
|
data = self._try(w, newword, asfunc=False)
|
|
if data:
|
|
self._show(w, data, newword)
|
|
return
|
|
parts.pop(-1)
|
|
|
|
# then try it as a function
|
|
data = self._try(w, word, asfunc=True)
|
|
if data:
|
|
self._show(w, data, word)
|
|
else:
|
|
w.application.set_error('nothing found for %r' % word)
|
|
|
|
class PerlInitFunctions(Method):
|
|
'''Jump to a function defined in this module'''
|
|
def _execute(self, w, **vargs):
|
|
w.mode.context.build_name_map()
|
|
w.application.set_error("Initialized function map")
|
|
|
|
class PerlGotoFunction(Method):
|
|
'''Jump to a function defined in this module'''
|
|
args = [Argument("name", type(""), "perlfunction", "Goto Function: ")]
|
|
def _execute(self, w, **vargs):
|
|
name = vargs['name']
|
|
functions = w.mode.context.get_names()
|
|
if name in functions:
|
|
w.goto(Point(0, functions[name]))
|
|
else:
|
|
w.application.set_error("Function %r was not found" % name)
|
|
|
|
class PerlListFunctions(Method):
|
|
'''Show the user all functions defined in this module'''
|
|
def _execute(self, w, **vargs):
|
|
names = w.mode.context.get_name_list()
|
|
output = "\n".join(names) + "\n"
|
|
w.application.data_buffer("*Perl-List-Functions*", output, switch_to=True)
|
|
|
|
class PerlWhichFunction(Method):
|
|
'''Show the user what function they are in'''
|
|
def _execute(self, w, **vargs):
|
|
cursor = w.logical_cursor()
|
|
name = w.mode.context.get_line_name(cursor.y)
|
|
if name is None:
|
|
w.application.set_error("None");
|
|
else:
|
|
functions = w.mode.context.get_names()
|
|
i = functions[name] + 1
|
|
w.application.set_error("line %d: %s" % (i, name))
|
|
|
|
class PerlHashCleanup(Method):
|
|
'''Correctly align assignment blocks and literal hashes'''
|
|
def _execute(self, w, **vargs):
|
|
cursor = w.logical_cursor()
|
|
b = w.buffer
|
|
|
|
# so this is where we will store the groups that we find
|
|
groups_by_line = {}
|
|
|
|
# the regex we will try
|
|
regexes = [regex.perl_hash_cleanup,
|
|
regex.perl_assign_cleanup]
|
|
|
|
# if we aren't in a hash, inform the user and exit
|
|
line = b.lines[cursor.y]
|
|
myregex = None
|
|
for r in regexes:
|
|
if r.match(line):
|
|
myregex = r
|
|
|
|
if myregex is None:
|
|
raise Exception, "Not a perl hash line"
|
|
|
|
groups_by_line[cursor.y] = myregex.match(line).groups()
|
|
|
|
# find the beginning of this hash block
|
|
start = 0
|
|
i = cursor.y - 1
|
|
while i >= 0:
|
|
line = b.lines[i]
|
|
m = myregex.match(line)
|
|
if not m:
|
|
start = i + 1
|
|
break
|
|
else:
|
|
groups_by_line[i] = m.groups()
|
|
i -= 1
|
|
|
|
# find the end of this hash block
|
|
end = len(b.lines) - 1
|
|
i = cursor.y + 1
|
|
while i < len(b.lines):
|
|
line = b.lines[i]
|
|
m = myregex.match(line)
|
|
if not m:
|
|
end = i - 1
|
|
break
|
|
else:
|
|
groups_by_line[i] = m.groups()
|
|
i += 1
|
|
|
|
# assume that the least indented line is correct
|
|
indent_w = min([len(groups_by_line[k][0]) for k in groups_by_line])
|
|
|
|
# find the longest hash key to base all the other padding on
|
|
key_w = max([len(groups_by_line[k][1]) for k in groups_by_line])
|
|
|
|
# for each line, format it correctly
|
|
keys = groups_by_line.keys()
|
|
keys.sort()
|
|
data = ''
|
|
for i in keys:
|
|
indent_pad = ' ' * indent_w
|
|
key = groups_by_line[i][1]
|
|
sep = groups_by_line[i][3]
|
|
value = groups_by_line[i][5]
|
|
key_pad = ' ' * (key_w - len(key))
|
|
data += indent_pad + key + key_pad + ' ' + sep + ' ' + value + '\n'
|
|
|
|
# remove the old text and add the new
|
|
start_p = Point(0, start)
|
|
if end < len(w.buffer.lines) - 1:
|
|
end_p = Point(0, end + 1)
|
|
else:
|
|
end_p = Point(len(w.buffer.lines[end]), end)
|
|
w.kill(start_p, end_p)
|
|
w.insert_string(start_p, data)
|
|
|
|
class PerlWrapParagraph(method.WrapParagraph):
|
|
'''Wrap Comments and POD'''
|
|
# enumerations for line types
|
|
LT_COMMENT = 1
|
|
LT_POD = 2
|
|
|
|
margin = 80
|
|
comment_re = re.compile('( *)(#+)( *)(.*)')
|
|
|
|
def _is_newline(self, t):
|
|
return t.name == 'eol'
|
|
def _is_space(self, t):
|
|
return t.name == 'null' and regex.space.match(t.string)
|
|
|
|
def _detect_line_type(self, w, y):
|
|
h = w.buffer.highlights[w.mode.name()]
|
|
ltype = None
|
|
for t in h.tokens[y]:
|
|
fqname = t.fqname()
|
|
if fqname == 'null' or fqname == 'eol':
|
|
pass
|
|
elif fqname.startswith('comment'):
|
|
if ltype and ltype != 'comment':
|
|
ltype = None
|
|
break
|
|
ltype = self.LT_COMMENT
|
|
elif fqname.startswith('pod'):
|
|
if ltype and ltype != 'pod':
|
|
ltype = None
|
|
break
|
|
ltype = self.LT_POD
|
|
else:
|
|
ltype = None
|
|
break
|
|
return ltype
|
|
|
|
def _fix_comments(self, c, w):
|
|
h = w.buffer.highlights[w.mode.name()]
|
|
y1 = c.y
|
|
y2 = c.y
|
|
while y2 < len(w.buffer.lines) - 1:
|
|
if self._detect_line_type(w, y2 + 1):
|
|
y2 += 1
|
|
else:
|
|
break
|
|
|
|
lines = w.buffer.lines[y1:y2 + 1]
|
|
m = self.comment_re.match(lines[0])
|
|
assert m
|
|
prepend = m.group(1) + m.group(2)
|
|
rmargin = self.margin - len(prepend)
|
|
dpad = m.group(3)
|
|
|
|
segments = []
|
|
for line in lines:
|
|
m = self.comment_re.match(line)
|
|
assert m
|
|
pad, data = m.group(3), m.group(4)
|
|
if segments and pad == dpad and segments[-1][0] == dpad and segments[-1][1]:
|
|
data = segments.pop(-1)[1] + ' ' + data
|
|
i = 0
|
|
while len(pad) + len(data[i:]) > rmargin:
|
|
while data[i] == ' ':
|
|
i += 1
|
|
j = rmargin - len(pad)
|
|
while j >= 0 and data[i + j] != ' ':
|
|
j -= 1
|
|
if j < 0:
|
|
j = rmargin - len(pad)
|
|
segments.append([pad, data[i:i + j]])
|
|
i += j
|
|
if data:
|
|
while data[i] == ' ':
|
|
i += 1
|
|
segments.append([pad, data[i:]])
|
|
else:
|
|
segments.append(['', ''])
|
|
|
|
lines2 = [prepend + x[0] + x[1] for x in segments]
|
|
p1 = Point(0, y1)
|
|
p2 = Point(len(w.buffer.lines[y2]), y2)
|
|
w.buffer.delete(p1, p2)
|
|
w.buffer.insert_lines(p1, lines2)
|
|
w.set_error("wrapped comment lines %d-%d" % (y1 + 1, y2 + 1))
|
|
|
|
def _fix_pod(self, c, w):
|
|
w.set_error("pod wrapping not yet supported")
|
|
|
|
def _execute(self, w, **vargs):
|
|
c = w.logical_cursor()
|
|
ltype = self._detect_line_type(w, c.y)
|
|
if ltype == self.LT_COMMENT:
|
|
self._fix_comments(c, w)
|
|
elif ltype == self.LT_POD:
|
|
WrapParagraph._execute(self, w, **vargs)
|
|
else:
|
|
w.set_error("did not detect comment or pod lines")
|
|
|
|
class PerlSemanticComplete(method.introspect.TokenComplete):
|
|
def _min_completion(self, w, t):
|
|
a = w.application
|
|
a.methods['iperl-path-start'].execute(w, switch=False)
|
|
|
|
name = buffer.IperlBuffer.create_name(w.buffer)
|
|
b = a.get_buffer_by_name(name)
|
|
|
|
line = w.buffer.lines[t.y]
|
|
(x1, x2) = (t.x, t.end_x())
|
|
candidates = [t.string + s for s in b.readline_completions(x1, x2, line)]
|
|
|
|
minlen = None
|
|
for candidate in candidates:
|
|
if minlen is None:
|
|
minlen = len(candidate)
|
|
else:
|
|
minlen = min(minlen, len(candidate))
|
|
|
|
return self._prune_candidates(t, minlen, candidates)
|
|
|
|
class PerlOpenModule(method.Method):
|
|
args = [Argument("module", type=type(""), prompt="Open Perl Module: ")]
|
|
def _execute(self, w, **vargs):
|
|
path = w.mode.find_module(vargs['module'])
|
|
if path:
|
|
w.application.methods['open-file'].execute(w, filename=path)
|
|
else:
|
|
w.set_error("Could not find module %r" % vargs['module'])
|
|
class PerlOpenModuleWord(method.Method):
|
|
namechars = string.letters + string.digits + '_'
|
|
def _execute(self, w, **vargs):
|
|
word = pkg = w.get_token().string
|
|
path = None
|
|
while pkg and pkg[0] not in self.namechars:
|
|
pkg = pkg[1:]
|
|
while True:
|
|
path = w.mode.find_module(pkg)
|
|
if path:
|
|
break
|
|
parent = pkg.rsplit('::', 1)[0]
|
|
if parent == pkg:
|
|
break
|
|
else:
|
|
pkg = parent
|
|
if path:
|
|
w.application.methods['open-file'].execute(w, filename=path)
|
|
else:
|
|
w.set_error("Could not find module related to %r" % word)
|
|
|
|
class PerlFunctionCompleter(completer.Completer):
|
|
def get_candidates(self, s, w=None):
|
|
old_window = w.buffer.method.old_window
|
|
functions = old_window.mode.context.get_names()
|
|
return [n for n in functions if n.startswith(s)]
|
|
|
|
class PerlContext(context.Context):
|
|
def _regen_stack(self, y):
|
|
if y > 0 and self.namelines[y - 1][1]:
|
|
return list(self.namelines[y - 1][1])
|
|
else:
|
|
return []
|
|
|
|
def _build_name_map(self, y1, y2, last, curr, stack):
|
|
blen = len(self.mode.window.buffer.lines)
|
|
highlights = self.mode.window.get_highlighter()
|
|
i = y1
|
|
starting = curr and not bool(stack)
|
|
while i < y2:
|
|
if not starting and not stack:
|
|
curr = None
|
|
|
|
g = highlights.tokens[i]
|
|
if (not stack and len(g) > 2 and g[0].name == 'perl_keyword' and
|
|
g[0].string == 'sub' and g[2].name == 'sub'):
|
|
curr = g[2].string
|
|
starting = True
|
|
|
|
if curr is not None and curr not in self.names:
|
|
self.names[curr] = i
|
|
|
|
if i == y2 - 1 and curr != self.namelines[i][0] and y2 < blen:
|
|
y2 += 1
|
|
|
|
m = self.mode
|
|
for t in g:
|
|
if t.name == 'delimiter' and t.string == '{':
|
|
stack.append(t.string)
|
|
starting = False
|
|
elif t.name == 'delimiter' and t.string == '}':
|
|
if not stack:
|
|
# we are totally hosed. start over. ugh.
|
|
self.build_name_map()
|
|
return
|
|
stack.pop(-1)
|
|
if curr:
|
|
self.namelines[i] = (curr, tuple(stack))
|
|
i += 1
|
|
|
|
class Perl(mode.Fundamental):
|
|
modename = 'Perl'
|
|
extensions = ['.pl', '.pm']
|
|
detection = ['perl']
|
|
tabbercls = PerlTabber
|
|
grammar = PerlGrammar
|
|
opentokens = ('delimiter',)
|
|
opentags = {'(': ')', '[': ']', '{': '}'}
|
|
closetokens = ('delimiter',)
|
|
closetags = {')': '(', ']': '[', '}': '{'}
|
|
colors = {
|
|
# comments
|
|
'endblock.start': ('red', 'default', 'bold'),
|
|
'endblock.null': ('red', 'default', 'bold'),
|
|
'endblock.end': ('red', 'default', 'bold'),
|
|
|
|
# pod
|
|
'pod.start': ('red', 'default', 'bold'),
|
|
'pod.null': ('red', 'default', 'bold'),
|
|
'pod.entry.start': ('magenta', 'default', 'bold'),
|
|
'pod.entry.null': ('magenta', 'default', 'bold'),
|
|
'pod.entry.end': ('magenta', 'default', 'bold'),
|
|
'pod.end': ('red', 'default', 'bold'),
|
|
|
|
# basic stuff
|
|
'escaped': ('magenta', 'default', 'bold'),
|
|
'null': ('default', 'default', 'bold'),
|
|
'sub': ('cyan', 'default', 'bold'),
|
|
'prototype': ('magenta', 'default', 'bold'),
|
|
'operator': ('default', 'default', 'bold'),
|
|
'noperator': ('magenta', 'default', 'bold'),
|
|
'endblock': ('red', 'default', 'bold'),
|
|
'perl_keyword': ('magenta', 'default', 'bold'),
|
|
'cast': ('yellow', 'default', 'bold'),
|
|
'scalar': ('yellow', 'default', 'bold'),
|
|
'array': ('yellow', 'default', 'bold'),
|
|
'deref': ('yellow', 'default', 'bold'),
|
|
'perl_hash': ('yellow', 'default', 'bold'),
|
|
'hash_key': ('green', 'default', 'bold'),
|
|
'perl_function': ('cyan', 'default', 'bold'),
|
|
'perl_namespace': ('cyan', 'default', 'bold'),
|
|
'perl_builtin': ('magenta', 'default', 'bold'),
|
|
'perl_label': ('cyan', 'default', 'bold'),
|
|
'package': ('cyan', 'default', 'bold'),
|
|
'perl_class': ('cyan', 'default', 'bold'),
|
|
'use': ('cyan', 'default', 'bold'),
|
|
'require': ('cyan', 'default', 'bold'),
|
|
|
|
# heredoc/evaldoc
|
|
'heredoc.start': ('green', 'default', 'bold'),
|
|
'heredoc.null': ('green', 'default', 'bold'),
|
|
'heredoc.end': ('green', 'default', 'bold'),
|
|
'evaldoc.start': ('cyan', 'default', 'bold'),
|
|
'evaldoc.null': ('cyan', 'default', 'bold'),
|
|
'evaldoc.end': ('cyan', 'default', 'bold'),
|
|
|
|
# strings
|
|
'perl_string.start': ('green', 'default', 'bold'),
|
|
'perl_string.null': ('green', 'default', 'bold'),
|
|
'perl_string.escaped': ('magenta', 'default', 'bold'),
|
|
'perl_string.deref': ('yellow', 'default', 'bold'),
|
|
'perl_string.end': ('green', 'default', 'bold'),
|
|
|
|
# `` strings
|
|
'evalstring.start': ('cyan', 'default', 'bold'),
|
|
'evalstring.null': ('cyan', 'default', 'bold'),
|
|
'evalstring.escaped': ('magenta', 'default', 'bold'),
|
|
'evalstring.deref': ('yellow', 'default', 'bold'),
|
|
'evalstring.end': ('cyan', 'default', 'bold'),
|
|
|
|
# quoted region
|
|
'quoted': ('cyan', 'default', 'bold'),
|
|
'quoted.start': ('cyan', 'default', 'bold'),
|
|
'quoted.null': ('cyan', 'default', 'bold'),
|
|
'quoted.escaped': ('magenta', 'default', 'bold'),
|
|
'quoted.deref': ('yellow', 'default', 'bold'),
|
|
'quoted.end': ('cyan', 'default', 'bold'),
|
|
|
|
# match regex
|
|
'match.start': ('cyan', 'default', 'bold'),
|
|
'match.end': ('cyan', 'default', 'bold'),
|
|
'match.null': ('cyan', 'default', 'bold'),
|
|
|
|
# replace regex
|
|
'replace.start': ('cyan', 'default', 'bold'),
|
|
'replace.middle0': ('cyan', 'default', 'bold'),
|
|
'replace.end': ('cyan', 'default', 'bold'),
|
|
'replace.null': ('cyan', 'default', 'bold'),
|
|
'replace.escaped': ('magenta', 'default', 'bold'),
|
|
'replace.deref': ('yellow', 'default', 'bold'),
|
|
'replace.length': ('yellow', 'default', 'bold'),
|
|
'replace.scalar': ('yellow', 'default', 'bold'),
|
|
'replace.perl_hash': ('yellow', 'default', 'bold'),
|
|
'replace.cast': ('yellow', 'default', 'bold'),
|
|
|
|
# translate regex
|
|
'translate.start': ('magenta', 'default', 'bold'),
|
|
'translate.middle0': ('magenta', 'default', 'bold'),
|
|
'translate.end': ('magenta', 'default', 'bold'),
|
|
'translate.null': ('magenta', 'default', 'bold'),
|
|
}
|
|
config = {
|
|
'perl.lib': 'lib',
|
|
}
|
|
actions = [PerlSetLib, PerlCheckSyntax, PerlHashCleanup,
|
|
PerlViewModulePerldoc, PerlViewWordPerldoc, PerlWrapParagraph,
|
|
PerlInitFunctions, PerlGotoFunction, PerlWhichFunction,
|
|
PerlListFunctions, PerlOpenModule, PerlOpenModuleWord,
|
|
PerlSemanticComplete]
|
|
completers = {
|
|
'perlfunction': PerlFunctionCompleter(),
|
|
}
|
|
format = "%(flag)s %(bname)-18s (%(mname)s) %(cursor)s/%(mark)s %(perc)s [%(func)s]"
|
|
#format = "%(flag)s %(bname)-18s (%(mname)s) %(cursor)s/%(mark)s %(perc)s"
|
|
def get_status_names(self):
|
|
w = self.window
|
|
c = w.logical_cursor()
|
|
names = {
|
|
'bname': w.buffer.name(),
|
|
'mname': self.name(),
|
|
'flag': self._get_flag(),
|
|
'perc': self._get_perc(),
|
|
'cursor': '(%d,%d)' % (c.y + 1, c.x + 1),
|
|
'mark': self._get_mark(),
|
|
'func': self.get_line_function(c.y),
|
|
}
|
|
return names
|
|
def __init__(self, w):
|
|
mode.Fundamental.__init__(self, w)
|
|
self.add_bindings('perl-set-lib', ('C-c l',))
|
|
self.add_bindings('perl-check-syntax', ('C-c s',))
|
|
self.add_bindings('perl-hash-cleanup', ('C-c h',))
|
|
self.add_bindings('perl-view-module-perldoc', ('C-c v',))
|
|
self.add_bindings('perl-view-word-perldoc', ('C-c p',))
|
|
self.add_bindings('perl-wrap-paragraph', ('M-q',))
|
|
self.add_bindings('perl-goto-function', ('C-c M-g',))
|
|
self.add_bindings('perl-open-module', ('C-c C-f',))
|
|
self.add_bindings('perl-open-module-word', ('C-c M-f',))
|
|
self.add_bindings('perl-semantic-complete', ('C-c TAB',))
|
|
self.add_bindings('close-paren', (')'))
|
|
self.add_bindings('close-bracket', (']'))
|
|
self.add_bindings('close-brace', ('}'))
|
|
self.context = PerlContext(self)
|
|
self.functions = None
|
|
self.funclines = None
|
|
|
|
def find_module(self, module):
|
|
parts = module.split('::')
|
|
parts[-1] += '.pm'
|
|
relpath = os.path.join(*parts)
|
|
path = None
|
|
for d in self.get_inc():
|
|
path2 = os.path.join(d, relpath)
|
|
if os.path.exists(path2):
|
|
path = path2
|
|
break
|
|
return path
|
|
|
|
def get_inc(self):
|
|
a = self.window.application
|
|
a.state.setdefault('perl', {})
|
|
if 'inc' not in a.state['perl']:
|
|
perllib = a.config.get('perl.lib')
|
|
if perllib:
|
|
cmd = "PERL5LIB=%r perl -e 'print join(\"\\n\", @INC);'" % perllib
|
|
else:
|
|
cmd = "perl -e 'print join(\"\\n\", @INC);'"
|
|
(status, data) = commands.getstatusoutput(cmd)
|
|
if status != 0:
|
|
raise Exception, "%r failed" % cmd
|
|
a.state['perl']['inc'] = data.split('\n')
|
|
return a.state['perl']['inc']
|
|
|
|
def get_functions(self):
|
|
return self.context.get_names()
|
|
def get_function_names(self):
|
|
return self.context.get_name_list()
|
|
def get_line_function(self, y):
|
|
return self.context.get_line_name(y)
|
|
|
|
install = Perl.install
|