import java.util.Objects;
import java.util.function.Function;
import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.sonar.ce.task.projectanalysis.analysis.Branch;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.scanner.protocol.output.ScannerReport;
import org.sonar.scanner.protocol.output.ScannerReport.Component.FileStatus;
import org.sonar.server.project.Project;
return component.getChildren().stream()
.map(ComponentTreeBuilder::buildChangedComponentTree)
.filter(Objects::nonNull)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static ComponentImpl.Builder changedComponentBuilder(Component component, String newShortName) {
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.ce.task.projectanalysis.component.Component;
import org.sonar.ce.task.projectanalysis.component.CrawlerDepthLimit;
import org.sonar.ce.task.projectanalysis.util.cache.DiskCache.CacheAppender;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.tracking.Input;
-import org.sonar.core.util.stream.MoreCollectors;
import static org.sonar.ce.task.projectanalysis.component.ComponentVisitor.Order.POST_ORDER;
private List<DefaultIssue> fillNewOpenIssues(Component component, Stream<DefaultIssue> newIssues, Input<DefaultIssue> rawInput) {
List<DefaultIssue> newIssuesList = newIssues
.peek(issueLifecycle::initNewOpenIssue)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
if (newIssuesList.isEmpty()) {
return newIssuesList;
package org.sonar.ce.task.projectexport.steps;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.utils.MessageException;
import org.sonar.ce.task.projectexport.taskprocessor.ProjectDescriptor;
import org.sonar.ce.task.step.ComputationStep;
import org.sonar.db.project.ProjectDto;
import static java.lang.String.format;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
/**
* Loads project from database and verifies that it's valid: it must exist and be a project !
.orElseThrow(() -> MessageException.of(format("Project with key [%s] does not exist", descriptor.getKey())));
definitionHolder.setProjectDto(project);
- List<BranchDto> branches = dbClient.branchDao().selectByProject(dbSession, project).stream().collect(toList());
+ List<BranchDto> branches = dbClient.branchDao().selectByProject(dbSession, project).stream().collect(Collectors.toList());
definitionHolder.setBranches(branches);
}
}
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.junit.Rule;
import org.junit.Test;
import org.slf4j.event.Level;
import org.sonar.api.testfixtures.log.LogTester;
import org.slf4j.LoggerFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.dialect.Oracle;
import static org.assertj.core.api.Assertions.assertThat;
List<String> outputs = DatabaseUtils.executeLargeInputs(inputs, input -> {
// Check that each partition is only done on 1000 elements max
assertThat(input).hasSizeLessThanOrEqualTo(1000);
- return input.stream().map(String::valueOf).collect(MoreCollectors.toList());
+ return input.stream().map(String::valueOf).collect(Collectors.toList());
});
assertThat(outputs).isEqualTo(expectedOutputs);
import java.util.Locale;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.lang.StringUtils;
import org.junit.rules.ExternalResource;
import org.slf4j.LoggerFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.Lists.asList;
columnNames.stream()
.sorted(PkColumn.ORDERING_BY_INDEX)
.map(PkColumn::getName)
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
}
}
import java.util.List;
import java.util.Optional;
import java.util.Random;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.sonar.api.impl.utils.TestSystem2;
import org.sonar.core.util.CloseableIterator;
import org.sonar.core.util.UuidFactoryFast;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.Pagination;
private List<String> selectPageOfUuids(Pagination pagination) {
return underTest.selectByQuery(db.getSession(), new CeTaskQuery(), pagination).stream()
.map(CeActivityToUuid.INSTANCE::apply)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private enum CeActivityToUuid implements Function<CeActivityDto, String> {
import java.util.List;
import java.util.Random;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.audit.NoOpAuditPersister;
.stream()
.flatMap(map -> map.entrySet().stream())
.map(entry -> (String) entry.getValue())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private ProjectData randomPublicOrPrivateProject() {
import java.util.List;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import org.apache.ibatis.session.ResultHandler;
import org.sonar.core.issue.FieldDiffs;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
return selectByTypeAndIssueKeys(session, singletonList(issueKey), IssueChangeDto.TYPE_FIELD_CHANGE)
.stream()
.map(IssueChangeDto::toFieldDiffs)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
public List<IssueChangeDto> selectByTypeAndIssueKeys(DbSession session, Collection<String> issueKeys, String changeType) {
return mapper.selectPurgeableAnalyses(componentUuid).stream()
.filter(new NewCodePeriodAnalysisFilter(mapper, componentUuid))
.sorted()
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
public void purgeCeActivities(DbSession session, PurgeProfiler profiler) {
List<String> subviewsOrProjectCopies = nonRootComponents.stream()
.filter(PurgeDao::isSubview)
.map(ComponentDto::uuid)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
purgeCommands.deleteByRootAndSubviews(subviewsOrProjectCopies);
List<String> nonRootComponentUuids = nonRootComponents.stream().map(ComponentDto::uuid).collect(Collectors.toList());
purgeCommands.deleteComponentMeasures(nonRootComponentUuids);
import com.google.common.base.Strings;
import java.util.Date;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.utils.DateUtils;
import org.slf4j.LoggerFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.purge.PurgeableAnalysisDto;
class KeepWithVersionFilter implements Filter {
return history.stream()
.filter(analysis -> analysis.getDate().before(before))
.filter(KeepWithVersionFilter::isDeletable)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
@Override
import java.util.Collection;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
import org.sonar.db.user.SearchGroupMembershipDto;
import org.sonar.db.user.SearchPermissionQuery;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
public class QualityGateGroupPermissionsDao implements Dao {
}
public boolean exists(DbSession dbSession, QualityGateDto qualityGate, Collection<GroupDto> groups) {
- return !executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(toList()),
+ return !executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(Collectors.toList()),
partition -> mapper(dbSession).selectByQualityGateAndGroups(qualityGate.getUuid(), partition))
.isEmpty();
}
package org.sonar.db.qualityprofile;
import java.util.List;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.rule.RuleStatus;
-import org.sonar.core.util.stream.MoreCollectors;
import static com.google.common.base.Preconditions.checkState;
private final String inheritance;
public ActiveRuleCountQuery(Builder builder) {
- this.profileUuids = builder.profiles.stream().map(QProfileDto::getKee).collect(MoreCollectors.toList());
+ this.profileUuids = builder.profiles.stream().map(QProfileDto::getKee).collect(Collectors.toList());
this.ruleStatus = builder.ruleStatus;
this.inheritance = builder.inheritance;
}
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
import org.sonar.db.DatabaseUtils;
import org.sonar.db.user.GroupDto;
import org.sonar.db.user.SearchGroupMembershipDto;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
import static org.sonar.db.DatabaseUtils.executeLargeUpdates;
}
public boolean exists(DbSession dbSession, QProfileDto profile, Collection<GroupDto> groups) {
- return !executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(toList()), partition -> mapper(dbSession).selectByQProfileAndGroups(profile.getKee(), partition))
+ return !executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(Collectors.toList()), partition -> mapper(dbSession).selectByQProfileAndGroups(profile.getKee(), partition))
.isEmpty();
}
}
public List<String> selectQProfileUuidsByGroups(DbSession dbSession, Collection<GroupDto> groups) {
- return DatabaseUtils.executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(toList()),
+ return DatabaseUtils.executeLargeInputs(groups.stream().map(GroupDto::getUuid).collect(Collectors.toList()),
g -> mapper(dbSession).selectQProfileUuidsByGroups(g));
}
int deletedRows = mapper(dbSession).deleteByQProfiles(partitionedProfiles
.stream()
.map(QProfileDto::getKee)
- .collect(toList()));
+ .collect(Collectors.toList()));
if (deletedRows > 0) {
partitionedProfiles.forEach(p -> auditPersister.deleteQualityProfileEditor(dbSession, new GroupEditorNewValue(p)));
package org.sonar.db.qualityprofile;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.utils.System2;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
import org.sonar.db.user.SearchUserMembershipDto;
import org.sonar.db.user.UserDto;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.DatabaseUtils.executeLargeUpdates;
public class QProfileEditUsersDao implements Dao {
int deletedRows = mapper(dbSession).deleteByQProfiles(partitionedProfiles
.stream()
.map(QProfileDto::getKee)
- .collect(toList()));
+ .collect(Collectors.toList()));
if (deletedRows > 0) {
partitionedProfiles.forEach(p -> auditPersister.deleteQualityProfileEditor(dbSession, new UserEditorNewValue(p)));
import java.util.Locale;
import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.utils.System2;
}
public Map<String, Long> countProjectsByProfiles(DbSession dbSession, List<QProfileDto> profiles) {
- List<String> profileUuids = profiles.stream().map(QProfileDto::getKee).collect(MoreCollectors.toList());
+ List<String> profileUuids = profiles.stream().map(QProfileDto::getKee).collect(Collectors.toList());
return KeyLongValue.toMap(executeLargeInputs(profileUuids, partition -> mapper(dbSession).countProjectsByProfiles(partition)));
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.core.util.UuidFactory;
import org.sonar.db.audit.AuditPersister;
import org.sonar.db.audit.model.UserTokenNewValue;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.DatabaseUtils.executeLargeInputs;
public class UserTokenDao implements Dao {
public Map<String, Integer> countTokensByUsers(DbSession dbSession, Collection<UserDto> users) {
Map<String, Integer> result = new HashMap<>(users.size());
executeLargeInputs(
- users.stream().map(UserDto::getUuid).collect(toList()),
+ users.stream().map(UserDto::getUuid).collect(Collectors.toList()),
input -> {
List<UserTokenCount> userTokenCounts = mapper(dbSession).countTokensByUserUuids(input);
for (UserTokenCount userTokenCount : userTokenCounts) {
.thenReturn(expected[3])
.thenThrow(oneCallTooMuch());
- assertThat(Arrays.stream(expected).map(ignored -> underTest.openSession(false)).collect(MoreCollectors.toList()))
+ assertThat(Arrays.stream(expected).map(ignored -> underTest.openSession(false)).collect(Collectors.toList()))
.containsExactly(expected);
}
.thenReturn(expected[3])
.thenThrow(oneCallTooMuch());
- assertThat(Arrays.stream(expected).map(ignored -> underTest.openSession(true)).collect(MoreCollectors.toList()))
+ assertThat(Arrays.stream(expected).map(ignored -> underTest.openSession(true)).collect(Collectors.toList()))
.containsExactly(expected);
}
package org.sonar.db.notification;
import java.util.List;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
.setUserUuid(userUuid)
.build(), dbSession).stream()
.filter(prop -> project == null ? prop.getEntityUuid() == null : prop.getEntityUuid() != null)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
assertThat(result).hasSize(1);
assertThat(result.get(0).getValue()).isEqualTo("true");
}
import java.util.Date;
import java.util.Random;
import java.util.function.Consumer;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.apache.commons.lang.math.RandomUtils;
import org.sonar.core.util.Uuids;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.protobuf.DbFileSources;
.setFileUuid(file.uuid())
.setSrcHash(randomAlphanumeric(50))
.setDataHash(randomAlphanumeric(50))
- .setLineHashes(IntStream.range(0, new Random().nextInt(21)).mapToObj(String::valueOf).collect(MoreCollectors.toList()))
+ .setLineHashes(IntStream.range(0, new Random().nextInt(21)).mapToObj(String::valueOf).collect(Collectors.toList()))
.setRevision(randomAlphanumeric(100))
.setSourceData(newRandomData(3).build())
.setCreatedAt(new Date().getTime())
.setFileUuid(file.uuid())
.setSrcHash(randomAlphanumeric(50))
.setDataHash(randomAlphanumeric(50))
- .setLineHashes(IntStream.range(0, numLines).mapToObj(String::valueOf).collect(MoreCollectors.toList()))
+ .setLineHashes(IntStream.range(0, numLines).mapToObj(String::valueOf).collect(Collectors.toList()))
.setRevision(randomAlphanumeric(100))
.setSourceData(newRandomData(numLines).build())
.setCreatedAt(new Date().getTime())
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.web.UserRole;
import org.sonar.core.util.Uuids;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbTester;
import org.sonar.db.ce.CeTaskMessageType;
return keys
.stream()
.map(GlobalPermission::fromKey)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
// USER TOKEN
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
+import java.util.stream.Collectors;
import org.sonar.db.Database;
import org.sonar.db.DatabaseUtils;
import org.sonar.server.platform.db.migration.step.RegisteredMigrationStep;
import static com.google.common.base.Preconditions.checkState;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
public class MigrationHistoryImpl implements MigrationHistory {
private static final String SCHEMA_MIGRATIONS_TABLE = "schema_migrations";
}
return res.stream()
.sorted(Comparator.naturalOrder())
- .collect(toList());
+ .collect(Collectors.toList());
}
}
}
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.dialect.Dialect;
import org.sonar.db.dialect.H2;
import org.sonar.db.dialect.MsSql;
checkState(!columnDefs.isEmpty() || !pkColumnDefs.isEmpty(), "at least one column must be specified");
return Stream.concat(of(createTableStatement()), createOracleAutoIncrementStatements())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
public CreateTableBuilder addColumn(ColumnDef columnDef) {
import java.util.List;
import java.util.Optional;
import java.util.Properties;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
import org.sonar.application.command.EsJvmOptions;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.process.Props;
import static org.sonar.process.ProcessProperties.Property.CLUSTER_ENABLED;
String dataPath = props.nonNullValue(PATH_DATA.getKey());
return Stream.of("es", "es5", "es6", "es7")
.map(t -> new File(dataPath, t))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static File buildDataDir(Props props) {
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang.StringUtils;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.MatchQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.newindex.DefaultIndexSettings;
import org.sonar.server.es.newindex.DefaultIndexSettingsElement;
import org.sonar.server.es.textsearch.ComponentTextSearchQueryFactory.ComponentTextSearchQuery;
if (tokens.isEmpty()) {
return Stream.empty();
}
- List<String> lowerCaseTokens = tokens.stream().map(t -> t.toLowerCase(Locale.ENGLISH)).collect(MoreCollectors.toList());
+ List<String> lowerCaseTokens = tokens.stream().map(t -> t.toLowerCase(Locale.ENGLISH)).collect(Collectors.toList());
BoolQueryBuilder queryBuilder = prefixAndPartialQuery(lowerCaseTokens, query.getFieldName(), SEARCH_PREFIX_CASE_INSENSITIVE_ANALYZER)
.boost(2F);
return Stream.of(queryBuilder);
import java.util.Arrays;
import java.util.List;
+import java.util.stream.Collectors;
import org.apache.commons.lang.StringUtils;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.newindex.DefaultIndexSettings;
import static org.sonar.server.es.newindex.DefaultIndexSettings.MINIMUM_NGRAM_LENGTH;
queryText.split(DefaultIndexSettings.SEARCH_TERM_TOKENIZER_PATTERN))
.filter(StringUtils::isNotEmpty)
.filter(s -> s.length() >= MINIMUM_NGRAM_LENGTH)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.BaseDoc;
import org.sonar.server.permission.index.AuthorizationDoc;
.map(entry -> ImmutableMap.<String, Object>of(
SUB_FIELD_MEASURES_KEY, entry.getKey(),
SUB_FIELD_MEASURES_VALUE, entry.getValue()))
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
return this;
}
.map(entry -> ImmutableMap.<String, Object>of(
SUB_FIELD_DISTRIB_LANGUAGE, entry.getKey(),
SUB_FIELD_DISTRIB_NCLOC, entry.getValue()))
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
return this;
}
import java.util.List;
import java.util.Map;
import java.util.function.Function;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.sonar.api.rule.Severity;
import org.sonar.api.rules.RuleType;
import org.sonar.api.utils.System2;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.es.EsClient;
import org.sonar.server.es.EsUtils;
public static final List<String> ALL_STATUSES_EXCEPT_REMOVED = Arrays.stream(RuleStatus.values())
.filter(status -> !RuleStatus.REMOVED.equals(status))
.map(RuleStatus::toString)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
private static final String AGGREGATION_NAME_FOR_TAGS = "tagsAggregation";
Collection<RuleType> types = query.getTypes();
if (isNotEmpty(types)) {
- List<String> typeNames = types.stream().map(RuleType::toString).collect(MoreCollectors.toList());
+ List<String> typeNames = types.stream().map(RuleType::toString).collect(Collectors.toList());
filters.put(FIELD_RULE_TYPE,
QueryBuilders.termsQuery(FIELD_RULE_TYPE, typeNames));
}
import static java.util.Collections.singleton;
import static java.util.Collections.singletonList;
import static org.sonar.api.server.rule.RulesDefinition.PciDssVersion.V3_2;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.server.security.SecurityStandards.VulnerabilityProbability.HIGH;
.stream()
.filter(k -> cwe.stream().anyMatch(CWES_BY_SQ_CATEGORY.get(k)::contains))
.sorted(SQ_CATEGORY_ORDERING)
- .collect(toList());
+ .collect(Collectors.toList());
return result.isEmpty() ? singletonList(SQCategory.OTHERS) : result;
}
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.server.ServerSide;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.project.ProjectDto;
List<Webhook> webhooks = readWebHooksFrom(analysis.projectUuid(), taskLogStatistics)
.map(dto -> new Webhook(dto.getUuid(), analysis.projectUuid(), analysis.ceTaskUuid(), analysis.analysisUuid(),
dto.getName(), dto.getUrl(), dto.getSecret()))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
if (webhooks.isEmpty()) {
return;
}
import java.util.Collection;
import java.util.Date;
import java.util.List;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Nullable;
import org.apache.commons.lang.time.DateUtils;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.FieldDiffs;
import org.sonar.core.issue.IssueChangeContext;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.issue.IssueFieldsSetter;
import static org.apache.commons.lang.RandomStringUtils.randomAlphabetic;
}
private Collection<String> keys(List<Transition> transitions) {
- return transitions.stream().map(Transition::key).collect(MoreCollectors.toList());
+ return transitions.stream().map(Transition::key).collect(Collectors.toList());
}
private static void setStatusPreviousToClosed(DefaultIssue hotspot, String previousStatus, @Nullable String previousResolution, @Nullable String newResolution) {
import java.util.List;
import java.util.Objects;
import java.util.Optional;
+import java.util.stream.Collectors;
import org.apache.commons.io.FileUtils;
import org.sonar.api.Startable;
import org.sonar.api.utils.HttpDownloader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.core.platform.PluginInfo;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.platform.ServerFileSystem;
import org.sonar.updatecenter.common.Release;
import org.sonar.updatecenter.common.UpdateCenter;
return listPlugins(this.downloadDir)
.stream()
.map(PluginInfo::create)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
public void download(String pluginKey, Version version) {
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
+import java.util.stream.Collectors;
import org.apache.commons.io.FileUtils;
import org.sonar.api.Startable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.core.platform.PluginInfo;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.platform.ServerFileSystem;
import static java.lang.String.format;
public Collection<PluginInfo> getUninstalledPlugins() {
return listJarFiles(fs.getUninstalledPluginsDir()).stream()
.map(PluginInfo::create)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static Collection<File> listJarFiles(File dir) {
import org.sonar.api.rules.RuleFinder;
import org.sonar.api.rules.RulePriority;
import org.sonar.api.rules.RuleQuery;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.rule.RuleDto;
.filter(entry -> matchQuery(entry.getKey(), query))
.sorted(FIND_BY_QUERY_ORDER)
.map(Map.Entry::getValue)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static boolean matchQuery(RuleDto ruleDto, RuleQuery ruleQuery) {
import java.util.List;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.entity.EntityDto;
import org.sonar.db.permission.GlobalPermission;
boolean allowPublicComponent = PUBLIC_PERMISSIONS.contains(permission);
return components.stream()
.filter(c -> (allowPublicComponent && !c.isPrivate()) || hasComponentPermission(permission, c))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
@Override
import static java.util.Collections.emptySet;
import static java.util.Collections.unmodifiableMap;
import static org.apache.commons.lang.StringUtils.isNotEmpty;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
// DeprecatedKeys that must be deleted
List<String> uuidsToBeDeleted = difference(deprecatedRuleKeysFromDB, deprecatedRuleKeysFromDefinition).stream()
.map(SingleDeprecatedRuleKey::getUuid)
- .collect(toList());
+ .collect(Collectors.toList());
dbClient.ruleDao().deleteDeprecatedRuleKeys(dbSession, uuidsToBeDeleted);
private static void verifyRuleKeyConsistency(List<RulesDefinition.Repository> repositories, RegisterRulesContext registerRulesContext) {
List<RulesDefinition.Rule> definedRules = repositories.stream()
.flatMap(r -> r.rules().stream())
- .collect(toList());
+ .collect(Collectors.toList());
Set<RuleKey> definedRuleKeys = definedRules.stream()
.map(r -> RuleKey.of(r.repository().key(), r.key()))
List<RuleKey> definedDeprecatedRuleKeys = definedRules.stream()
.flatMap(r -> r.deprecatedRuleKeys().stream())
- .collect(toList());
+ .collect(Collectors.toList());
// Find duplicates in declared deprecated rule keys
Set<RuleKey> duplicates = findDuplicates(definedDeprecatedRuleKeys);
return getSearchResponse(sourceBuilder)
.getAggregations().asList().stream()
.map(c -> processSecurityReportIssueSearchResultsWithLevelDistribution((ParsedFilter) c, version, level))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private List<SecurityStandardCategoryStatistics> searchWithDistribution(SearchSourceBuilder sourceBuilder, String version, @Nullable Integer level) {
return getSearchResponse(sourceBuilder)
.getAggregations().asList().stream()
.map(c -> processSecurityReportIssueSearchResultsWithDistribution((ParsedFilter) c, version, level))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private List<SecurityStandardCategoryStatistics> search(SearchSourceBuilder sourceBuilder, boolean includeDistribution, @Nullable String version) {
return getSearchResponse(sourceBuilder)
.getAggregations().asList().stream()
.map(c -> processSecurityReportIssueSearchResults((ParsedFilter) c, includeDistribution, version))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private SearchResponse getSearchResponse(SearchSourceBuilder sourceBuilder) {
import static org.sonar.api.utils.DateUtils.parseStartingDateOrDateTime;
import static org.sonar.api.web.UserRole.USER;
import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.newcodeperiod.NewCodePeriodType.REFERENCE_BRANCH;
SearchRequest request) {
builder.onComponentOnly(onComponentOnly);
if (onComponentOnly) {
- builder.componentUuids(components.stream().map(ComponentDto::uuid).collect(toList()));
+ builder.componentUuids(components.stream().map(ComponentDto::uuid).collect(Collectors.toList()));
setBranch(builder, components.get(0), request.getBranch(), request.getPullRequest(), session);
return;
}
addDirectories(builder, components);
break;
case Qualifiers.FILE, Qualifiers.UNIT_TEST_FILE:
- builder.componentUuids(components.stream().map(ComponentDto::uuid).collect(toList()));
+ builder.componentUuids(components.stream().map(ComponentDto::uuid).collect(Collectors.toList()));
break;
default:
throw new IllegalArgumentException("Unable to set search root context for components " + Joiner.on(',').join(components));
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import javax.annotation.Nullable;
return aggregation.getBuckets().stream()
.skip((page-1) * size)
.map(Bucket::getKeyAsString)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private interface FacetBuilder {
import java.util.Arrays;
import java.util.List;
-import org.elasticsearch.action.search.SearchRequest;
+import java.util.stream.Collectors;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.es.EsClient;
import static org.sonar.server.permission.index.FooIndexDefinition.DESCRIPTOR;
.getHits();
List<String> names = Arrays.stream(hits.getHits())
.map(h -> h.getSourceAsMap().get(FooIndexDefinition.FIELD_NAME).toString())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
return names.size() == 2 && names.contains("bar") && names.contains("baz");
}
}
import java.util.List;
import java.util.Optional;
import java.util.function.Consumer;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import javax.annotation.Nullable;
import static org.sonar.api.server.ws.WebService.Param.PAGE_SIZE;
import static org.sonar.api.server.ws.WebService.Param.SORT;
import static org.sonar.api.utils.DateUtils.formatDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_002;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_003;
assertThat(def.isInternal()).isTrue();
assertThat(def.isPost()).isFalse();
assertThat(def.responseExampleAsString()).isNotEmpty();
- assertThat(def.params().stream().map(Param::key).collect(toList())).containsOnly("filter", "facets", "s", "asc", "ps", "p", "f");
+ assertThat(def.params().stream().map(Param::key).collect(Collectors.toList())).containsOnly("filter", "facets", "s", "asc", "ps", "p", "f");
assertThat(def.changelog()).hasSize(2);
Param sort = def.param("s");
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbTester;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.ComponentTesting;
public class SuggestionsActionIT {
private static final String[] SUGGESTION_QUALIFIERS = Stream.of(SuggestionCategory.values())
.map(SuggestionCategory::getQualifier)
- .collect(MoreCollectors.toList()).toArray(new String[0]);
+ .collect(Collectors.toList()).toArray(new String[0]);
@Rule
public final DbTester db = DbTester.create(System2.INSTANCE);
import com.google.common.base.Joiner;
import java.util.List;
+import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.System2;
import org.sonar.core.component.DefaultResourceTypes;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
db.components().insertSnapshot(mainBranch);
List<String> metrics = IntStream.range(0, 20)
.mapToObj(i -> "metric" + i)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
db.commit();
assertThatThrownBy(() -> {
package org.sonar.server.measure.ws;
import java.util.List;
+import java.util.stream.Collectors;
import java.util.stream.LongStream;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
.mapToObj(i -> dbClient.snapshotDao().insert(dbSession, newAnalysis(project).setCreatedAt(i * 1_000_000_000)))
.peek(a -> dbClient.measureDao().insert(dbSession, newMeasureDto(complexityMetric, project, a).setValue(101d)))
.map(a -> formatDateTime(a.getCreatedAt()))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
db.commit();
SearchHistoryRequest request = SearchHistoryRequest.builder()
.mapToObj(i -> dbClient.snapshotDao().insert(dbSession, newAnalysis(project).setCreatedAt(System2.INSTANCE.now() + i * 1_000_000_000L)))
.peek(a -> dbClient.measureDao().insert(dbSession, newMeasureDto(complexityMetric, project, a).setValue(Double.valueOf(a.getCreatedAt()))))
.map(a -> formatDateTime(a.getCreatedAt()))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
db.commit();
SearchHistoryRequest request = SearchHistoryRequest.builder()
package org.sonar.server.qualityprofile.ws;
import java.util.List;
+import java.util.stream.Collectors;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Language;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.System2;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbTester;
import org.sonar.db.permission.GlobalPermission;
db.qualityProfiles().setAsDefault(sonarWayCs, myCompanyProfile, sonarWayPython);
// rules
List<RuleDto> javaRules = range(0, 10).mapToObj(i -> db.rules().insertRule(r -> r.setLanguage(java.getKey())))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
List<RuleDto> deprecatedJavaRules = range(0, 5)
.mapToObj(i -> db.rules().insertRule(r -> r.setLanguage(java.getKey()).setStatus(DEPRECATED)))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
range(0, 7).forEach(i -> db.qualityProfiles().activateRule(myCompanyProfile, javaRules.get(i)));
range(0, 2).forEach(i -> db.qualityProfiles().activateRule(myCompanyProfile, deprecatedJavaRules.get(i)));
range(0, 10).forEach(i -> db.qualityProfiles().activateRule(myBuProfile, javaRules.get(i)));
import org.sonar.api.utils.System2;
import org.sonar.core.util.UuidFactory;
import org.sonar.core.util.UuidFactoryFast;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbTester;
import org.sonar.db.qualityprofile.ActiveRuleParamDto;
import org.sonar.db.qualityprofile.QProfileDto;
assertThat(response.getP()).isOne();
assertThat(response.getPaging().getPageIndex()).isOne();
assertThat(response.getPaging().getPageSize()).isNotZero();
- RuleKey[] expectedRuleKeys = stream(expectedRules).map(RuleDto::getKey).collect(MoreCollectors.toList()).toArray(new RuleKey[0]);
+ RuleKey[] expectedRuleKeys = stream(expectedRules).map(RuleDto::getKey).collect(Collectors.toList()).toArray(new RuleKey[0]);
assertThat(response.getRulesList())
.extracting(r -> RuleKey.parse(r.getKey()))
.containsExactlyInAnyOrder(expectedRuleKeys);
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import static org.sonar.api.measures.CoreMetrics.ALERT_STATUS_KEY;
import static org.sonar.api.utils.DateUtils.formatDateTime;
import static org.sonar.api.web.UserRole.USER;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.component.BranchType.BRANCH;
import static org.sonar.db.permission.GlobalPermission.SCAN;
Collection<BranchDto> branches = dbClient.branchDao().selectByProject(dbSession, projectOrApp).stream()
.filter(b -> b.getBranchType() == BRANCH)
- .collect(toList());
- List<String> branchUuids = branches.stream().map(BranchDto::getUuid).collect(toList());
+ .collect(Collectors.toList());
+ List<String> branchUuids = branches.stream().map(BranchDto::getUuid).collect(Collectors.toList());
Map<String, LiveMeasureDto> qualityGateMeasuresByComponentUuids = dbClient.liveMeasureDao()
.selectByComponentUuidsAndMetricKeys(dbSession, branchUuids, singletonList(ALERT_STATUS_KEY)).stream()
import java.util.List;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import static org.sonar.api.server.ws.WebService.Param.TEXT_QUERY;
import static org.sonar.api.utils.DateUtils.parseEndingDateOrDateTime;
import static org.sonar.api.utils.DateUtils.parseStartingDateOrDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.Pagination.forPage;
import static org.sonar.server.ce.ws.CeWsParameters.PARAM_COMPONENT;
import static org.sonar.server.ce.ws.CeWsParameters.PARAM_MAX_EXECUTED_AT;
} else if (componentQuery != null) {
query.setEntityUuids(loadEntities(dbSession, componentQuery).stream()
.map(EntityDto::getUuid)
- .collect(toList()));
+ .collect(Collectors.toList()));
}
return query;
}
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.measure.index.ProjectMeasuresQuery;
import static com.google.common.base.Strings.isNullOrEmpty;
public static List<Criterion> parse(String filter) {
return StreamSupport.stream(CRITERIA_SPLITTER.split(filter).spliterator(), false)
.map(FilterParser::parseCriterion)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static Criterion parseCriterion(String rawCriterion) {
import static java.util.Collections.emptySet;
import static java.util.Collections.singletonList;
import static org.sonar.api.web.UserRole.USER;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.server.component.index.SuggestionQuery.DEFAULT_LIMIT;
import static org.sonar.server.es.newindex.DefaultIndexSettings.MINIMUM_NGRAM_LENGTH;
.map(hit -> toSuggestion(hit, recentlyBrowsedKeys, favoriteUuids, entitiesByUuids))
.filter(Optional::isPresent)
.map(Optional::get)
- .collect(toList());
+ .collect(Collectors.toList());
return Category.newBuilder()
.setQ(qualifier.getQualifier())
.setMore(Math.max(0, qualifier.getTotalHits() - coveredItems))
.addAllItems(suggestions)
.build();
- }).collect(toList());
+ }).collect(Collectors.toList());
}
/**
import static java.lang.String.format;
import static java.util.Collections.emptyMap;
import static org.sonar.api.utils.Paging.offset;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.component.ComponentTreeQuery.Strategy.CHILDREN;
import static org.sonar.db.component.ComponentTreeQuery.Strategy.LEAVES;
import static org.sonar.server.component.ws.ComponentDtoToWsComponent.componentDtoToWsComponent;
List<String> referenceComponentIds = components.stream()
.map(ComponentDto::getCopyComponentUuid)
.filter(Objects::nonNull)
- .collect(toList());
+ .collect(Collectors.toList());
if (referenceComponentIds.isEmpty()) {
return emptyMap();
}
private static List<ComponentDto> paginateComponents(List<ComponentDto> components, Request wsRequest) {
return components.stream().skip(offset(wsRequest.getPage(), wsRequest.getPageSize()))
- .limit(wsRequest.getPageSize()).collect(toList());
+ .limit(wsRequest.getPageSize()).collect(Collectors.toList());
}
private static List<ComponentDto> sortComponents(List<ComponentDto> components, Request wsRequest) {
import static java.util.Comparator.comparing;
import static org.sonar.api.utils.DateUtils.formatDateTime;
import static org.sonar.api.utils.DateUtils.parseDateTimeQuietly;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.component.BranchType.BRANCH;
import static org.sonar.db.component.BranchType.PULL_REQUEST;
return Stream.empty();
}
- List<String> branchUuids = analyses.stream().map(SnapshotDto::getRootComponentUuid).collect(toList());
+ List<String> branchUuids = analyses.stream().map(SnapshotDto::getRootComponentUuid).collect(Collectors.toList());
Map<String, BranchDto> branchesByUuids = dbClient.branchDao().selectByUuids(dbSession, branchUuids).stream().collect(uniqueIndex(BranchDto::getUuid));
return Stream.concat(
checkArgument(date != null, "'%s' cannot be parsed as either a date or date+time", stringDate);
return date.getTime() + 1_000L;
})
- .collect(toList());
+ .collect(Collectors.toList());
}
private static String encode(String text) {
package org.sonar.server.favorite.ws;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.Paging;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.entity.EntityDto;
import org.sonar.server.favorite.FavoriteFinder;
import org.sonar.server.user.UserSession;
List<EntityDto> displayedFavorites = authorizedFavorites.stream()
.skip(paging.offset())
.limit(paging.pageSize())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
return new SearchResults(paging, displayedFavorites);
}
import static java.util.Optional.empty;
import static java.util.Optional.ofNullable;
import static org.sonar.api.utils.DateUtils.formatDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.issue.IssueChangeDto.TYPE_COMMENT;
List<IssueChangeDto> all = dbClient.issueChangeDao().selectByIssueKeys(dbSession, issueKeys);
changes = all.stream()
.filter(t -> TYPE_FIELD_CHANGE.equals(t.getChangeType()))
- .collect(toList());
+ .collect(Collectors.toList());
comments = all.stream()
.filter(t -> TYPE_COMMENT.equals(t.getChangeType()))
- .collect(toList());
+ .collect(Collectors.toList());
break;
default:
throw new IllegalStateException("Unsupported Load value:" + load);
import java.util.Collections;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.core.issue.DefaultIssue;
import org.sonar.core.issue.IssueChangeContext;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.issue.workflow.IssueWorkflow;
import org.sonar.server.issue.workflow.Transition;
import org.sonar.server.user.UserSession;
.stream()
.filter(transition -> (userSession.isLoggedIn() && isBlank(transition.requiredProjectPermission()))
|| userSession.hasComponentUuidPermission(transition.requiredProjectPermission(), projectUuid))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
public boolean doTransition(DefaultIssue defaultIssue, IssueChangeContext issueChangeContext, String transitionKey) {
List<DefaultIssue> items = bulkChangeData.issues.stream()
.filter(bulkChange(issueChangeContext, bulkChangeData, result))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
issueStorage.save(dbSession, items);
refreshLiveMeasures(dbSession, bulkChangeData, result);
.map(data.componentsByUuid::get)
.collect(Collectors.toList());
- List<DefaultIssue> changedIssues = data.issues.stream().filter(result.success::contains).collect(MoreCollectors.toList());
+ List<DefaultIssue> changedIssues = data.issues.stream().filter(result.success::contains).collect(Collectors.toList());
issueChangePostProcessor.process(dbSession, changedIssues, touchedComponents, false);
}
this.availableActions = actions.stream()
.filter(action -> propertiesByActions.containsKey(action.key()))
.filter(action -> action.verify(getProperties(action.key()), issues, userSession))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private List<ComponentDto> getComponents(DbSession dbSession, Collection<String> componentUuids) {
return allIssues.stream()
.filter(issue -> branchUuids.contains(issue.getProjectUuid()))
.map(IssueDto::toDefaultIssue)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
Map<String, Object> getProperties(String actionKey) {
}
List<Action> getActionsWithoutComment() {
- return availableActions.stream().filter(action -> !action.key().equals(COMMENT_KEY)).collect(MoreCollectors.toList());
+ return availableActions.stream().filter(action -> !action.key().equals(COMMENT_KEY)).collect(Collectors.toList());
}
Optional<Action> getCommentAction() {
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import static org.sonar.api.resources.Qualifiers.PROJECT;
import static org.sonar.api.resources.Qualifiers.SUBVIEW;
import static org.sonar.api.resources.Qualifiers.VIEW;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.measure.ws.MeasureDtoToWsMeasure.updateMeasureBuilder;
import static org.sonar.server.measure.ws.MeasuresWsParametersBuilder.createMetricKeysParameter;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
private List<MetricDto> searchMetrics() {
List<MetricDto> dbMetrics = dbClient.metricDao().selectByKeys(dbSession, request.getMetricKeys());
- List<String> metricKeys = dbMetrics.stream().map(MetricDto::getKey).collect(toList());
+ List<String> metricKeys = dbMetrics.stream().map(MetricDto::getKey).collect(Collectors.toList());
checkRequest(request.getMetricKeys().size() == dbMetrics.size(), "The following metrics are not found: %s",
String.join(", ", difference(request.getMetricKeys(), metricKeys)));
return dbMetrics;
return expected.stream()
.filter(value -> !actualSet.contains(value))
.sorted(String::compareTo)
- .collect(toList());
+ .collect(Collectors.toList());
}
private List<LiveMeasureDto> searchMeasures() {
return measure;
})
.sorted(comparing(byMetricKey).thenComparing(byComponentName))
- .collect(toList());
+ .collect(Collectors.toList());
}
}
import java.util.List;
import java.util.Set;
import java.util.function.Function;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
Date to = parseEndingDateOrDateTime(request.getTo());
PastMeasureQuery dbQuery = new PastMeasureQuery(
result.getComponent().uuid(),
- result.getMetrics().stream().map(MetricDto::getUuid).collect(MoreCollectors.toList()),
+ result.getMetrics().stream().map(MetricDto::getUuid).collect(Collectors.toList()),
from == null ? null : from.getTime(),
to == null ? null : (to.getTime() + 1_000L));
return dbClient.measureDao().selectPastMeasures(dbSession, dbQuery);
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.component.ComponentDto;
import org.sonar.db.component.SnapshotDto;
public SearchHistoryResult setAnalyses(List<SnapshotDto> analyses) {
this.paging = Common.Paging.newBuilder().setPageIndex(page).setPageSize(pageSize).setTotal(analyses.size()).build();
- this.analyses = analyses.stream().skip(offset(page, pageSize)).limit(pageSize).collect(MoreCollectors.toList());
+ this.analyses = analyses.stream().skip(offset(page, pageSize)).limit(pageSize).collect(Collectors.toList());
return this;
}
import org.sonarqube.ws.NewCodePeriods;
import org.sonarqube.ws.NewCodePeriods.ListWSResponse;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.ws.WsUtils.createHtmlExternalLink;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
import static org.sonarqube.ws.NewCodePeriods.ShowWSResponse.newBuilder;
Collection<BranchDto> branches = dbClient.branchDao().selectByProject(dbSession, project).stream()
.filter(b -> b.getBranchType() == BranchType.BRANCH)
.sorted(Comparator.comparing(BranchDto::getKey))
- .collect(toList());
+ .collect(Collectors.toList());
List<NewCodePeriodDto> newCodePeriods = newCodePeriodDao.selectAllByProject(dbSession, project.getUuid());
package org.sonar.server.notification.ws;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.Startable;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.notification.NotificationDispatcherMetadata.GLOBAL_NOTIFICATION;
import static org.sonar.server.notification.NotificationDispatcherMetadata.PER_PROJECT_NOTIFICATION;
this.globalDispatchers = notificationCenter.getDispatcherKeysForProperty(GLOBAL_NOTIFICATION, "true")
.stream()
.sorted()
- .collect(toList());
+ .collect(Collectors.toList());
this.projectDispatchers = notificationCenter.getDispatcherKeysForProperty(PER_PROJECT_NOTIFICATION, "true")
.stream()
.sorted()
- .collect(toList());
+ .collect(Collectors.toList());
}
@Override
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.sonar.api.notifications.NotificationChannel;
import org.sonar.api.server.ws.Request;
public ListAction(NotificationCenter notificationCenter, DbClient dbClient, UserSession userSession, Dispatchers dispatchers) {
this.dbClient = dbClient;
this.userSession = userSession;
- this.channels = notificationCenter.getChannels().stream().map(NotificationChannel::getKey).sorted().collect(MoreCollectors.toList());
+ this.channels = notificationCenter.getChannels().stream().map(NotificationChannel::getKey).sorted().collect(Collectors.toList());
this.dispatchers = dispatchers;
}
import java.util.List;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.entity.EntityDto;
.build(),
dbSession).stream()
.filter(notificationScope(project))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
checkArgument(existingNotification.isEmpty()
|| !PROP_NOTIFICATION_VALUE.equals(existingNotification.get(0).getValue()), "Notification already added");
.build(),
dbSession).stream()
.filter(notificationScope(project))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
checkArgument(!existingNotification.isEmpty() && PROP_NOTIFICATION_VALUE.equals(existingNotification.get(0).getValue()), "Notification doesn't exist");
dbClient.propertiesDao().delete(dbSession, new PropertyDto()
*/
package org.sonar.server.permission;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.db.entity.EntityDto;
import org.sonar.db.permission.GlobalPermission;
import static java.util.Objects.requireNonNull;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.exceptions.BadRequestException.checkRequest;
public abstract class PermissionChange {
if (entity == null) {
checkRequest(permissionService.getGlobalPermissions().stream().anyMatch(p -> p.getKey().equals(permission)),
"Invalid global permission '%s'. Valid values are %s", permission,
- permissionService.getGlobalPermissions().stream().map(GlobalPermission::getKey).collect(toList()));
+ permissionService.getGlobalPermissions().stream().map(GlobalPermission::getKey).collect(Collectors.toList()));
} else {
checkRequest(permissionService.getAllProjectPermissions().contains(permission), "Invalid project permission '%s'. Valid values are %s", permission,
permissionService.getAllProjectPermissions());
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.Scopes;
import org.sonar.api.server.ws.Change;
import static java.util.Optional.ofNullable;
import static org.sonar.api.utils.DateUtils.parseEndingDateOrDateTime;
import static org.sonar.api.utils.DateUtils.parseStartingDateOrDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.component.SnapshotDto.STATUS_LIVE_MEASURE_COMPUTED;
import static org.sonar.db.component.SnapshotDto.STATUS_PROCESSED;
import static org.sonar.db.component.SnapshotDto.STATUS_UNPROCESSED;
}
private void addEvents(SearchData.Builder data) {
- List<String> analyses = data.getAnalyses().stream().map(SnapshotDto::getUuid).collect(toList());
+ List<String> analyses = data.getAnalyses().stream().map(SnapshotDto::getUuid).collect(Collectors.toList());
data.setEvents(dbClient.eventDao().selectByAnalysisUuids(data.getDbSession(), analyses));
data.setComponentChanges(dbClient.eventComponentChangeDao().selectByAnalysisUuids(data.getDbSession(), analyses));
}
.limit(request.getPageSize());
}
- this.analyses = stream.collect(MoreCollectors.toList());
+ this.analyses = stream.collect(Collectors.toList());
this.countAnalyses = analyses.size();
return this;
}
.filter(byCategory)
.skip(Paging.offset(request.getPage(), request.getPageSize()))
.limit(request.getPageSize())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
SearchData build() {
import java.util.List;
import java.util.Locale;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.utils.System2;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.project.ProjectDto;
.map(t -> t.toLowerCase(Locale.ENGLISH))
.map(TagsWsSupport::checkTag)
.distinct()
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private static String checkTag(String tag) {
import com.google.common.io.Resources;
import java.util.Collection;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonarqube.ws.Qualitygates.ListWsResponse;
import org.sonarqube.ws.Qualitygates.ListWsResponse.QualityGate;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
public class ListAction implements QualityGatesWsAction {
.setCaycStatus(qualityGateCaycChecker.checkCaycCompliant(dbSession, qualityGate.getUuid()).toString())
.setActions(wsSupport.getActions(dbSession, qualityGate, defaultQualityGate))
.build())
- .collect(toList()));
+ .collect(Collectors.toList()));
return builder.build();
}
import com.google.common.io.Resources;
import java.util.Collection;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.Paging;
import org.sonar.api.web.UserRole;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.qualitygate.ProjectQgateAssociationDto;
}
private List<ProjectQgateAssociationDto> keepAuthorizedProjects(DbSession dbSession, List<ProjectQgateAssociationDto> projects) {
- List<String> projectUuids = projects.stream().map(ProjectQgateAssociationDto::getUuid).collect(MoreCollectors.toList());
+ List<String> projectUuids = projects.stream().map(ProjectQgateAssociationDto::getUuid).collect(Collectors.toList());
Collection<String> authorizedProjectUuids = dbClient.authorizationDao().keepAuthorizedEntityUuids(dbSession, projectUuids, userSession.getUuid(), UserRole.USER);
- return projects.stream().filter(project -> authorizedProjectUuids.contains(project.getUuid())).collect(MoreCollectors.toList());
+ return projects.stream().filter(project -> authorizedProjectUuids.contains(project.getUuid())).collect(Collectors.toList());
}
}
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import static org.sonar.api.server.ws.WebService.SelectionMode.ALL;
import static org.sonar.api.server.ws.WebService.SelectionMode.DESELECTED;
import static org.sonar.api.server.ws.WebService.SelectionMode.fromParam;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.Pagination.forPage;
import static org.sonar.db.qualitygate.SearchQualityGatePermissionQuery.builder;
import static org.sonar.db.user.SearchPermissionQuery.ANY;
List<SearchGroupMembershipDto> groupMemberships = dbClient.qualityGateGroupPermissionsDao().selectByQuery(dbSession, query,
forPage(wsRequest.getPage()).andSize(wsRequest.getPageSize()));
Map<String, GroupDto> groupsByUuid = dbClient.groupDao().selectByUuids(dbSession,
- groupMemberships.stream().map(SearchGroupMembershipDto::getGroupUuid).collect(MoreCollectors.toList()))
+ groupMemberships.stream().map(SearchGroupMembershipDto::getGroupUuid).collect(Collectors.toList()))
.stream()
.collect(MoreCollectors.uniqueIndex(GroupDto::getUuid));
writeProtobuf(
Qualitygates.SearchGroupsResponse.newBuilder()
.addAllGroups(groupMemberships.stream()
.map(groupsMembership -> toGroup(groupsByUuid.get(groupsMembership.getGroupUuid()), groupsMembership.isSelected()))
- .collect(toList()))
+ .collect(Collectors.toList()))
.setPaging(buildPaging(wsRequest, total)).build(),
request, response);
}
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import static org.sonar.api.server.ws.WebService.SelectionMode.ALL;
import static org.sonar.api.server.ws.WebService.SelectionMode.DESELECTED;
import static org.sonar.api.server.ws.WebService.SelectionMode.fromParam;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.Pagination.forPage;
import static org.sonar.db.qualitygate.SearchQualityGatePermissionQuery.builder;
int total = dbClient.qualityGateUserPermissionDao().countByQuery(dbSession, query);
List<SearchUserMembershipDto> usersMembership = dbClient.qualityGateUserPermissionDao().selectByQuery(dbSession, query,
forPage(wsRequest.getPage()).andSize(wsRequest.getPageSize()));
- Map<String, UserDto> usersById = dbClient.userDao().selectByUuids(dbSession, usersMembership.stream().map(SearchUserMembershipDto::getUserUuid).collect(toList()))
+ Map<String, UserDto> usersById = dbClient.userDao().selectByUuids(dbSession, usersMembership.stream().map(SearchUserMembershipDto::getUserUuid).collect(Collectors.toList()))
.stream().collect(uniqueIndex(UserDto::getUuid));
writeProtobuf(
SearchUsersResponse.newBuilder()
.addAllUsers(usersMembership.stream()
.map(userMembershipDto -> toUser(usersById.get(userMembershipDto.getUserUuid()), userMembershipDto.isSelected()))
- .collect(toList()))
+ .collect(Collectors.toList()))
.setPaging(buildPaging(wsRequest, total)).build(),
request, response);
}
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Optional.ofNullable;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.server.qualitygate.ws.QualityGatesWsParameters.PARAM_NAME;
.setCaycStatus(caycStatus.toString())
.addAllConditions(conditions.stream()
.map(toWsCondition(metricsByUuid))
- .collect(toList()))
+ .collect(Collectors.toList()))
.setActions(wsSupport.getActions(dbSession, qualityGate, defaultQualityGate))
.build();
}
String inheritance = change.getActiveRule().getInheritance();
return inheritance == null || NONE.name().equals(inheritance);
})
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
}
});
if (!changedProfiles.isEmpty()) {
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.sonar.api.rule.RuleKey;
List<ActiveRuleChange> changes = builtInQProfile.getActiveRules().stream()
.map(activeRule -> insertActiveRule(batchDbSession, ruleProfile, activeRule, now.getTime()))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
changes.forEach(change -> dbClient.qProfileChangeDao().insert(batchDbSession, change.toDto(null)));
.filter(BuiltInQProfileRepositoryImpl::ensureAtMostOneDeclaredDefault)
.map(entry -> toQualityProfiles(entry.getValue()))
.flatMap(Collection::stream)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
}
private Map<RuleKey, RuleDto> loadRuleDefinitionsByRuleKey() {
import java.util.Collection;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
List<ProjectQprofileAssociationDto> projects = loadAllProjects(profileKey, session, selected, query).stream()
.sorted(comparing(ProjectQprofileAssociationDto::getProjectName)
.thenComparing(ProjectQprofileAssociationDto::getProjectUuid))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
Collection<String> projectUuids = projects.stream()
.map(ProjectQprofileAssociationDto::getProjectUuid)
.filter(input -> authorizedProjectUuids.contains(input.getProjectUuid()))
.skip(paging.offset())
.limit(paging.pageSize())
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
writeProjects(response, authorizedProjects, paging);
}
import static java.util.function.Function.identity;
import static org.sonar.api.rule.RuleStatus.DEPRECATED;
import static org.sonar.api.utils.DateUtils.formatDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.permission.GlobalPermission.ADMINISTER_QUALITY_PROFILES;
import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
return Stream.concat(
dbClient.qProfileEditUsersDao().selectQProfileUuidsByUser(dbSession, user).stream(),
dbClient.qProfileEditGroupsDao().selectQProfileUuidsByGroups(dbSession, userSession.getGroups()).stream())
- .collect(toList());
+ .collect(Collectors.toList());
}
private List<QProfileDto> searchProfiles(DbSession dbSession, SearchRequest request, List<QProfileDto> defaultProfiles, @Nullable ProjectDto project) {
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Languages;
import org.sonar.api.server.ws.Request;
import static org.sonar.api.server.ws.WebService.SelectionMode.ALL;
import static org.sonar.api.server.ws.WebService.SelectionMode.DESELECTED;
import static org.sonar.api.server.ws.WebService.SelectionMode.fromParam;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.db.Pagination.forPage;
import static org.sonar.db.qualityprofile.SearchQualityProfilePermissionQuery.ANY;
List<SearchGroupMembershipDto> groupMemberships = dbClient.qProfileEditGroupsDao().selectByQuery(dbSession, query,
forPage(wsRequest.getPage()).andSize(wsRequest.getPageSize()));
Map<String, GroupDto> groupsByUuid = dbClient.groupDao().selectByUuids(dbSession,
- groupMemberships.stream().map(SearchGroupMembershipDto::getGroupUuid).collect(MoreCollectors.toList()))
+ groupMemberships.stream().map(SearchGroupMembershipDto::getGroupUuid).collect(Collectors.toList()))
.stream()
.collect(MoreCollectors.uniqueIndex(GroupDto::getUuid));
writeProtobuf(
Qualityprofiles.SearchGroupsResponse.newBuilder()
.addAllGroups(groupMemberships.stream()
.map(groupsMembership -> toGroup(groupsByUuid.get(groupsMembership.getGroupUuid()), groupsMembership.isSelected()))
- .collect(toList()))
+ .collect(Collectors.toList()))
.setPaging(buildPaging(wsRequest, total)).build(),
request, response);
}
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import java.util.stream.Collectors;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Languages;
import org.sonar.api.server.ws.Request;
import static org.sonar.api.server.ws.WebService.SelectionMode.ALL;
import static org.sonar.api.server.ws.WebService.SelectionMode.DESELECTED;
import static org.sonar.api.server.ws.WebService.SelectionMode.fromParam;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.db.Pagination.forPage;
int total = dbClient.qProfileEditUsersDao().countByQuery(dbSession, query);
List<SearchUserMembershipDto> usersMembership = dbClient.qProfileEditUsersDao().selectByQuery(dbSession, query,
forPage(wsRequest.getPage()).andSize(wsRequest.getPageSize()));
- Map<String, UserDto> usersById = dbClient.userDao().selectByUuids(dbSession, usersMembership.stream().map(SearchUserMembershipDto::getUserUuid).collect(toList()))
+ Map<String, UserDto> usersById = dbClient.userDao().selectByUuids(dbSession, usersMembership.stream().map(SearchUserMembershipDto::getUserUuid).collect(Collectors.toList()))
.stream().collect(uniqueIndex(UserDto::getUuid));
writeProtobuf(
SearchUsersResponse.newBuilder()
.addAllUsers(usersMembership.stream()
.map(userMembershipDto -> toUser(usersById.get(userMembershipDto.getUserUuid()), userMembershipDto.isSelected()))
- .collect(toList()))
+ .collect(Collectors.toList()))
.setPaging(buildPaging(wsRequest, total)).build(),
request, response);
}
.map(QProfileDto::getParentKee)
.filter(StringUtils::isNotEmpty)
.filter(uuid -> !profilesByUuid.containsKey(uuid))
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
if (!parentUuids.isEmpty()) {
dbClient.qualityProfileDao().selectByUuids(dbSession, parentUuids)
.forEach(p -> profilesByUuid.put(p.getKee(), p));
import org.sonarqube.ws.Rules;
import static org.sonar.api.utils.DateUtils.formatDateTime;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.db.rule.RuleDto.Format.MARKDOWN;
import static org.sonar.server.rule.ws.RulesWsParameters.FIELD_CREATED_AT;
import static org.sonar.server.rule.ws.RulesWsParameters.FIELD_DEBT_REM_FUNCTION;
private static void setParams(Rules.Rule.Builder ruleResponse, RuleDto ruleDto, SearchResult searchResult, Set<String> fieldsToReturn) {
if (shouldReturnField(fieldsToReturn, FIELD_PARAMS)) {
List<RuleParamDto> ruleParameters = searchResult.getRuleParamsByRuleUuid().get(ruleDto.getUuid());
- ruleResponse.getParamsBuilder().addAllParams(ruleParameters.stream().map(RuleParamDtoToWsRuleParam.INSTANCE).collect(toList()));
+ ruleResponse.getParamsBuilder().addAllParams(ruleParameters.stream().map(RuleParamDtoToWsRuleParam.INSTANCE).collect(Collectors.toList()));
}
}
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.rule.DeprecatedRuleKeyDto;
List<String> templateRuleUuids = rules.stream()
.map(RuleDto::getTemplateUuid)
.filter(Objects::nonNull)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
List<RuleDto> templateRules = dbClient.ruleDao().selectByUuids(dbSession, templateRuleUuids);
List<RuleParamDto> ruleParamDtos = dbClient.ruleDao().selectRuleParamsByRuleUuids(dbSession, ruleUuids);
return new SearchResult()
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
-import org.sonar.core.util.stream.MoreCollectors;
+import java.util.stream.Collectors;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.protobuf.DbFileSources;
.filter(line -> line.hasLine() && line.getLine() >= from)
.limit((toInclusive - from) + 1L)
.map(function)
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
}
private <E> Optional<Iterable<E>> getLines(DbSession dbSession, String fileUuid, Set<Integer> lines, Function<DbFileSources.Line, E> function) {
return Optional.of(dto.getSourceData().getLinesList().stream()
.filter(line -> line.hasLine() && lines.contains(line.getLine()))
.map(function)
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
}
private static void verifyLine(int line) {
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.List;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
import org.sonar.api.Startable;
import org.sonar.api.server.ServerSide;
import static java.util.Objects.requireNonNull;
import static org.sonar.api.web.page.Page.Scope.COMPONENT;
import static org.sonar.api.web.page.Page.Scope.GLOBAL;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
+
import org.springframework.beans.factory.annotation.Autowired;
@ServerSide
.filter(p -> p.getScope().equals(scope))
.filter(p -> p.isAdmin() == isAdmin)
.filter(p -> !COMPONENT.equals(p.getScope()) || p.getComponentQualifiers().contains(qualifier))
- .collect(toList());
+ .collect(Collectors.toList());
}
@VisibleForTesting
package org.sonar.server.user.ws;
import java.util.function.Function;
+import java.util.stream.Collectors;
import org.sonar.api.server.authentication.Display;
import org.sonar.api.server.authentication.IdentityProvider;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
-import org.sonar.core.util.stream.MoreCollectors;
import org.sonar.server.authentication.IdentityProviderRepository;
import org.sonarqube.ws.Users;
import org.sonarqube.ws.Users.IdentityProvidersWsResponse;
response.addAllIdentityProviders(identityProviderRepository.getAllEnabledAndSorted()
.stream()
.map(toWsIdentityProvider())
- .collect(MoreCollectors.toList()));
+ .collect(Collectors.toList()));
return response.build();
}
import static org.sonar.api.server.ws.WebService.Param.PAGE_SIZE;
import static org.sonar.api.server.ws.WebService.Param.TEXT_QUERY;
import static org.sonar.api.utils.Paging.forPageIndex;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.server.ws.WsUtils.writeProtobuf;
import static org.sonarqube.ws.Users.SearchWsResponse.Groups;
import static org.sonarqube.ws.Users.SearchWsResponse.ScmAccounts;
List<UserDto> users = findUsersAndSortByLogin(request, dbSession, userQuery);
int totalUsers = dbClient.userDao().countUsers(dbSession, userQuery);
- List<String> logins = users.stream().map(UserDto::getLogin).collect(toList());
+ List<String> logins = users.stream().map(UserDto::getLogin).collect(Collectors.toList());
Multimap<String, String> groupsByLogin = dbClient.groupMembershipDao().selectGroupsByLogins(dbSession, logins);
Map<String, Integer> tokenCountsByLogin = dbClient.userTokenDao().countTokensByUsers(dbSession, users);
Map<String, Boolean> userUuidToIsManaged = managedInstanceService.getUserUuidToManaged(dbSession, getUserUuids(users));
import com.google.common.collect.Ordering;
import java.util.Comparator;
import java.util.List;
+import java.util.stream.Collectors;
import org.sonar.api.server.ws.Change;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.Version;
import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.core.util.stream.MoreCollectors;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Optional.ofNullable;
}
private static void writeParameters(JsonWriter writer, WebService.Action action, boolean includeInternals) {
- List<WebService.Param> params = action.params().stream().filter(p -> includeInternals || !p.isInternal()).collect(MoreCollectors.toList());
+ List<WebService.Param> params = action.params().stream().filter(p -> includeInternals || !p.isInternal()).collect(Collectors.toList());
if (!params.isEmpty()) {
// sort parameters by key
Ordering<WebService.Param> ordering = Ordering.natural().onResultOf(WebService.Param::key);
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import org.sonar.core.util.stream.MoreCollectors;
import static java.lang.String.format;
Predicate<Redirect> match = redirect -> redirect.test(path);
List<Redirect> redirects = REDIRECTS.stream()
.filter(match)
- .collect(MoreCollectors.toList());
+ .collect(Collectors.toList());
switch (redirects.size()) {
case 0:
// prevents instantiation
}
- public static <T> Collector<T, ?, List<T>> toList() {
- return Collectors.toList();
- }
-
public static <E> Collector<E, ?, ImmutableList<E>> toImmutableList() {
return ImmutableList.toImmutableList();
}
import static org.sonar.core.util.stream.MoreCollectors.toHashSet;
import static org.sonar.core.util.stream.MoreCollectors.toImmutableList;
import static org.sonar.core.util.stream.MoreCollectors.toImmutableSet;
-import static org.sonar.core.util.stream.MoreCollectors.toList;
import static org.sonar.core.util.stream.MoreCollectors.toSet;
import static org.sonar.core.util.stream.MoreCollectors.uniqueIndex;
import static org.sonar.core.util.stream.MoreCollectors.unorderedFlattenIndex;
.containsExactly(1, 2, 3, 4, 5);
}
- @Test
- public void toList_parallel_stream() {
- assertThat(HUGE_LIST.parallelStream().collect(toList())).isEqualTo(HUGE_LIST);
- }
-
@Test
public void toList_with_size_builds_an_ImmutableList() {
List<Integer> res = Stream.of(1, 2, 3, 4, 5).collect(toImmutableList());
projects / sonarqube.git / commitdiff