def show_docstring(): '''Attempts to find the docstring for a definition and disply it in a preview window.''' # TODO: Syntax highlighting would be cool definitions = createScript().goto_definitions() if not definitions: return definition = definitions[0] if len(definitions) > 1: definition = _choose_definition(definitions) vim.command('let s:docstring=[]') vim.bindeval('s:docstring').extend([definition.docstring()]) vim_docstring_cmds = ''' split Doc setlocal noswapfile setlocal buftype=nofile setlocal modifiable silent $put=s:docstring[0] silent normal! ggdd setlocal nomodifiable setlocal nomodified noremap <buffer> q :q<CR> highlight Midi_Chlorian_Docstring ctermfg=blue match Midi_Chlorian_Docstring /./ ''' for cmd in vim_docstring_cmds.split('\n')[1:]: vim.command(cmd)
def get_command_for_file(filename): """ Get the command for the given file :param filename: The name of the file :returns: The command to run for compilation """ if not _config_exists(): return else: with open(CONFIG_FILE_NAME) as json_file: data = json.load(json_file) if filename not in data.keys(): try: vim.bindeval("g:CurSyntaxCommand") command_str = "unlet g:CurSyntaxCommand" except Exception as e: command_str = "" else: command_str = "let g:CurSyntaxCommand = \""\ + data[filename] + "\"" vim.command(command_str)
def on_done(self, should_open, returncode): if self._run_command and self._output_file_path: if vim.bindeval("g:pantondoc_use_message_buffers") and returncode != '0': vim.command("let split = &splitbelow") vim.command("set splitbelow") vim.command("5new pandoc\ output") vim.command("let &splitbelow = split") vim.command("setlocal wrap") vim.command("setlocal linebreak") vim.current.buffer[0] = "# Press <Esc> to close this" vim.current.buffer.append("▶ " + self._run_command) vim.command("normal! G") if vim.bindeval('filereadable("pandoc.out")'): vim.command("silent r pandoc.out") vim.command("setlocal buftype=nofile") vim.command("setlocal nobuflisted") # pressing <esc> on the buffer will delete it vim.command("map <buffer> <esc> :bd<cr>") # we will highlight some elements in the buffer vim.command("syn match PandocOutputMarks /^>>/") vim.command("syn match PandocCommand /^▶.*$/hs=s+1") vim.command("syn match PandocInstructions /^#.*$/") vim.command("hi! link PandocOutputMarks Operator") vim.command("hi! link PandocCommand Statement") vim.command("hi! link PandocInstructions Comment") if os.path.exists("pandoc.out"): os.remove("pandoc.out") vim.command("echohl Statement") vim.command("echom 'pantondoc:execute:" + self._run_command + "'") vim.command("echohl None") # open file if needed if os.path.exists(self._output_file_path) and should_open: if sys.platform == "darwin": pandoc_open_command = "open" #OSX elif sys.platform.startswith("linux"): pandoc_open_command = "xdg-open" # freedesktop/linux elif sys.platform.startswith("win"): pandoc_open_command = 'cmd /c \"start' # Windows # On windows, we pass commands as an argument to `start`, # which is a cmd.exe builtin, so we have to quote it if sys.platform.startswith("win"): pandoc_open_command_tail = '"' else: pandoc_open_command_tail = '' pid = Popen([pandoc_open_command, self._output_file_path + pandoc_open_command_tail]) # we reset this self._output_file_path = None self._run_command = None
def run(self): while not self.stopped: try: available = vim.bindeval('getchar(1)') if available == 0: try: callback = self.thunkQueue.get(False) callback() except Queue.Empty: time.sleep(0.01) else: char = vim.bindeval('getchar()') self.charCallback(char) except KeyboardInterrupt: self.charCallback(key_val('<C-c>'))
def getSetting(self, setting_name): name = '__tab_' + setting_name if name in vim.current.tabpage.vars: return vim.current.tabpage.vars[name] else: return vim.bindeval('g:IB_' + setting_name)
def __search_usr_and_rename_refs(tu, usr, new_name): if tu is None: return symbols = [] clighter_helper.find_cursors_by_usr(tu.cursor, usr, symbols) if not symbols: return # all symbols with the same name old_name = clighter_helper.get_spelling_or_displayname(symbols[0]) locs = set() for sym in symbols: clighter_helper.search_ref_tokens(tu, sym, locs) if len(locs): if vim.vars['clighter_rename_prompt_level'] >= 1: if vim.bindeval( "confirm(\"found symbols in {0}, rename them?\", \"&Yes\n&No\", 1)".format( vim.current.buffer.name)) == 2: return __vim_multi_replace( locs, old_name, new_name, vim.vars['clighter_rename_prompt_level'])
def __search_usr_and_rename_refs(tu, usr, new_name): if tu is None: return symbols = [] clighter_helper.find_cursors_by_usr(tu.cursor, usr, symbols) if not symbols: return # all symbols with the same name old_name = clighter_helper.get_spelling_or_displayname(symbols[0]) locs = set() for sym in symbols: clighter_helper.search_ref_tokens(tu, sym, locs) if len(locs): if vim.vars['clighter_rename_prompt_level'] >= 1: if vim.bindeval( "confirm(\"found symbols in {0}, rename them?\", \"&Yes\n&No\", 1)" .format(vim.current.buffer.name)) == 2: return __vim_multi_replace(locs, old_name, new_name, vim.vars['clighter_rename_prompt_level'])
def vim_extend(val, var='d', utf=True, list=False): d_vim = vim.bindeval(var) if list: d_vim.extend(val) else: for key in val: d_vim[key] = val[key]
def parse(): """ Python implementation of maktaba#json#Parse(). Arguments and return values are passed using a Vim list named 'l:buffer', as follows: l:buffer[0] - the mapping of null/true/false to the (possibly-custom) Vim values. l:buffer[1] - the Vim string to parse. l:buffer[2] - (out) the Vim value result. l:buffer[3] - (out) the error message, if there is an error. """ buffer = vim.bindeval('l:buffer') custom_values = buffer[0] json_str = buffer[1] try: value = [json.loads(json_str)] except ValueError as e: buffer[3] = e.message return # Now mutate the resulting Python object to something that can be stored # in a Vim value (i.e. has no None values, which Vim won't accept). _py2vim_list_inplace( value, custom_values['null'], custom_values['true'], custom_values['false']) buffer[2] = value[0]
def openSideWindow(self, name, keylist): buf_num = int(vim.bindeval("bufnr('" + name + "',1)")) vim.command("silent topleft 40 vsplit") vim.command("set winfixwidth") try: vim.command("set winwidth=40") vim.command("set winminwidth=40") vim.command("silent exe 'buffer! ' . " + str(buf_num)) vim.command("setlocal buftype=nofile bufhidden=wipe nobuflisted noswapfile nowrap") vim.current.buffer.vars['__ib_marker__'] = 1 vim.current.buffer.vars['__ib_side_window__'] = 1 except vim.error: print("Failed to open side window - don't know why?", name) self.buffer_list.append(buf_num) for item in keylist: vim.command(":map <buffer> <silent> " + item.key_value + " :py3 tab_control.keyPressed(" + str(item.action) + ", vim.eval('getcurpos()'))<cr>") self.setSideWindowKeys() vim.command(":map <buffer> <silent> <LeftRelease> :py3 tab_control.onMouseClickHandler()<cr>") return (vim.current.window, buf_num)
def closeWindow(self, window): try: if vim.bindeval('winnr("$")') == 2: # create a spare empty window so the layout does not break vim.command("vnew") if type(window) == str or type(window) == str: wind_name = window.replace('#', '\\#') wind_name = wind_name.replace(':', '\\:') window = vim.bindeval('bufwinnr("' + wind_name + '")') if window != -1: vim.command("sign unplace * buffer=" + str(vim.current.window.buffer.number)) vim.command(str(window) + "wincmd w") vim.command("q") except vim.error: pass
def vim_get_func(f, rettype=None): '''Return a vim function binding.''' try: func = vim.bindeval('function("' + f + '")') except vim.error: return None else: return rettype_func[rettype](func)
def setPosition(self, window, position): if type(window) == type(vim.current.window): buf_num = window.number else: buf_num = vim.bindeval('winbufnr(' + str(window) + ')') if buf_num != -1: vim.command('call setpos(".", [' + str(buf_num) + ',' + str(position[0]) + ',' + str(position[1]) + ',0])')
def get_ignored_modules(self): """ Update the ignored modules list. """ # Get the ignored modules setting as a string. ignored_modules = vim.bindeval('g:vimpy_ignored_modules') ignored_modules = ignored_modules.split(',') # Remove all empty items from resulting list. return filter(None, ignored_modules)
def vim_get_func(f, rettype=None): '''Return a vim function binding.''' try: func = vim.bindeval('function("' + f + '")') if sys.version_info >= (3,) and rettype is str: return (lambda *args, **kwargs: func(*args, **kwargs).decode('utf-8', errors='replace')) return func except vim.error: return None
def sort_unite(): candidates = vim.bindeval('a:candidates') is_file = vim.eval('is_file') pattern = vim.eval('a:context.input') for candidate in candidates: word = candidate['word'] rank = abbrev_matcher.rank(pattern, word, is_file=is_file) candidate['filter__rank'] = rank
def filter(self, items, pat, limit, mmode, ispath, crfile, regexp): if not pat: self.logger.debug("No pattern, returning original items") self.queue.put(self.initialList(items, limit, ispath, crfile), timeout=1) self.process(pat) return self.logger.debug("Filtering {number} items using {pat}".format(number = len(items), pat=pat)) self.process(pat) if self.lastpat == pat and self.lastmmode == mmode \ and self.lastispath == ispath and self.lastregexp == regexp: if self.process(pat) and self.queue.qsize() == 0 and not self.thread.isAlive(): self.logger.debug("Thread job is processed for {pat}".format(pat=pat)) self.lastpat = None elif self.thread.isAlive() or self.queue.qsize() > 0: self.logger.debug("Waiting for thread job for {pat}".format(pat=pat)) self.forceCursorHold() else: self.logger.debug("The same pattern '{pat}'".format(pat=pat)) elif pat: self.logger.debug("Starting thread for {pat}".format(pat=pat)) self.patterns.append(pat) mru = vim.bindeval('ctrlp#mrufiles#list()') mru = list(mru)[:50] if isinstance(mru, vim.List) else [] self.thread = Thread(target=thread_worker, args=( self.queue, items, pat, limit, mmode, ispath, crfile, regexp, mru, vim.bindeval('&ic'), vim.bindeval('&scs'), self.logger )) self.thread.daemon = True self.thread.start() self.lastpat = pat self.lastmmode = mmode self.lastispath = ispath self.lastregexp = regexp self.forceCursorHold()
def openFileWithContent(self, name, contents, force_new=False, readonly=True, replace=False): # escape name - some chars cause problems name = name.replace('#', '\\#') buf_number = vim.bindeval("bufnr('" + name + "')") if int(buf_number) != -1: # the buffer exists? Is it in a window? wind_num = vim.bindeval("bufwinnr('" + str(buf_number) + "')") if wind_num != -1 and not replace: # If the buffer is in a window - lets exit. return else: self.setBufferContents(int(buf_number), contents, readonly=readonly) else: # we need to create the buffer. buf_number = vim.eval("bufnr('" + name + "', 1)") self.setBufferContents(int(buf_number), contents, readonly=readonly) # Ok, we have a buffer we need to put it in a window. if force_new: # easy, force new - always create a new window. vim.command("silent rightbelow vsplit " + name) wind_num = vim.bindeval("winnr()") else: wind_num = self.findNotOurWindow() if wind_num == -1: # did not find a good window --- create a new one vim.command("silent rightbelow vsplit " + name) wind_num = vim.bindeval("winnr()") # Ok, put the buffer in a window vim.command(str(wind_num) + " wincmd w") vim.command("silent buffer " + str(buf_number)) buf = vim.buffers[int(buf_number)] if readonly: buf.options['buflisted'] = False buf.options['modifiable'] = False #vim.windows[wind_num].options['wrap'] = False return vim.current.window
def Cljfmt(code): repl = create_or_get_repl() job = CljfmtJob(repl, code) job.start() formatted_code = job.wait() if not formatted_code: pass else: vl = vim.bindeval("s:formatted_code") vl.extend(formatted_code.split("\n"))
def execute(self, should_open): with open("pandoc.out", 'w') as tmp: if vim.bindeval("has('clientserver')"): async_runner = os.path.join(os.path.dirname(__file__), "async.py") servername_arg = "--servername=" + vim.bindeval("v:servername") open_arg = "--open" if should_open else "--noopen" async_command = " ".join([async_runner, servername_arg, open_arg, self._run_command]) try: pid = Popen(shlex.split(async_command), stdout=tmp, stderr=tmp) except: vim.command('echoe "pantondoc: could not execute pandoc asynchronously"') else: try: com = Popen(shlex.split(self._run_command), stdout=tmp, stderr=tmp) com.wait() except: vim.command('echoe "pantondoc: could not execute pandoc"') return self.on_done(should_open, com.returncode)
def openBottomWindow(self, name, contents=None): buf_num = int(vim.bindeval("bufnr('" + name + "',1)")) vim.command("bot new") vim.command("silent buffer " + str(buf_num)) vim.command("setlocal bufhidden=wipe nobuflisted noswapfile nowrap") if contents is not None: vim.buffers[buf_num-1][:] = contents vim.current.buffer.vars['__ib_marker__'] = 1 return vim.current.window
def initialize(self, path): if path == self.path: return else: self.flush() # flush previous self.dirty = False vim.command("let " + self.vim_cfg_name + " = {}") self.vim_cfg = vim.bindeval(self.vim_cfg_name) self.path = path if os.path.isfile(path): with open(path) as f: try: cfg = json.load(f) self.vim_cfg.update(cfg) except BaseException: vim.command("let " + self.vim_cfg_name + " = {}") # re-bindeval due to new dictionary created self.vim_cfg = vim.bindeval(self.vim_cfg_name) self.fill_with_boilerplate()
def findSyntaxRegionEnd(self, start_line, column, hightlight): next_line = start_line last_line = vim.bindeval('line("$")') - 1 while next_line < last_line: if self.findSyntaxGroup(next_line, column, hightlight): next_line += 1 else: next_line -= 1 break return next_line
def _vimify(obj): """Convert a dict, list, etc. into a vim-consumable format""" if isinstance(obj, dict): d = vim.bindeval("{}") for key, val in obj.iteritems(): key = str(key) try: d[key] = _vimify(val) except TypeError, e: print "Failed to convert ", val raise e return d
def filter_unite(): pattern = vim.eval('input') candidates = vim.bindeval('a:candidates') regex = abbrev_matcher.make_regex(pattern) def candidate_word(candidate): return (candidate['word'] if isinstance(candidate, vim.Dictionary) else candidate) candidate_words = map(candidate_word, candidates) line_nums = filter_grep_exc_handling(regex, candidate_words) filter_by_indices(candidates, line_nums)
def rename(clang_service): clang_service.update_buffers(__get_bufctx_list(), False) clang_service.parse_all( string.atoi(vim.eval('g:clighter_heuristic_compile_args')), vim.bindeval('g:clighter_compile_args')) cc = clang_service.get_cc(vim.current.buffer.name) if not cc: return tu = cc.current_tu if not tu: return symbol = clighter_helper.get_vim_symbol( clighter_helper.get_vim_cursor(tu, tu.get_file(cc.name))) if not symbol: return old_name = clighter_helper.get_spelling_or_displayname(symbol) vim.command("echohl WildMenu") new_name = vim.eval("input(' Rename {0} : ', '{1}')".format( old_name, old_name)) vim.command("echohl None") if not new_name or old_name == new_name: return print ' ' pos = vim.current.window.cursor locs = set() locs.add((symbol.location.line, symbol.location.column, symbol.location.file.name)) clighter_helper.search_referenced_tokens(tu, symbol, locs) prompt = string.atoi(vim.eval('g:clighter_rename_prompt_level')) __vim_multi_replace(locs, old_name, new_name, prompt) if clighter_helper.is_global_symbol(symbol) and vim.eval( 'g:clighter_enable_cross_rename') == '1': __cross_buffer_rename(clang_service, symbol.get_usr(), new_name, prompt) vim.current.window.cursor = pos clang_service.update_buffers(__get_bufctx_list(), True)
def getUsefullWindow(self): wind_num = vim.bindeval("winnr('#')") - 1 if "__ib_marker__" in vim.current.tabpage.windows[wind_num].buffer.vars: # ok, we are not going to use this - it is special, so search for another. if len(vim.current.tabpage.windows) == 2: if wind_num == 0: wind_num = 1 else: wind_num = 0 else: wind_num = -1 for index, window in enumerate(vim.current.tabpage.windows): if "__ib_marker__" not in window.buffer.vars: # we have a winner! wind_num = index break else: # Ok, did not find one - so give up and create a new window. vim.command("silent rightbelow vsplit") wind_num = vim.bindeval("winnr()") - 1 return wind_num + 1
def SetUpCommandBuffer( cmd, name ): bufs = vim.bindeval( 'vimspector#internal#job#StartCommandWithLog( {}, "{}" )'.format( json.dumps( cmd ), name ) ) if bufs is None: raise RuntimeError( "Unable to start job {}: {}".format( cmd, name ) ) elif not all( b > 0 for b in bufs ): raise RuntimeError( "Unable to get all streams for job {}: {}".format( name, cmd ) ) return [ vim.buffers[ b ] for b in bufs ]
def hubr_to_vim(bindName, result): """Called from vim to copy the method result back into vim-space """ if type(result) == HubrResult: result = { 'status': result.get_status(), 'next': result.next(), 'json': result.json() } d = vim.bindeval(bindName) vimified = _vimify(result) d['result'] = vimified
def vimfunc(funcname, *args): countermap = localstate.cache('vimfunc_countermap', lambda: {}) counter = countermap.setdefault('count', 0) countermap['count'] = counter + 1 vim_arg_list_name = 'g:__vimfunc__arg_map_' + str(counter) vc('let %s = []' % (vim_arg_list_name)) arg_list = vim.bindeval(vim_arg_list_name) arg_list.extend(args) arg_expr = ', '.join(['%s[%s]' %(vim_arg_list_name, i) for i in range(len(args))]) expr = '%s(%s)' % (funcname, arg_expr) vim.eval(expr) vc('unlet %s' % (vim_arg_list_name))
def rename(clang_service): tu_ctx = clang_service.get_tu_ctx(vim.current.buffer.name) if tu_ctx is None: return clang_service.update_unsaved_dict(__get_buffer_dict(), False) clang_service.parse_all() vim_cursor, def_cursor = clighter_helper.get_vim_cursor_and_def(tu_ctx) if vim_cursor is None or def_cursor is None: return old_name = clighter_helper.get_spelling_or_displayname(def_cursor) vim.command("echohl WildMenu") new_name = vim.bindeval( "input(' Rename {0} : ', '{1}')".format(old_name, old_name)) vim.command("echohl None") if not new_name or old_name == new_name: return print ' ' pos = vim.current.window.cursor locs = set() locs.add((def_cursor.location.line, def_cursor.location.column, def_cursor.location.file.name)) clighter_helper.search_ref_tokens( tu_ctx.translation_unit, def_cursor, locs) __vim_multi_replace( locs, old_name, new_name, vim.vars['clighter_rename_prompt_level']) if clighter_helper.is_symbol_cursor( def_cursor) and vim.vars['clighter_enable_cross_rename'] == 1: __cross_buffer_rename(clang_service, def_cursor.get_usr(), new_name) vim.current.window.cursor = pos clang_service.update_unsaved_dict(__get_buffer_dict(), True)
def setupWindow(self): # save current window self.current_winnr = vim.bindeval('winnr()') # setup our typeahead buffer vc('botright 1new "File Search"', 'setlocal buftype=nofile', 'nohlsearch', 'setlocal noswapfile winfixheight', 'setlocal nocursorcolumn', 'setlocal nocursorline', 'setlocal nonumber', 'setlocal nowrap', 'setlocal bufhidden=wipe', 'resize %s' % (self.win_size), 'normal "10oggzt"' )
def trailing_whitespace(pl, segment_info): '''Return the line number for trailing whitespaces It is advised not to use this segment in insert mode: in Insert mode it will iterate over all lines in buffer each time you happen to type a character which may cause lags. It will also show you whitespace warning each time you happen to type space. Highlight groups used: ``trailing_whitespace`` or ``warning``. ''' global trailing_whitespace_cache if trailing_whitespace_cache is None: trailing_whitespace_cache = register_buffer_cache(defaultdict(lambda: (0, None))) bufnr = segment_info['bufnr'] changedtick = getbufvar(bufnr, 'changedtick') if trailing_whitespace_cache[bufnr][0] == changedtick: return trailing_whitespace_cache[bufnr][1] else: buf = segment_info['buffer'] bws = b' \t' sws = str(bws) for i in range(len(buf)): try: line = buf[i] except UnicodeDecodeError: # May happen in Python 3 if hasattr(vim, 'bindeval'): line = vim.bindeval('getbufline({0}, {1})'.format( bufnr, i + 1)) has_trailing_ws = (line[-1] in bws) else: line = vim.eval('strtrans(getbufline({0}, {1}))'.format( bufnr, i + 1)) has_trailing_ws = (line[-1] in bws) else: has_trailing_ws = (line and line[-1] in sws) if has_trailing_ws: break if has_trailing_ws: ret = [{ 'contents': str(i + 1), 'highlight_groups': ['trailing_whitespace', 'warning'], }] else: ret = None trailing_whitespace_cache[bufnr] = (changedtick, ret) return ret
def getText(url): session = requests.session() res = session.get(ATCODER_LOGIN) page = BeautifulSoup(res.text, 'lxml') csrf_token = page.find(attrs={'name': 'csrf_token'}).get('value') login_info = { "csrf_token": csrf_token, "username": vim.eval('g:atcoder_name'), "password": vim.eval('g:atcoder_pass'), } session.post(ATCODER_LOGIN, data=login_info) page = session.get(url) page = BeautifulSoup(page.text, 'lxml').find_all(class_="part") s = vim.bindeval('s:') s['text'] = str(page)
def _StartDebugAdapter(self): self._logger.info('Starting debug adapter with: {0}'.format( json.dumps(self._adapter))) channel_send_func = vim.bindeval( "vimspector#internal#job#StartDebugSession( {0} )".format( json.dumps(self._adapter))) self._connection = debug_adapter_connection.DebugAdapterConnection( self, channel_send_func) self._logger.info('Debug Adapter Started') vim.command('augroup vimspector_cleanup') vim.command('autocmd!') vim.command( 'autocmd VimLeavePre * py3 _vimspector_session.CloseDown()') vim.command('augroup END')
def _StartDebugAdapter( self ): if self._connection: utils.UserMessage( 'The connection is already created. Please try again', persist = True ) return self._logger.info( 'Starting debug adapter with: %s', json.dumps( self._adapter ) ) self._init_complete = False self._on_init_complete_handlers = [] self._launch_complete = False self._run_on_server_exit = None self._connection_type = 'job' if 'port' in self._adapter: self._connection_type = 'channel' if self._adapter[ 'port' ] == 'ask': port = utils.AskForInput( 'Enter port to connect to: ' ) self._adapter[ 'port' ] = port # TODO: Do we actually need to copy and update or does Vim do that? env = os.environ.copy() if 'env' in self._adapter: env.update( self._adapter[ 'env' ] ) self._adapter[ 'env' ] = env if 'cwd' not in self._adapter: self._adapter[ 'cwd' ] = os.getcwd() channel_send_func = vim.bindeval( "vimspector#internal#{}#StartDebugSession( {} )".format( self._connection_type, json.dumps( self._adapter ) ) ) if channel_send_func is None: self._logger.error( "Unable to start debug server" ) else: self._connection = debug_adapter_connection.DebugAdapterConnection( self, channel_send_func ) self._logger.info( 'Debug Adapter Started' )
def process(self, pat): queue = [] while True: try: queue.append(self.queue.get(False)) self.queue.task_done() except Empty: break if not queue: self.logger.debug("Empty queue") return False data = None for d in queue: if d["pat"]: try: index = self.patterns.index(d["pat"]) self.patterns = self.patterns[index+1:] data = d except ValueError: continue else: data = d self.lastpat = None self.patterns = [] break if not data: self.logger.debug("No valid data entry") return False callback = vim.bindeval('function("ctrlp#process")') lines = vim.List(data["items"]) subitems = vim.List(data["subitems"]) callback(lines, pat, 1, subitems) if data["pat"] == pat: self.queue = Queue() return True
def run_pytest(): """ Main entry point If current file is a test file, run it and store its name, Otherwise, run the latest stored test. """ cur_filename = vim.current.buffer.name if not cur_filename: return basename = os.path.basename(cur_filename) if basename.startswith("test"): to_run = cur_filename else: to_run = vim.bindeval("t:pytest_latest_test") if not to_run: return vim.command("!py.test %s" % to_run) vim.command('let t:pytest_latest_test="%s"' % to_run)
def get_boilerplate(): current_file = vim.eval('g:moon_current_file_path') current_file = current_file.replace(moon.moon_project_dir, '') prefix = get_prefix() bd = boilerplate.get( moon.moon_project_dir, current_file, get_author(), moon.moon_project_cfg.get_value('macro_ignored_dir'), prefix) vim_bd = vim.bindeval('g:moon_boilerplate') if 'copyright_declaration' in bd: vim_bd.extend([get_vim_let_string(bd['copyright_declaration']), ""]) if 'include_guard' in bd: include_guard_lines = bd['include_guard'] vim_bd.extend([include_guard_lines[0], include_guard_lines[1], "", "", include_guard_lines[2]]) if 'cpp_include_header' in bd: vim_bd.extend([bd['cpp_include_header']])
def rename(clang_service): tu_ctx = clang_service.get_tu_ctx(vim.current.buffer.name) if tu_ctx is None: return clang_service.update_unsaved_dict(__get_buffer_dict(), False) clang_service.parse_all() vim_cursor, def_cursor = clighter_helper.get_vim_cursor_and_def(tu_ctx) if vim_cursor is None or def_cursor is None: return old_name = clighter_helper.get_spelling_or_displayname(def_cursor) vim.command("echohl WildMenu") new_name = vim.bindeval("input(' Rename {0} : ', '{1}')".format( old_name, old_name)) vim.command("echohl None") if not new_name or old_name == new_name: return print ' ' pos = vim.current.window.cursor locs = set() locs.add((def_cursor.location.line, def_cursor.location.column, def_cursor.location.file.name)) clighter_helper.search_ref_tokens(tu_ctx.translation_unit, def_cursor, locs) __vim_multi_replace(locs, old_name, new_name, vim.vars['clighter_rename_prompt_level']) if clighter_helper.is_symbol_cursor( def_cursor) and vim.vars['clighter_enable_cross_rename'] == 1: __cross_buffer_rename(clang_service, def_cursor.get_usr(), new_name) vim.current.window.cursor = pos clang_service.update_unsaved_dict(__get_buffer_dict(), True)
def initialList(self, items, limit, ispath, crfile): mru = None if ispath: mru = vim.bindeval('ctrlp#mrufiles#list()') if isinstance(mru, vim.List) and mru: mrudict = {} mrucount = len(mru) index = 0 for f in mru: mrudict[f] = index index += 1 recentCount = 0 restCount = 0 recent = [] rest = [] for item in items: if item == crfile: continue if mrudict.get(item, -1) != -1: recent.append(item) recentCount += 1 mrucount -= 1 elif restCount + recentCount < limit: rest.append(item) restCount += 1 if recentCount == limit or not mrucount and restCount + recentCount >= limit: break recent = sorted(recent, cmp=lambda a, b: mrudict.get(a, -1) - mrudict.get(b, -1)) return {"items": recent + rest[:limit - restCount], "subitems": items[recentCount-1:], "pat": ""} else: return {"items": items[:limit], "subitems": items[limit-1:], "pat": ""}
def format(): """ Python implementation of maktaba#json#Format(). Arguments and return values are passed using a Vim list named 'l:buffer', as follows: l:buffer[0] - the mapping of null/true/false to the default Vim sentinels. l:buffer[1] - the Vim value to format. l:buffer[2] - (out) the string result. l:buffer[3] - (out) the error message, if there is an error. """ buffer = vim.bindeval('l:buffer') custom_values = buffer[0] value = buffer[1] # Now translate the Vim value to something that uses Python types (e.g. # None, True, False), based on the custom values we're using. Note that # this must return a copy of the input, as we cannot store None (or True # or False) in a Vim value. (Doing this also avoids needing to tell # json.dumps() how to serialize a vim.List or vim.Dictionary.) # Note that to do this we need to check our custom values for equality, # which we also can't do if they're a vim.List or vim.Dictionary. # Fortunately, there's an easy way to fix that. custom_values = _vim2py_deepcopy(custom_values, None, None, None) # Now we can use those custom values to translate the real value. value = _vim2py_deepcopy( value, custom_values['null'], custom_values['true'], custom_values['false']) try: buffer[2] = json.dumps(value, allow_nan=False) except ValueError as e: # e.g. attempting to format NaN buffer[3] = e.message except TypeError as e: # e.g. attempting to format a Function buffer[3] = e.message
def wrapper(): return func(vim.bindeval('a:'))
r = vim.eval(self.f + '(' + json.dumps(args)[1:-1] + ')') if self.rettype: return self.rettype(r) return r vim_get_func = VimFunc _getbufvar = vim_get_func('getbufvar') # It may crash on some old vim versions and I do not remember in which patch # I fixed this crash. if hasattr(vim, 'vvars') and vim.vvars['version'] > 703: _vim_to_python_types = { getattr(vim, 'Dictionary', None) or type(vim.bindeval('{}')): lambda value: dict(((key, _vim_to_python(value[key])) for key in value.keys())), getattr(vim, 'List', None) or type(vim.bindeval('[]')): lambda value: [_vim_to_python(item) for item in value], getattr(vim, 'Function', None) or type(vim.bindeval('function("mode")')): lambda _: None, } def vim_getvar(varname): return _vim_to_python(vim.vars[str(varname)]) def bufvar_exists(buffer, varname): buffer = buffer or vim.current.buffer return varname in buffer.vars def vim_getwinvar(segment_info, varname):
def highlight_window(clang_service, extend=50): tu_ctx = clang_service.get_tu_ctx(vim.current.buffer.name) if tu_ctx is None: clear_highlight() return tu = tu_ctx.translation_unit if tu is None: clear_highlight() return (top, bottom) = (vim.bindeval("line('w0')"), vim.bindeval("line('w$')")) draw_syntax = False draw_def_ref = False if highlight_window.hl_tick < clang_service.parse_tick or highlight_window.syntactic_range is None or top < highlight_window.syntactic_range[ 0] or bottom > highlight_window.syntactic_range[1]: draw_syntax = True vim.command("call s:clear_match_pri([{0}])".format(SYNTAX_PRI)) highlight_window.hl_tick = clang_service.parse_tick if vim.vars["ClighterCursorHL"] == 1: vim_cursor, def_cursor = clighter_helper.get_vim_cursor_and_def(tu_ctx) if highlight_window.highlighted_define_cur is not None and( def_cursor is None or highlight_window.highlighted_define_cur != def_cursor): vim.command("call s:clear_match_pri([{0}])".format(DEF_REF_PRI)) if def_cursor is not None and( highlight_window. highlighted_define_cur is None or highlight_window.highlighted_define_cur != def_cursor): draw_def_ref = True # special case for preprocessor if def_cursor.kind.is_preprocessing( ) and def_cursor.location.file.name == vim.current.buffer.name: __vim_matchaddpos( 'clighterCursorDefRef', def_cursor.location.line, def_cursor.location.column, len( clighter_helper.get_spelling_or_displayname(def_cursor)), DEF_REF_PRI) highlight_window.highlighted_define_cur = def_cursor if not draw_syntax and not draw_def_ref: return target_range = [top, bottom] if draw_syntax: buflinenr = len(vim.current.buffer) target_range = [max(top - extend, 1), min(bottom + extend, buflinenr)] highlight_window.syntactic_range = target_range file = tu.get_file(tu_ctx.bufname) tokens = tu.get_tokens( extent=cindex.SourceRange.from_locations( cindex.SourceLocation.from_position( tu, file, target_range[0], 1), cindex.SourceLocation.from_position( tu, file, target_range[1] + 1, 1))) for t in tokens: """ Do semantic highlighting' """ if t.kind.value != 2: continue t_cursor = cindex.Cursor.from_location( tu, cindex.SourceLocation.from_position( tu, file, t.location.line, t.location.column)) # cursor under vim if draw_syntax: __draw_token(t.location.line, t.location.column, len( t.spelling), t_cursor.kind, t_cursor.type.kind) """ Do definition/reference highlighting' """ if draw_def_ref: t_def_cursor = clighter_helper.get_semantic_definition(t_cursor) if t_def_cursor is not None and t_def_cursor == highlight_window.highlighted_define_cur: __vim_matchaddpos( 'clighterCursorDefRef', t.location.line, t.location.column, len( t.spelling), DEF_REF_PRI)
def status(fname): return funcs.status(path, fname) def branch(): return funcs.branch(path) return Funcs(status=status, branch=branch) funcs_cache = {} fname_cache = {} def plugin_eval(expr): global plugin_eval plugin_eval = vim_get_func('<SNR>'+sid+'_Eval') return plugin_eval(expr) if hasattr(vim, 'bindeval'): self_dict = vim.bindeval('{}') def get_repo(path): global get_repo vim_get_repo = plugin_eval('s:_r.repo.get') get_repo = lambda path: vim_get_repo(path, self=self_dict) return get_repo(path) def get_interval(key): global get_interval vim_get_interval = plugin_eval('s:_r.cache.getinterval') get_interval = lambda key: vim_get_interval(key, self=self_dict) return get_interval(key) rf_dict = vim.bindeval('{"repo": ":"}')
def forceCursorHold(self): vim.bindeval('function("ctrlp#forcecursorhold")')()
def vim_get_func(f, rettype=None): '''Return a vim function binding.''' try: return vim.bindeval('function("' + f + '")') except vim.error: return None
def source_plugin(): import sys import os if sys.version_info[:2] == (3, 3): vim.command('let g:powerline_pycmd = "python3"') vim.command('let g:powerline_pyeval = "py3eval"') else: vim.command('let g:powerline_pycmd = "python"') vim.command('let g:powerline_pyeval = "pyeval"') fnameescape = vim_get_func('fnameescape') vim.command('source ' + fnameescape(os.path.join(os.path.abspath(os.path.dirname(__file__)), 'powerline.vim')).decode('utf-8')) try: _vim_globals = vim.bindeval('g:') def vim_set_global_var(var, val): '''Set a global var in vim using bindeval().''' _vim_globals[var] = val def vim_get_func(f, rettype=None): '''Return a vim function binding.''' try: return vim.bindeval('function("' + f + '")') except vim.error: return None except AttributeError: import json def vim_set_global_var(var, val): # NOQA