Merge pull request #23 from MichaelZinsmaier/PR_addingDirectoryCoverage

Adding directory coverage thus supporting the Treemap widget

Author: RadoBuransky

plugin/src/main/scala/com/buransky/plugins/scoverage/StatementCoverage.scala

@@ -38,12 +38,12 @@ sealed trait StatementCoverage {
   /**
    * Total number of all statements within the source code unit,
    */
-  val statementCount: Int
+  def statementCount: Int
 
   /**
    * Number of statements covered by unit tests.
    */
-  val coveredStatementsCount: Int
+  def coveredStatementsCount: Int
 
   require(statementCount >= 0, "Statements count cannot be negative! [" + statementCount + "]")
   require(coveredStatementsCount >= 0, "Statements count cannot be negative! [" +
@@ -57,29 +57,43 @@ sealed trait StatementCoverage {
  * Allows to build tree structure from state coverage values.
  */
 trait NodeStatementCoverage extends StatementCoverage {
-  val children: Iterable[StatementCoverage]
-  val statementCount = children.map(_.statementCount).sum
-  val coveredStatementsCount = children.map(_.coveredStatementsCount).sum
+  def name: String
+  def children: Iterable[NodeStatementCoverage]
+  def statementSum: Int = children.map(_.statementSum).sum
+  def coveredStatementsSum: Int = children.map(_.coveredStatementsSum).sum
 }
 
 /**
  * Root node. In multi-module projects it can contain other ProjectStatementCoverage
  * elements as children.
  */
-case class ProjectStatementCoverage(name: String, children: Iterable[StatementCoverage])
-  extends NodeStatementCoverage
+case class ProjectStatementCoverage(name: String, children: Iterable[NodeStatementCoverage])
+  extends NodeStatementCoverage {
+  // projects' coverage values are defined as sums of their child values
+  val statementCount = statementSum
+  val coveredStatementsCount = coveredStatementsSum
+}
 
 /**
  * Physical directory in file system.
  */
-case class DirectoryStatementCoverage(name: String, children: Iterable[StatementCoverage])
-  extends NodeStatementCoverage
+case class DirectoryStatementCoverage(name: String, children: Iterable[NodeStatementCoverage])
+  extends NodeStatementCoverage {
+  // directories' coverage values are defined as sums of their DIRECT child values 
+  val statementCount = children.filter(_.isInstanceOf[FileStatementCoverage]).map(_.statementCount).sum
+  val coveredStatementsCount = children.filter(_.isInstanceOf[FileStatementCoverage]).map(_.coveredStatementsCount).sum
+}  
 
 /**
  * Scala source code file.
  */
 case class FileStatementCoverage(name: String, statementCount: Int, coveredStatementsCount: Int,
-                                 statements: Iterable[CoveredStatement]) extends StatementCoverage
+                                 statements: Iterable[CoveredStatement]) extends NodeStatementCoverage {
+  // leaf implementation sums==values
+  val children = List.empty[NodeStatementCoverage]
+  override val statementSum = statementCount
+  override val coveredStatementsSum = coveredStatementsCount
+}
 
 /**
  * Position a Scala source code file.

plugin/src/main/scala/com/buransky/plugins/scoverage/measure/ScalaMetrics.scala

@@ -53,6 +53,5 @@ object ScalaMetrics {
     .setDirection(Metric.DIRECTION_BETTER)
     .setQualitative(false)
     .setDomain(CoreMetrics.DOMAIN_SIZE)
-    .setFormula(new org.sonar.api.measures.SumChildValuesFormula(false))
     .create[java.lang.Integer]()
 }

plugin/src/main/scala/com/buransky/plugins/scoverage/sensor/ScoverageSensor.scala

@@ -25,12 +25,12 @@ import com.buransky.plugins.scoverage.language.Scala
 import com.buransky.plugins.scoverage.measure.ScalaMetrics
 import com.buransky.plugins.scoverage.util.LogUtil
 import com.buransky.plugins.scoverage.xml.XmlScoverageReportParser
-import com.buransky.plugins.scoverage.{CoveredStatement, DirectoryStatementCoverage, FileStatementCoverage, _}
-import org.sonar.api.batch.fs.{FileSystem, InputFile}
-import org.sonar.api.batch.{CoverageExtension, Sensor, SensorContext}
+import com.buransky.plugins.scoverage.{ CoveredStatement, DirectoryStatementCoverage, FileStatementCoverage, _ }
+import org.sonar.api.batch.fs.{ FileSystem, InputFile, InputDir, InputPath }
+import org.sonar.api.batch.{ CoverageExtension, Sensor, SensorContext }
 import org.sonar.api.config.Settings
-import org.sonar.api.measures.{CoreMetrics, CoverageMeasuresBuilder, Measure}
-import org.sonar.api.resources.{File, Project, Resource}
+import org.sonar.api.measures.{ CoreMetrics, CoverageMeasuresBuilder, Measure }
+import org.sonar.api.resources.{ File, Project, Directory, Resource }
 import org.sonar.api.scan.filesystem.PathResolver
 import org.sonar.api.utils.log.Loggers
 
@@ -151,33 +151,55 @@ class ScoverageSensor(settings: Settings, pathResolver: PathResolver, fileSystem
     processChildren(projectCoverage.children, context, sonarSources)
   }
 
-  private def processDirectory(directoryCoverage: DirectoryStatementCoverage, context: SensorContext,
-                               parentDirectory: String) {
+  private def processDirectory(directoryCoverage: DirectoryStatementCoverage, context: SensorContext, parentDirectory: String) {
+    // save measures if any
+    if (directoryCoverage.statementCount > 0) {
+      val path = appendFilePath(parentDirectory, directoryCoverage.name)
+
+      getResource(path, context, false) match {
+        case Some(srcDir) => {
+          // Save directory measures
+          saveMeasures(context, srcDir, directoryCoverage)
+        }
+        case None =>
+      }
+    }
     // Process children
     processChildren(directoryCoverage.children, context, appendFilePath(parentDirectory, directoryCoverage.name))
   }
 
   private def processFile(fileCoverage: FileStatementCoverage, context: SensorContext, directory: String) {
     val path = appendFilePath(directory, fileCoverage.name)
-    val p = fileSystem.predicates()
-
-    val files = fileSystem.inputFiles(p.and(
-      p.hasRelativePath(path),
-      p.hasLanguage(scala.getKey),
-      p.hasType(InputFile.Type.MAIN))).toList
-
-    files.headOption match {
-      case Some(file) =>
-        val scalaSourceFile = File.create(file.relativePath())
 
+    getResource(path, context, true) match {
+      case Some(scalaSourceFile) => {
         // Save measures
         saveMeasures(context, scalaSourceFile, fileCoverage)
-
         // Save line coverage. This is needed just for source code highlighting.
         saveLineCoverage(fileCoverage.statements, scalaSourceFile, context)
+      }
+      case None =>
+    }
+  }
 
+  private def getResource(path: String, context: SensorContext, isFile: Boolean): Option[Resource] = {
+    
+    val inputOption: Option[InputPath] = if (isFile) {
+      val p = fileSystem.predicates()
+      Option(fileSystem.inputFile(p.and(
+        p.hasRelativePath(path),
+        p.hasLanguage(scala.getKey),
+        p.hasType(InputFile.Type.MAIN))))
+    } else {
+      Option(fileSystem.inputDir(pathResolver.relativeFile(fileSystem.baseDir(), path)))
+    }
+  
+    inputOption match {
+      case Some(path: InputPath) =>
+        Some(context.getResource(path))
       case None => {
-        log.warn(s"File not found in file system! [$path]")
+        log.warn(s"File or directory not found in file system! ${path}")
+        None
       }
     }
   }

plugin/src/main/scala/com/buransky/plugins/scoverage/xml/XmlScoverageReportConstructingParser.scala

@@ -139,7 +139,7 @@ class XmlScoverageReportConstructingParser(source: Source, pathSanitizer: PathSa
       }
     }
 
-    def toStatementCoverage: StatementCoverage = {
+    def toStatementCoverage: NodeStatementCoverage = {
       val childNodes = children.map(_.toStatementCoverage)
 
       childNodes match {
@@ -151,7 +151,6 @@ class XmlScoverageReportConstructingParser(source: Source, pathSanitizer: PathSa
     def toProjectStatementCoverage: ProjectStatementCoverage = {
       toStatementCoverage match {
         case node: NodeStatementCoverage => ProjectStatementCoverage("", node.children)
-        case file: FileStatementCoverage => ProjectStatementCoverage("", List(file))
         case _ => throw new ScoverageException("Illegal statement coverage!")
       }
     }

plugin/src/test/scala/com/buransky/plugins/scoverage/xml/XmlScoverageReportConstructingParserSpec.scala

@@ -27,6 +27,8 @@ import com.buransky.plugins.scoverage.xml.data.XmlReportFile1
 import scala._
 import com.buransky.plugins.scoverage.{ProjectStatementCoverage, FileStatementCoverage, DirectoryStatementCoverage}
 import com.buransky.plugins.scoverage.pathcleaner.PathSanitizer
+import com.buransky.plugins.scoverage.StatementCoverage
+import com.buransky.plugins.scoverage.NodeStatementCoverage
 
 @RunWith(classOf[JUnitRunner])
 class XmlScoverageReportConstructingParserSpec extends FlatSpec with Matchers {
@@ -52,9 +54,16 @@ class XmlScoverageReportConstructingParserSpec extends FlatSpec with Matchers {
     assertReportFile(XmlReportFile1.scoverage104Data, 50.0, sanitizer) { projectCoverage =>
       assert(projectCoverage.name === "")
       assert(projectCoverage.children.size.toInt === 1)
+
       projectCoverage.children.head match {
-        case rootDir: DirectoryStatementCoverage =>
-          assert(rootDir.name == "com")
+        case rootDir: DirectoryStatementCoverage => { 
+          val rr = checkNode(rootDir, "com", 0, 0, 0.0).head
+          val test = checkNode(rr, "rr", 0, 0, 0.0).head
+          val sonar = checkNode(test, "test", 0, 0, 0.0).head
+          val mainClass = checkNode(sonar, "sonar", 2, 1, 50.0).head
+      
+          checkNode(mainClass, "MainClass.scala", 2, 1, 50.0)
+        }
         case other => fail(s"This is not a directory statement coverage! [$other]")
       }
     }
@@ -111,4 +120,14 @@ class XmlScoverageReportConstructingParserSpec extends FlatSpec with Matchers {
   private def checkRate(expected: Double, real: Double) {
     BigDecimal(real).setScale(2, BigDecimal.RoundingMode.HALF_UP).should(equal(BigDecimal(expected)))
   }
+  
+  private def checkNode(node: NodeStatementCoverage, name: String, count: Int, covered: Int, rate: Double): Iterable[NodeStatementCoverage] = {
+    node.name shouldEqual name
+    node.statementCount shouldEqual count
+    node.coveredStatementsCount shouldEqual covered
+    
+    checkRate(rate, node.rate)
+    
+    node.children
+  }
 }