Allow the coverage parser to be specified

Author: Daniel Reigada

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 with any parser")(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)