diff options
Diffstat (limited to 'vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py')
| m--------- | vim/bundle/YouCompleteMe | 0 | ||||
| -rw-r--r-- | vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py | 711 |
2 files changed, 0 insertions, 711 deletions
diff --git a/vim/bundle/YouCompleteMe b/vim/bundle/YouCompleteMe new file mode 160000 +Subproject 0de1c0c9bb13ce82172b472c676035cd47cf6a6 diff --git a/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py b/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py deleted file mode 100644 index fa4bcf1..0000000 --- a/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py +++ /dev/null @@ -1,711 +0,0 @@ -# Copyright (C) 2011, 2012 Google Inc. -# -# This file is part of YouCompleteMe. -# -# YouCompleteMe is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# YouCompleteMe is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>. - -from __future__ import unicode_literals -from __future__ import print_function -from __future__ import division -from __future__ import absolute_import -from future import standard_library -standard_library.install_aliases() -from builtins import * # noqa - -from future.utils import iteritems -import os -import vim -import json -import re -import signal -import base64 -from subprocess import PIPE -from tempfile import NamedTemporaryFile -from ycm import paths, vimsupport -from ycmd import utils -from ycmd import server_utils -from ycmd.request_wrap import RequestWrap -from ycmd.responses import ServerError -from ycm.diagnostic_interface import DiagnosticInterface -from ycm.omni_completer import OmniCompleter -from ycm import syntax_parse -from ycm.client.ycmd_keepalive import YcmdKeepalive -from ycm.client.base_request import BaseRequest, BuildRequestData -from ycm.client.completer_available_request import SendCompleterAvailableRequest -from ycm.client.command_request import SendCommandRequest -from ycm.client.completion_request import ( CompletionRequest, - ConvertCompletionDataToVimData ) -from ycm.client.omni_completion_request import OmniCompletionRequest -from ycm.client.event_notification import ( SendEventNotificationAsync, - EventNotification ) - -try: - from UltiSnips import UltiSnips_Manager - USE_ULTISNIPS_DATA = True -except ImportError: - USE_ULTISNIPS_DATA = False - - -def PatchNoProxy(): - current_value = os.environ.get('no_proxy', '') - additions = '127.0.0.1,localhost' - os.environ['no_proxy'] = ( additions if not current_value - else current_value + ',' + additions ) - -# We need this so that Requests doesn't end up using the local HTTP proxy when -# talking to ycmd. Users should actually be setting this themselves when -# configuring a proxy server on their machine, but most don't know they need to -# or how to do it, so we do it for them. -# Relevant issues: -# https://github.com/Valloric/YouCompleteMe/issues/641 -# https://github.com/kennethreitz/requests/issues/879 -PatchNoProxy() - -# Force the Python interpreter embedded in Vim (in which we are running) to -# ignore the SIGINT signal. This helps reduce the fallout of a user pressing -# Ctrl-C in Vim. -signal.signal( signal.SIGINT, signal.SIG_IGN ) - -HMAC_SECRET_LENGTH = 16 -SERVER_SHUTDOWN_MESSAGE = ( - "The ycmd server SHUT DOWN (restart with ':YcmRestartServer')." ) -STDERR_FILE_MESSAGE = ( - "Run ':YcmToggleLogs stderr' to check the logs." ) -STDERR_FILE_DELETED_MESSAGE = ( - "Logfile was deleted; set 'g:ycm_server_keep_logfiles' to see errors " - "in the future." ) -CORE_UNEXPECTED_MESSAGE = ( - 'Unexpected error while loading the YCM core library.' ) -CORE_MISSING_MESSAGE = ( - 'YCM core library not detected; you need to compile YCM before using it. ' - 'Follow the instructions in the documentation.' ) -CORE_PYTHON2_MESSAGE = ( - "YCM core library compiled for Python 2 but loaded in Python 3. " - "Set the 'g:ycm_server_python_interpreter' option to a Python 2 " - "interpreter path." ) -CORE_PYTHON3_MESSAGE = ( - "YCM core library compiled for Python 3 but loaded in Python 2. " - "Set the 'g:ycm_server_python_interpreter' option to a Python 3 " - "interpreter path." ) -CORE_OUTDATED_MESSAGE = ( - 'YCM core library too old; PLEASE RECOMPILE by running the install.py ' - 'script. See the documentation for more details.' ) -SERVER_IDLE_SUICIDE_SECONDS = 10800 # 3 hours -DIAGNOSTIC_UI_FILETYPES = set( [ 'cpp', 'cs', 'c', 'objc', 'objcpp' ] ) - - -class YouCompleteMe( object ): - def __init__( self, user_options ): - self._user_options = user_options - self._user_notified_about_crash = False - self._diag_interface = DiagnosticInterface( user_options ) - self._omnicomp = OmniCompleter( user_options ) - self._latest_file_parse_request = None - self._latest_completion_request = None - self._latest_diagnostics = [] - self._server_stdout = None - self._server_stderr = None - self._server_popen = None - self._filetypes_with_keywords_loaded = set() - self._ycmd_keepalive = YcmdKeepalive() - self._SetupServer() - self._ycmd_keepalive.Start() - self._complete_done_hooks = { - 'cs': lambda self: self._OnCompleteDone_Csharp() - } - - def _SetupServer( self ): - self._available_completers = {} - server_port = utils.GetUnusedLocalhostPort() - # The temp options file is deleted by ycmd during startup - with NamedTemporaryFile( delete = False, mode = 'w+' ) as options_file: - hmac_secret = os.urandom( HMAC_SECRET_LENGTH ) - options_dict = dict( self._user_options ) - options_dict[ 'hmac_secret' ] = utils.ToUnicode( - base64.b64encode( hmac_secret ) ) - json.dump( options_dict, options_file ) - options_file.flush() - - args = [ paths.PathToPythonInterpreter(), - paths.PathToServerScript(), - '--port={0}'.format( server_port ), - '--options_file={0}'.format( options_file.name ), - '--log={0}'.format( self._user_options[ 'server_log_level' ] ), - '--idle_suicide_seconds={0}'.format( - SERVER_IDLE_SUICIDE_SECONDS )] - - filename_format = os.path.join( utils.PathToCreatedTempDir(), - 'server_{port}_{std}.log' ) - - self._server_stdout = filename_format.format( port = server_port, - std = 'stdout' ) - self._server_stderr = filename_format.format( port = server_port, - std = 'stderr' ) - args.append( '--stdout={0}'.format( self._server_stdout ) ) - args.append( '--stderr={0}'.format( self._server_stderr ) ) - - if self._user_options[ 'server_keep_logfiles' ]: - args.append( '--keep_logfiles' ) - - self._server_popen = utils.SafePopen( args, stdin_windows = PIPE, - stdout = PIPE, stderr = PIPE ) - BaseRequest.server_location = 'http://127.0.0.1:' + str( server_port ) - BaseRequest.hmac_secret = hmac_secret - - self._NotifyUserIfServerCrashed() - - - def IsServerAlive( self ): - returncode = self._server_popen.poll() - # When the process hasn't finished yet, poll() returns None. - return returncode is None - - - def _NotifyUserIfServerCrashed( self ): - if self._user_notified_about_crash or self.IsServerAlive(): - return - self._user_notified_about_crash = True - - try: - vimsupport.CheckFilename( self._server_stderr ) - stderr_message = STDERR_FILE_MESSAGE - except RuntimeError: - stderr_message = STDERR_FILE_DELETED_MESSAGE - - message = SERVER_SHUTDOWN_MESSAGE - return_code = self._server_popen.poll() - if return_code == server_utils.CORE_UNEXPECTED_STATUS: - message += ' ' + CORE_UNEXPECTED_MESSAGE + ' ' + stderr_message - elif return_code == server_utils.CORE_MISSING_STATUS: - message += ' ' + CORE_MISSING_MESSAGE - elif return_code == server_utils.CORE_PYTHON2_STATUS: - message += ' ' + CORE_PYTHON2_MESSAGE - elif return_code == server_utils.CORE_PYTHON3_STATUS: - message += ' ' + CORE_PYTHON3_MESSAGE - elif return_code == server_utils.CORE_OUTDATED_STATUS: - message += ' ' + CORE_OUTDATED_MESSAGE - else: - message += ' ' + stderr_message - vimsupport.PostVimMessage( message ) - - - def ServerPid( self ): - if not self._server_popen: - return -1 - return self._server_popen.pid - - - def _ServerCleanup( self ): - if self.IsServerAlive(): - self._server_popen.terminate() - - - def RestartServer( self ): - self._CloseLogs() - vimsupport.PostVimMessage( 'Restarting ycmd server...' ) - self._user_notified_about_crash = False - self._ServerCleanup() - self._SetupServer() - - - def CreateCompletionRequest( self, force_semantic = False ): - request_data = BuildRequestData() - if ( not self.NativeFiletypeCompletionAvailable() and - self.CurrentFiletypeCompletionEnabled() ): - wrapped_request_data = RequestWrap( request_data ) - if self._omnicomp.ShouldUseNow( wrapped_request_data ): - self._latest_completion_request = OmniCompletionRequest( - self._omnicomp, wrapped_request_data ) - return self._latest_completion_request - - request_data[ 'working_dir' ] = os.getcwd() - - self._AddExtraConfDataIfNeeded( request_data ) - if force_semantic: - request_data[ 'force_semantic' ] = True - self._latest_completion_request = CompletionRequest( request_data ) - return self._latest_completion_request - - - def SendCommandRequest( self, arguments, completer ): - if self.IsServerAlive(): - return SendCommandRequest( arguments, completer ) - - - def GetDefinedSubcommands( self ): - if self.IsServerAlive(): - try: - return BaseRequest.PostDataToHandler( BuildRequestData(), - 'defined_subcommands' ) - except ServerError: - return [] - else: - return [] - - - def GetCurrentCompletionRequest( self ): - return self._latest_completion_request - - - def GetOmniCompleter( self ): - return self._omnicomp - - - def FiletypeCompleterExistsForFiletype( self, filetype ): - try: - return self._available_completers[ filetype ] - except KeyError: - pass - - if not self.IsServerAlive(): - return False - - exists_completer = SendCompleterAvailableRequest( filetype ) - if exists_completer is None: - return False - - self._available_completers[ filetype ] = exists_completer - return exists_completer - - - def NativeFiletypeCompletionAvailable( self ): - return any( [ self.FiletypeCompleterExistsForFiletype( x ) for x in - vimsupport.CurrentFiletypes() ] ) - - - def NativeFiletypeCompletionUsable( self ): - return ( self.CurrentFiletypeCompletionEnabled() and - self.NativeFiletypeCompletionAvailable() ) - - - def OnFileReadyToParse( self ): - if not self.IsServerAlive(): - self._NotifyUserIfServerCrashed() - return - - self._omnicomp.OnFileReadyToParse( None ) - - extra_data = {} - self._AddTagsFilesIfNeeded( extra_data ) - self._AddSyntaxDataIfNeeded( extra_data ) - self._AddExtraConfDataIfNeeded( extra_data ) - - self._latest_file_parse_request = EventNotification( 'FileReadyToParse', - extra_data ) - self._latest_file_parse_request.Start() - - - def OnBufferUnload( self, deleted_buffer_file ): - if not self.IsServerAlive(): - return - SendEventNotificationAsync( 'BufferUnload', - { 'unloaded_buffer': deleted_buffer_file } ) - - - def OnBufferVisit( self ): - if not self.IsServerAlive(): - return - extra_data = {} - _AddUltiSnipsDataIfNeeded( extra_data ) - SendEventNotificationAsync( 'BufferVisit', extra_data ) - - - def OnInsertLeave( self ): - if not self.IsServerAlive(): - return - SendEventNotificationAsync( 'InsertLeave' ) - - - def OnCursorMoved( self ): - self._diag_interface.OnCursorMoved() - - - def OnVimLeave( self ): - self._ServerCleanup() - - - def OnCurrentIdentifierFinished( self ): - if not self.IsServerAlive(): - return - SendEventNotificationAsync( 'CurrentIdentifierFinished' ) - - - def OnCompleteDone( self ): - complete_done_actions = self.GetCompleteDoneHooks() - for action in complete_done_actions: - action(self) - - - def GetCompleteDoneHooks( self ): - filetypes = vimsupport.CurrentFiletypes() - for key, value in iteritems( self._complete_done_hooks ): - if key in filetypes: - yield value - - - def GetCompletionsUserMayHaveCompleted( self ): - latest_completion_request = self.GetCurrentCompletionRequest() - if not latest_completion_request or not latest_completion_request.Done(): - return [] - - completions = latest_completion_request.RawResponse() - - result = self._FilterToMatchingCompletions( completions, True ) - result = list( result ) - if result: - return result - - if self._HasCompletionsThatCouldBeCompletedWithMoreText( completions ): - # Since the way that YCM works leads to CompleteDone called on every - # character, return blank if the completion might not be done. This won't - # match if the completion is ended with typing a non-keyword character. - return [] - - result = self._FilterToMatchingCompletions( completions, False ) - - return list( result ) - - - def _FilterToMatchingCompletions( self, completions, full_match_only ): - self._PatchBasedOnVimVersion() - return self._FilterToMatchingCompletions( completions, full_match_only) - - - def _HasCompletionsThatCouldBeCompletedWithMoreText( self, completions ): - self._PatchBasedOnVimVersion() - return self._HasCompletionsThatCouldBeCompletedWithMoreText( completions ) - - - def _PatchBasedOnVimVersion( self ): - if vimsupport.VimVersionAtLeast( "7.4.774" ): - self._HasCompletionsThatCouldBeCompletedWithMoreText = \ - self._HasCompletionsThatCouldBeCompletedWithMoreText_NewerVim - self._FilterToMatchingCompletions = \ - self._FilterToMatchingCompletions_NewerVim - else: - self._FilterToMatchingCompletions = \ - self._FilterToMatchingCompletions_OlderVim - self._HasCompletionsThatCouldBeCompletedWithMoreText = \ - self._HasCompletionsThatCouldBeCompletedWithMoreText_OlderVim - - - def _FilterToMatchingCompletions_NewerVim( self, - completions, - full_match_only ): - """Filter to completions matching the item Vim said was completed""" - completed = vimsupport.GetVariableValue( 'v:completed_item' ) - for completion in completions: - item = ConvertCompletionDataToVimData( completion ) - match_keys = ( [ "word", "abbr", "menu", "info" ] if full_match_only - else [ 'word' ] ) - - def matcher( key ): - return ( utils.ToUnicode( completed.get( key, "" ) ) == - utils.ToUnicode( item.get( key, "" ) ) ) - - if all( [ matcher( i ) for i in match_keys ] ): - yield completion - - - def _FilterToMatchingCompletions_OlderVim( self, completions, - full_match_only ): - """ Filter to completions matching the buffer text """ - if full_match_only: - return # Only supported in 7.4.774+ - # No support for multiple line completions - text = vimsupport.TextBeforeCursor() - for completion in completions: - word = completion[ "insertion_text" ] - # Trim complete-ending character if needed - text = re.sub( r"[^a-zA-Z0-9_]$", "", text ) - buffer_text = text[ -1 * len( word ) : ] - if buffer_text == word: - yield completion - - - def _HasCompletionsThatCouldBeCompletedWithMoreText_NewerVim( self, - completions ): - completed_item = vimsupport.GetVariableValue( 'v:completed_item' ) - if not completed_item: - return False - - completed_word = utils.ToUnicode( completed_item[ 'word' ] ) - if not completed_word: - return False - - # Sometimes CompleteDone is called after the next character is inserted. - # If so, use inserted character to filter possible completions further. - text = vimsupport.TextBeforeCursor() - reject_exact_match = True - if text and text[ -1 ] != completed_word[ -1 ]: - reject_exact_match = False - completed_word += text[ -1 ] - - for completion in completions: - word = utils.ToUnicode( - ConvertCompletionDataToVimData( completion )[ 'word' ] ) - if reject_exact_match and word == completed_word: - continue - if word.startswith( completed_word ): - return True - return False - - - def _HasCompletionsThatCouldBeCompletedWithMoreText_OlderVim( self, - completions ): - # No support for multiple line completions - text = vimsupport.TextBeforeCursor() - for completion in completions: - word = utils.ToUnicode( - ConvertCompletionDataToVimData( completion )[ 'word' ] ) - for i in range( 1, len( word ) - 1 ): # Excluding full word - if text[ -1 * i : ] == word[ : i ]: - return True - return False - - - def _OnCompleteDone_Csharp( self ): - completions = self.GetCompletionsUserMayHaveCompleted() - namespaces = [ self._GetRequiredNamespaceImport( c ) - for c in completions ] - namespaces = [ n for n in namespaces if n ] - if not namespaces: - return - - if len( namespaces ) > 1: - choices = [ "{0} {1}".format( i + 1, n ) - for i, n in enumerate( namespaces ) ] - choice = vimsupport.PresentDialog( "Insert which namespace:", choices ) - if choice < 0: - return - namespace = namespaces[ choice ] - else: - namespace = namespaces[ 0 ] - - vimsupport.InsertNamespace( namespace ) - - - def _GetRequiredNamespaceImport( self, completion ): - if ( "extra_data" not in completion - or "required_namespace_import" not in completion[ "extra_data" ] ): - return None - return completion[ "extra_data" ][ "required_namespace_import" ] - - - def GetErrorCount( self ): - return self._diag_interface.GetErrorCount() - - - def GetWarningCount( self ): - return self._diag_interface.GetWarningCount() - - - def DiagnosticUiSupportedForCurrentFiletype( self ): - return any( [ x in DIAGNOSTIC_UI_FILETYPES - for x in vimsupport.CurrentFiletypes() ] ) - - - def ShouldDisplayDiagnostics( self ): - return bool( self._user_options[ 'show_diagnostics_ui' ] and - self.DiagnosticUiSupportedForCurrentFiletype() ) - - - def PopulateLocationListWithLatestDiagnostics( self ): - # Do nothing if loc list is already populated by diag_interface - if not self._user_options[ 'always_populate_location_list' ]: - self._diag_interface.PopulateLocationList( self._latest_diagnostics ) - return bool( self._latest_diagnostics ) - - - def UpdateDiagnosticInterface( self ): - self._diag_interface.UpdateWithNewDiagnostics( self._latest_diagnostics ) - - - def FileParseRequestReady( self, block = False ): - return bool( self._latest_file_parse_request and - ( block or self._latest_file_parse_request.Done() ) ) - - - def HandleFileParseRequest( self, block = False ): - # Order is important here: - # FileParseRequestReady has a low cost, while - # NativeFiletypeCompletionUsable is a blocking server request - if ( self.FileParseRequestReady( block ) and - self.NativeFiletypeCompletionUsable() ): - - if self.ShouldDisplayDiagnostics(): - self._latest_diagnostics = self._latest_file_parse_request.Response() - self.UpdateDiagnosticInterface() - else: - # YCM client has a hard-coded list of filetypes which are known - # to support diagnostics, self.DiagnosticUiSupportedForCurrentFiletype() - # - # For filetypes which don't support diagnostics, we just want to check - # the _latest_file_parse_request for any exception or UnknownExtraConf - # response, to allow the server to raise configuration warnings, etc. - # to the user. We ignore any other supplied data. - self._latest_file_parse_request.Response() - - # We set the file parse request to None because we want to prevent - # repeated issuing of the same warnings/errors/prompts. Setting this to - # None makes FileParseRequestReady return False until the next - # request is created. - # - # Note: it is the server's responsibility to determine the frequency of - # error/warning/prompts when receiving a FileReadyToParse event, but - # it our responsibility to ensure that we only apply the - # warning/error/prompt received once (for each event). - self._latest_file_parse_request = None - - - def ShowDetailedDiagnostic( self ): - if not self.IsServerAlive(): - return - try: - debug_info = BaseRequest.PostDataToHandler( BuildRequestData(), - 'detailed_diagnostic' ) - if 'message' in debug_info: - vimsupport.EchoText( debug_info[ 'message' ] ) - except ServerError as e: - vimsupport.PostVimMessage( str( e ) ) - - - def DebugInfo( self ): - if self.IsServerAlive(): - debug_info = BaseRequest.PostDataToHandler( BuildRequestData(), - 'debug_info' ) - else: - debug_info = 'Server crashed, no debug info from server' - debug_info += '\nServer running at: {0}'.format( - BaseRequest.server_location ) - debug_info += '\nServer process ID: {0}'.format( self._server_popen.pid ) - if self._server_stderr or self._server_stdout: - debug_info += '\nServer logfiles:\n {0}\n {1}'.format( - self._server_stdout, - self._server_stderr ) - - return debug_info - - - def _OpenLogs( self, stdout = True, stderr = True ): - # Open log files in a horizontal window with the same behavior as the - # preview window (same height and winfixheight enabled). Automatically - # watch for changes. Set the cursor position at the end of the file. - options = { - 'size': vimsupport.GetIntValue( '&previewheight' ), - 'fix': True, - 'watch': True, - 'position': 'end' - } - - if stdout: - vimsupport.OpenFilename( self._server_stdout, options ) - if stderr: - vimsupport.OpenFilename( self._server_stderr, options ) - - - def _CloseLogs( self, stdout = True, stderr = True ): - if stdout: - vimsupport.CloseBuffersForFilename( self._server_stdout ) - if stderr: - vimsupport.CloseBuffersForFilename( self._server_stderr ) - - - def ToggleLogs( self, stdout = True, stderr = True ): - if ( stdout and - vimsupport.BufferIsVisibleForFilename( self._server_stdout ) or - stderr and - vimsupport.BufferIsVisibleForFilename( self._server_stderr ) ): - return self._CloseLogs( stdout = stdout, stderr = stderr ) - - # Close hidden logfile buffers if any to keep a clean state - self._CloseLogs( stdout = stdout, stderr = stderr ) - - try: - self._OpenLogs( stdout = stdout, stderr = stderr ) - except RuntimeError as error: - vimsupport.PostVimMessage( 'YouCompleteMe encountered an error when ' - 'opening logs: {0}.'.format( error ) ) - - - def CurrentFiletypeCompletionEnabled( self ): - filetypes = vimsupport.CurrentFiletypes() - filetype_to_disable = self._user_options[ - 'filetype_specific_completion_to_disable' ] - if '*' in filetype_to_disable: - return False - else: - return not any([ x in filetype_to_disable for x in filetypes ]) - - - def _AddSyntaxDataIfNeeded( self, extra_data ): - if not self._user_options[ 'seed_identifiers_with_syntax' ]: - return - filetype = vimsupport.CurrentFiletypes()[ 0 ] - if filetype in self._filetypes_with_keywords_loaded: - return - - self._filetypes_with_keywords_loaded.add( filetype ) - extra_data[ 'syntax_keywords' ] = list( - syntax_parse.SyntaxKeywordsForCurrentBuffer() ) - - - def _AddTagsFilesIfNeeded( self, extra_data ): - def GetTagFiles(): - tag_files = vim.eval( 'tagfiles()' ) - # getcwd() throws an exception when the CWD has been deleted. - try: - current_working_directory = os.getcwd() - except OSError: - return [] - return [ os.path.join( current_working_directory, x ) for x in tag_files ] - - if not self._user_options[ 'collect_identifiers_from_tags_files' ]: - return - extra_data[ 'tag_files' ] = GetTagFiles() - - - def _AddExtraConfDataIfNeeded( self, extra_data ): - def BuildExtraConfData( extra_conf_vim_data ): - return dict( ( expr, vimsupport.VimExpressionToPythonType( expr ) ) - for expr in extra_conf_vim_data ) - - extra_conf_vim_data = self._user_options[ 'extra_conf_vim_data' ] - if extra_conf_vim_data: - extra_data[ 'extra_conf_data' ] = BuildExtraConfData( - extra_conf_vim_data ) - - -def _AddUltiSnipsDataIfNeeded( extra_data ): - if not USE_ULTISNIPS_DATA: - return - - try: - # Since UltiSnips may run in a different python interpreter (python 3) than - # YCM, UltiSnips_Manager singleton is not necessary the same as the one - # used by YCM. In particular, it means that we cannot rely on UltiSnips to - # set the current filetypes to the singleton. We need to do it ourself. - UltiSnips_Manager.reset_buffer_filetypes() - UltiSnips_Manager.add_buffer_filetypes( - vimsupport.GetVariableValue( '&filetype' ) ) - rawsnips = UltiSnips_Manager._snips( '', True ) - except: - return - - # UltiSnips_Manager._snips() returns a class instance where: - # class.trigger - name of snippet trigger word ( e.g. defn or testcase ) - # class.description - description of the snippet - extra_data[ 'ultisnips_snippets' ] = [ - { 'trigger': x.trigger, 'description': x.description } for x in rawsnips - ] |