private static void processRule(Rule rule, SMInputCursor ruleC) throws XMLStreamException {
/* BACKWARD COMPATIBILITY WITH DEPRECATED FORMAT */
String keyAttribute = ruleC.getAttrValue("key");
if (StringUtils.isNotBlank(keyAttribute)) {
rule.setKey(StringUtils.trim(keyAttribute));
}
/* BACKWARD COMPATIBILITY WITH DEPRECATED FORMAT */
String priorityAttribute = ruleC.getAttrValue("priority");
if (StringUtils.isNotBlank(priorityAttribute)) {
rule.setSeverity(RulePriority.valueOf(StringUtils.trim(priorityAttribute)));
}
List<String> tags = Lists.newArrayList();
SMInputCursor cursor = ruleC.childElementCursor();
while (cursor.getNext() != null) {
String nodeName = cursor.getLocalName();
if (StringUtils.equalsIgnoreCase("name", nodeName)) {
rule.setName(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equalsIgnoreCase("description", nodeName)) {
rule.setDescription(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equalsIgnoreCase("key", nodeName)) {
rule.setKey(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equalsIgnoreCase("configKey", nodeName)) {
rule.setConfigKey(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equalsIgnoreCase("priority", nodeName)) {
rule.setSeverity(
RulePriority.valueOf(StringUtils.trim(cursor.collectDescendantText(false))));
} else if (StringUtils.equalsIgnoreCase("cardinality", nodeName)) {
rule.setCardinality(
Cardinality.valueOf(StringUtils.trim(cursor.collectDescendantText(false))));
} else if (StringUtils.equalsIgnoreCase("status", nodeName)) {
rule.setStatus(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equalsIgnoreCase("param", nodeName)) {
processParameter(rule, cursor);
} else if (StringUtils.equalsIgnoreCase("tag", nodeName)) {
tags.add(StringUtils.trim(cursor.collectDescendantText(false)));
}
}
if (Strings.isNullOrEmpty(rule.getKey())) {
throw new SonarException("Node <key> is missing in <rule>");
}
rule.setTags(tags.toArray(new String[tags.size()]));
}
private void sortByPriority(Vector<Rule> rules) {
RulePriority priority = new RulePriority(rules);
Integer startPriority = priority.getStartPriority();
Hashtable<Integer, HashSet<Rule>> invertedRulePriority = priority.invertPriority();
OrderedSet<Integer> rulePrioritySet = new OrderedSet<Integer>(new IntComparator<Integer>());
for (Enumeration<Integer> en = invertedRulePriority.keys(); en.hasMoreElements(); ) {
rulePrioritySet.add(en.nextElement());
}
int i = 0;
Integer maxPriorityInt = null;
HashSet<Rule> priority0Set = null;
Integer currentPriority = startPriority;
boolean nextPriorityExists = true;
while (nextPriorityExists && (currentPriority != null)) {
HashSet<Rule> rulesForPriority = invertedRulePriority.get(currentPriority);
Pair<Integer, HashSet<Rule>> p =
new Pair<Integer, HashSet<Rule>>(currentPriority, rulesForPriority);
if (currentPriority.intValue() > 0) this.sortedRules.add(p);
else {
priority0Set = rulesForPriority;
}
maxPriorityInt = currentPriority;
// set next Layer
i++;
if (i < rulePrioritySet.size()) {
currentPriority = rulePrioritySet.get(i);
} else {
nextPriorityExists = false;
}
}
if (priority0Set != null && maxPriorityInt != null) {
int maxPriority = maxPriorityInt.intValue() + 1;
Pair<Integer, HashSet<Rule>> p0 =
new Pair<Integer, HashSet<Rule>>(new Integer(maxPriority), priority0Set);
this.sortedRules.add(p0);
}
}
private Rule toRule(String repositoryKey, Class clazz, org.sonar.check.Rule ruleAnnotation) {
String ruleKey = StringUtils.defaultIfEmpty(ruleAnnotation.key(), clazz.getCanonicalName());
String ruleName = StringUtils.defaultIfEmpty(ruleAnnotation.name(), null);
String description = StringUtils.defaultIfEmpty(ruleAnnotation.description(), null);
Rule rule = Rule.create(repositoryKey, ruleKey, ruleName);
rule.setDescription(description);
rule.setSeverity(RulePriority.fromCheckPriority(ruleAnnotation.priority()));
rule.setCardinality(ruleAnnotation.cardinality());
rule.setStatus(ruleAnnotation.status().name());
List<Field> fields = FieldUtils2.getFields(clazz, true);
for (Field field : fields) {
addRuleProperty(rule, field);
}
return rule;
}
private ProfileDefinition loadFromDeprecatedCheckProfile(CheckProfile cp) {
DefaultProfileDefinition definition =
DefaultProfileDefinition.create(cp.getName(), cp.getLanguage());
for (Check check : cp.getChecks()) {
RulePriority priority = null;
if (check.getPriority() != null) {
priority = RulePriority.fromCheckPriority(check.getPriority());
}
Rule rule = ruleFinder.findByKey(check.getRepositoryKey(), check.getTemplateKey());
if (rule != null) {
ActiveRule activeRule = definition.activateRule(rule, priority);
for (Map.Entry<String, String> entry : check.getProperties().entrySet()) {
activeRule.setParameter(entry.getKey(), entry.getValue());
}
}
}
return definition;
}
