Filter and sort candidates when query is empty

CORE_VERSION

@@ -1 +1 @@
-28
+29

cpp/ycm/IdentifierDatabase.cpp

@@ -74,7 +74,7 @@ void IdentifierDatabase::ResultsForQueryAndType(
     std::lock_guard< std::mutex > locker( filetype_candidate_map_mutex_ );
     it = filetype_candidate_map_.find( filetype );
 
-    if ( it == filetype_candidate_map_.end() || query.empty() )
+    if ( it == filetype_candidate_map_.end() )
       return;
   }
   Bitset query_bitset = LetterBitsetFromString( query );
@@ -93,7 +93,8 @@ void IdentifierDatabase::ResultsForQueryAndType(
         else
           seen_candidates.insert( candidate );
 
-        if ( !candidate->MatchesQueryBitset( query_bitset ) )
+        if ( candidate->Text().empty() ||
+             !candidate->MatchesQueryBitset( query_bitset ) )
           continue;
 
         Result result = candidate->QueryMatchResult(

cpp/ycm/PythonSupport.cpp

@@ -65,9 +65,6 @@ boost::python::list FilterAndSortCandidates(
   const std::string &query ) {
   pylist filtered_candidates;
 
-  if ( query.empty() )
-    return candidates;
-
   if ( !IsPrintable( query ) )
     return boost::python::list();
 
@@ -84,7 +81,8 @@ boost::python::list FilterAndSortCandidates(
     for ( int i = 0; i < num_candidates; ++i ) {
       const Candidate *candidate = repository_candidates[ i ];
 
-      if ( !candidate->MatchesQueryBitset( query_bitset ) )
+      if ( candidate->Text().empty() ||
+           !candidate->MatchesQueryBitset( query_bitset ) )
         continue;
 
       Result result = candidate->QueryMatchResult( query,

cpp/ycm/tests/IdentifierCompleter_test.cpp

@@ -28,12 +28,19 @@ using ::testing::WhenSorted;
 namespace YouCompleteMe {
 
 
-// This differs from what we expect from the ClangCompleter. That one should
-// return results for an empty query.
-TEST( IdentifierCompleterTest, EmptyQueryNoResults ) {
+TEST( IdentifierCompleterTest, SortOnEmptyQuery ) {
   EXPECT_THAT( IdentifierCompleter(
                  StringVector(
-                   "foobar" ) ).CandidatesForQuery( "" ),
+                   "foo",
+                   "bar" ) ).CandidatesForQuery( "" ),
+               ElementsAre( "bar",
+                            "foo" ) );
+}
+
+TEST( IdentifierCompleterTest, IgnoreEmptyCandidate ) {
+  EXPECT_THAT( IdentifierCompleter(
+                 StringVector(
+                   "" ) ).CandidatesForQuery( "" ),
                IsEmpty() );
 }
 

ycmd/completers/completer.py

@@ -215,10 +215,7 @@ def ComputeCandidates( self, request_data ):
       return []
 
     candidates = self._GetCandidatesFromSubclass( request_data )
-    if request_data[ 'query' ]:
-      candidates = self.FilterAndSortCandidates( candidates,
-                                                 request_data[ 'query' ] )
-    return candidates
+    return self.FilterAndSortCandidates( candidates, request_data[ 'query' ] )
 
 
   def _GetCandidatesFromSubclass( self, request_data ):

ycmd/tests/clang/get_completions_test.py

@@ -508,6 +508,9 @@ def GetCompletions_FilenameCompleter_ClientDataGivenToExtraConf_test( app ):
   )
 
 
+@ExpectedFailure( 'Filtering and sorting does not support candidates with '
+                  'non-ASCII characters.',
+                  contains_string( "value for 'completions' no item matches" ) )
 @SharedYcmd
 def GetCompletions_UnicodeInLine_test( app ):
   RunTest( app, {
@@ -536,9 +539,8 @@ def GetCompletions_UnicodeInLine_test( app ):
   } )
 
 
-@ExpectedFailure( 'Filtering and sorting does not work when the candidate '
-                  'contains non-ASCII characters. This is due to the way '
-                  'the filtering and sorting code works.',
+@ExpectedFailure( 'Filtering and sorting does not support candidates with '
+                  'non-ASCII characters.',
                   contains_string( "value for 'completions' no item matches" ) )
 @SharedYcmd
 def GetCompletions_UnicodeInLineFilter_test( app ):

ycmd/tests/completer_test.py

@@ -60,6 +60,18 @@ def FilterAndSortCandidates_ServerCompleter_test():
                                   [ { 'insertion_text': 'password' } ] )
 
 
+def FilterAndSortCandidates_SortOnEmptyQuery_test():
+  _FilterAndSortCandidates_Match( [ 'foo', 'bar' ],
+                                  '',
+                                  [ 'bar', 'foo' ] )
+
+
+def FilterAndSortCandidates_IgnoreEmptyCandidate_test():
+  _FilterAndSortCandidates_Match( [ '' ],
+                                  '',
+                                  [] )
+
+
 @ExpectedFailure( 'Filtering does not support unicode characters',
                   contains_string( '[]' ) )
 def FilterAndSortCandidates_Unicode_test():

ycmd/tests/cs/get_completions_test.py

@@ -24,13 +24,14 @@
 # Not installing aliases from python-future; it's unreliable and slow.
 from builtins import *  # noqa
 
-from hamcrest import ( assert_that, calling, empty, greater_than, has_item,
-                       has_items, has_entries, raises )
+from hamcrest import ( assert_that, calling, contains_string, empty,
+                       greater_than, has_item, has_items, has_entries, raises )
 from nose.tools import eq_
 from webtest import AppError
 
 from ycmd.tests.cs import PathToTestFile, SharedYcmd, WrapOmniSharpServer
-from ycmd.tests.test_utils import BuildRequest, CompletionEntryMatcher
+from ycmd.tests.test_utils import ( BuildRequest, CompletionEntryMatcher,
+                                    ExpectedFailure )
 from ycmd.utils import ReadFile
 
 
@@ -52,6 +53,11 @@ def GetCompletions_Basic_test( app ):
     eq_( 12, response_data[ 'completion_start_column' ] )
 
 
+@ExpectedFailure( 'Filtering and sorting does not support candidates with '
+                  'non-ASCII characters.',
+                  contains_string( "but: a sequence containing a dictionary "
+                                   "containing {'insertion_text': 'a_unicøde'} "
+                                   "was" ) )
 @SharedYcmd
 def GetCompletions_Unicode_test( app ):
   filepath = PathToTestFile( 'testy', 'Unicode.cs' )

ycmd/tests/go/get_completions_test.py

@@ -24,10 +24,11 @@
 # Not installing aliases from python-future; it's unreliable and slow.
 from builtins import *  # noqa
 
-from hamcrest import assert_that, has_item, has_items
+from hamcrest import assert_that, contains_string, has_item, has_items
 
 from ycmd.tests.go import PathToTestFile, SharedYcmd
-from ycmd.tests.test_utils import BuildRequest, CompletionEntryMatcher
+from ycmd.tests.test_utils import ( BuildRequest, CompletionEntryMatcher,
+                                    ExpectedFailure )
 from ycmd.utils import ReadFile
 
 
@@ -64,6 +65,11 @@ def GetCompletions_Unicode_InLine_test( app ):
                           CompletionEntryMatcher( u'Sprintf' ) ) )
 
 
+@ExpectedFailure( 'Filtering and sorting does not support candidates with '
+                  'non-ASCII characters.',
+                  contains_string( "but: a sequence containing a dictionary "
+                                   "containing {'insertion_text': 'Unicøde'} "
+                                   "was <[]>" ) )
 @SharedYcmd
 def GetCompletions_Unicode_Identifier_test( app ):
   filepath = PathToTestFile( 'unicode.go' )