def __init__(self, user_options):
     super(GeneralCompleterStore, self).__init__(user_options)
     self._identifier_completer = IdentifierCompleter(user_options)
     self._filename_completer = FilenameCompleter(user_options)
     self._ultisnips_completer = UltiSnipsCompleter(user_options)
     self._non_filename_completers = filter(
         lambda x: x,
         [self._ultisnips_completer, self._identifier_completer])
     self._all_completers = filter(lambda x: x, [
         self._identifier_completer, self._filename_completer,
         self._ultisnips_completer
     ])
     self._current_query_completers = []
 def __init__(self):
     super(GeneralCompleterStore, self).__init__()
     self._identifier_completer = IdentifierCompleter()
     self._filename_completer = FilenameCompleter()
     self._ultisnips_completer = (UltiSnipsCompleter()
                                  if USE_ULTISNIPS_COMPLETER else None)
     self._non_filename_completers = filter(
         lambda x: x,
         [self._ultisnips_completer, self._identifier_completer])
     self._all_completers = filter(lambda x: x, [
         self._identifier_completer, self._filename_completer,
         self._ultisnips_completer
     ])
     self._current_query_completers = []
Example #3
0
    def __init__(self, user_options):
        super(GeneralCompleterStore, self).__init__(user_options)
        self._identifier_completer = IdentifierCompleter(user_options)
        self._filename_completer = FilenameCompleter(user_options)
        self._ultisnips_completer = UltiSnipsCompleter(user_options)
        self._non_filename_completers = [self._identifier_completer]
        if user_options.get('use_ultisnips_completer', True):
            self._non_filename_completers.append(self._ultisnips_completer)

        self._all_completers = [
            self._identifier_completer, self._filename_completer,
            self._ultisnips_completer
        ]
        self._current_query_completers = []
class GeneralCompleterStore(Completer):
    """
  Holds a list of completers that can be used in all filetypes.

  It overrides all Competer API methods so that specific calls to
  GeneralCompleterStore are passed to all general completers.
  """
    def __init__(self):
        super(GeneralCompleterStore, self).__init__()
        self._identifier_completer = IdentifierCompleter()
        self._filename_completer = FilenameCompleter()
        self._ultisnips_completer = (UltiSnipsCompleter()
                                     if USE_ULTISNIPS_COMPLETER else None)
        self._non_filename_completers = filter(
            lambda x: x,
            [self._ultisnips_completer, self._identifier_completer])
        self._all_completers = filter(lambda x: x, [
            self._identifier_completer, self._filename_completer,
            self._ultisnips_completer
        ])
        self._current_query_completers = []

    def SupportedFiletypes(self):
        return set()

    def ShouldUseNow(self, start_column):
        self._current_query_completers = []

        if self._filename_completer.ShouldUseNow(start_column):
            self._current_query_completers = [self._filename_completer]
            return True

        should_use_now = False

        for completer in self._non_filename_completers:
            should_use_this_completer = completer.ShouldUseNow(start_column)
            should_use_now = should_use_now or should_use_this_completer

            if should_use_this_completer:
                self._current_query_completers.append(completer)

        return should_use_now

    def CandidatesForQueryAsync(self, query, start_column):
        for completer in self._current_query_completers:
            completer.CandidatesForQueryAsync(query, start_column)

    def AsyncCandidateRequestReady(self):
        return all(x.AsyncCandidateRequestReady()
                   for x in self._current_query_completers)

    def CandidatesFromStoredRequest(self):
        candidates = []
        for completer in self._current_query_completers:
            candidates += completer.CandidatesFromStoredRequest()

        return candidates

    def OnFileReadyToParse(self):
        for completer in self._all_completers:
            completer.OnFileReadyToParse()

    def OnCursorMovedInsertMode(self):
        for completer in self._all_completers:
            completer.OnCursorMovedInsertMode()

    def OnCursorMovedNormalMode(self):
        for completer in self._all_completers:
            completer.OnCursorMovedNormalMode()

    def OnBufferVisit(self):
        for completer in self._all_completers:
            completer.OnBufferVisit()

    def OnBufferUnload(self, deleted_buffer_file):
        for completer in self._all_completers:
            completer.OnBufferUnload(deleted_buffer_file)

    def OnCursorHold(self):
        for completer in self._all_completers:
            completer.OnCursorHold()

    def OnInsertLeave(self):
        for completer in self._all_completers:
            completer.OnInsertLeave()

    def OnVimLeave(self):
        for completer in self._all_completers:
            completer.OnVimLeave()

    def OnCurrentIdentifierFinished(self):
        for completer in self._all_completers:
            completer.OnCurrentIdentifierFinished()

    def GettingCompletions(self):
        for completer in self._all_completers:
            completer.GettingCompletions()
# 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/>.

import os
from nose.tools import eq_
from ycm.completers.general.filename_completer import FilenameCompleter
from ycm import user_options_store

test_dir = os.path.dirname(os.path.abspath(__file__))
data_dir = os.path.join(test_dir, "testdata", "filename_completer")
file_path = os.path.join(data_dir, "test.cpp")

fnc = FilenameCompleter(user_options_store.DefaultOptions())
# We cache include flags for test.cpp file for unit testing.
fnc._flags.flags_for_file[file_path] = [
    "-I",
    os.path.join(data_dir, "include"),
    "-I",
    os.path.join(data_dir, "include", "Qt"),
    "-I",
    os.path.join(data_dir, "include", "QtGui"),
]

request_data = {
    'filepath': file_path,
    'file_data': {
        file_path: {
            'filetypes': 'cpp'
Example #6
0
class GeneralCompleterStore(Completer):
    """
  Holds a list of completers that can be used in all filetypes.

  It overrides all Competer API methods so that specific calls to
  GeneralCompleterStore are passed to all general completers.
  """
    def __init__(self, user_options):
        super(GeneralCompleterStore, self).__init__(user_options)
        self._identifier_completer = IdentifierCompleter(user_options)
        self._filename_completer = FilenameCompleter(user_options)
        self._ultisnips_completer = UltiSnipsCompleter(user_options)
        self._non_filename_completers = [self._identifier_completer]
        if user_options.get('use_ultisnips_completer', True):
            self._non_filename_completers.append(self._ultisnips_completer)

        self._all_completers = [
            self._identifier_completer, self._filename_completer,
            self._ultisnips_completer
        ]
        self._current_query_completers = []

    def SupportedFiletypes(self):
        return set()

    def GetIdentifierCompleter(self):
        return self._identifier_completer

    def ShouldUseNow(self, request_data):
        self._current_query_completers = []

        if self._filename_completer.ShouldUseNow(request_data):
            self._current_query_completers = [self._filename_completer]
            return True

        should_use_now = False

        for completer in self._non_filename_completers:
            should_use_this_completer = completer.ShouldUseNow(request_data)
            should_use_now = should_use_now or should_use_this_completer

            if should_use_this_completer:
                self._current_query_completers.append(completer)

        return should_use_now

    def ComputeCandidates(self, request_data):
        if not self.ShouldUseNow(request_data):
            return []

        candidates = []
        for completer in self._current_query_completers:
            candidates += completer.ComputeCandidates(request_data)

        return candidates

    def OnFileReadyToParse(self, request_data):
        for completer in self._all_completers:
            completer.OnFileReadyToParse(request_data)

    def OnBufferVisit(self, request_data):
        for completer in self._all_completers:
            completer.OnBufferVisit(request_data)

    def OnBufferUnload(self, request_data):
        for completer in self._all_completers:
            completer.OnBufferUnload(request_data)

    def OnInsertLeave(self, request_data):
        for completer in self._all_completers:
            completer.OnInsertLeave(request_data)

    def OnCurrentIdentifierFinished(self, request_data):
        for completer in self._all_completers:
            completer.OnCurrentIdentifierFinished(request_data)

    def GettingCompletions(self):
        for completer in self._all_completers:
            completer.GettingCompletions()

    def Shutdown(self):
        for completer in self._all_completers:
            completer.Shutdown()