package org.sonar.batch.bootstrapper;
import com.google.common.base.Throwables;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
+
+import java.util.ArrayList;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
private boolean started = false;
private LoggingConfiguration loggingConfig;
private List<Object> components;
- private Map<String, String> bootstrapProperties = Maps.newHashMap();
+ private Map<String, String> bootstrapProperties = new HashMap<>();
private GlobalContainer bootstrapContainer;
private Batch(Builder builder) {
- components = Lists.newArrayList();
+ components = new ArrayList<>();
components.addAll(builder.components);
if (builder.environment != null) {
components.add(builder.environment);
public static final class Builder {
private Map<String, String> bootstrapProperties;
private EnvironmentInformation environment;
- private List<Object> components = Lists.newArrayList();
+ private List<Object> components = new ArrayList<>();
private boolean enableLoggingConfiguration = true;
private LogOutput logOutput;
package org.sonar.batch.bootstrapper;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Maps;
+
+import java.util.HashMap;
import java.util.Map;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
@VisibleForTesting
static final String FORMAT_MAVEN = "[%level] [%d{HH:mm:ss.SSS}] %msg%n";
- private Map<String, String> substitutionVariables = Maps.newHashMap();
+ private Map<String, String> substitutionVariables = new HashMap<>();
private LogOutput logOutput = null;
private boolean verbose;
*/
package org.sonar.scanner.bootstrap;
-import com.google.common.base.Predicates;
-import com.google.common.collect.Collections2;
-import com.google.common.collect.Lists;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
+import java.util.stream.Collectors;
+
import javax.annotation.Nullable;
import org.apache.commons.lang.ClassUtils;
import org.sonar.api.batch.CheckProject;
}
private <T> List<T> getFilteredExtensions(Class<T> type, @Nullable DefaultInputModule module, @Nullable ExtensionMatcher matcher) {
- List<T> result = Lists.newArrayList();
+ List<T> result = new ArrayList<>();
for (Object extension : getExtensions(type)) {
if (org.sonar.api.batch.Sensor.class.equals(type) && extension instanceof Sensor) {
extension = new SensorWrapper((Sensor) extension, sensorContext, sensorOptimizer);
}
protected <T> List<T> getExtensions(Class<T> type) {
- List<T> extensions = Lists.newArrayList();
+ List<T> extensions = new ArrayList<>();
completeBatchExtensions(componentContainer, extensions, type);
return extensions;
}
}
List<?> sortedList = dag.sort();
- return (Collection<T>) Collections2.filter(sortedList, Predicates.in(extensions));
+ return (Collection<T>) sortedList.stream()
+ .filter(extensions::contains)
+ .collect(Collectors.toList());
}
/**
}
protected List<Object> evaluateAnnotatedClasses(Object extension, Class<? extends Annotation> annotation) {
- List<Object> results = Lists.newArrayList();
+ List<Object> results = new ArrayList<>();
Class<? extends Object> aClass = extension.getClass();
while (aClass != null) {
evaluateClass(aClass, annotation, results);
package org.sonar.scanner.bootstrap;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
+import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
}
private Map<String, PluginInfo> loadPlugins(List<RemotePlugin> remotePlugins) {
- Map<String, PluginInfo> infosByKey = new HashMap<>();
+ Map<String, PluginInfo> infosByKey = new HashMap<>(remotePlugins.size());
Profiler profiler = Profiler.create(LOG).startDebug("Load plugins");
try {
String pluginIndex = loadPluginIndex();
String[] rows = StringUtils.split(pluginIndex, CharUtils.LF);
- List<RemotePlugin> result = Lists.newArrayList();
+ List<RemotePlugin> result = new ArrayList<>();
for (String row : rows) {
result.add(RemotePlugin.unmarshal(row));
}
String str;
try (Reader reader = wsClient.call(getRequest).contentReader()) {
str = IOUtils.toString(reader);
- } catch(IOException e) {
+ } catch (IOException e) {
throw new IllegalStateException(e);
}
-
+
profiler.stopInfo();
return str;
}
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
-import com.google.common.collect.Lists;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
import javax.annotation.Nonnull;
private static List<String> propertyValues(Settings settings, String key, String defaultValue) {
String s = StringUtils.defaultIfEmpty(settings.getString(key), defaultValue);
- return Lists.newArrayList(Splitter.on(",").trimResults().omitEmptyStrings().split(s));
+ return StreamSupport.stream(Splitter.on(",").trimResults().omitEmptyStrings().split(s).spliterator(), false)
+ .collect(Collectors.toList());
}
}
*/
package org.sonar.scanner.bootstrap;
-import com.google.common.collect.Maps;
import org.sonar.api.config.Encryption;
import javax.annotation.Nullable;
+import java.util.HashMap;
import java.util.Map;
/**
public UserProperties(Map<String, String> properties, @Nullable String pathToSecretKey) {
encryption = new Encryption(pathToSecretKey);
- Map<String, String> decryptedProps = Maps.newHashMap();
+ Map<String, String> decryptedProps = new HashMap<>(properties.size());
for (Map.Entry<String, String> entry : properties.entrySet()) {
String value = entry.getValue();
if (value != null && encryption.isEncrypted(value)) {
}
decryptedProps.put(entry.getKey(), value);
}
- this.properties = Maps.newHashMap(decryptedProps);
+ this.properties = decryptedProps;
}
public Map<String, String> properties() {
*/
package org.sonar.scanner.events;
-import com.google.common.collect.Lists;
import org.sonar.api.batch.events.EventHandler;
+import java.util.ArrayList;
import java.util.List;
/**
}
private List<EventHandler> getDispatchList(Class<? extends EventHandler> handlerType) {
- List<EventHandler> result = Lists.newArrayList();
+ List<EventHandler> result = new ArrayList<>(registeredHandlers.length);
for (EventHandler handler : registeredHandlers) {
if (handlerType.isAssignableFrom(handler.getClass())) {
result.add(handler);
import java.util.ArrayList;
import java.util.Collection;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import org.sonar.api.resources.File;
import org.sonar.api.resources.Project;
import org.sonar.api.resources.Resource;
-import org.sonar.core.util.stream.Collectors;
import org.sonar.scanner.scan.filesystem.InputComponentStore;
import org.sonar.scanner.scan.measure.MeasureCache;
import org.sonar.scanner.sensor.DefaultSensorStorage;
*/
package org.sonar.scanner.issue;
-import com.google.common.collect.ImmutableList;
import org.sonar.api.scan.issue.filter.IssueFilter;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
import org.sonar.api.scan.issue.filter.FilterableIssue;
private final List<IssueFilter> filters;
public DefaultIssueFilterChain(IssueFilter... filters) {
- this.filters = ImmutableList.copyOf(filters);
+ this.filters = Collections.unmodifiableList(Arrays.asList(filters));
}
public DefaultIssueFilterChain() {
- this.filters = ImmutableList.of();
+ this.filters = Collections.emptyList();
}
private DefaultIssueFilterChain(List<IssueFilter> filters) {
*/
package org.sonar.scanner.issue;
-import com.google.common.base.Function;
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.ProjectIssues;
import org.sonar.scanner.issue.tracking.TrackedIssue;
+
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
import javax.annotation.Nullable;
/**
* @since 4.0
*/
public class DefaultProjectIssues implements ProjectIssues {
-
+ private static final Predicate<TrackedIssue> RESOLVED = new ResolvedPredicate(true);
+ private static final Predicate<TrackedIssue> NOT_RESOLVED = new ResolvedPredicate(false);
private final IssueCache cache;
public DefaultProjectIssues(IssueCache cache) {
@Override
public Iterable<Issue> issues() {
- return Iterables.transform(
- Iterables.filter(cache.all(), new ResolvedPredicate(false)),
- new IssueTransformer());
+ return StreamSupport.stream(cache.all().spliterator(), false)
+ .filter(NOT_RESOLVED)
+ .map(TrackedIssueAdapter::new)
+ .collect(Collectors.toList());
}
@Override
public Iterable<Issue> resolvedIssues() {
- return Iterables.transform(
- Iterables.filter(cache.all(), new ResolvedPredicate(true)),
- new IssueTransformer());
+ return StreamSupport.stream(cache.all().spliterator(), false)
+ .filter(RESOLVED)
+ .map(TrackedIssueAdapter::new)
+ .collect(Collectors.toList());
}
private static class ResolvedPredicate implements Predicate<TrackedIssue> {
}
@Override
- public boolean apply(@Nullable TrackedIssue issue) {
+ public boolean test(@Nullable TrackedIssue issue) {
if (issue != null) {
return resolved ? (issue.resolution() != null) : (issue.resolution() == null);
}
return false;
}
}
-
- private static class IssueTransformer implements Function<TrackedIssue, Issue> {
- @Override
- public Issue apply(TrackedIssue issue) {
- return new TrackedIssueAdapter(issue);
- }
- }
}
*/
package org.sonar.scanner.issue;
-import com.google.common.collect.ImmutableList;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.batch.IssueFilter;
import org.sonar.api.issue.batch.IssueFilterChain;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.List;
/**
private final List<IssueFilter> filters;
public DeprecatedIssueFilterChain(IssueFilter... filters) {
- this.filters = ImmutableList.copyOf(filters);
+ this.filters = Arrays.asList(filters);
}
public DeprecatedIssueFilterChain() {
- this.filters = ImmutableList.of();
+ this.filters = Collections.emptyList();
}
private DeprecatedIssueFilterChain(List<IssueFilter> filters) {
package org.sonar.scanner.issue.ignore.pattern;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.batch.ScannerSide;
import org.sonar.api.config.Settings;
+import java.util.ArrayList;
import java.util.List;
import static com.google.common.base.MoreObjects.firstNonNull;
@VisibleForTesting
protected final void initPatterns() {
// Patterns Multicriteria
- multicriteriaPatterns = Lists.newArrayList();
+ multicriteriaPatterns = new ArrayList<>();
String patternConf = StringUtils.defaultIfBlank(settings.getString(getMulticriteriaConfigurationKey()), "");
for (String id : StringUtils.split(patternConf, ',')) {
String propPrefix = getMulticriteriaConfigurationKey() + "." + id + ".";
package org.sonar.scanner.issue.ignore.pattern;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.config.Settings;
import org.sonar.core.config.IssueExclusionProperties;
+import java.util.ArrayList;
import java.util.List;
import static com.google.common.base.Strings.nullToEmpty;
@VisibleForTesting
protected final void loadFileContentPatterns() {
// Patterns Block
- blockPatterns = Lists.newArrayList();
+ blockPatterns = new ArrayList<>();
String patternConf = StringUtils.defaultIfBlank(getSettings().getString(IssueExclusionProperties.PATTERNS_BLOCK_KEY), "");
for (String id : StringUtils.split(patternConf, ',')) {
String propPrefix = IssueExclusionProperties.PATTERNS_BLOCK_KEY + "." + id + ".";
}
// Patterns All File
- allFilePatterns = Lists.newArrayList();
+ allFilePatterns = new ArrayList<>();
patternConf = StringUtils.defaultIfBlank(getSettings().getString(IssueExclusionProperties.PATTERNS_ALLFILE_KEY), "");
for (String id : StringUtils.split(patternConf, ',')) {
String propPrefix = IssueExclusionProperties.PATTERNS_ALLFILE_KEY + "." + id + ".";
package org.sonar.scanner.issue.ignore.pattern;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
+import java.util.LinkedHashSet;
import java.util.Set;
public class LineRange {
}
public Set<Integer> toLines() {
- Set<Integer> lines = Sets.newLinkedHashSet();
+ Set<Integer> lines = new LinkedHashSet<>(to-from+1);
for (int index = from; index <= to; index++) {
lines.add(index);
}
package org.sonar.scanner.issue.ignore.pattern;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.utils.SonarException;
+import java.util.LinkedList;
import java.util.List;
public class PatternDecoder {
private static final String CONFIG_FORMAT_ERROR_PREFIX = "Exclusions > Issues : Invalid format. ";
public List<IssuePattern> decode(String patternsList) {
- List<IssuePattern> patterns = Lists.newLinkedList();
+ List<IssuePattern> patterns = new LinkedList<>();
String[] patternsLines = StringUtils.split(patternsList, "\n");
for (String patternLine : patternsLines) {
IssuePattern pattern = decodeLine(patternLine.trim());
*/
package org.sonar.scanner.issue.ignore.scanner;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashSet;
import java.util.List;
import java.util.Set;
public IssueExclusionsRegexpScanner(IssueExclusionPatternInitializer patternsInitializer) {
this.exclusionPatternInitializer = patternsInitializer;
- lineExclusions = Lists.newArrayList();
- allFilePatterns = Lists.newArrayList();
- blockMatchers = Lists.newArrayList();
+ lineExclusions = new ArrayList<>();
+ allFilePatterns = new ArrayList<>();
+ blockMatchers = new ArrayList<>();
for (IssuePattern pattern : patternsInitializer.getAllFilePatterns()) {
allFilePatterns.add(java.util.regex.Pattern.compile(pattern.getAllFileRegexp()));
LOG.debug("Scanning {}", resource);
init();
- List<String> lines = FileUtils.readLines(file, sourcesEncoding.name());
+ List<String> lines = Files.readAllLines(file.toPath(), sourcesEncoding);
int lineIndex = 0;
for (String line : lines) {
lineIndex++;
}
private Set<LineRange> convertLineExclusionsToLineRanges() {
- Set<LineRange> lineRanges = Sets.newHashSet();
+ Set<LineRange> lineRanges = new HashSet<>(lineExclusions.size());
for (LineExclusion lineExclusion : lineExclusions) {
lineRanges.add(lineExclusion.toLineRange());
}
*/
package org.sonar.scanner.issue.tracking;
-import com.google.common.base.Function;
+import java.util.function.Function;
+
import javax.annotation.Nullable;
import org.sonar.api.batch.ScannerSide;
import org.sonar.api.batch.fs.InputComponent;
*/
package org.sonar.scanner.issue.tracking;
-import com.google.common.collect.ImmutableSet;
import org.sonar.api.batch.fs.InputFile.Status;
import org.sonar.api.batch.fs.internal.DefaultInputFile;
import javax.annotation.CheckForNull;
import java.util.Collection;
+import java.util.Collections;
public class SourceHashHolder {
public Collection<Integer> getNewLinesMatching(Integer originLine) {
FileHashes reference = getHashedReference();
if (reference == null) {
- return ImmutableSet.of();
+ return Collections.emptySet();
} else {
return getHashedSource().getLinesForHash(reference.getHash(originLine));
}
}
}
- private ClassLoader getSensorClassLoader(Sensor sensor) {
+ private static ClassLoader getSensorClassLoader(Sensor sensor) {
if (sensor instanceof SensorWrapper) {
SensorWrapper wrapper = (SensorWrapper) sensor;
return wrapper.wrappedSensor().getClass().getClassLoader();
*/
package org.sonar.scanner.phases;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.Collection;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.batch.PostJob;
public void execute(SensorContext context) {
Collection<PostJob> postJobs = selector.select(PostJob.class, module, true, null);
- eventBus.fireEvent(new PostJobPhaseEvent(Lists.newArrayList(postJobs), true));
+ eventBus.fireEvent(new PostJobPhaseEvent(new ArrayList<>(postJobs), true));
execute(context, postJobs);
- eventBus.fireEvent(new PostJobPhaseEvent(Lists.newArrayList(postJobs), false));
+ eventBus.fireEvent(new PostJobPhaseEvent(new ArrayList<>(postJobs), false));
}
private void execute(SensorContext context, Collection<PostJob> postJobs) {
*/
package org.sonar.scanner.postjob;
-import com.google.common.base.Function;
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
+
import javax.annotation.Nullable;
import org.sonar.api.batch.AnalysisMode;
import org.sonar.api.batch.fs.InputComponent;
if (!analysisMode.isIssues()) {
throw new UnsupportedOperationException("Issues are only available to PostJobs in 'issues' mode.");
}
- return Iterables.transform(Iterables.filter(cache.all(), new ResolvedPredicate(false)), new IssueTransformer());
+ return StreamSupport.stream(cache.all().spliterator(), false)
+ .filter(new ResolvedPredicate(false))
+ .map(DefaultIssueWrapper::new)
+ .collect(Collectors.toList());
}
@Override
if (!analysisMode.isIssues()) {
throw new UnsupportedOperationException("Resolved issues are only available to PostJobs in 'issues' mode.");
}
- return Iterables.transform(Iterables.filter(cache.all(), new ResolvedPredicate(true)), new IssueTransformer());
+ return StreamSupport.stream(cache.all().spliterator(), false)
+ .filter(new ResolvedPredicate(true))
+ .map(DefaultIssueWrapper::new)
+ .collect(Collectors.toList());
}
private class DefaultIssueWrapper implements PostJobIssue {
}
}
- private class IssueTransformer implements Function<TrackedIssue, PostJobIssue> {
- @Override
- public PostJobIssue apply(TrackedIssue input) {
- return new DefaultIssueWrapper(input);
- }
- }
-
private static class ResolvedPredicate implements Predicate<TrackedIssue> {
private final boolean resolved;
}
@Override
- public boolean apply(@Nullable TrackedIssue issue) {
+ public boolean test(@Nullable TrackedIssue issue) {
if (issue != null) {
return resolved ? issue.resolution() != null : issue.resolution() == null;
}
package org.sonar.scanner.report;
import java.util.Collection;
+import java.util.stream.Collectors;
import javax.annotation.CheckForNull;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.batch.fs.internal.InputComponentTree;
import org.sonar.api.batch.fs.internal.InputModuleHierarchy;
import org.sonar.core.util.CloseableIterator;
-import org.sonar.core.util.stream.Collectors;
import org.sonar.scanner.protocol.output.ScannerReport;
import org.sonar.scanner.protocol.output.ScannerReportReader;
import org.sonar.scanner.protocol.output.ScannerReport.Component.ComponentType;
*/
package org.sonar.scanner.report;
-import com.google.common.base.Function;
-import com.google.common.collect.Iterables;
import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
import javax.annotation.Nonnull;
import org.sonar.api.config.Settings;
import org.sonar.scanner.protocol.output.ScannerReport;
import org.sonar.scanner.protocol.output.ScannerReportWriter;
import org.sonar.scanner.repository.ContextPropertiesCache;
-import static com.google.common.collect.FluentIterable.from;
import static org.sonar.core.config.WebhookProperties.ANALYSIS_PROPERTY_PREFIX;
public class ContextPropertiesPublisher implements ReportPublisherStep {
MapEntryToContextPropertyFunction transformer = new MapEntryToContextPropertyFunction();
// properties defined programmatically by plugins
- Iterable<ScannerReport.ContextProperty> fromCache = from(cache.getAll().entrySet())
- .transform(transformer);
+ Stream<ScannerReport.ContextProperty> fromCache = cache.getAll().entrySet().stream().map(transformer);
// properties that are automatically included to report so that
// they can be included to webhook payloads
- Iterable<ScannerReport.ContextProperty> fromSettings = from(settings.getProperties().entrySet())
+ Stream<ScannerReport.ContextProperty> fromSettings = settings.getProperties().entrySet().stream()
.filter(e -> e.getKey().startsWith(ANALYSIS_PROPERTY_PREFIX))
- .transform(transformer);
+ .map(transformer);
- writer.writeContextProperties(Iterables.concat(fromCache, fromSettings));
+ writer.writeContextProperties(Stream.concat(fromCache, fromSettings).collect(Collectors.toList()));
}
private static final class MapEntryToContextPropertyFunction implements Function<Map.Entry<String, String>, ScannerReport.ContextProperty> {
import java.io.Serializable;
import java.util.Collections;
import java.util.Map;
+import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import org.sonar.api.batch.fs.InputComponent;
import org.sonar.api.test.MutableTestPlan;
import org.sonar.api.test.TestCase.Status;
import org.sonar.api.utils.KeyValueFormat;
-import org.sonar.core.util.stream.Collectors;
import org.sonar.scanner.deprecated.test.TestPlanBuilder;
import org.sonar.scanner.protocol.output.ScannerReport;
import org.sonar.scanner.protocol.output.ScannerReport.Measure.BoolValue;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Throwables;
-import com.google.common.io.Files;
+
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.net.URL;
import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.annotation.Nullable;
}
private void dumpMetadata(Map<String, String> metadata) {
- File file = new File(projectReactor.getRoot().getWorkDir(), METADATA_DUMP_FILENAME);
- try (Writer output = Files.newWriter(file, StandardCharsets.UTF_8)) {
+ Path file = projectReactor.getRoot().getWorkDir().toPath().resolve(METADATA_DUMP_FILENAME);
+ try (Writer output = Files.newBufferedWriter(file, StandardCharsets.UTF_8)) {
for (Map.Entry<String, String> entry : metadata.entrySet()) {
output.write(entry.getKey());
output.write("=");
*/
package org.sonar.scanner.repository;
-import com.google.common.base.Function;
import java.io.IOException;
import java.io.InputStream;
+import java.util.function.Function;
+
import org.apache.commons.io.IOUtils;
import org.sonar.scanner.bootstrap.ScannerWsClient;
import org.sonar.scanner.protocol.input.ScannerInput.ServerIssue;
*/
package org.sonar.scanner.repository;
-import com.google.common.base.Function;
+import java.util.function.Function;
+
import org.sonar.scanner.protocol.input.ScannerInput.ServerIssue;
public interface ServerIssuesLoader {
import org.sonar.api.utils.DateUtils;
import org.sonarqube.ws.QualityProfiles.SearchWsResponse.QualityProfile;
-import com.google.common.collect.ImmutableMap;
import org.sonar.api.batch.ScannerSide;
import javax.annotation.CheckForNull;
import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.Map;
/**
private final Map<String, QProfile> byLanguage;
public ModuleQProfiles(Collection<QualityProfile> profiles) {
- ImmutableMap.Builder<String, QProfile> builder = ImmutableMap.builder();
+ Map<String, QProfile> map = new HashMap<>(profiles.size());
for (QualityProfile qProfile : profiles) {
- builder.put(qProfile.getLanguage(),
+ map.put(qProfile.getLanguage(),
new QProfile()
.setKey(qProfile.getKey())
.setName(qProfile.getName())
.setLanguage(qProfile.getLanguage())
.setRulesUpdatedAt(DateUtils.parseDateTime(qProfile.getRulesUpdatedAt())));
}
- byLanguage = builder.build();
+ byLanguage = Collections.unmodifiableMap(map);
}
public Collection<QProfile> findAll() {
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import java.util.stream.Collectors;
+
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;
import org.sonar.api.rules.Rule;
import org.sonar.api.rules.RuleFinder;
import org.sonar.api.rules.RuleQuery;
-import org.sonar.core.util.stream.Collectors;
public class RuleFinderCompatibility implements RuleFinder {
private Collection<Rule> byRepository(RuleQuery query) {
return rules.findByRepository(query.getRepositoryKey()).stream()
.map(RuleFinderCompatibility::toRule)
- .collect(Collectors.toArrayList());
+ .collect(Collectors.toList());
}
private Collection<Rule> byKey(RuleQuery query) {
private Collection<Rule> byInternalKey(RuleQuery query) {
return rules.findByInternalKey(query.getRepositoryKey(), query.getConfigKey()).stream()
.map(RuleFinderCompatibility::toRule)
- .collect(Collectors.toArrayList());
+ .collect(Collectors.toList());
}
@CheckForNull
*/
package org.sonar.scanner.rule;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
if (qProfile != null) {
return new RulesProfileWrapper(select(qProfile, activeRules));
}
- return new RulesProfileWrapper(Lists.<RulesProfile>newArrayList());
+ return new RulesProfileWrapper(new ArrayList<>());
}
private static RulesProfile loadProfiles(ModuleQProfiles qProfiles, ActiveRules activeRules) {
- Collection<RulesProfile> dtos = Lists.newArrayList();
- for (QProfile qProfile : qProfiles.findAll()) {
+ Collection<QProfile> profiles = qProfiles.findAll();
+ Collection<RulesProfile> dtos = new ArrayList<>(profiles.size());
+ for (QProfile qProfile : profiles) {
dtos.add(select(qProfile, activeRules));
}
return new RulesProfileWrapper(dtos);
*/
package org.sonar.scanner.rule;
-import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.profiles.RulesProfile;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Collections;
import java.util.List;
/**
}
public RulesProfileWrapper(RulesProfile profile) {
- this.profiles = Lists.newArrayList(profile);
+ this.profiles = Collections.singletonList(profile);
this.singleLanguageProfile = profile;
}
*/
package org.sonar.scanner.scan;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
* From root to given project
*/
static List<ProjectDefinition> getTopDownParentProjects(ProjectDefinition project) {
- List<ProjectDefinition> result = Lists.newArrayList();
+ List<ProjectDefinition> result = new ArrayList<>();
ProjectDefinition p = project;
while (p != null) {
result.add(0, p);
package org.sonar.scanner.scan.filesystem;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.Lists;
import java.io.File;
import java.nio.charset.Charset;
+import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.CoreProperties;
private FileIndexer indexer;
private Settings settings;
- private List<File> sourceDirsOrFiles = Lists.newArrayList();
- private List<File> testDirsOrFiles = Lists.newArrayList();
+ private List<File> sourceDirsOrFiles = new ArrayList<>();
+ private List<File> testDirsOrFiles = new ArrayList<>();
private boolean initialized;
private Charset charset = null;
package org.sonar.scanner.scan.filesystem;
import com.google.common.base.Joiner;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.CheckForNull;
/**
* Lower-case extension -> languages
*/
- private final Map<String, PathPattern[]> patternsByLanguage = Maps.newLinkedHashMap();
- private final List<String> languagesToConsider = Lists.newArrayList();
+ private final Map<String, PathPattern[]> patternsByLanguage = new LinkedHashMap<>();
+ private final List<String> languagesToConsider = new ArrayList<>();
private final String forcedLanguage;
public LanguageDetection(Settings settings, LanguagesRepository languages) {
*/
package org.sonar.scanner.scan.filesystem;
-import com.google.common.collect.Lists;
import java.io.File;
+import java.util.ArrayList;
import java.util.List;
import org.apache.commons.io.FileUtils;
import org.sonar.api.batch.ScannerSide;
private File baseDir;
private File workingDir;
- private List<File> sourceDirsOrFiles = Lists.newArrayList();
- private List<File> testDirsOrFiles = Lists.newArrayList();
+ private List<File> sourceDirsOrFiles = new ArrayList<>();
+ private List<File> testDirsOrFiles = new ArrayList<>();
public ModuleFileSystemInitializer(ProjectDefinition module, TempFolder tempUtils, PathResolver pathResolver) {
baseDir = module.getBaseDir();
*/
package org.sonar.scanner.scan.measure;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.sonar.api.measures.Metric;
public final class DeprecatedMetricFinder implements MetricFinder {
- private Map<String, Metric> metricsByKey = Maps.newLinkedHashMap();
- private Map<Integer, Metric> metricsById = Maps.newLinkedHashMap();
+ private Map<String, Metric> metricsByKey = new LinkedHashMap<>();
+ private Map<Integer, Metric> metricsById = new LinkedHashMap<>();
public DeprecatedMetricFinder(MetricsRepository metricsRepository) {
for (Metric metric : metricsRepository.metrics()) {
@Override
public Collection<Metric> findAll(List<String> metricKeys) {
- List<Metric> result = Lists.newLinkedList();
+ List<Metric> result = new LinkedList<>();
for (String metricKey : metricKeys) {
Metric metric = findByKey(metricKey);
if (metric != null) {
*/
package org.sonar.scanner.scan.report;
-import com.google.common.collect.Maps;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
public final class ResourceReport {
private final InputComponent component;
private final IssueVariation total = new IssueVariation();
- private final Map<ReportRuleKey, RuleReport> ruleReportByRuleKey = Maps.newHashMap();
+ private final Map<ReportRuleKey, RuleReport> ruleReportByRuleKey = new HashMap<>();
private List<TrackedIssue> issues = new ArrayList<>();
- private Map<Integer, List<TrackedIssue>> issuesPerLine = Maps.newHashMap();
- private Map<Integer, List<TrackedIssue>> newIssuesPerLine = Maps.newHashMap();
- private Map<Rule, AtomicInteger> issuesByRule = Maps.newHashMap();
- private Map<RulePriority, AtomicInteger> issuesBySeverity = Maps.newHashMap();
+ private Map<Integer, List<TrackedIssue>> issuesPerLine = new HashMap<>();
+ private Map<Integer, List<TrackedIssue>> newIssuesPerLine = new HashMap<>();
+ private Map<Rule, AtomicInteger> issuesByRule = new HashMap<>();
+ private Map<RulePriority, AtomicInteger> issuesBySeverity = new EnumMap<>(RulePriority.class);
public ResourceReport(InputComponent component) {
this.component = component;
*/
package org.sonar.scanner.source;
-import com.google.common.collect.Lists;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
* Used when no plugin is defining some CodeColorizerFormat
*/
public CodeColorizers() {
- this(Lists.<CodeColorizerFormat>newArrayList());
+ this(new ArrayList<>());
}
@CheckForNull
*/
package org.sonar.scanner.source;
-import com.google.common.base.Function;
-import com.google.common.collect.Sets;
import java.util.Map;
import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.StreamSupport;
+
import org.sonar.api.batch.Phase;
import org.sonar.api.batch.fs.FileSystem;
import org.sonar.api.batch.fs.InputFile;
import org.sonar.api.batch.sensor.measure.internal.DefaultMeasure;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.utils.KeyValueFormat;
+import org.sonar.core.util.stream.Collectors;
import org.sonar.scanner.scan.measure.MeasureCache;
import org.sonar.scanner.sensor.coverage.CoverageExclusions;
-import static com.google.common.collect.Iterables.transform;
-import static com.google.common.collect.Sets.newHashSet;
+import com.google.common.collect.Sets;
@Phase(name = Phase.Name.POST)
public final class ZeroCoverageSensor implements Sensor {
}
private boolean isCoverageMeasuresAlreadyDefined(InputFile f) {
- Set<String> metricKeys = newHashSet(transform(measureCache.byComponentKey(f.key()), new MeasureToMetricKey()));
+ Set<String> metricKeys = StreamSupport.stream(measureCache.byComponentKey(f.key()).spliterator(), false)
+ .map(new MeasureToMetricKey()).collect(Collectors.toSet());
Function<Metric, String> metricToKey = new MetricToKey();
- Set<String> allCoverageMetricKeys = newHashSet(transform(CoverageType.UNIT.allMetrics(), metricToKey));
+ Set<String> allCoverageMetricKeys = CoverageType.UNIT.allMetrics().stream().map(metricToKey).collect(Collectors.toSet());
return !Sets.intersection(metricKeys, allCoverageMetricKeys).isEmpty();
}
package org.sonar.scanner.storage;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
import com.persistit.Exchange;
import com.persistit.Persistit;
import com.persistit.Value;
import com.persistit.encoding.CoderManager;
import com.persistit.encoding.ValueCoder;
import com.persistit.exception.PersistitException;
+
+import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import org.picocontainer.Startable;
@ScannerSide
public class Storages implements Startable {
- private final Map<String, Exchange> cacheMap = Maps.newHashMap();
+ private final Map<String, Exchange> cacheMap = new HashMap<>();
private Persistit persistit;
private Volume volume;
*/
package org.sonar.scanner.mediumtest;
-import com.google.common.base.Function;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;
import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.Properties;
+import java.util.function.Function;
+
import javax.annotation.Nullable;
import org.apache.commons.io.FileUtils;
import org.sonar.api.CoreProperties;
import org.sonar.scanner.WsTestUtil;
import org.sonar.scanner.bootstrap.ScannerWsClient;
-import org.sonar.scanner.protocol.input.ScannerInput;
import org.sonar.scanner.protocol.input.ScannerInput.ServerIssue;
import org.sonar.scanner.repository.DefaultServerIssuesLoader;
-import com.google.common.base.Function;
import org.junit.Before;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
+import java.util.function.Function;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
WsTestUtil.mockStream(wsClient, "/batch/issues.protobuf?key=foo", is);
final List<ServerIssue> result = new ArrayList<>();
- loader.load("foo", new Function<ScannerInput.ServerIssue, Void>() {
-
- @Override
- public Void apply(ServerIssue input) {
- result.add(input);
- return null;
- }
+ loader.load("foo", issue -> {
+ result.add(issue);
+ return null;
});
assertThat(result).extracting("key").containsExactly("ab1", "ab2");
projects / sonarqube.git / commitdiff