/*
* SonarQube
* Copyright (C) 2009-2017 SonarSource SA
* mailto:info AT sonarsource DOT com
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.sonar.core.issue.tracking;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.Objects;
import javax.annotation.Nonnull;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.batch.ScannerSide;
import org.sonar.api.batch.InstantiationStrategy;
import org.sonar.api.rule.RuleKey;
@InstantiationStrategy(InstantiationStrategy.PER_BATCH)
@ScannerSide
public class Tracker<RAW extends Trackable, BASE extends Trackable> {
public Tracking<RAW, BASE> track(Input<RAW> rawInput, Input<BASE> baseInput) {
Tracking<RAW, BASE> tracking = new Tracking<>(rawInput, baseInput);
// 1. match issues with same rule, same line and same line hash, but not necessarily with same message
match(tracking, LineAndLineHashKeyFactory.INSTANCE);
// 2. detect code moves by comparing blocks of codes
detectCodeMoves(rawInput, baseInput, tracking);
// 3. match issues with same rule, same message and same line hash
match(tracking, LineHashAndMessageKeyFactory.INSTANCE);
// 4. match issues with same rule, same line and same message
match(tracking, LineAndMessageKeyFactory.INSTANCE);
// 5. match issues with same rule and same line hash but different line and different message.
// See SONAR-2812
match(tracking, LineHashKeyFactory.INSTANCE);
return tracking;
}
private void detectCodeMoves(Input<RAW> rawInput, Input<BASE> baseInput, Tracking<RAW, BASE> tracking) {
if (!tracking.isComplete()) {
new BlockRecognizer<RAW, BASE>().match(rawInput, baseInput, tracking);
}
}
private void match(Tracking<RAW, BASE> tracking, SearchKeyFactory factory) {
if (tracking.isComplete()) {
return;
}
Multimap<SearchKey, BASE> baseSearch = ArrayListMultimap.create();
for (BASE base : tracking.getUnmatchedBases()) {
baseSearch.put(factory.create(base), base);
}
for (RAW raw : tracking.getUnmatchedRaws()) {
SearchKey rawKey = factory.create(raw);
Collection<BASE> bases = baseSearch.get(rawKey);
if (!bases.isEmpty()) {
// TODO taking the first one. Could be improved if there are more than 2 issues on the same line.
// Message could be checked to take the best one.
BASE match = bases.iterator().next();
tracking.match(raw, match);
baseSearch.remove(rawKey, match);
}
}
}
private interface SearchKey {
}
private interface SearchKeyFactory {
SearchKey create(Trackable trackable);
}
private static class LineAndLineHashKey implements SearchKey {
private final RuleKey ruleKey;
private final String lineHash;
private final Integer line;
LineAndLineHashKey(Trackable trackable) {
this.ruleKey = trackable.getRuleKey();
this.line = trackable.getLine();
this.lineHash = StringUtils.defaultString(trackable.getLineHash(), "");
}
@Override
public boolean equals(@Nonnull Object o) {
if (this == o) {
return true;
}
LineAndLineHashKey that = (LineAndLineHashKey) o;
// start with most discriminant field
return Objects.equals(line, that.line)
&& lineHash.equals(that.lineHash)
&& ruleKey.equals(that.ruleKey);
}
@Override
public int hashCode() {
int result = ruleKey.hashCode();
result = 31 * result + lineHash.hashCode();
result = 31 * result + (line != null ? line.hashCode() : 0);
return result;
}
}
private enum LineAndLineHashKeyFactory implements SearchKeyFactory {
INSTANCE;
@Override
public SearchKey create(Trackable t) {
return new LineAndLineHashKey(t);
}
}
private static class LineHashAndMessageKey implements SearchKey {
private final RuleKey ruleKey;
private final String message;
private final String lineHash;
LineHashAndMessageKey(Trackable trackable) {
this.ruleKey = trackable.getRuleKey();
this.message = trackable.getMessage();
this.lineHash = StringUtils.defaultString(trackable.getLineHash(), "");
}
@Override
public boolean equals(@Nonnull Object o) {
if (this == o) {
return true;
}
LineHashAndMessageKey that = (LineHashAndMessageKey) o;
// start with most discriminant field
return lineHash.equals(that.lineHash)
&& message.equals(that.message)
&& ruleKey.equals(that.ruleKey);
}
@Override
public int hashCode() {
int result = ruleKey.hashCode();
result = 31 * result + message.hashCode();
result = 31 * result + lineHash.hashCode();
return result;
}
}
private enum LineHashAndMessageKeyFactory implements SearchKeyFactory {
INSTANCE;
@Override
public SearchKey create(Trackable t) {
return new LineHashAndMessageKey(t);
}
}
private static class LineAndMessageKey implements SearchKey {
private final RuleKey ruleKey;
private final String message;
private final Integer line;
LineAndMessageKey(Trackable trackable) {
this.ruleKey = trackable.getRuleKey();
this.message = trackable.getMessage();
this.line = trackable.getLine();
}
@Override
public boolean equals(@Nonnull Object o) {
if (this == o) {
return true;
}
LineAndMessageKey that = (LineAndMessageKey) o;
// start with most discriminant field
return Objects.equals(line, that.line)
&& message.equals(that.message)
&& ruleKey.equals(that.ruleKey);
}
@Override
public int hashCode() {
int result = ruleKey.hashCode();
result = 31 * result + message.hashCode();
result = 31 * result + (line != null ? line.hashCode() : 0);
return result;
}
}
private enum LineAndMessageKeyFactory implements SearchKeyFactory {
INSTANCE;
@Override
public SearchKey create(Trackable t) {
return new LineAndMessageKey(t);
}
}
private static class LineHashKey implements SearchKey {
private final RuleKey ruleKey;
private final String lineHash;
LineHashKey(Trackable trackable) {
this.ruleKey = trackable.getRuleKey();
this.lineHash = StringUtils.defaultString(trackable.getLineHash(), "");
}
@Override
public boolean equals(@Nonnull Object o) {
if (this == o) {
return true;
}
LineHashKey that = (LineHashKey) o;
// start with most discriminant field
return lineHash.equals(that.lineHash)
&& ruleKey.equals(that.ruleKey);
}
@Override
public int hashCode() {
int result = ruleKey.hashCode();
result = 31 * result + lineHash.hashCode();
return result;
}
}
private enum LineHashKeyFactory implements SearchKeyFactory {
INSTANCE;
@Override
public SearchKey create(Trackable t) {
return new LineHashKey(t);
}
}
}