Merge pull request #31 from kciesielski/fix-reporter

Load custom reporter in a plugin component

Author: adamw

model/src/main/scala/com/softwaremill/clippy/StringDiff.scala

@@ -3,10 +3,8 @@ package com.softwaremill.clippy
 import com.softwaremill.clippy.StringDiff.{DeltaEnd, DeltaStart}
 
 object StringDiff {
-  val AnsiReset = "\u001B[0m"
-  val AnsiRed = "\u001B[31m"
-  val DeltaEnd = AnsiReset
-  val DeltaStart = AnsiRed
+  val DeltaEnd = Console.RESET
+  val DeltaStart = Console.RED
 }
 
 class StringDiff(expected: String, actual: String) {

plugin/src/main/scala/com/softwaremill/clippy/ClippyPlugin.scala

@@ -13,40 +13,49 @@ class ClippyPlugin(val global: Global) extends Plugin {
 
   override val name: String = "clippy"
 
-  override val components: List[PluginComponent] = Nil
-
   override val description: String = "gives good advice"
 
-  override def processOptions(options: List[String], error: (String) => Unit) = {
-    val r = global.reporter
+  var url: String = ""
+  var enableColors = false
+  var testMode = false
+  val DefaultStoreDir = new File(System.getProperty("user.home"), ".clippy")
+  var localStoreDir = DefaultStoreDir
+  var projectRoot: Option[File] = None
 
-    val url = urlFromOptions(options)
-    val enableColors = colorsFromOptions(options)
-    val localStoreDir = localStoreDirFromOptions(options)
-    val projectRoot = projectRootFromOptions(options)
+  def handleError(pos: Position, msg: String): String = {
     val advices = loadAdvices(url, localStoreDir, projectRoot)
+    val parsedMsg = CompilationErrorParser.parse(msg)
+    val matchers = advices.map(_.errMatching.lift)
+    val matches = matchers.flatMap(pf => parsedMsg.flatMap(pf))
+
+    matches.size match {
+      case 0 =>
+        parsedMsg match {
+          case Some(tme: TypeMismatchError[ExactT]) if enableColors => prettyPrintTypeMismatchError(tme, msg)
+          case _ => msg
+        }
+      case 1 =>
+        matches.mkString(s"$msg\n Clippy advises: ", "", "")
+      case _ =>
+        matches.mkString(s"$msg\n Clippy advises you to try one of these solutions: \n   ", "\n or\n   ", "")
+    }
+  }
+
+  override def processOptions(options: List[String], error: (String) => Unit): Unit = {
+    enableColors = colorsFromOptions(options)
+    url = urlFromOptions(options)
+    testMode = testModeFromOptions(options)
+    localStoreDir = localStoreDirFromOptions(options)
+    projectRoot = projectRootFromOptions(options)
 
-    global.reporter = new DelegatingReporter(r, handleError)
-
-    def handleError(pos: Position, msg: String): String = {
-      val parsedMsg = CompilationErrorParser.parse(msg)
-      val matchers = advices.map(_.errMatching.lift)
-      val matches = matchers.flatMap(pf => parsedMsg.flatMap(pf))
-
-      matches.size match {
-        case 0 =>
-          parsedMsg match {
-            case Some(tme: TypeMismatchError[ExactT]) if enableColors => prettyPrintTypeMismatchError(tme, msg)
-            case _ => msg
-          }
-        case 1 =>
-          matches.mkString(s"$msg\n Clippy advises: ", "", "")
-        case _ =>
-          matches.mkString(s"$msg\n Clippy advises you to try one of these solutions: \n   ", "\n or\n   ", "")
-      }
+    if (testMode) {
+      val r = global.reporter
+      global.reporter = new DelegatingReporter(r, handleError)
     }
   }
 
+  override val components: List[PluginComponent] = List(new InjectReporter(handleError, global))
+
   private def prettyPrintTypeMismatchError(tme: TypeMismatchError[ExactT], msg: String): String = {
     val plain = new StringDiff(tme.required.toString, tme.found.toString)
     val expands = new StringDiff(tme.requiredExpandsTo.toString, tme.foundExpandsTo.toString)
@@ -64,8 +73,12 @@ class ClippyPlugin(val global: Global) extends Plugin {
   private def urlFromOptions(options: List[String]): String =
     options.find(_.startsWith("url=")).map(_.substring(4)).getOrElse("https://www.scala-clippy.org") + "/api/advices"
 
-  private def colorsFromOptions(options: List[String]): Boolean =
-    options.find(_.startsWith("colors=")).map(_.substring(7))
+  private def colorsFromOptions(options: List[String]): Boolean = boolFromOptions(options, "colors")
+
+  private def testModeFromOptions(options: List[String]): Boolean = boolFromOptions(options, "testmode")
+
+  private def boolFromOptions(options: List[String], option: String): Boolean =
+    options.find(_.startsWith(s"$option=")).map(_.substring(option.length + 1))
       .getOrElse("false")
       .toBoolean
 
@@ -75,9 +88,7 @@ class ClippyPlugin(val global: Global) extends Plugin {
       .filter(_.exists())
 
   private def localStoreDirFromOptions(options: List[String]): File =
-    options.find(_.startsWith("store=")).map(_.substring(6)).map(new File(_)).getOrElse {
-      new File(System.getProperty("user.home"), ".clippy")
-    }
+    options.find(_.startsWith("store=")).map(_.substring(6)).map(new File(_)).getOrElse(DefaultStoreDir)
 
   private def loadAdvices(url: String, localStoreDir: File, projectAdviceFile: Option[File]): List[Advice] = {
     implicit val ec = scala.concurrent.ExecutionContext.Implicits.global

plugin/src/main/scala/com/softwaremill/clippy/InjectReporter.scala

@@ -0,0 +1,27 @@
+package com.softwaremill.clippy
+
+import scala.reflect.internal.util.Position
+import scala.tools.nsc.plugins.PluginComponent
+import scala.tools.nsc.{Global, Phase}
+
+class InjectReporter(handleError: (Position, String) => String, superGlobal: Global) extends PluginComponent {
+
+  override val global = superGlobal
+
+  override val runsAfter = List[String]("parser")
+  override val runsBefore = List[String]("namer")
+  override val phaseName = "inject-clippy-reporter"
+
+  override def newPhase(prev: Phase) = new Phase(prev) {
+
+    override def name = phaseName
+
+    override def description = "Switches the reporter to Clippy's DelegatingReporter"
+
+    override def run(): Unit = {
+      val r = global.reporter
+      global.reporter = new DelegatingReporter(r, handleError)
+    }
+  }
+
+}

tests/src/test/scala/org/softwaremill/clippy/CompileTests.scala

@@ -2,10 +2,9 @@ package org.softwaremill.clippy
 
 import java.io.{FileOutputStream, File}
 import java.util.zip.GZIPOutputStream
-
+import scala.reflect.runtime.currentMirror
 import com.softwaremill.clippy._
 import org.scalatest.{BeforeAndAfterAll, Matchers, FlatSpec}
-
 import scala.tools.reflect.ToolBox
 import scala.tools.reflect.ToolBoxError
 
@@ -136,23 +135,19 @@ class CompileTests extends FlatSpec with Matchers with BeforeAndAfterAll {
 
   val tb = {
     val cpp = sys.env("CLIPPY_PLUGIN_PATH")
-
-    import scala.reflect.runtime._
-    val cm = universe.runtimeMirror(getClass.getClassLoader)
-
-    cm.mkToolBox(options = s"-Xplugin:$cpp -Xplugin-require:clippy -P:clippy:colors=true")
+    currentMirror.mkToolBox(options = s"-Xplugin:$cpp -Xplugin-require:clippy -P:clippy:colors=true -P:clippy:testmode=true")
   }
 
-  def parse(snippet: String) = tb.eval(tb.parse(snippet))
+  def tryCompile(snippet: String) = tb.compile(tb.parse(snippet))
 
   for ((name, s) <- snippets) {
     name should "compile with errors" in {
-      (the[ToolBoxError] thrownBy parse(s)).message should include("Clippy advises")
+      (the[ToolBoxError] thrownBy tryCompile(s)).message should include("Clippy advises")
     }
   }
 
   "Clippy" should "return all matching advice" in {
-    (the[ToolBoxError] thrownBy parse(snippets("macwire")))
+    (the[ToolBoxError] thrownBy tryCompile(snippets("macwire")))
       .message should include("Clippy advises you to try one of these")
   }