Merge pull request #434 from codacy/io-142-remove-total-field

IO-142-Remove total field from coverage parser implementation

Author: OMaluhaCodacy

build.sbt

@@ -85,7 +85,7 @@ lazy val coverageParser = project
   .in(file("coverage-parser"))
   .settings(
     libraryDependencies ++= Seq(
-      "com.codacy" %% "codacy-api-scala" % "7.0.7",
+      "com.codacy" %% "codacy-api-scala" % "7.0.8",
       "com.codacy" %% "codacy-plugins-api" % "5.2.0",
       "org.scala-lang.modules" %% "scala-xml" % "1.2.0",
       "org.scalatest" %% "scalatest" % "3.0.8" % Test

coverage-parser/src/main/scala/com/codacy/parsers/implementation/CloverParser.scala

@@ -4,7 +4,7 @@ import java.io.File
 import java.nio.file.Paths
 
 import com.codacy.api.{CoverageFileReport, CoverageReport}
-import com.codacy.parsers.util.{MathUtils, TextUtils}
+import com.codacy.parsers.util.TextUtils
 import com.codacy.parsers.{CoverageParser, XmlReportParser}
 
 import scala.xml.{Elem, Node, NodeSeq}
@@ -27,10 +27,6 @@ object CloverParser extends CoverageParser with XmlReportParser {
   override def getRootNode(xml: Elem): NodeSeq = xml \\ CoverageTag
 
   private def parseReportNode(rootProject: File, report: NodeSeq): Either[String, CoverageReport] = {
-    val metricsNode = report \ ProjectTag \ MetricsTag
-    val totalCoverage = getCoveragePercentage(metricsNode).left
-      .map(errorMessage => s"Could not retrieve total coverage from metrics tag in project: $errorMessage")
-
     val rootPath = TextUtils.sanitiseFilename(rootProject.getAbsolutePath)
 
     val coverageFiles = (report \\ "file").foldLeft[Either[String, Seq[CoverageFileReport]]](Right(List())) {
@@ -41,17 +37,7 @@ object CloverParser extends CoverageParser with XmlReportParser {
       case (Left(errorMessage), _) => Left(errorMessage)
     }
 
-    for {
-      totalCoverage <- totalCoverage
-      coverageFiles <- coverageFiles
-    } yield CoverageReport(totalCoverage, coverageFiles)
-  }
-
-  private def getCoveragePercentage(metrics: NodeSeq): Either[String, Int] = {
-    for {
-      totalStatements <- getFirstNonEmptyValueAsInt(metrics, "statements")
-      coveredStatements <- getFirstNonEmptyValueAsInt(metrics, "coveredstatements")
-    } yield MathUtils.computePercentage(coveredStatements, totalStatements)
+    coverageFiles.map(CoverageReport(_))
   }
 
   private def getCoverageFileReport(rootPath: String, fileNode: Node): Either[String, CoverageFileReport] = {
@@ -72,15 +58,9 @@ object CloverParser extends CoverageParser with XmlReportParser {
 
     for {
       relativeFilePath <- relativeFilePath
-      metricsNode = fileNode \ MetricsTag
-      fileCoverage <- getCoveragePercentage(metricsNode).left
-        .map(
-          errorMessage =>
-            s"Could not retrieve file coverage from metrics tag for file '$relativeFilePath': $errorMessage"
-        )
       linesCoverage <- getLinesCoverage(fileNode).left
         .map(errorMessage => s"Could not retrieve lines coverage for file '$relativeFilePath': $errorMessage")
-    } yield CoverageFileReport(relativeFilePath, fileCoverage, linesCoverage)
+    } yield CoverageFileReport(relativeFilePath, linesCoverage)
   }
 
   private def getLinesCoverage(fileNode: Node): Either[String, Map[Int, Int]] = {

coverage-parser/src/main/scala/com/codacy/parsers/implementation/CoberturaParser.scala

@@ -31,31 +31,23 @@ object CoberturaParser extends CoverageParser with XmlReportParser {
   private def parseReportNode(projectRoot: File, report: NodeSeq) = {
     val projectRootStr: String = TextUtils.sanitiseFilename(projectRoot.getAbsolutePath)
 
-    val total = math.round(TextUtils.asFloat(report \\ CoverageTag \@ LineRateAttribute) * 100)
-
     val fileReports: List[CoverageFileReport] = (for {
       (filename, classes) <- (report \\ "class").groupBy(c => c \@ "filename")
     } yield {
       val cleanFilename = TextUtils.sanitiseFilename(filename).stripPrefix(projectRootStr).stripPrefix("/")
       lineCoverage(cleanFilename, classes)
     })(collection.breakOut)
 
-    CoverageReport(total, fileReports)
+    CoverageReport(fileReports)
   }
 
   private def lineCoverage(sourceFilename: String, classes: NodeSeq): CoverageFileReport = {
-    val classHit = (classes \\ s"@$LineRateAttribute").map { total =>
-      val totalValue = TextUtils.asFloat(total.text)
-      math.round(totalValue * 100)
-    }
-    val fileHit = if (classHit.nonEmpty) { classHit.sum / classHit.length } else 0
-
     val lineHitMap: Map[Int, Int] =
       (for {
         xClass <- classes
         line <- xClass \\ "line"
       } yield (line \@ "number").toInt -> (line \@ "hits").toIntOrMaxValue).toMap
 
-    CoverageFileReport(sourceFilename, fileHit, lineHitMap)
+    CoverageFileReport(sourceFilename, lineHitMap)
   }
 }

coverage-parser/src/main/scala/com/codacy/parsers/implementation/DotcoverParser.scala

@@ -3,13 +3,11 @@ package com.codacy.parsers.implementation
 import java.io.File
 
 import com.codacy.api.{CoverageFileReport, CoverageReport}
-import com.codacy.parsers.util.{MathUtils, TextUtils}
+import com.codacy.parsers.util.TextUtils
 import com.codacy.parsers.{CoverageParser, XmlReportParser}
 
 import scala.xml.{Elem, NodeSeq}
 
-case class StatementNode(fileIndex: Int, line: Int, covered: Boolean)
-
 object DotcoverParser extends CoverageParser with XmlReportParser {
   override val name: String = "DotCover"
 
@@ -29,8 +27,6 @@ object DotcoverParser extends CoverageParser with XmlReportParser {
   private def parseReportNode(rootProject: File, rootNode: NodeSeq): CoverageReport = {
     val projectRootStr: String = TextUtils.sanitiseFilename(rootProject.getAbsolutePath)
 
-    val totalCoverage = (rootNode \@ CoverageAttribute).toInt
-
     val fileIndices: Map[Int, String] = (rootNode \ "FileIndices" \ "File").map { x =>
       (x \@ "Index").toInt -> (x \@ "Name")
     }.toMap
@@ -41,12 +37,9 @@ object DotcoverParser extends CoverageParser with XmlReportParser {
       (fileIndex, statements) <- statementsPerFile
       filename = TextUtils.sanitiseFilename(fileIndices(fileIndex)).stripPrefix(projectRootStr).stripPrefix("/")
       lineCoverage = getLineCoverage(statements)
-      totalLines = lineCoverage.keys.size
-      coveredLines = lineCoverage.values.count(_ > 0)
-      total = MathUtils.computePercentage(coveredLines, totalLines)
-    } yield CoverageFileReport(filename, total, lineCoverage)
+    } yield CoverageFileReport(filename, lineCoverage)
 
-    CoverageReport(totalCoverage, fileReports.toSeq)
+    CoverageReport(fileReports.toSeq)
   }
 
   private def getLineCoverage(statementNodes: NodeSeq) = {

coverage-parser/src/main/scala/com/codacy/parsers/implementation/GoParser.scala

@@ -3,7 +3,6 @@ package com.codacy.parsers.implementation
 import com.codacy.parsers.CoverageParser
 
 import java.io.File
-import com.codacy.parsers.util.MathUtils
 
 import com.codacy.api.{CoverageFileReport, CoverageReport}
 
@@ -63,31 +62,14 @@ object GoParser extends CoverageParser {
               acc ++ lineHits(coverageInfo)
             }
 
-            val totalForFile = calculateTotal(statementsCountForFile)
-
             accum :+ CoverageFileReportWithStatementsCount(
               statementsCountForFile,
-              CoverageFileReport(filename, totalForFile, coverage)
+              CoverageFileReport(filename, coverage)
             )
         }
       })
 
-    val (covered, total) = coverageFileReports
-      .foldLeft[(Int, Int)]((0, 0)) {
-        case ((covered, total), coverageFileReportWithStatementsCount) =>
-          (
-            covered + coverageFileReportWithStatementsCount.statementsCount.coveredStatements,
-            total + coverageFileReportWithStatementsCount.statementsCount.numberStatements
-          )
-      }
-
-    val totalCoverage = MathUtils.computePercentage(covered, total)
-
-    CoverageReport(totalCoverage, coverageFileReports.map(_.coverageFileReport))
-  }
-
-  private def calculateTotal(coverageFileStatements: GoCoverageStatementsCount): Int = {
-    MathUtils.computePercentage(coverageFileStatements.coveredStatements, coverageFileStatements.numberStatements)
+    CoverageReport(coverageFileReports.map(_.coverageFileReport))
   }
 
   private def lineHits(coverageInfo: GoCoverageInfo): Map[Int, Int] = {

coverage-parser/src/main/scala/com/codacy/parsers/implementation/JacocoParser.scala

@@ -1,72 +1,47 @@
 package com.codacy.parsers.implementation
 
 import java.io.File
-
 import com.codacy.api._
 import com.codacy.parsers.util.TextUtils
 import com.codacy.parsers.{CoverageParser, XmlReportParser}
 
 import scala.xml.{Elem, Node, NodeSeq}
 
-private case class LineCoverage(missedInstructions: Int, coveredInstructions: Int)
-
 object JacocoParser extends CoverageParser with XmlReportParser {
 
   override val name: String = "Jacoco"
 
   private val ReportTag = "report"
 
   override def parse(projectRoot: File, reportFile: File): Either[String, CoverageReport] =
-    parseReport(reportFile, s"Could not find top level <$ReportTag> tag") {
-      parseReportNode(projectRoot, _)
+    parseReport(reportFile, s"Could not find top level <$ReportTag> tag") { node =>
+      Right(parseReportNode(projectRoot, node))
     }
 
   override def validateSchema(xml: Elem): Boolean = getRootNode(xml).nonEmpty
 
   override def getRootNode(xml: Elem): NodeSeq = xml \\ ReportTag
 
-  private def parseReportNode(projectRoot: File, report: NodeSeq): Either[String, CoverageReport] = {
+  private def parseReportNode(projectRoot: File, report: NodeSeq): CoverageReport = {
     val projectRootStr: String = TextUtils.sanitiseFilename(projectRoot.getAbsolutePath)
-    totalPercentage(report).map { total =>
-      val filesCoverage = for {
-        pkg <- report \\ "package"
-        packageName = (pkg \@ "name")
-        sourceFile <- pkg \\ "sourcefile"
-      } yield {
-        val filename =
-          TextUtils
-            .sanitiseFilename(s"$packageName/${(sourceFile \@ "name")}")
-            .stripPrefix(projectRootStr)
-            .stripPrefix("/")
-        lineCoverage(filename, sourceFile)
-      }
-
-      CoverageReport(total, filesCoverage)
+    val filesCoverage = for {
+      pkg <- report \\ "package"
+      packageName = (pkg \@ "name")
+      sourceFile <- pkg \\ "sourcefile"
+    } yield {
+      val filename =
+        TextUtils
+          .sanitiseFilename(s"$packageName/${(sourceFile \@ "name")}")
+          .stripPrefix(projectRootStr)
+          .stripPrefix("/")
+      calculateCoverageFileReport(filename, sourceFile)
     }
+    CoverageReport(filesCoverage)
   }
 
-  private def totalPercentage(report: NodeSeq): Either[String, Int] = {
-    (report \\ ReportTag \ "counter")
-      .collectFirst {
-        case counter if (counter \@ "type") == "LINE" =>
-          val covered = TextUtils.asFloat((counter \@ "covered"))
-          val missed = TextUtils.asFloat((counter \@ "missed"))
-          Right(((covered / (covered + missed)) * 100).toInt)
-      }
-      .getOrElse {
-        Left("Could not retrieve total percentage of coverage.")
-      }
-  }
-
-  private def lineCoverage(filename: String, fileNode: Node): CoverageFileReport = {
-    val lineHit = (fileNode \ "counter").collect {
-      case counter if (counter \@ "type") == "LINE" =>
-        val covered = TextUtils.asFloat((counter \@ "covered"))
-        val missed = TextUtils.asFloat((counter \@ "missed"))
-        (if ((covered + missed) > 0) (covered / (covered + missed)) * 100 else 0f).toInt
-    }
+  private def calculateCoverageFileReport(filename: String, fileNode: Node): CoverageFileReport = {
 
-    val fileHit = if (lineHit.sum != 0) { lineHit.sum / lineHit.length } else 0
+    case class LineCoverage(missedInstructions: Int, coveredInstructions: Int)
 
     val lineHitMap: Map[Int, Int] = (fileNode \\ "line")
       .map { line =>
@@ -77,6 +52,6 @@ object JacocoParser extends CoverageParser with XmlReportParser {
           key -> (if (lineCoverage.coveredInstructions > 0) 1 else 0)
       }(collection.breakOut)
 
-    CoverageFileReport(filename, fileHit, lineHitMap)
+    CoverageFileReport(filename, lineHitMap)
   }
 }

coverage-parser/src/main/scala/com/codacy/parsers/implementation/LCOVParser.scala

@@ -5,7 +5,7 @@ import com.codacy.parsers.util.MathUtils._
 import com.codacy.api.{CoverageFileReport, CoverageReport}
 import java.io.File
 
-import com.codacy.parsers.util.{MathUtils, XMLoader}
+import com.codacy.parsers.util.XMLoader
 
 import scala.io.Source
 import scala.util.{Failure, Success, Try}
@@ -36,7 +36,7 @@ object LCOVParser extends CoverageParser {
         (accum, next) =>
           accum.flatMap {
             case reports if next startsWith SF =>
-              Right(CoverageFileReport(next stripPrefix SF, 0, Map()) +: reports)
+              Right(CoverageFileReport(next stripPrefix SF, Map()) +: reports)
             case reports if next startsWith DA =>
               reports.headOption match {
                 case Some(value) =>
@@ -56,25 +56,9 @@ object LCOVParser extends CoverageParser {
       )
     coverageFileReports.map { fileReports =>
       val totalFileReport = fileReports.map { report =>
-        val coveredLines = report.coverage.count { case (_, hit) => hit > 0 }
-        val totalLines = report.coverage.size
-        val fileCoverage =
-          MathUtils.computePercentage(coveredLines, totalLines)
-
-        CoverageFileReport(report.filename, fileCoverage, report.coverage)
+        CoverageFileReport(report.filename, report.coverage)
       }
-
-      val (covered, total) = totalFileReport
-        .map { f =>
-          (f.coverage.count { case (_, hit) => hit > 0 }, f.coverage.size)
-        }
-        .foldLeft(0 -> 0) {
-          case ((accumCovered, accumTotal), (nextCovered, nextTotal)) =>
-            (accumCovered + nextCovered, accumTotal + nextTotal)
-        }
-
-      val totalCoverage = MathUtils.computePercentage(covered, total)
-      CoverageReport(totalCoverage, totalFileReport)
+      CoverageReport(totalFileReport)
     }
   }
 }

coverage-parser/src/main/scala/com/codacy/parsers/implementation/OpenCoverParser.scala

@@ -3,7 +3,7 @@ package com.codacy.parsers.implementation
 import java.io.File
 
 import com.codacy.api.{CoverageFileReport, CoverageReport}
-import com.codacy.parsers.util.{MathUtils, TextUtils}
+import com.codacy.parsers.util.TextUtils
 import com.codacy.parsers.{CoverageParser, XmlReportParser}
 
 import scala.xml.{Elem, NodeSeq}
@@ -43,35 +43,18 @@ object OpenCoverParser extends CoverageParser with XmlReportParser {
       filename <- fileIndices.get(fileIndex)
 
       sanitisedFileName = TextUtils.sanitiseFilename(filename).stripPrefix(projectRoot).stripPrefix("/")
-      lineCoverage = getLineCoverage(methods, sanitisedFileName)
-      totalLines = lineCoverage.size
-      coveredLines = lineCoverage.count { case (_, visitCount) => visitCount > 0 }
-      coverage = MathUtils.computePercentage(coveredLines, totalLines)
-    } yield CoverageFileReport(sanitisedFileName, coverage, lineCoverage)).toSeq
+      lineCoverage = getLineCoverage(methods)
+    } yield CoverageFileReport(sanitisedFileName, lineCoverage)).toSeq
 
-    val totalCoverage = computeTotalCoverage(fileReports)
-
-    CoverageReport(totalCoverage, fileReports)
+    CoverageReport(fileReports)
   }
 
-  private def getLineCoverage(methodNodes: NodeSeq, filename: String) = {
+  private def getLineCoverage(methodNodes: NodeSeq) = {
     val lineCoverage = for {
       methodNode <- methodNodes
       sequencePoint <- methodNode \\ SequencePointTag
     } yield (sequencePoint \@ LineAttribute).toInt -> (sequencePoint \@ VisitCounterAttribute).toInt
 
     lineCoverage.toMap
   }
-
-  private def computeTotalCoverage(fileReports: Seq[CoverageFileReport]) = {
-    val (totalLines, coveredLines) = fileReports
-      .foldLeft((0, 0)) {
-        case ((total, covered), f) =>
-          val totalLines = f.coverage.size
-          val coveredLines = (f.total * totalLines) / 100
-          (total + totalLines, covered + coveredLines)
-      }
-
-    MathUtils.computePercentage(coveredLines, totalLines)
-  }
 }