Add parser for Python coverage

src/main/java/edu/hm/hafner/coverage/CoverageParser.java

@@ -207,4 +207,16 @@
     protected static ParsingException createEofException(final String fileName) {
         return new ParsingException("Unexpected end of file '%s'", fileName);
     }
+
+    protected static Value createValue(final String currentType, final int covered, final int missed) {
+        if (currentType.equals("COMPLEXITY")) {
+            return new CyclomaticComplexity(covered + missed);
+        }
+        else {
+            var builder = new Coverage.CoverageBuilder();
+            return builder.withMetric(Metric.valueOf(currentType))
+                    .withCovered(covered)
+                    .withMissed(missed).build();
+        }
+    }
 }

src/main/java/edu/hm/hafner/coverage/parser/JacocoParser.java

@@ -15,16 +15,16 @@
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 
 import edu.hm.hafner.coverage.ClassNode;
 import edu.hm.hafner.coverage.Coverage.CoverageBuilder;
 import edu.hm.hafner.coverage.CoverageParser;
 import edu.hm.hafner.coverage.CyclomaticComplexity;
 import edu.hm.hafner.coverage.FileNode;
 import edu.hm.hafner.coverage.MethodNode;
 import edu.hm.hafner.coverage.Metric;
 import edu.hm.hafner.coverage.ModuleNode;
 import edu.hm.hafner.coverage.Node;
 import edu.hm.hafner.coverage.PackageNode;
 import edu.hm.hafner.coverage.Value;
 import edu.hm.hafner.util.FilteredLog;
 import edu.hm.hafner.util.PathUtil;
 import edu.hm.hafner.util.SecureXmlParserFactory;
@@ -316,16 +316,4 @@
             }
         }
     }
-
-    private Value createValue(final String currentType, final int covered, final int missed) {
-        if (VALUE_COMPLEXITY.equals(currentType)) {
-            return new CyclomaticComplexity(covered + missed);
-        }
-        else {
-            var builder = new CoverageBuilder();
-            return builder.withMetric(Metric.valueOf(currentType))
-                        .withCovered(covered)
-                        .withMissed(missed).build();
-        }
-    }
 }

src/main/java/edu/hm/hafner/coverage/parser/PythonParser.java

@@ -0,0 +1,230 @@
+package edu.hm.hafner.coverage.parser;
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import edu.hm.hafner.coverage.*;
+import edu.hm.hafner.util.FilteredLog;
+import edu.hm.hafner.util.SecureXmlParserFactory;
+import edu.hm.hafner.util.TreeString;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLEventReader;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.StartElement;
+import javax.xml.stream.events.XMLEvent;
+import java.io.Reader;
+
+public class PythonParser extends CoverageParser {
+    private static final java.util.logging.Logger LOGGER = java.util.logging.Logger.getLogger(PythonParser.class.getName());
+
+    private static final long serialVersionUID = -2343357235229921679L;
+
+    private static final QName COVERAGE = new QName("coverage");
+    private static final QName LINES_VALID = new QName("lines-valid");
+    private static final QName LINES_COVERED = new QName("lines-covered");
+    private static final QName PACKAGES = new QName("packages");
+    private static final QName PACKAGE = new QName("package");
+    private static final QName FILENAME = new QName("filename");
+    private static final QName CLASSES = new QName("classes");
+    private static final QName CLASS = new QName("class");
+    private static final QName METHODS = new QName("methods");
+    private static final QName LINES = new QName("lines");
+    private static final QName LINE = new QName("line");
+    private static final QName NUMBER = new QName("number");
+    private static final QName HITS = new QName("hits");
+    private static final QName NAME = new QName("name");
+
+
+    public PythonParser(ProcessingMode processingMode) {
+        super(processingMode);
+    }
+
+
+    @Override
+    protected ModuleNode parseReport(Reader reader, String fileName, FilteredLog log) {
+        ModuleNode root = null;
+        try {
+            var factory = new SecureXmlParserFactory();
+            var eventReader = factory.createXmlEventReader(reader);
+
+            while (eventReader.hasNext()) {
+                XMLEvent event = eventReader.nextEvent();
+
+                if (event.isStartElement()) {
+                    var startElement = event.asStartElement();
+                    var tagName = startElement.getName();
+                    if (COVERAGE.equals(tagName)) {
+                        root = new ModuleNode("");
+                        var linesValid = getIntegerValueOf(startElement, LINES_VALID);
+                        var linesCovered = getIntegerValueOf(startElement, LINES_COVERED);
+                        root.addValue(createValue("LINE", linesCovered, linesValid - linesCovered));
+                        if (readCoverage(eventReader, root, fileName) == null) {
+                            handleEmptyResults(fileName, log);
+                        } else {
+                            return root;
+                        }
+                    }
+                }
+            }
+            handleEmptyResults(fileName, log);
+
+            return new ModuleNode("empty");
+        }
+        catch (XMLStreamException exception) {
+            throw new SecureXmlParserFactory.ParsingException(exception);
+        }
+    }
+
+    @CanIgnoreReturnValue
+    private ModuleNode readCoverage(final XMLEventReader reader, final ModuleNode module, String fileName)
+            throws XMLStreamException {
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+
+            if (event.isStartElement()) {
+                var startElement = event.asStartElement();
+                if (PACKAGES.equals(startElement.getName())) {
+                    readPackages(reader, module, fileName);
+                }
+            } else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (COVERAGE.equals((endElement.getName()))) {
+                    if (module.hasChildren()) {
+                        return module;
+                    } else {
+                        return null;
+                    }
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    @CanIgnoreReturnValue
+    private Node readPackages(final XMLEventReader reader, final ModuleNode root, final String fileName) throws XMLStreamException {
+        while (reader.hasNext()) {
+            var event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var startElement = event.asStartElement();
+                if (PACKAGE.equals(startElement.getName())) {
+                    readPackage(reader, root, startElement, fileName);
+                }
+            } else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (PACKAGES.equals(endElement.getName())) {
+                    return root;
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    @CanIgnoreReturnValue
+    private PackageNode readPackage(final XMLEventReader reader, final ModuleNode root, final StartElement startElement, String fileName)
+            throws XMLStreamException {
+        var packageName = getValueOf(startElement, NAME);
+        var packageNode = root.findOrCreatePackageNode(packageName);
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+
+            if (event.isStartElement()) {
+                var nextElement = event.asStartElement();
+                if (CLASSES.equals(nextElement.getName())) {
+                    readClasses(reader, packageNode, fileName);
+                }
+            }
+            else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (PACKAGE.equals(endElement.getName())) {
+                    return packageNode;
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    @CanIgnoreReturnValue
+    private Node readClasses(final XMLEventReader reader, final PackageNode packageNode, String fileName) throws XMLStreamException {
+        while (reader.hasNext()) {
+            var event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var startElement = event.asStartElement();
+                if (CLASS.equals(startElement.getName())) {
+                    readClass(reader, packageNode, startElement, fileName);
+                }
+            } else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (CLASSES.equals(endElement.getName())) {
+                    return packageNode;
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    @CanIgnoreReturnValue
+    private ClassNode readClass(final XMLEventReader reader, final PackageNode packageNode, final StartElement startElement, String fileName) throws XMLStreamException {
+        String className = getValueOf(startElement, NAME);
+        String filePath = getValueOf(startElement, FILENAME);
+        if (!filePath.contains("/")) {
+            filePath = "./" + filePath; // Workaround for Nodes needing unique names where ClassName=FileName, and prepending the current working dir to filepath if file is located in current dir
+        }
+        FileNode fileNode = packageNode.findOrCreateFileNode(className, TreeString.valueOf(filePath));
+        ClassNode classNode = fileNode.findOrCreateClassNode(className);
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var e = event.asStartElement();
+                // TODO methods(?) seems to be empty block
+                if (LINES.equals(e.getName())) {
+                    readLines(reader, fileNode, fileName);
+                } else {
+                    LOGGER.warning("Unexpected element in <class> block: " + e.getName());
+                }
+            } else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (CLASS.equals(endElement.getName())) {
+                    resolveLines(fileNode);
+                    return classNode;
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    @CanIgnoreReturnValue
+    private Node readLines(final XMLEventReader reader, final FileNode fileNode, String fileName) throws XMLStreamException {
+        while (reader.hasNext()) {
+            XMLEvent event = reader.nextEvent();
+            if (event.isStartElement()) {
+                var nextElement = event.asStartElement();
+                if (LINE.equals(nextElement.getName())) {
+                    readLine(fileNode, nextElement);
+                }
+            } else if (event.isEndElement()) {
+                var endElement = event.asEndElement();
+                if (LINES.equals(endElement.getName())) {
+                    return fileNode;
+                }
+            }
+        }
+        throw createEofException(fileName);
+    }
+
+    private void readLine(final FileNode fileNode, StartElement element) {
+        int lineNumber = getIntegerValueOf(element, NUMBER);
+        int hits = getIntegerValueOf(element, HITS);
+        if (hits > 0) {
+            fileNode.addCounters(lineNumber, hits, 0);
+        } else {
+            fileNode.addCounters(lineNumber, 0, 1);
+        }
+    }
+
+    private void resolveLines(final FileNode fileNode) {
+        var val = createValue("LINE", fileNode.getCoveredLines().size(), fileNode.getMissedLines().size());
+        fileNode.addValue(val);
+        for (ClassNode c: fileNode.getAllClassNodes()) {
+            c.addValue(val);
+        }
+    }
+}

src/main/java/edu/hm/hafner/coverage/registry/ParserRegistry.java

@@ -1,16 +1,10 @@
 package edu.hm.hafner.coverage.registry;
 
+import edu.hm.hafner.coverage.parser.*;
 import org.apache.commons.lang3.StringUtils;
 
 import edu.hm.hafner.coverage.CoverageParser;
 import edu.hm.hafner.coverage.CoverageParser.ProcessingMode;
-import edu.hm.hafner.coverage.parser.CoberturaParser;
-import edu.hm.hafner.coverage.parser.JacocoParser;
-import edu.hm.hafner.coverage.parser.JunitParser;
-import edu.hm.hafner.coverage.parser.NunitParser;
-import edu.hm.hafner.coverage.parser.OpenCoverParser;
-import edu.hm.hafner.coverage.parser.PitestParser;
-import edu.hm.hafner.coverage.parser.XunitParser;
 
 /**
  * Provides a registry for all available {@link CoverageParserType parsers}.
@@ -26,7 +20,8 @@
         JACOCO,
         PIT,
         JUNIT,
-        XUNIT
+        XUNIT,
+        PYTHON
     }
 
     /**
@@ -58,7 +53,7 @@
      *
      * @return the created parser
      */
     public CoverageParser get(final CoverageParserType parser, final ProcessingMode processingMode) {
         switch (parser) {
             case COBERTURA:
                 return new CoberturaParser(processingMode);
@@ -74,6 +69,8 @@
                 return new JunitParser(processingMode);
             case XUNIT:
                 return new XunitParser(processingMode);
+            case PYTHON:
+                return new PythonParser(processingMode);
         }
         throw new IllegalArgumentException("Unknown parser type: " + parser);
     }

src/test/java/edu/hm/hafner/coverage/parser/PythonParserTest.java

@@ -0,0 +1,66 @@
+package edu.hm.hafner.coverage.parser;
+
+import edu.hm.hafner.coverage.CoverageParser;
+import edu.hm.hafner.coverage.FileNode;
+import edu.hm.hafner.coverage.assertions.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class PythonParserTest extends AbstractParserTest {
+
+
+    @Override
+    protected String getFolder() {
+        return "python";
+    }
+
+    @Override
+    PythonParser createParser(CoverageParser.ProcessingMode processingMode) {
+        return new PythonParser(processingMode);
+    }
+
+    @Test
+    void testBasic() throws Exception {
+        var root = readReport("coverage.xml");
+        for (FileNode f: root.getAllFileNodes()) {
+            switch (f.getRelativePath()) {
+                case "src/__init__.py":
+                    Assertions.assertThat(f).hasMissedLines(8).hasCoveredLines(1,2,4,5,7,10,12,13,14,16);
+                    break;
+                case "src/file1.py":
+                    Assertions.assertThat(f).hasMissedLines(12,13,17,18,19,20,21,22,23,25,29)
+                            .hasCoveredLines(1,2,3,4,5,7,10,11,15);
+                    break;
+                case "src/dir/__init__.py":
+                    Assertions.assertThat(f).hasMissedLines().hasCoveredLines();
+                    break;
+                case "src/dir/file2.py":
+                    Assertions.assertThat(f)
+                            .hasMissedLines(26,27,28,29,30,31,36,37,38,39,40,42,43,45,53,54,65,66,68,69,70,72,73,77,80,82,86,87,88,90,91,92,93,94,95,96,97)
+                            .hasCoveredLines(1,2,3,4,5,6,7,8,10,13,14,33,84,85);
+                    break;
+                default:
+                    throw new Exception("Unexpected file: " + f.getRelativePath());
+            }
+        }
+    }
+
+    @Test
+    void testWorkspace() throws Exception {
+        var root = readReport("coverage-2.xml");
+        for (FileNode f: root.getAllFileNodes()) {
+            switch (f.getRelativePath()) {
+                case "./__init__.py":
+                    Assertions.assertThat(f).hasMissedLines().hasCoveredLines();
+                    break;
+                case "./components.py":
+                    Assertions.assertThat(f).hasMissedLines()
+                            .hasCoveredLines(1,3,6,15,18);
+                    break;
+                default:
+                    throw new Exception("Unexpected file: " + f.getRelativePath());
+            }
+        }
+    }
+}