Python vim.eval函数代码示例

def tabnew(path):
    "Open a file in a new tab or switch to an existing one"
    path = os.path.abspath(path)
    if vim.eval('has("gui")') == '1':
        vim.command('tab drop %s' % path)
        return

    for tab_nr in range(int(vim.eval("tabpagenr('$')"))):
        for buf_nr in vim.eval("tabpagebuflist(%i + 1)" % tab_nr):
            buf_nr = int(buf_nr) - 1
            try:
                buf_path = vim.buffers[buf_nr].name
            except IndexError:
                # Just do good old asking for forgiveness.
                # don't know why this happens :-)
                pass
            else:
                if buf_path == path:
                    # tab exists, just switch to that tab
                    vim.command('tabfirst | tabnext %i' % (tab_nr + 1))
                    break
        else:
            continue
        break
    else:
        # tab doesn't exist, add a new one.
        vim.command('tabnew %s' % path)

def tern_startServer(project):
  if time.time() - project.last_failed < 30: return None

  win = platform.system() == "Windows"
  env = None
  if platform.system() == "Darwin":
    env = os.environ.copy()
    env["PATH"] += ":/usr/local/bin"
  command = vim.eval("g:tern#command") + vim.eval("g:tern#arguments")
  try:
    proc = subprocess.Popen(command,
                            cwd=project.dir, env=env,
                            stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                            stderr=subprocess.STDOUT, shell=win)
  except Exception as e:
    tern_displayError("Failed to start server: " + str(e))
    return None
  output = ""
  while True:
    line = proc.stdout.readline().decode('utf8')
    if not line:
      tern_displayError("Failed to start server" + (output and ":\n" + output))
      project.last_failed = time.time()
      return None
    match = re.match("Listening on port (\\d+)", line)
    if match:
      port = int(match.group(1))
      project.port = port
      project.proc = proc
      return port
    else:
      output += line

def LoadDictIntoVimGlobals( new_globals, overwrite = True ):
  extend_option = '"force"' if overwrite else '"keep"'

  # We need to use json.dumps because that won't use the 'u' prefix on strings
  # which Vim would bork on.
  vim.eval( 'extend( g:, {0}, {1})'.format( json.dumps( new_globals ),
                                            extend_option ) )

def fold_text(allow_dirty=False):
	u""" Set the fold text
		:setlocal foldtext=Method-which-calls-foldtext

	:allow_dirty:	Perform a query without (re)building the DOM if True
	:returns: None
	"""
	line = int(vim.eval(u_encode(u'v:foldstart')))
	d = ORGMODE.get_document(allow_dirty=allow_dirty)
	heading = None
	if allow_dirty:
		heading = d.find_current_heading(line - 1)
	else:
		heading = d.current_heading(line - 1)
	if heading:
		str_heading = unicode(heading)

		# expand tabs
		ts = int(vim.eval(u_encode(u'&ts')))
		idx = str_heading.find(u'\t')
		if idx != -1:
			tabs, spaces = divmod(idx, ts)
			str_heading = str_heading.replace(u'\t', u' ' * (ts - spaces), 1)
			str_heading = str_heading.replace(u'\t', u' ' * ts)

		# Workaround for vim.command seems to break the completion menu
		vim.eval(u_encode(u'SetOrgFoldtext("%s...")' % (re.sub(r'\[\[([^[\]]*\]\[)?([^[\]]+)\]\]', r'\2',
				str_heading).replace( u'\\', u'\\\\').replace(u'"', u'\\"'), )))

def main():
    binary = 'clang-rename'
    if vim.eval('exists("g:clang_rename_path")') == "1":
        binary = vim.eval('g:clang_rename')

    # Get arguments for clang-rename binary.
    offset = int(vim.eval('line2byte(line("."))+col(".")')) - 2
    if offset < 0:
        print >> sys.stderr, '''Couldn\'t determine cursor position.
                                Is your file empty?'''
        return
    filename = vim.current.buffer.name

    new_name_request_message = 'type new name:'
    new_name = vim.eval("input('{}\n')".format(new_name_request_message))

    # Call clang-rename.
    command = [binary,
               filename,
               '-i',
               '-offset', str(offset),
               '-new-name', str(new_name)]
    # FIXME: make it possible to run the tool on unsaved file.
    p = subprocess.Popen(command,
                         stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    stdout, stderr = p.communicate()

    if stderr:
        print stderr

    # Reload all buffers in Vim.
    vim.command("bufdo edit")

    def base_snippet_files_for(self, ft, default=True):
        """ Returns a list of snippet files matching the given filetype (ft).
        If default is set to false, it doesn't include shipped files.

        Searches through each path in 'runtimepath' in reverse order,
        in each of these, it searches each directory name listed in
        'g:UltiSnipsSnippetDirectories' in order, then looks for files in these
        directories called 'ft.snippets' or '*_ft.snippets' replacing ft with
        the filetype.
        """

        snippet_dirs = vim.eval("g:UltiSnipsSnippetDirectories")
        base_snippets = os.path.realpath(os.path.join(__file__, "../../../UltiSnips"))
        ret = []

        paths = vim.eval("&runtimepath").split(',')

        if vim.eval("exists('g:UltiSnipsDontReverseSearchPath')") == "0" or \
           vim.eval("g:UltiSnipsDontReverseSearchPath") == "0":
            paths = paths[::-1]

        for rtp in paths:
            for snippet_dir in snippet_dirs:
                pth = os.path.realpath(os.path.expanduser(os.path.join(rtp, snippet_dir)))

                patterns = ["%s.snippets", "*_%s.snippets"]
                if not default and pth == base_snippets:
                    patterns.remove("%s.snippets")

                for pattern in patterns:
                    for fn in glob.glob(os.path.join(pth, pattern % ft)):
                        if fn not in ret:
                            ret.append(fn)

        return ret

 def create_new_note_from_current_buffer(self):
     """ get content of the current buffer and create new note """
     content = "\n".join(str(line) for line in vim.current.buffer[:])
     markdown = (vim.eval("&filetype") == "markdown")
     if markdown:
         note, status = self.simplenote.update_note({"content": content,
                                                     "systemtags": ["markdown"]})
     else:
         note, status = self.simplenote.update_note({"content": content})
     if status == 0:
         self.note_version[note["key"]] = note["version"]
         self.transform_to_scratchbuffer()
         # Replace any non alphanumeric characters to play safe with valid vim buffer names
         # otherwise vim will happily add them, but will fail to switch to them
         regex = re.compile("[^a-zA-Z0-9]")
         firstline = regex.sub("_", vim.current.buffer[0])
         buffertitle = "SN_%s" % firstline
         self.set_current_note(buffertitle, note["key"])
         self.bufnum_to_noteid[vim.current.buffer.number] = note["key"]
         vim.command("doautocmd BufReadPost")
         # BufReadPost can cause auto-selection of filetype based on file content so reset filetype after this
         if int(vim.eval("exists('g:SimplenoteFiletype')")) == 1:
             vim.command("setlocal filetype="+vim.eval("g:SimplenoteFiletype"))
         # But let simplenote markdown flag override the above
         if markdown:
             vim.command("setlocal filetype=markdown")
         print("New note created.")
     else:
         print("Update failed.: %s" % note["key"])

 def _get_preview_url(self):
     wiki_repo_defined = int(vim.eval("exists('g:ghwiki_preview_repo')"))
     if not wiki_repo_defined:
         self._err = "please set ghwiki_preview_repo in your ~/.vimrc"
         return
     wiki_repo = vim.eval("g:ghwiki_preview_repo")
     if len(wiki_repo.split('/')) != 2:
         self._err = "invalid ghwiki_preview_repo set, "
         self._err += "must have the form: 'user/repo'"
         return
     user, repo = wiki_repo.split('/')
     gh = github.GitHub()
     try:
         repo_exists = gh.repos.show(user, repo)
         if not repo_exists.has_wiki:
             self._err = "repo %s does not have a git-backed wiki enabled"
             self._err = self._err % repo
             return
     except urllib2.HTTPError:
         self._err = "repo %s does not exist" % wiki_repo
         return
     except urllib2.URLError:
         self._err = "no internet connection available"
         return
     return 'https://github.com/%s/%s/wiki/_preview' % (user, repo)

	def set_tags(cls):
		u""" Set tags for current heading
		"""
		d = ORGMODE.get_document()
		heading = d.current_heading()
		if not heading:
			return

		# retrieve tags
		res = None
		if heading.tags:
			res = vim.eval(u'input("Tags: ", ":%s:", "customlist,Org_complete_tags")' % u':'.join(heading.tags))
		else:
			res = vim.eval(u'input("Tags: ", "", "customlist,Org_complete_tags")')

		if res is None:
			# user pressed <Esc> abort any further processing
			return

		# remove empty tags
		heading.tags = filter(lambda x: x.strip() != u'', res.decode(u'utf-8').strip().strip(u':').split(u':'))

		d.write()

		return u'OrgSetTags'

def getCurrentCompletions(base):
    priority = vim.eval("g:clang_sort_algo") == "priority"
    line = int(vim.eval("line('.')"))
    column = int(vim.eval("b:col"))

    t = CompleteThread(line, column, getCurrentFile(), vim.current.buffer.name)
    t.start()
    while t.isAlive():
        t.join(0.01)
        cancel = int(vim.eval("complete_check()"))
        if cancel != 0:
            return []
    cr = t.result
    if cr is None:
        return []

    regexp = re.compile("^" + base)
    filteredResult = filter(lambda x: regexp.match(getAbbr(x.string)), cr.results)

    getPriority = lambda x: x.string.priority
    getAbbrevation = lambda x: getAbbr(x.string).lower()
    if priority:
        key = getPriority
    else:
        key = getAbbrevation
    sortedResult = sorted(filteredResult, None, key)
    return map(formatResult, sortedResult)

def debugger_init(debug=0):
    global debugger

    # get needed vim variables

    # port that the engine will connect on
    port = int(vim.eval("debuggerPort"))
    if port == 0:
        port = 9000

    # the max_depth variable to set in the engine
    max_children = vim.eval("debuggerMaxChildren")
    if max_children == "":
        max_children = "32"

    max_data = vim.eval("debuggerMaxData")
    if max_data == "":
        max_data = "1024"

    max_depth = vim.eval("debuggerMaxDepth")
    if max_depth == "":
        max_depth = "1"

    minibufexpl = int(vim.eval("debuggerMiniBufExpl"))
    if minibufexpl == 0:
        minibufexpl = 0

    debugger = Debugger(port, max_children, max_data, max_depth, minibufexpl, debug)

def updateCurrentDiagnostics():
    global debug
    debug = int(vim.eval("g:clang_debug")) == 1
    userOptionsGlobal = splitOptions(vim.eval("g:clang_user_options"))
    userOptionsLocal = splitOptions(vim.eval("b:clang_user_options"))
    args = userOptionsGlobal + userOptionsLocal
    getCurrentTranslationUnit(args, getCurrentFile(), vim.current.buffer.name, update=True)

  def CandidatesForQueryAsyncInner( self, query, unused_start_column ):
    if not self.omnifunc:
      self.stored_candidates = None
      return

    try:
      return_value = int( vim.eval( self.omnifunc + '(1,"")' ) )
      if return_value < 0:
        self.stored_candidates = None
        return

      omnifunc_call = [ self.omnifunc,
                        "(0,'",
                        vimsupport.EscapeForVim( query ),
                        "')" ]

      items = vim.eval( ''.join( omnifunc_call ) )

      if 'words' in items:
        items = items['words']
      if not hasattr( items, '__iter__' ):
        raise TypeError( OMNIFUNC_NOT_LIST )

      self.stored_candidates = filter( bool, items )
    except (TypeError, ValueError) as error:
      vimsupport.PostVimMessage(
        OMNIFUNC_RETURNED_BAD_VALUE + ' ' + str( error ) )
      self.stored_candidates = None
      return

    def execute(self, should_open):
        with open("pandoc.out", 'w') as tmp:
            if vim.eval("has('clientserver')") == '1' and \
               vim.eval("v:servername") != "" and \
               vim.eval("executable('python')") == '1':
                async_runner = '"' + os.path.join(os.path.dirname(__file__), "async.py") + '"'
                servername_arg = "--servername=" + vim.eval("v:servername")
                open_arg  = "--open" if should_open else "--noopen"
                async_command = " ".join(["python", async_runner, servername_arg, open_arg, self._run_command])
                try:
                    Popen(shlex.split(async_command), stdout=tmp, stderr=tmp)
                except:
                    vim.command('echoe "vim-pandoc: could not execute pandoc asynchronously"')
            elif vim.eval("has('nvim')") == '1':
                vim.command("call jobstart("+ \
                        str(['pandoc'] + shlex.split(self._run_command)[1:]) + \
                                ", extend({'should_open': '" + str(int(should_open)) + \
                                "'}, {'on_exit': 'pandoc#command#JobHandler'}))")
                #vim.command('call jobstart(["pandoc", ' + str(shlex.split(self._run_command)[1:]) + '])')
            else:
                try:
                    com = Popen(shlex.split(self._run_command), stdout=tmp, stderr=tmp)
                    com.wait()
                except:
                    vim.command('echoe "vim-pandoc: could not execute pandoc"')
                    return

                self.on_done(should_open, com.returncode)

def debugger_init(debug = 0):
  global debugger

  # get needed vim variables

  # port that the engine will connect on
  port = int(vim.eval('debuggerPort'))
  if port == 0:
    port = 9000

  # the max_depth variable to set in the engine
  max_children = vim.eval('debuggerMaxChildren')
  if max_children == '':
    max_children = '32'

  max_data = vim.eval('debuggerMaxData')
  if max_data == '':
    max_data = '1024'

  max_depth = vim.eval('debuggerMaxDepth')
  if max_depth == '':
    max_depth = '1'

  minibufexpl = int(vim.eval('debuggerMiniBufExpl'))
  if minibufexpl == 0:
    minibufexpl = 0

  debugger  = Debugger(port, max_children, max_data, max_depth, minibufexpl, debug)