Merge branch 'release/1.0'

Author: sksamuel

build.sbt

@@ -0,0 +1,98 @@
+import sbt.Keys._
+import sbt._
+
+object Scoverage extends Build {
+
+  val Org = "org.scoverage"
+  val Version = "1.0.0.BETA2"
+  val Scala = "2.11.4"
+  val Slf4jVersion = "1.7.7"
+  val ScalatestVersion = "2.2.2"
+
+  lazy val LocalTest = config("local") extend Test
+
+  val appSettings = Seq(
+    version := Version,
+    organization := Org,
+    scalaVersion := Scala,
+    crossScalaVersions := Seq("2.10.4", "2.11.4"),
+    fork in Test := false,
+    publishMavenStyle := true,
+    publishArtifact in Test := false,
+    parallelExecution in Test := false,
+    scalacOptions := Seq("-unchecked", "-deprecation", "-feature", "-encoding", "utf8"),
+    resolvers := ("releases" at "https://oss.sonatype.org/service/local/staging/deploy/maven2") +: resolvers.value,
+    concurrentRestrictions in Global += Tags.limit(Tags.Test, 1),
+    scalacOptions := Seq("-unchecked", "-deprecation", "-encoding", "utf8"),
+    javacOptions := Seq("-source", "1.6", "-target", "1.6"),
+    libraryDependencies ++= Seq(
+      "org.joda" % "joda-convert" % "1.6" % "test",
+      "joda-time" % "joda-time" % "2.3" % "test",
+      "com.typesafe.scala-logging" %% "scala-logging-slf4j" % "2.1.2" % "test",
+      "org.mockito" % "mockito-all" % "1.9.5" % "test",
+      "org.scalatest" %% "scalatest" % ScalatestVersion % "test"
+    ),
+    publishTo <<= version {
+      (v: String) =>
+        val nexus = "https://oss.sonatype.org/"
+        if (v.trim.endsWith("SNAPSHOT"))
+          Some(Resolver.file("file", new File(Path.userHome.absolutePath + "/.m2/repository")))
+        else
+          Some("releases" at nexus + "service/local/staging/deploy/maven2")
+    },
+    pomExtra := {
+      <url>https://github.com/scoverage/scalac-scoverage-plugin</url>
+        <licenses>
+          <license>
+            <name>Apache 2</name>
+            <url>http://www.apache.org/licenses/LICENSE-2.0</url>
+            <distribution>repo</distribution>
+          </license>
+        </licenses>
+        <scm>
+          <url>git@github.com:scoverage/scalac-scoverage-plugin.git</url>
+          <connection>scm:git@github.com:scoverage/scalac-scoverage-plugin.git</connection>
+        </scm>
+        <developers>
+          <developer>
+            <id>sksamuel</id>
+            <name>Stephen Samuel</name>
+            <url>http://github.com/sksamuel</url>
+          </developer>
+        </developers>
+    },
+    pomIncludeRepository := {
+      _ => false
+    }
+  )
+
+  lazy val root = Project("scalac-scoverage", file("."))
+    .settings(name := "scalac-scoverage")
+    .settings(appSettings: _*)
+    .settings(publishArtifact := false)
+    .aggregate(plugin, runtime)
+
+  lazy val runtime = Project("scalac-scoverage-runtime", file("scalac-scoverage-runtime"))
+    .settings(name := "scalac-scoverage-runtime")
+    .settings(appSettings: _*)
+
+  lazy val plugin = Project("scalac-scoverage-plugin", file("scalac-scoverage-plugin"))
+    .settings(name := "scalac-scoverage-plugin")
+    .dependsOn(runtime)
+    .settings(appSettings: _*)
+    .settings(libraryDependencies ++= Seq(
+    "org.slf4j" % "slf4j-api" % Slf4jVersion,
+    "commons-io" % "commons-io" % "2.4",
+    "org.scala-lang" % "scala-reflect" % scalaVersion.value,
+    "org.scala-lang" % "scala-compiler" % scalaVersion.value
+  )).settings(libraryDependencies ++= {
+    CrossVersion.partialVersion(scalaVersion.value) match {
+      case Some((2, scalaMajor)) if scalaMajor == 11 =>
+        EnvSupport.setEnv("CrossBuildScalaVersion", "2.11.4")
+        Seq("org.scala-lang.modules" %% "scala-xml" % "1.0.1")
+      case _ =>
+        EnvSupport.setEnv("CrossBuildScalaVersion", "2.10.4")
+        Nil
+    }
+  })
+}

src/main/misc/logo1.png renamed to misc/logo1.png

@@ -0,0 +1 @@
+package scoverage

src/main/misc/logo2.png renamed to misc/logo2.png

@@ -1,8 +1,7 @@
 package scoverage
 
 import scala.collection.mutable
-import scala.reflect.internal.util.SourceFile
-import scala.reflect.internal.util.Position
+import scala.reflect.internal.util.{Position, SourceFile}
 
 /**
  * Methods related to filtering the instrumentation and coverage.

src/main/misc/scales.png renamed to misc/scales.png

@@ -1,10 +1,10 @@
 package scoverage
 
 import java.io._
-import scala.xml.{XML, Utility, Node}
-import scala.collection.Set
-import scala.collection.mutable
+
+import scala.collection.{Set, mutable}
 import scala.io.Source
+import scala.xml.{Node, Utility, XML}
 
 /** @author Stephen Samuel */
 object IOUtils {
@@ -87,19 +87,22 @@ object IOUtils {
           {stmt.source}
         </source>
         <package>
-          {stmt.location._package}
+          {stmt.location.packageName}
         </package>
         <class>
-          {stmt.location._class}
+          {stmt.location.className}
         </class>
         <classType>
           {stmt.location.classType.toString}
         </classType>
+        <topLevelClass>
+          {stmt.location.topLevelClass}
+        </topLevelClass>
         <method>
           {stmt.location.method}
         </method>
         <path>
-          {stmt.location.path}
+          {stmt.location.sourcePath}
         </path>
         <id>
           {stmt.id.toString}
@@ -143,6 +146,7 @@ object IOUtils {
       val branch = (node \ "branch").text.toBoolean
       val _package = (node \ "package").text
       val _class = (node \ "class").text
+      val topLevelClass = (node \ "topLevelClass").text
       val method = (node \ "method").text
       val path = (node \ "path").text
       val treeName = (node \ "treeName").text
@@ -157,8 +161,8 @@ object IOUtils {
         case "Object" => ClassType.Object
         case _ => ClassType.Class
       }
-      MeasuredStatement(source,
-        Location(_package, _class, classType, method, path),
+      Statement(source,
+        Location(_package, _class, topLevelClass, classType, method, path),
         id,
         start,
         end,

src/main/misc/scales2.png renamed to misc/scales2.png

@@ -0,0 +1,60 @@
+package scoverage
+
+import scala.tools.nsc.Global
+
+case class Location(packageName: String,
+                    className: String,
+                    topLevelClass: String,
+                    classType: ClassType,
+                    method: String,
+                    sourcePath: String) extends java.io.Serializable {
+  val fqn = (packageName + ".").replace("<empty>.", "") + className
+}
+
+object Location {
+
+  def apply(global: Global): global.Tree => Option[Location] = { tree =>
+
+    def packageName(s: global.Symbol): String = {
+      s.enclosingPackage.fullName
+    }
+
+    def className(s: global.Symbol): String = {
+      // anon functions are enclosed in proper classes.
+      if (s.enclClass.isAnonymousFunction || s.enclClass.isAnonymousClass) className(s.owner)
+      else s.enclClass.nameString
+    }
+
+    def classType(s: global.Symbol): ClassType = {
+      if (s.enclClass.isTrait) ClassType.Trait
+      else if (s.enclClass.isModuleOrModuleClass) ClassType.Object
+      else ClassType.Class
+    }
+
+    def topLevelClass(s: global.Symbol): String = {
+      s.enclosingTopLevelClass.nameString
+    }
+
+    def enclosingMethod(s: global.Symbol): String = {
+      // check if we are in a proper method and return that, otherwise traverse up
+      if (s.enclClass.isAnonymousFunction ) enclosingMethod(s.owner)
+      else if (s.enclMethod.isPrimaryConstructor) "<init>"
+      else Option(s.enclMethod.nameString).getOrElse("<none>")
+    }
+
+    def sourcePath(symbol: global.Symbol): String = {
+      Option(symbol.sourceFile).map(_.canonicalPath).getOrElse("<none>")
+    }
+
+    Option(tree.symbol) map {
+      symbol =>
+        Location(
+          packageName(symbol),
+          className(symbol),
+          topLevelClass(symbol),
+          classType(symbol),
+          enclosingMethod(symbol),
+          sourcePath(symbol))
+    }
+  }
+}