public List<Block> parse(
ComponentDto component, @Nullable String duplicationsData, DbSession session) {
Map<String, ComponentDto> componentsByKey = newHashMap();
List<Block> blocks = newArrayList();
if (duplicationsData != null) {
try {
SMInputFactory inputFactory = initStax();
SMHierarchicCursor root =
inputFactory.rootElementCursor(new StringReader(duplicationsData));
root.advance(); // <duplications>
SMInputCursor cursor = root.childElementCursor("g");
while (cursor.getNext() != null) {
List<Duplication> duplications = newArrayList();
SMInputCursor bCursor = cursor.childElementCursor("b");
while (bCursor.getNext() != null) {
String from = bCursor.getAttrValue("s");
String size = bCursor.getAttrValue("l");
String componentKey = bCursor.getAttrValue("r");
if (from != null && size != null && componentKey != null) {
duplications.add(
createDuplication(componentsByKey, from, size, componentKey, session));
}
}
Collections.sort(
duplications, new DuplicationComparator(component.uuid(), component.projectUuid()));
blocks.add(new Block(duplications));
}
Collections.sort(blocks, new BlockComparator());
} catch (XMLStreamException e) {
throw new IllegalStateException("XML is not valid", e);
}
}
return blocks;
}
public List<Rule> parse(Reader reader) {
XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
xmlFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.FALSE);
// just so it won't try to load DTD in if there's DOCTYPE
xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
xmlFactory.setProperty(XMLInputFactory.IS_VALIDATING, Boolean.FALSE);
SMInputFactory inputFactory = new SMInputFactory(xmlFactory);
try {
SMHierarchicCursor rootC = inputFactory.rootElementCursor(reader);
rootC.advance(); // <rules>
List<Rule> rules = new ArrayList<>();
SMInputCursor rulesC = rootC.childElementCursor("rule");
while (rulesC.getNext() != null) {
// <rule>
Rule rule = Rule.create();
rules.add(rule);
processRule(rule, rulesC);
}
return rules;
} catch (XMLStreamException e) {
throw new SonarException("XML is not valid", e);
}
}
private void loadRuleKeys() {
XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
xmlFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.FALSE);
// just so it won't try to load DTD in if there's DOCTYPE
xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
xmlFactory.setProperty(XMLInputFactory.IS_VALIDATING, Boolean.FALSE);
SMInputFactory inputFactory = new SMInputFactory(xmlFactory);
InputStream inputStream =
getClass().getResourceAsStream(AndroidLintRulesDefinition.RULES_XML_PATH);
InputStreamReader reader = new InputStreamReader(inputStream, Charsets.UTF_8);
try {
SMHierarchicCursor rootC = inputFactory.rootElementCursor(reader);
rootC.advance(); // <rules>
SMInputCursor rulesC = rootC.childElementCursor("rule");
while (rulesC.getNext() != null) {
// <rule>
SMInputCursor cursor = rulesC.childElementCursor();
while (cursor.getNext() != null) {
if (StringUtils.equalsIgnoreCase("key", cursor.getLocalName())) {
String key = StringUtils.trim(cursor.collectDescendantText(false));
ruleKeys.add(key);
}
}
}
} catch (XMLStreamException e) {
throw new IllegalStateException("XML is not valid", e);
}
}
public RulesProfile parse(Reader reader, ValidationMessages messages) {
RulesProfile profile = RulesProfile.create();
SMInputFactory inputFactory = initStax();
try {
SMHierarchicCursor rootC = inputFactory.rootElementCursor(reader);
rootC.advance(); // <profile>
SMInputCursor cursor = rootC.childElementCursor();
while (cursor.getNext() != null) {
String nodeName = cursor.getLocalName();
if (StringUtils.equals("rules", nodeName)) {
SMInputCursor rulesCursor = cursor.childElementCursor("rule");
processRules(rulesCursor, profile, messages);
} else if (StringUtils.equals("name", nodeName)) {
profile.setName(StringUtils.trim(cursor.collectDescendantText(false)));
} else if (StringUtils.equals("language", nodeName)) {
profile.setLanguage(StringUtils.trim(cursor.collectDescendantText(false)));
}
}
} catch (XMLStreamException e) {
messages.addErrorText("XML is not valid: " + e.getMessage());
}
checkProfile(profile, messages);
return profile;
}
@Override
public RulesProfile importProfile(Reader reader, ValidationMessages messages) {
SMInputFactory inputFactory = initStax();
RulesProfile profile = RulesProfile.create();
try {
SMHierarchicCursor rootC = inputFactory.rootElementCursor(reader);
rootC.advance(); // <ruleset>
SMInputCursor ruleCursor = rootC.childElementCursor(RULE_NODE);
while (ruleCursor.getNext() != null) {
String ruleKey = ruleCursor.getAttrValue(RULE_CLASS_ATTR);
Rule rule = ruleFinder.findByKey(CodeNarcConstants.REPOSITORY_KEY, ruleKey);
if (rule == null) {
messages.addWarningText("CodeNarc rule '" + ruleKey + "' not found");
} else {
ActiveRule activeRule = profile.activateRule(rule, null);
processProperties(ruleCursor, activeRule);
}
}
} catch (XMLStreamException e) {
messages.addErrorText("XML is not valid: " + e.getMessage());
}
return profile;
}
@Override
public void stream(SMHierarchicCursor rootCursor) throws XMLStreamException {
rootCursor.advance();
SMInputCursor fileCursor = rootCursor.descendantElementCursor("srcfile");
while (fileCursor.getNext() != null) {
CoverageFileData data = collectCoverageData(fileCursor);
saveCoverageData(data);
}
}
/** {@inheritDoc} */
public void stream(SMHierarchicCursor rootCursor) throws javax.xml.stream.XMLStreamException {
try {
rootCursor.advance();
} catch (com.ctc.wstx.exc.WstxEOFException eofExc) {
throw new EmptyReportException();
}
SMInputCursor errorCursor = rootCursor.childElementCursor("error");
while (errorCursor.getNext() != null) {
valgrindErrors.add(parseErrorTag(errorCursor));
}
}
private void parse(SMHierarchicCursor rootCursor) throws XMLStreamException {
try {
streamHandler.stream(rootCursor);
} finally {
rootCursor.getStreamReader().closeCompletely();
}
}
/**
* Parses a processed violation file.
*
* @param file the file to parse
*/
public void parse(File file) {
SMInputFactory inputFactory = initStax();
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(file);
SMHierarchicCursor cursor =
inputFactory.rootElementCursor(new InputStreamReader(fileInputStream, getEncoding()));
SMInputCursor mainCursor = cursor.advance().childElementCursor();
parseStyleCopViolationsBloc(mainCursor);
cursor.getStreamReader().closeCompletely();
} catch (XMLStreamException e) {
throw new SonarException(
"Error while reading StyleCop result file: " + file.getAbsolutePath(), e);
} catch (FileNotFoundException e) {
throw new SonarException("Cannot find StyleCop result file: " + file.getAbsolutePath(), e);
} finally {
IOUtils.closeQuietly(fileInputStream);
}
}
public void load(RulesDefinition.NewExtendedRepository repo, Reader reader) {
XMLInputFactory xmlFactory = XMLInputFactory.newInstance();
xmlFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
xmlFactory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.FALSE);
// just so it won't try to load DTD in if there's DOCTYPE
xmlFactory.setProperty(XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
xmlFactory.setProperty(XMLInputFactory.IS_VALIDATING, Boolean.FALSE);
SMInputFactory inputFactory = new SMInputFactory(xmlFactory);
try {
SMHierarchicCursor rootC = inputFactory.rootElementCursor(reader);
rootC.advance(); // <rules>
SMInputCursor rulesC = rootC.childElementCursor("rule");
while (rulesC.getNext() != null) {
// <rule>
processRule(repo, rulesC);
}
} catch (XMLStreamException e) {
throw new IllegalStateException("XML is not valid", e);
}
}