def __init__(self, *args, **kwargs):

super(VimUtils, self).__init__(*args, **kwargs)

self.completeopt = vim.eval('&completeopt')

self.preview = 'preview' in self.completeopt

def ask(self, prompt, default=None, starting=None):

if starting is None:

starting = ''

if default is not None:

prompt = prompt + '[{0}] '.format(default)

result = call('input("{0}", "{1}")'.format(prompt, starting))

if default is not None and result == '':

return default

return result

def ask_values(self, prompt, values, default=None,

starting=None, show_values=None):

if show_values or (show_values is None and len(values) < 14):

self._print_values(values)

if default is not None:

prompt = prompt + '[{0}] '.format(default)

starting = starting or ''

_completer.values = values

answer = call(

'input("{0}", "{1}", "customlist,RopeValueCompleter")'.format(

prompt, starting

)

)

if answer is None:

if 'cancel' in values:

return 'cancel'

return

if default is not None and not answer:

return default

if answer.isdigit() and 0 <= int(answer) < len(values):

return values[int(answer)]

return answer

def _print_values(self, values):

numbered = []

for index, value in enumerate(values):

numbered.append('%s. %s' % (index, str(value)))

echo('\n'.join(numbered) + '\n')

def ask_directory(self, prompt, default=None, starting=None):

return call('input("{0}", ".", "dir")'.format(prompt))

def _update_proposals(self, values):

self.completeopt = vim.eval('&completeopt')

self.preview = 'preview' in self.completeopt

if not self.get('extended_complete'):

return u','.join(u"'{0}'".format(self._completion_text(proposal))

for proposal in values)

return u','.join(self._extended_completion(proposal)

for proposal in values)

def _command(self, command, encode=False):

if encode:

command = command.encode(self._get_encoding())

vim.command(command)

def ask_completion(self, prompt, values, starting=None):

if self.get('vim_completion') and 'i' in call('mode()'):

proposals = self._update_proposals(values)

col = int(call('col(".")'))

if starting:

col -= len(starting)

self._command(u'call complete({0}, [{1}])'.format(col, proposals),

encode=True)

return None

return self.ask_values(prompt, values, starting=starting,

show_values=False)

def message(self, message):

echo(message)

def yes_or_no(self, prompt):

return self.ask_values(prompt, ['yes', 'no']) == 'yes'

def y_or_n(self, prompt):

return self.yes_or_no(prompt)

def get(self, name, default=None):

vimname = 'g:pymode_rope_{0}'.format(name)

if str(vim.eval('exists("{0}")'.format(vimname))) == '0':

return default

result = vim.eval(vimname)

if isinstance(result, str) and result.isdigit():

return int(result)

return result

def get_offset(self):

result = self._position_to_offset(*self.cursor)

return result

@staticmethod

def _get_encoding():

return vim.eval('&encoding') or 'utf-8'

def _encode_line(self, line):

return line.encode(self._get_encoding())

def _decode_line(self, line):

return line.decode(self._get_encoding())

def _position_to_offset(self, lineno, colno):

result = min(colno, len(self.buffer[lineno - 1]) + 1)

for line in self.buffer[:lineno - 1]:

line = self._decode_line(line)

result += len(line) + 1

return result

def get_text(self):

return self._decode_line('\n'.join(self.buffer)) + u'\n'

def get_region(self):

start = self._position_to_offset(*self.buffer.mark('<'))

end = self._position_to_offset(*self.buffer.mark('>'))

return start, end

@property

def buffer(self):

return vim.current.buffer

def _get_cursor(self):

lineno, col = vim.current.window.cursor

line = self._decode_line(vim.current.line[:col])

col = len(line)

return (lineno, col)

def _set_cursor(self, cursor):

lineno, col = cursor

line = self._decode_line(vim.current.line)

line = self._encode_line(line[:col])

col = len(line)

vim.current.window.cursor = (lineno, col)

cursor = property(_get_cursor, _set_cursor)

@staticmethod

def get_cur_dir():

return vim.eval('getcwd()')

def filename(self):

return self.buffer.name

def is_modified(self):

return vim.eval('&modified')

def goto_line(self, lineno):

self.cursor = (lineno, 0)

def insert_line(self, line, lineno):

self.buffer[lineno - 1:lineno - 1] = [line]

def insert(self, text):

lineno, colno = self.cursor

line = self.buffer[lineno - 1]

self.buffer[lineno - 1] = line[:colno] + text + line[colno:]

self.cursor = (lineno, colno + len(text))

def delete(self, start, end):

lineno1, colno1 = self._offset_to_position(start - 1)

lineno2, colno2 = self._offset_to_position(end - 1)

lineno, colno = self.cursor

if lineno1 == lineno2:

line = self.buffer[lineno1 - 1]

self.buffer[lineno1 - 1] = line[:colno1] + line[colno2:]

if lineno == lineno1 and colno >= colno1:

diff = colno2 - colno1

self.cursor = (lineno, max(0, colno - diff))

def _offset_to_position(self, offset):

text = self.get_text()

lineno = text.count('\n', 0, offset) + 1

try:

colno = offset - text.rindex('\n', 0, offset) - 1

except ValueError:

colno = offset

return lineno, colno

def filenames(self):

result = []

for buffer in vim.buffers:

if buffer.name:

result.append(buffer.name)

return result

def save_files(self, filenames):

vim.command('wall')

def reload_files(self, filenames, moves={}):

initial = self.filename()

for filename in filenames:

self.find_file(moves.get(filename, filename), force=True)

if initial:

self.find_file(initial)

def find_file(self, filename, readonly=False, other=False, force=False):

if filename != self.filename() or force:

if other:

vim.command(other)

filename = '\\ '.join(s.rstrip() for s in filename.split())

vim.command('e %s' % filename)

if readonly:

vim.command('set nomodifiable')

def create_progress(self, name):

return VimProgress(name)

def current_word(self):

return vim.eval('expand("<cword>")')

def push_mark(self):

vim.command('mark `')

def prefix_value(self, prefix):

return prefix

def show_occurrences(self, locations):

self._quickfixdefs(locations)

vim.command('cwindow')

def _quickfixdefs(self, locations):

filename = os.path.join(tempfile.gettempdir(), tempfile.mktemp())

try:

self._writedefs(locations, filename)

vim.command('let old_errorfile = &errorfile')

vim.command('let old_errorformat = &errorformat')

vim.command('set errorformat=%f:%l:\ %m')

vim.command('cfile ' + filename)

vim.command('let &errorformat = old_errorformat')

vim.command('let &errorfile = old_errorfile')

finally:

os.remove(filename)

def _writedefs(self, locations, filename):

tofile = open(filename, 'w')

try:

for location in locations:

err = '%s:%d: - %s\n' % (location.filename,

location.lineno, location.note)

echo(err)

tofile.write(err)

finally:

tofile.close()

def show_doc(self, docs, altview=False):

if docs:

docs = docs.encode(self._get_encoding()).replace('"', '\\"')

vim.command('call pymode#ShowStr("{0}")'.format(docs))

def preview_changes(self, diffs):

echo(diffs)

return self.y_or_n('Do the changes? ')

def local_command(self, name, callback, key=None, prefix=False):

self._add_command(name, callback, key, prefix,

prekey=self.get('local_prefix'))

def global_command(self, name, callback, key=None, prefix=False):

self._add_command(name, callback, key, prefix,

prekey=self.get('global_prefix'))

def add_hook(self, name, callback, hook):

mapping = {'before_save': 'FileWritePre,BufWritePre',

'after_save': 'FileWritePost,BufWritePost',

'exit': 'VimLeave'}

self._add_function(name, callback)

vim.command(

'autocmd {0} *.py call {1}()'.format(

mapping[hook], _vim_name(name)

)

)

def _add_command(self, name, callback, key, prefix, prekey):

self._add_function(name, callback, prefix)

vim.command(

'command! -range {0} call {1}()'.format(

_vim_name(name), _vim_name(name)

)

)

if key is not None:

key = prekey + key.replace(' ', '')

vim.command(

'noremap {0} :call {1}()<cr>'.format(key, _vim_name(name))

)

def _add_function(self, name, callback, prefix=False):

globals()[name] = callback

arg = 'None' if prefix else ''

vim.command(

'function! {0}()\n'

'python ropevim.{1}({2})\n'

'endfunction\n'.format(_vim_name(name), name, arg)

)

def _completion_data(self, proposal):

return proposal

_docstring_re = re.compile('^[\s\t\n]*([^\n]*)')

def _extended_completion(self, proposal):

# we are using extended complete and return dicts instead of strings.

# `ci` means "completion item". see `:help complete-items`

word, _, menu = map(lambda x: x.strip(), proposal.name.partition(':'))

ci = dict(

word=word,

info='',

kind=''.join(

s if s not in 'aeyuo' else '' for s in proposal.type)[:3],

menu=menu or '')

if proposal.scope == 'parameter_keyword':

default = proposal.get_default()

ci["menu"] += '*' if default is None else '= {0}'.format(default)

if self.preview and not ci['menu']:

doc = proposal.get_doc()

ci['info'] = self._docstring_re.match(doc).group(1) if doc else ''

return self._conv(ci)

def _conv(self, obj):

if isinstance(obj, dict):

return u'{' + u','.join([

u"{0}:{1}".format(self._conv(key), self._conv(value))

for key, value in obj.iteritems()]) + u'}'

def __init__(self, name):

self.name = name

self.last = 0

status('{0} ... '.format(self.name))

def update(self, percent):

try:

vim.eval('getchar(0)')

except vim.error:

raise KeyboardInterrupt(

'Task {0} was interrupted!'.format(self.name)

)

if percent > self.last + 4:

status('{0} ... {1}%'.format(self.name, percent))

self.last = percent

def done(self):

if _rope_quiet:

return

message = message.encode(VimUtils._get_encoding())

def __init__(self):

self.values = []

vim.command('python import vim')

vim.command('function! RopeValueCompleter(A, L, P)\n'

'python args = [vim.eval("a:" + p) for p in "ALP"]\n'

'python ropevim._completer(*args)\n'

'return s:completions\n'

'endfunction\n')

def __call__(self, arg_lead, cmd_line, cursor_pos):

# don't know if self.values can be empty but better safe then sorry

if self.values:

if not isinstance(self.values[0], basestring):

result = [proposal.name for proposal in self.values

if proposal.name.startswith(arg_lead)]

else:

result = [proposal for proposal in self.values

if proposal.startswith(arg_lead)]

@decorators.global_command('o')

def open_project(self, root=None, quiet=False):

global _rope_quiet

_rope_quiet = quiet

super(RopeMode, self).open_project(root=root)

rope_project_dir = os.path.join(self.project.address, '.ropeproject')

vimfiles = glob.glob(os.path.join(rope_project_dir, '*.vim'))

if not vimfiles:

return

txt = 'Sourcing vim files under \'.ropeproject/\''

progress = self.env.create_progress(txt)

for idx, vimfile in enumerate(sorted(vimfiles)):

progress.name = txt + ' ({0})'.format(os.path.basename(vimfile))

vim.command(':silent source {0}'.format(vimfile))

progress.update(idx * 100 / len(vimfiles))

progress.name = txt