private void computeTotalViolations(DecoratorContext context) {
if (context.getMeasure(CoreMetrics.VIOLATIONS) == null) {
Collection<Measure> childrenViolations = context.getChildrenMeasures(CoreMetrics.VIOLATIONS);
Double sum = MeasureUtils.sum(true, childrenViolations);
context.saveMeasure(CoreMetrics.VIOLATIONS, sum + context.getViolations().size());
}
}
void compareWithPastMeasures(DecoratorContext context, int index, List<Object[]> pastMeasures) {
Map<MeasureKey, Object[]> pastMeasuresByKey = Maps.newHashMap();
for (Object[] pastMeasure : pastMeasures) {
pastMeasuresByKey.put(new MeasureKey(pastMeasure), pastMeasure);
}
// for each measure, search equivalent past measure
for (Measure measure : context.getMeasures(MeasuresFilters.all())) {
// compare with past measure
Integer metricId =
(measure.getMetric().getId() != null
? measure.getMetric().getId()
: metricFinder.findByKey(measure.getMetric().getKey()).getId());
Integer characteristicId =
(measure.getCharacteristic() != null ? measure.getCharacteristic().getId() : null);
Integer ruleId =
(measure instanceof RuleMeasure ? ((RuleMeasure) measure).getRule().getId() : null);
Object[] pastMeasure =
pastMeasuresByKey.get(new MeasureKey(metricId, characteristicId, ruleId));
if (updateVariation(measure, pastMeasure, index)) {
context.saveMeasure(measure);
}
}
}
private void decorateResource(DecoratorContext context) {
Metric.Level globalLevel = Metric.Level.OK;
List<String> labels = Lists.newArrayList();
for (final Alert alert : profile.getAlerts()) {
Measure measure = context.getMeasure(alert.getMetric());
if (measure != null) {
Metric.Level level = AlertUtils.getLevel(alert, measure);
measure.setAlertStatus(level);
String text = getText(alert, level);
if (!StringUtils.isBlank(text)) {
measure.setAlertText(text);
labels.add(text);
}
context.saveMeasure(measure);
if (Metric.Level.WARN == level && globalLevel != Metric.Level.ERROR) {
globalLevel = Metric.Level.WARN;
} else if (Metric.Level.ERROR == level) {
globalLevel = Metric.Level.ERROR;
}
}
}
Measure globalMeasure = new Measure(CoreMetrics.ALERT_STATUS, globalLevel);
globalMeasure.setAlertStatus(globalLevel);
globalMeasure.setAlertText(StringUtils.join(labels, ", "));
context.saveMeasure(globalMeasure);
}
private void computeViolationsPerRules(DecoratorContext context) {
Map<RulePriority, Multiset<Rule>> rulesPerSeverity = Maps.newHashMap();
for (Violation violation : context.getViolations()) {
Multiset<Rule> rulesBag = initRules(rulesPerSeverity, violation.getSeverity());
rulesBag.add(violation.getRule());
}
for (RulePriority severity : RulePriority.values()) {
Metric metric = SeverityUtils.severityToViolationMetric(severity);
Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.rules(metric));
for (Measure child : children) {
RuleMeasure childRuleMeasure = (RuleMeasure) child;
Rule rule = childRuleMeasure.getRule();
if (rule != null && MeasureUtils.hasValue(childRuleMeasure)) {
Multiset<Rule> rulesBag = initRules(rulesPerSeverity, severity);
rulesBag.add(rule, childRuleMeasure.getIntValue());
}
}
Multiset<Rule> rulesBag = rulesPerSeverity.get(severity);
if (rulesBag != null) {
for (Multiset.Entry<Rule> entry : rulesBag.entrySet()) {
RuleMeasure measure =
RuleMeasure.createForRule(metric, entry.getElement(), (double) entry.getCount());
measure.setSeverity(severity);
context.saveMeasure(measure);
}
}
}
}
/** {@inheritDoc} */
public void decorate(Resource resource, DecoratorContext context) {
if (!shouldDecorateResource(resource, context)) {
return;
}
Double functions = MeasureUtils.getValue(context.getMeasure(CoreMetrics.FUNCTIONS), null);
Double complexity = MeasureUtils.getValue(context.getMeasure(CoreMetrics.COMPLEXITY), null);
if (complexity != null && functions != null && functions > 0.0) {
context.saveMeasure(CoreMetrics.FUNCTION_COMPLEXITY, complexity / functions);
}
}
private void computeViolationsPerSeverities(DecoratorContext context) {
Multiset<RulePriority> severitiesBag = HashMultiset.create();
for (Violation violation : context.getViolations()) {
severitiesBag.add(violation.getSeverity());
}
for (RulePriority severity : RulePriority.values()) {
Metric metric = SeverityUtils.severityToViolationMetric(severity);
if (context.getMeasure(metric) == null) {
Collection<Measure> children = context.getChildrenMeasures(MeasuresFilters.metric(metric));
int sum = MeasureUtils.sum(true, children).intValue() + severitiesBag.count(severity);
context.saveMeasure(metric, (double) sum);
}
}
}
/** {@inheritDoc} */
public void decorate(Resource resource, DecoratorContext context) {
if (!shouldDecorateResource(context)) {
return;
}
Measure dividend = context.getMeasure(getDividendMetric());
Measure divisor = context.getMeasure(getDivisorMetric());
if (MeasureUtils.hasValue(dividend)
&& MeasureUtils.hasValue(divisor)
&& divisor.getValue() > 0.0) {
context.saveMeasure(
new Measure(
getQuotientMetric(),
compute(dividend, divisor, getQuotientMetric().isPercentageType())));
}
}
private void saveOnRequirement(
DecoratorContext context, Map<TechnicalDebtRequirement, Double> requirementCosts) {
for (Map.Entry<TechnicalDebtRequirement, Double> entry : requirementCosts.entrySet()) {
saveCost(
context,
entry.getKey().toCharacteristic(),
entry.getValue(),
ResourceUtils.isEntity(context.getResource()));
}
}
@VisibleForTesting
void saveCost(
DecoratorContext context,
org.sonar.api.qualitymodel.Characteristic characteristic,
Double value,
boolean inMemory) {
// we need the value on projects (root or module) even if value==0 in order to display correctly
// the SQALE history chart (see SQALE-122)
// BUT we don't want to save zero-values for non top-characteristics (see SQALE-147)
if (value > 0.0
|| (ResourceUtils.isProject(context.getResource())
&& characteristic.getDepth() == org.sonar.api.qualitymodel.Characteristic.ROOT_DEPTH)) {
Measure measure = new Measure(CoreMetrics.TECHNICAL_DEBT);
measure.setCharacteristic(characteristic);
measure.setValue(value, DECIMALS_PRECISION);
if (inMemory) {
measure.setPersistenceMode(PersistenceMode.MEMORY);
}
context.saveMeasure(measure);
}
}
public void decorate(Resource resource, DecoratorContext context) {
if (!shouldDecorateResource(resource)) {
return;
}
Measure currentStatus = context.getMeasure(CoreMetrics.ALERT_STATUS);
if (currentStatus == null) {
return;
}
TimeMachineQuery query =
new TimeMachineQuery(resource)
.setOnlyLastAnalysis(true)
.setMetrics(CoreMetrics.ALERT_STATUS);
List<Measure> measures = timeMachine.getMeasures(query);
Measure pastStatus = measures != null && measures.size() == 1 ? measures.get(0) : null;
checkQualityGateStatusChange(resource, context, currentStatus, pastStatus);
}
private void saveMeasures(DecoratorContext context, List<Issue> issues) {
// group issues by requirement
ListMultimap<TechnicalDebtRequirement, Issue> issuesByRequirement = issuesByRequirement(issues);
double total = 0.0;
Map<TechnicalDebtCharacteristic, Double> characteristicCosts = newHashMap();
Map<TechnicalDebtRequirement, Double> requirementCosts = newHashMap();
for (TechnicalDebtRequirement requirement : technicalDebtModel.getAllRequirements()) {
List<Issue> requirementIssues = issuesByRequirement.get(requirement);
double value =
computeTechnicalDebt(CoreMetrics.TECHNICAL_DEBT, context, requirement, requirementIssues);
requirementCosts.put(requirement, value);
total += value;
propagateTechnicalDebtInParents(requirement.getParent(), value, characteristicCosts);
}
context.saveMeasure(new Measure(CoreMetrics.TECHNICAL_DEBT, total, DECIMALS_PRECISION));
saveOnCharacteristic(context, characteristicCosts);
saveOnRequirement(context, requirementCosts);
}
private double computeTechnicalDebt(
Metric metric,
DecoratorContext context,
TechnicalDebtRequirement requirement,
Collection<Issue> issues) {
double value = 0.0;
if (issues != null) {
for (Issue issue : issues) {
value += converter.toDays(((DefaultIssue) issue).technicalDebt());
}
}
for (Measure measure :
context.getChildrenMeasures(
MeasuresFilters.characteristic(metric, requirement.toCharacteristic()))) {
if (measure.getCharacteristic() != null
&& measure.getCharacteristic().equals(requirement.toCharacteristic())
&& measure.getValue() != null) {
value += measure.getValue();
}
}
return value;
}
private boolean shouldSaveMeasure(DecoratorContext context) {
return context.getMeasure(CoreMetrics.TECHNICAL_DEBT) == null;
}
private int sumChildren(DecoratorContext context, Metric metric) {
return MeasureUtils.sum(true, context.getChildrenMeasures(metric)).intValue();
}
protected boolean shouldDecorateResource(DecoratorContext context) {
return context.getMeasure(getQuotientMetric()) == null;
}
private void createEvent(DecoratorContext context, String name, String description) {
context.createEvent(name, description, Event.CATEGORY_ALERT, null);
}
private boolean shouldDecorateResource(Resource resource, DecoratorContext context) {
return !MeasureUtils.hasValue(context.getMeasure(CoreMetrics.FUNCTION_COMPLEXITY));
}
private void saveMeasure(DecoratorContext context, Metric metric, int value) {
context.saveMeasure(metric, (double) (value + sumChildren(context, metric)));
}
