--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2017 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+package org.sonar.server.component.ws;
+
+import org.sonar.api.resources.Qualifiers;
+
+import static java.util.Arrays.stream;
+
+public enum SuggestionCategory {
+ VIEW("views", Qualifiers.VIEW),
+ SUBVIEW("sub-views", Qualifiers.SUBVIEW),
+ PROJECT("projects", Qualifiers.PROJECT),
+ MODULE("modules", Qualifiers.MODULE),
+ FILE("files", Qualifiers.FILE),
+ UNIT_TEST_FILE("unit-test-files", Qualifiers.UNIT_TEST_FILE),;
+
+ private final String name;
+ private final String qualifier;
+
+ SuggestionCategory(String name, String qualifier) {
+ this.name = name;
+ this.qualifier = qualifier;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getQualifier() {
+ return qualifier;
+ }
+
+ public static SuggestionCategory getByName(String name) {
+ return stream(values()).filter(c -> c.getName().equals(name)).findAny()
+ .orElseThrow(() -> new IllegalStateException(String.format("Cannot find category for name '%s'.", name)));
+ }
+}
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
-import org.sonar.api.resources.Qualifiers;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.es.textsearch.ComponentTextSearchFeature;
import org.sonarqube.ws.WsComponents.Component;
import org.sonarqube.ws.WsComponents.SuggestionsWsResponse;
-import org.sonarqube.ws.WsComponents.SuggestionsWsResponse.Qualifier;
+import org.sonarqube.ws.WsComponents.SuggestionsWsResponse.Category;
import static com.google.common.base.Preconditions.checkState;
-import static java.util.Arrays.asList;
+import static java.util.Arrays.stream;
+import static java.util.Collections.singletonList;
import static java.util.Optional.ofNullable;
import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.es.DefaultIndexSettings.MINIMUM_NGRAM_LENGTH;
static final String PARAM_MORE = "more";
static final String SHORT_INPUT_WARNING = "short_input";
- private static final String[] QUALIFIERS = {
- Qualifiers.VIEW,
- Qualifiers.SUBVIEW,
- Qualifiers.PROJECT,
- Qualifiers.MODULE,
- Qualifiers.FILE,
- Qualifiers.UNIT_TEST_FILE
- };
-
static final int DEFAULT_LIMIT = 6;
static final int EXTENDED_LIMIT = 20;
.setExampleValue("sonar");
action.createParam(PARAM_MORE)
- .setDescription("Qualifier, for which to display " + EXTENDED_LIMIT + " instead of " + DEFAULT_LIMIT + " results")
- .setPossibleValues(QUALIFIERS)
+ .setDescription("Category, for which to display " + EXTENDED_LIMIT + " instead of " + DEFAULT_LIMIT + " results")
+ .setPossibleValues(stream(SuggestionCategory.values()).map(SuggestionCategory::getName).toArray(String[]::new))
.setSince("6.4");
}
private List<ComponentsPerQualifier> getComponentsPerQualifiers(String more, ComponentIndexQuery.Builder queryBuilder) {
List<ComponentsPerQualifier> componentsPerQualifiers;
if (more == null) {
- queryBuilder.setQualifiers(asList(QUALIFIERS))
+ queryBuilder.setQualifiers(stream(SuggestionCategory.values()).map(SuggestionCategory::getQualifier).collect(Collectors.toList()))
.setLimit(DEFAULT_LIMIT);
} else {
- queryBuilder.setQualifiers(Collections.singletonList(more))
+ queryBuilder.setQualifiers(singletonList(SuggestionCategory.getByName(more).getQualifier()))
.setLimit(EXTENDED_LIMIT);
}
componentsPerQualifiers = searchInIndex(queryBuilder.build());
private SuggestionsWsResponse toResponse(List<ComponentsPerQualifier> componentsPerQualifiers, @Nullable String warning) {
SuggestionsWsResponse.Builder builder = SuggestionsWsResponse.newBuilder()
- .addAllResults(getResultsOfAllQualifiers(componentsPerQualifiers));
+ .addAllSuggestions(getResultsOfAllQualifiers(componentsPerQualifiers));
ofNullable(warning).ifPresent(builder::setWarning);
return builder.build();
}
- private List<Qualifier> getResultsOfAllQualifiers(List<ComponentsPerQualifier> componentsPerQualifiers) {
+ private List<Category> getResultsOfAllQualifiers(List<ComponentsPerQualifier> componentsPerQualifiers) {
if (componentsPerQualifiers.isEmpty()) {
return Collections.emptyList();
}
.map(dto -> dtoToComponent(dto, organizationKeyByUuids))
.collect(toList());
- return Qualifier.newBuilder()
- .setQ(qualifier.getQualifier())
+ return Category.newBuilder()
+ .setCategory(qualifier.getQualifier())
.setMore(qualifier.getNumberOfFurtherResults())
.addAllItems(results)
.build();
{
- "results": [
+ "suggestions": [
{
- "q": "TRK",
+ "category": "projects",
"items": [
{
"organization": "default-organization",
"more": 74
},
{
- "q": "FIL",
+ "category": "files",
"items": [
]
}
.executeProtobuf(SuggestionsWsResponse.class);
// assert match in qualifier "TRK"
- assertThat(response.getResultsList())
+ assertThat(response.getSuggestionsList())
.filteredOn(q -> q.getItemsCount() > 0)
- .extracting(SuggestionsWsResponse.Qualifier::getQ)
+ .extracting(SuggestionsWsResponse.Category::getCategory)
.containsExactly(Qualifiers.PROJECT);
// assert correct id to be found
- assertThat(response.getResultsList())
- .flatExtracting(SuggestionsWsResponse.Qualifier::getItemsList)
+ assertThat(response.getSuggestionsList())
+ .flatExtracting(SuggestionsWsResponse.Category::getItemsList)
.extracting(WsComponents.Component::getKey, WsComponents.Component::getOrganization)
.containsExactly(tuple(project.getKey(), organization.getKey()));
}
.setParam(PARAM_QUERY, "S o")
.executeProtobuf(SuggestionsWsResponse.class);
- assertThat(response.getResultsList()).filteredOn(q -> q.getItemsCount() > 0).isEmpty();
+ assertThat(response.getSuggestionsList()).filteredOn(q -> q.getItemsCount() > 0).isEmpty();
assertThat(response.getWarning()).contains(SHORT_INPUT_WARNING);
}
@Test
public void show_show_more_results_if_requested() throws Exception {
- check_proposal_to_show_more_results(21, EXTENDED_LIMIT, 1L, Qualifiers.PROJECT);
+ check_proposal_to_show_more_results(21, EXTENDED_LIMIT, 1L, SuggestionCategory.PROJECT);
}
- private void check_proposal_to_show_more_results(int numberOfProjects, int results, long numberOfMoreResults, @Nullable String moreQualifier) throws Exception {
+ private void check_proposal_to_show_more_results(int numberOfProjects, int results, long numberOfMoreResults, @Nullable SuggestionCategory more) throws Exception {
String namePrefix = "MyProject";
List<ComponentDto> projects = range(0, numberOfProjects)
TestRequest request = actionTester.newRequest()
.setMethod("POST")
.setParam(PARAM_QUERY, namePrefix);
- ofNullable(moreQualifier).ifPresent(q -> request.setParam(PARAM_MORE, q));
+ ofNullable(more).ifPresent(c -> request.setParam(PARAM_MORE, c.getName()));
SuggestionsWsResponse response = request
.executeProtobuf(SuggestionsWsResponse.class);
// assert match in qualifier "TRK"
- assertThat(response.getResultsList())
+ assertThat(response.getSuggestionsList())
.filteredOn(q -> q.getItemsCount() > 0)
- .extracting(SuggestionsWsResponse.Qualifier::getQ)
+ .extracting(SuggestionsWsResponse.Category::getCategory)
.containsExactly(Qualifiers.PROJECT);
// include limited number of results in the response
- assertThat(response.getResultsList())
- .flatExtracting(SuggestionsWsResponse.Qualifier::getItemsList)
+ assertThat(response.getSuggestionsList())
+ .flatExtracting(SuggestionsWsResponse.Category::getItemsList)
.hasSize(Math.min(results, numberOfProjects));
// indicate, that there are more results
- assertThat(response.getResultsList())
+ assertThat(response.getSuggestionsList())
.filteredOn(q -> q.getItemsCount() > 0)
- .extracting(SuggestionsWsResponse.Qualifier::getMore)
+ .extracting(SuggestionsWsResponse.Category::getMore)
.containsExactly(numberOfMoreResults);
}
}
// WS api/components/suggestions
message SuggestionsWsResponse {
- repeated Qualifier results = 1;
+ repeated Category suggestions = 1;
optional string warning = 2;
- message Qualifier {
- optional string q = 1;
+ message Category {
+ optional string category = 1;
repeated Component items = 2;
optional int64 more = 3;
}