Merge pull request #21 from DReigada/allow-specifying-parser

Allow the coverage parser to be specified

Author: rtfpessoa

src/main/scala/com/codacy/parsers/CoverageParser.scala

@@ -1,9 +1,11 @@
 package com.codacy.parsers
 
+import java.io.File
+
 import com.codacy.api.{CoverageReport, Language}
 import com.codacy.parsers.implementation.{CoberturaParser, JacocoParser}
 import com.codacy.parsers.util.XML
-import java.io.File
+
 import scala.util.Try
 import scala.xml.Elem
 
@@ -25,9 +27,17 @@ trait XMLCoverageParser extends CoverageParser {
 
 }
 
+trait CoverageParserFactory {
+  def apply(language: Language.Value, rootProject: File, reportFile: File): CoverageParser
+}
+
 object CoverageParserFactory {
 
-  def withCoverageReport[A](language: Language.Value, rootProject: File, reportFile: File)(block: CoverageReport => A): Either[String, A] = {
+  def withCoverageReport[A](language: Language.Value,
+                            rootProject: File,
+                            reportFile: File,
+                            parserFactory: Option[CoverageParserFactory] = None
+                           )(block: CoverageReport => A): Either[String, A] = {
     val isEmptyReport = {
       // just starting by detecting the simplest case: a single report file
       Try(reportFile.isFile && reportFile.length() == 0).getOrElse(false)
@@ -36,27 +46,27 @@ object CoverageParserFactory {
     if (isEmptyReport) {
       Left(s"report file is empty: ${reportFile.getAbsolutePath}")
     } else {
-      create(language, rootProject, reportFile).map {
-        parser =>
-          val report = parser.generateReport()
-          Right(block(report))
-      }.getOrElse {
-        Left(s"no parser for $language")
+      parserFactory.fold[Either[String, A]] {
+        val parsers = allParsers(language, rootProject, reportFile)
+        withReport(parsers)(s"could not parse report, unrecognized report format")(block)
+      } { parserFactory =>
+        val parser = parserFactory(language, rootProject, reportFile)
+        withReport(Seq(parser))("could not parse report with the provided parser")(block)
       }
     }
   }
 
-  private def create(language: Language.Value, rootProject: File, reportFile: File): Option[CoverageParser] = {
-    val implementations =
-      Seq(
-        new CoberturaParser(language, rootProject, reportFile),
-        new JacocoParser(language, rootProject, reportFile)
-      )
+  private def allParsers(language: Language.Value, rootProject: File, reportFile: File): Seq[CoverageParser] = {
+    Seq(
+      new CoberturaParser(language, rootProject, reportFile),
+      new JacocoParser(language, rootProject, reportFile)
+    )
+  }
 
-    implementations.collectFirst {
-      case implementation if implementation.isValidReport =>
-        implementation
-    }
+  private def withReport[A](parsers: Seq[CoverageParser])(errorMessage: String)(block: CoverageReport => A): Either[String, A] = {
+    parsers
+      .find(_.isValidReport)
+      .fold[Either[String, A]](Left(errorMessage))(parser => Right(block(parser.generateReport())))
   }
 
 }

src/main/scala/com/codacy/parsers/implementation/CoberturaParser.scala

@@ -5,12 +5,17 @@ import java.text.NumberFormat
 import java.util.Locale
 
 import com.codacy.api.{CoverageFileReport, CoverageReport, Language}
-import com.codacy.parsers.XMLCoverageParser
 import com.codacy.parsers.util.LanguageUtils
+import com.codacy.parsers.{CoverageParser, CoverageParserFactory, XMLCoverageParser}
 
 import scala.util.Try
 import scala.xml.Node
 
+object CoberturaParser extends CoverageParserFactory {
+  override def apply(language: Language.Value, rootProject: File, reportFile: File): CoverageParser =
+    new CoberturaParser(language, rootProject, reportFile)
+}
+
 class CoberturaParser(val language: Language.Value, val rootProject: File, val coverageReport: File) extends XMLCoverageParser {
 
   val rootProjectDir = sanitiseFilename(rootProject.getAbsolutePath + File.separator)

src/main/scala/com/codacy/parsers/implementation/JacocoParser.scala

@@ -3,12 +3,17 @@ package com.codacy.parsers.implementation
 import java.io.File
 
 import com.codacy.api._
-import com.codacy.parsers.XMLCoverageParser
+import com.codacy.parsers.{CoverageParser, CoverageParserFactory, XMLCoverageParser}
 
 import scala.xml.Node
 
 private case class LineCoverage(missedInstructions: Int, coveredInstructions: Int)
 
+object JacocoParser extends CoverageParserFactory {
+  override def apply(language: Language.Value, rootProject: File, reportFile: File): CoverageParser =
+    new JacocoParser(language, rootProject, reportFile)
+}
+
 class JacocoParser(val language: Language.Value, val rootProject: File, val coverageReport: File) extends XMLCoverageParser {
 
   val rootProjectDir = rootProject.getAbsolutePath + File.separator
@@ -52,9 +57,9 @@ class JacocoParser(val language: Language.Value, val rootProject: File, val cove
       line =>
         (line \ "@nr").text.toInt -> LineCoverage((line \ "@mi").text.toInt, (line \ "@ci").text.toInt)
     }.toMap.collect {
-      case (key, lineCoverage) if lineCoverage.missedInstructions+ lineCoverage.coveredInstructions > 0 =>
+      case (key, lineCoverage) if lineCoverage.missedInstructions + lineCoverage.coveredInstructions > 0 =>
 
-        key -> (if(lineCoverage.coveredInstructions > 0) 1 else 0)
+        key -> (if (lineCoverage.coveredInstructions > 0) 1 else 0)
     }
 
     CoverageFileReport(sourceFilename.stripPrefix(rootProjectDir), fileHit, lineHitMap)

src/test/resources/invalid_report.xml

@@ -0,0 +1,9 @@
+<coverageReport>
+    <files>
+        <file name="test.scala">
+            <lines>
+                <line id="2">3</line>
+            </lines>
+        </file>
+    </files>
+</coverageReport>

src/test/scala/com/codacy/parsers/CoverageParserFactoryTest.scala

@@ -0,0 +1,50 @@
+package com.codacy.parsers
+
+import java.io.File
+
+import com.codacy.api.{CoverageFileReport, CoverageReport, Language}
+import com.codacy.parsers.implementation.{CoberturaParser, JacocoParser}
+import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpec}
+
+class CoverageParserFactoryTest extends WordSpec with BeforeAndAfterAll with Matchers {
+  "CoverageParserFactory" should {
+    "get report with unspecified parser" in {
+      val expectedReport = CoverageReport(87, List(
+        CoverageFileReport("src/test/resources/TestSourceFile.scala", 87,
+          Map(5 -> 1, 10 -> 1, 6 -> 2, 9 -> 1, 3 -> 0, 4 -> 1)),
+        CoverageFileReport("src/test/resources/TestSourceFile2.scala", 87,
+          Map(1 -> 1, 2 -> 1, 3 -> 1))))
+
+      runForFile("src/test/resources/test_cobertura.xml", None) shouldEqual Right(expectedReport)
+    }
+
+    "get report with jacoco parser" in {
+      val expectedReport = CoverageReport(73, List(
+        CoverageFileReport("org/eluder/coverage/sample/InnerClassCoverage.java", 81,
+          Map(10 -> 1, 6 -> 1, 9 -> 1, 13 -> 1, 22 -> 1, 27 -> 0, 12 -> 1, 3 -> 1, 16 -> 1, 26 -> 0, 19 -> 1)),
+        CoverageFileReport("org/eluder/coverage/sample/SimpleCoverage.java", 50,
+          Map(3 -> 1, 6 -> 1, 10 -> 0, 11 -> 0))))
+
+      runForFile("src/test/resources/test_jacoco.xml", Some(JacocoParser)) shouldEqual Right(expectedReport)
+    }
+
+    "fail to get invalid report" in {
+      runForFile("invalid_report.xml", None) shouldEqual
+        Left("could not parse report, unrecognized report format")
+    }
+
+    "fail to get report with wrong parser" in {
+      runForFile("src/test/resources/test_jacoco.xml", Some(CoberturaParser)) shouldEqual
+        Left("could not parse report with the provided parser")
+    }
+  }
+
+  private def runForFile(file: String, parser: Option[CoverageParserFactory]) = {
+    CoverageParserFactory.withCoverageReport(
+      Language.Scala,
+      new File("."),
+      new File(file),
+      parser
+    )(identity)
+  }
+}