Add current configurations from old repository

1 files changed, 711 insertions, 0 deletions

diff --git a/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py b/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py
new file mode 100644
index 0000000..fa4bcf1
--- /dev/null
+++ b/vim/bundle/YouCompleteMe/python/ycm/youcompleteme.py
@@ -0,0 +1,711 @@
+# 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
+  ]