Coverage Data Model

case class Coverage() extends CoverageMetrics
    with MethodBuilders
    with ClassBuilders
    with PackageBuilders
    with FileBuilders {
  
  def add(stmt: Statement): Unit
  def addIgnoredStatement(stmt: Statement): Unit
  def apply(ids: Iterable[(Int, String)]): Unit
  def invoked(id: (Int, String)): Unit
  
  // Aggregation methods
  def avgClassesPerPackage: Double
  def avgClassesPerPackageFormatted: String
  def avgMethodsPerClass: Double
  def avgMethodsPerClassFormatted: String
  def loc: Int
  def linesPerFile: Double
  def linesPerFileFormatted: String
  def risks(limit: Int): Seq[MeasuredClass]
}

case class Statement(
  location: Location,
  id: Int,
  start: Int,
  end: Int,
  line: Int,
  desc: String,
  symbolName: String,
  treeName: String,
  branch: Boolean,
  count: Int = 0,
  ignored: Boolean = false,
  tests: mutable.Set[String] = mutable.Set[String]()
) {
  def source: String
  def invoked(test: String): Unit
  def isInvoked: Boolean
}

case class Location(
  packageName: String,
  className: String,
  fullClassName: String,
  classType: ClassType,
  method: String,
  sourcePath: String
)

case class MeasuredClass(
  fullClassName: String, 
  statements: Iterable[Statement]
) extends CoverageMetrics with MethodBuilders {
  
  def source: String
  def loc: Int
  def displayClassName: String
}

case class MeasuredMethod(
  name: String,
  statements: Iterable[Statement]
) extends CoverageMetrics

case class MeasuredPackage(
  name: String,
  statements: Iterable[Statement]
) extends CoverageMetrics with ClassCoverage with ClassBuilders with FileBuilders

case class MeasuredFile(
  source: String,
  statements: Iterable[Statement]
) extends CoverageMetrics with ClassCoverage with ClassBuilders {
  
  def filename: String
  def loc: Int
}

trait CoverageMetrics {
  def statements: Iterable[Statement]
  def ignoredStatements: Iterable[Statement]
  
  // Statement metrics
  def statementCount: Int
  def ignoredStatementCount: Int
  def invokedStatements: Iterable[Statement]
  def invokedStatementCount: Int
  def statementCoverage: Double
  def statementCoveragePercent: Double
  def statementCoverageFormatted: String
  
  // Branch metrics
  def branches: Iterable[Statement]
  def branchCount: Int
  def invokedBranches: Iterable[Statement]
  def invokedBranchesCount: Int
  def branchCoverage: Double
  def branchCoveragePercent: Double
  def branchCoverageFormatted: String
}

sealed trait ClassType

object ClassType {
  case object Object extends ClassType
  case object Class extends ClassType
  case object Trait extends ClassType
  
  def fromString(str: String): ClassType
}

class CodeGrid(mFile: MeasuredFile, sourceEncoding: Option[String]) {
  val highlighted: String
}

// Backward compatibility constructor
class CodeGrid(mFile: MeasuredFile)

sealed trait StatementStatus
case object Invoked extends StatementStatus
case object NotInvoked extends StatementStatus
case object NoData extends StatementStatus

case class ClassRef(name: String) {
  lazy val simpleName: String
  lazy val getPackage: String
}

object ClassRef {
  def fromFilepath(path: String): ClassRef
  def apply(_package: String, className: String): ClassRef
}

trait MethodBuilders {
  def statements: Iterable[Statement]
  def methods: Seq[MeasuredMethod]
  def methodCount: Int
}

trait PackageBuilders {
  def statements: Iterable[Statement]
  def packages: Seq[MeasuredPackage]
  def packageCount: Int
}

trait ClassBuilders {
  def statements: Iterable[Statement]
  def classes: Iterable[MeasuredClass]
  def classCount: Int
}

trait FileBuilders {
  def statements: Iterable[Statement]
  def files: Iterable[MeasuredFile]
  def fileCount: Int
}

import scoverage.domain._

// Create a new coverage container
val coverage = Coverage()

// Create a statement
val location = Location(
  packageName = "com.example",
  className = "MyClass",
  fullClassName = "com.example.MyClass",
  classType = ClassType.Class,
  method = "myMethod",
  sourcePath = "/path/to/MyClass.scala"
)

val statement = Statement(
  location = location,
  id = 1,
  start = 100,
  end = 120,
  line = 10,
  desc = "println(\"Hello\")",
  symbolName = "scala.Predef.println",
  treeName = "Apply",
  branch = false
)

// Add statement to coverage
coverage.add(statement)

// Measurement data represents which statements were executed
val measurements = Set(
  (1, "com.example.MyTest"),  // Statement 1 was hit by MyTest
  (2, "com.example.MyTest"),  // Statement 2 was hit by MyTest
  (3, "")                     // Statement 3 was hit but test name unknown
)

// Apply measurements to coverage
coverage.apply(measurements)

// Check coverage metrics
println(s"Statement coverage: ${coverage.statementCoverageFormatted}%")
println(s"Branch coverage: ${coverage.branchCoverageFormatted}%")

// Get classes with lowest coverage (highest risk)
val riskyClasses = coverage.risks(10)
riskyClasses.foreach { cls =>
  println(s"${cls.fullClassName}: ${cls.statementCoverageFormatted}% coverage")
}

// Analyze by package
coverage.packages.foreach { pkg =>
  println(s"Package ${pkg.name}: ${pkg.statementCoverageFormatted}% coverage")
  
  // Analyze classes in package
  pkg.classes.foreach { cls =>
    println(s"  Class ${cls.displayClassName}: ${cls.statementCoverageFormatted}%")
  }
}

// Analyze file-level coverage
coverage.files.foreach { file =>
  println(s"File ${file.filename}: ${file.statementCoverageFormatted}% coverage, ${file.loc} LOC")
  
  // Check methods in file
  file.methods.foreach { method =>
    println(s"  Method ${method.name}: ${method.statementCoverageFormatted}% coverage")
  }
}