Reformatted code

Author: sksamuel

src/main/scala/scales/IOUtils.scala

@@ -1,26 +1,26 @@
 package scales
 
-import java.io.{FileWriter, BufferedWriter}
+import java.io.{File, FileWriter, BufferedWriter}
 
 /** @author Stephen Samuel */
 object IOUtils {
 
-    def dropScalaPath(path: String) = path.split("src/main/scala").last
+  def dropScalaPath(path: String) = path.split("src/main/scala").last
 
-    def toOutputPath(path: String) = "target/scales/" + dropScalaPath(path)
-    def createDirs(path: String) = new File(path).isDirectory match {
-        case false => new File(path).getParentFile.mkdirs
-        case true => new File(path).mkdirs
-    }
+  def toOutputPath(path: String) = "target/scales/" + dropScalaPath(path)
+  def createDirs(path: String) = new File(path).isDirectory match {
+    case false => new File(path).getParentFile.mkdirs
+    case true => new File(path).mkdirs
+  }
 
-    // write to relative path
-    def write(path: String, data: AnyRef) {
-        val outputPath = toOutputPath(path)
-        createDirs(outputPath)
-        println(s"Writing to path $outputPath")
-        val file = new File(outputPath)
-        val writer = new BufferedWriter(new FileWriter(file))
-        writer.write(data.toString)
-        writer.close()
-    }
+  // write to relative path
+  def write(path: String, data: AnyRef) {
+    val outputPath = toOutputPath(path)
+    createDirs(outputPath)
+    println(s"Writing to path $outputPath")
+    val file = new File(outputPath)
+    val writer = new BufferedWriter(new FileWriter(file))
+    writer.write(data.toString)
+    writer.close()
+  }
 }

src/main/scala/scales/Instrumenter.scala

@@ -6,20 +6,26 @@ import scala.reflect.internal.util.SourceFile
 /** @author Stephen Samuel */
 object Instrumentation {
 
-    val ids = new AtomicInteger(0)
-    val coverage = new Coverage
+  val ids = new AtomicInteger(0)
+  val coverage = new Coverage
 
-    def add(source: SourceFile, _package: String, _class: String, _method: String, start: Int, line: Int, desc: String) = {
-        val id = ids.incrementAndGet()
-        val stmt = MeasuredStatement(source, _package, _class, _method: String, id, start, line, desc)
-        coverage.add(stmt)
-        stmt
-    }
+  def add(source: SourceFile,
+          _package: String,
+          _class: String,
+          _method: String,
+          start: Int,
+          line: Int,
+          desc: String) = {
+    val id = ids.incrementAndGet()
+    val stmt = MeasuredStatement(source, _package, _class, _method: String, id, start, line, desc)
+    coverage.add(stmt)
+    stmt
+  }
 
-    def invoked(id: Int): Int = {
-        coverage.invoked(id)
-        id
-    }
+  def invoked(id: Int): Int = {
+    coverage.invoked(id)
+    id
+  }
 }
 
 sealed trait LineStatus

src/main/scala/scales/coverage.scala

@@ -7,45 +7,51 @@ import scala.collection.mutable
 /** @author Stephen Samuel */
 class Coverage extends StatementCoverage {
 
-    val statements = new ListBuffer[MeasuredStatement]
-    val sources = new ListBuffer[SourceFile]
-    val packageNames = mutable.Set[String]()
-    val classNames = new ListBuffer[String]()
-    val methodNames = new ListBuffer[String]()
+  val statements = new ListBuffer[MeasuredStatement]
+  val sources = new ListBuffer[SourceFile]
+  val packageNames = mutable.Set[String]()
+  val classNames = new ListBuffer[String]()
+  val methodNames = new ListBuffer[String]()
 
-    def loc = sources.map(src => new String(src.content).replaceAll("^\\s.*$", "").split("\n").length).sum
-    def ncloc =
-        sources
-          .map(src => new String(src.content).replaceAll("/\\*.*?\\*/", "").replace("//.*$", "").split("\n").count(_ == '\n')).sum
-    def packageCount = packageNames.size
-    def classCount = classNames.size
-    def methodCount = methodNames.size
-    def classesPerPackage = classCount / packageCount.toDouble
-    def methodsPerClass = methodCount / classCount.toDouble
+  def loc = sources.map(src => new String(src.content).replaceAll("^\\s.*$", "").split("\n").length).sum
+  def ncloc =
+    sources
+      .map(src => new String(src.content)
+      .replaceAll("/\\*.*?\\*/", "")
+      .replace("//.*$", "")
+      .split("\n")
+      .count(_ == '\n')).sum
+  def packageCount = packageNames.size
+  def classCount = classNames.size
+  def methodCount = methodNames.size
+  def classesPerPackage = classCount / packageCount.toDouble
+  def methodsPerClass = methodCount / classCount.toDouble
 
-    def add(stmt: MeasuredStatement): Unit = statements.append(stmt)
-    def invoked(id: Int): Unit = statements.find(_.id == id).foreach(_.invoked)
+  def add(stmt: MeasuredStatement): Unit = statements.append(stmt)
+  def invoked(id: Int): Unit = statements.find(_.id == id).foreach(_.invoked)
 
-    def files = statements.groupBy(_.source.path).map(arg => MeasuredFile(arg._2.head.source, arg._2))
-    def packages: Iterable[MeasuredPackage] = statements.groupBy(_._package).map(arg => MeasuredPackage(arg._1, arg._2))
-    def classes = statements.groupBy(_.fqn).map(arg => MeasuredClass(arg._1, arg._2))
+  def files = statements.groupBy(_.source.path).map(arg => MeasuredFile(arg._2.head.source, arg._2))
+  def packages: Iterable[MeasuredPackage] = statements.groupBy(_._package).map(arg => MeasuredPackage(arg._1, arg._2))
+  def classes = statements.groupBy(_.fqn).map(arg => MeasuredClass(arg._1, arg._2))
 
-    def risks(limit: Int) = classes.toSeq.sortBy(_.statementCoverage).take(limit)
+  def risks(limit: Int) = classes.toSeq.sortBy(_.statementCoverage).take(limit)
 }
 
-case class MeasuredPackage(name: String, statements: Iterable[MeasuredStatement]) extends StatementCoverage with ClassCoverage {
-    def files = statements.groupBy(_.source).map(arg => MeasuredFile(arg._1, arg._2))
+case class MeasuredPackage(name: String, statements: Iterable[MeasuredStatement])
+  extends StatementCoverage with ClassCoverage {
+  def files = statements.groupBy(_.source).map(arg => MeasuredFile(arg._1, arg._2))
 }
 
-case class MeasuredFile(source: SourceFile, statements: Iterable[MeasuredStatement]) extends StatementCoverage with ClassCoverage {
-    def lineStatus(lineNumber: Int): LineStatus = {
-        statements.filter(_.line == lineNumber) match {
-            case i if i.isEmpty => NotInstrumented
-            case i if i.size > 0 && i.exists(_.count == 0) => MissingCoverage
-            case _ => Covered
-        }
+case class MeasuredFile(source: SourceFile, statements: Iterable[MeasuredStatement])
+  extends StatementCoverage with ClassCoverage {
+  def lineStatus(lineNumber: Int): LineStatus = {
+    statements.filter(_.line == lineNumber) match {
+      case i if i.isEmpty => NotInstrumented
+      case i if i.size > 0 && i.exists(_.count == 0) => MissingCoverage
+      case _ => Covered
     }
-    def packages: Iterable[MeasuredPackage] = statements.groupBy(_._package).map(arg => MeasuredPackage(arg._1, arg._2))
+  }
+  def packages: Iterable[MeasuredPackage] = statements.groupBy(_._package).map(arg => MeasuredPackage(arg._1, arg._2))
 }
 
 case class MeasuredClass(name: String, statements: Iterable[MeasuredStatement]) extends StatementCoverage
@@ -58,22 +64,22 @@ case class MeasuredStatement(source: SourceFile,
                              start: Int,
                              line: Int,
                              desc: String) {
-    val fqn = (_package + ".").replace("<empty>.", "") + _class
-    var count = 0
-    def invoked: Unit = count = count + 1
+  val fqn = (_package + ".").replace("<empty>.", "") + _class
+  var count = 0
+  def invoked(): Unit = count = count + 1
 }
 
 trait StatementCoverage {
-    val statements: Iterable[MeasuredStatement]
-    def statementCoverage: Double = invokedStatements / statements.size.toDouble
-    def statementCount: Int = statements.size
-    def invokedStatements: Int = statements.count(_.count > 0)
+  val statements: Iterable[MeasuredStatement]
+  def statementCoverage: Double = invokedStatements / statements.size.toDouble
+  def statementCount: Int = statements.size
+  def invokedStatements: Int = statements.count(_.count > 0)
 }
 
 trait ClassCoverage {
-    val statements: Iterable[MeasuredStatement]
-    def classes = statements.groupBy(_._class).map(arg => MeasuredClass(arg._1, arg._2))
-    def classCount: Int = classes.size
-    def invokedClasses: Int = classes.count(_.statements.count(_.count > 0) > 0)
-    def classCoverage: Double = invokedClasses / classes.size.toDouble
+  val statements: Iterable[MeasuredStatement]
+  def classes = statements.groupBy(_._class).map(arg => MeasuredClass(arg._1, arg._2))
+  def classCount: Int = classes.size
+  def invokedClasses: Int = classes.count(_.statements.count(_.count > 0) > 0)
+  def classCoverage: Double = invokedClasses / classes.size.toDouble
 }