Add testing and rework applying SemanticDB plugin after feedback in c…

…omments

config/src/main/scala-2.10/bloop/config/ConfigEncoderDecoders.scala

@@ -189,9 +189,6 @@ object ConfigEncoderDecoders {
   implicit val projectEncoder: ObjectEncoder[Project] = deriveEncoder
   implicit val projectDecoder: Decoder[Project] = deriveDecoder
 
-  implicit val settingsEncoder: ObjectEncoder[Settings] = deriveEncoder
-  implicit val settingsDecoder: Decoder[Settings] = deriveDecoder
-
   implicit val allEncoder: ObjectEncoder[File] = deriveEncoder
   implicit val allDecoder: Decoder[File] = deriveDecoder
 }

config/src/main/scala-2.11-12/bloop/config/ConfigEncoderDecoders.scala

@@ -177,9 +177,6 @@ object ConfigEncoderDecoders {
   implicit val projectEncoder: ObjectEncoder[Project] = deriveEncoder
   implicit val projectDecoder: Decoder[Project] = deriveDecoder
 
-  implicit val settingsEncoder: ObjectEncoder[Settings] = deriveEncoder
-  implicit val settingsDecoder: Decoder[Settings] = deriveDecoder
-
   implicit val allEncoder: ObjectEncoder[File] = deriveEncoder
   implicit val allDecoder: Decoder[File] = deriveDecoder
 }

config/src/main/scala/bloop/config/Config.scala

@@ -213,8 +213,6 @@ object Config {
       modules: List[Module]
   )
 
-  case class Settings(semanticDBVersion: String)
-
   case class Project(
       name: String,
       directory: Path,
@@ -288,8 +286,7 @@ object Config {
             List(),
             Some(outAnalysisFile),
             Some(CompileSetup.empty)
-          )
-        ),
+          )),
         Some(Java(List("-version"))),
         Some(Sbt("1.1.0", Nil)),
         Some(Test(List(), TestOptions(Nil, Nil))),

frontend/src/it/scala/bloop/CommunityBuild.scala

@@ -88,8 +88,8 @@ abstract class CommunityBuild(val buildpressHomeDir: AbsolutePath) {
 
   def loadStateForBuild(configDirectory: AbsolutePath, logger: Logger): State = {
     assert(configDirectory.exists, "Does not exist: " + configDirectory)
-    val loadedProjects = BuildLoader.loadSynchronously(configDirectory, logger)
-    val build = Build(configDirectory, loadedProjects)
+    val (loadedProjects, buildSettings) = BuildLoader.loadSynchronously(configDirectory, logger)
+    val build = Build(configDirectory, buildSettings, loadedProjects)
     val state = State.forTests(build, compilerCache, logger)
     state.copy(results = ResultsCache.emptyForTests)
   }

frontend/src/main/scala/bloop/Bloop.scala

@@ -21,6 +21,7 @@ import _root_.monix.eval.Task
 
 import scala.annotation.tailrec
 import scala.concurrent.Promise
+import bloop.data.BuildSettings
 
 object Bloop extends CaseApp[CliOptions] {
   private val reader = consoleReader()
@@ -35,8 +36,8 @@ object Bloop extends CaseApp[CliOptions] {
     )
     logger.warn("Please refer to our documentation for more information.")
     val client = ClientInfo.CliClientInfo("bloop-single-app", () => true)
-    val projects = BuildLoader.loadSynchronously(configDirectory, logger)
-    val build = Build(configDirectory, projects)
+    val (projects, settings) = BuildLoader.loadSynchronously(configDirectory, logger)
+    val build = Build(configDirectory, settings, projects)
     val state = State(build, client, NoPool, options.common, logger)
     run(state, options)
   }

frontend/src/main/scala/bloop/bsp/BloopBspServices.scala

@@ -38,6 +38,7 @@ import scala.concurrent.duration.FiniteDuration
 import scala.util.Success
 import scala.util.Failure
 import monix.execution.Cancelable
+import bloop.data.BuildSettings
 
 final class BloopBspServices(
     callSiteState: State,
@@ -180,34 +181,45 @@ final class BloopBspServices(
       () => isClientConnected.get
     )
 
-    /*Metals*/ 
-    if (params.displayName.contains("Metals")) {
-      BuildLoader.writeSettingsFile(params.data, configDir, callSiteState.logger)
+    /*Metals*/
+    val saveSettings = Task {
+      if (params.displayName.contains("Metals")) {
+        params.data match {
+          case Some(json) =>
+            val settings = BuildSettings.fromJson(json)
+            val savedSettings = BuildSettings.fromFile(configDir, callSiteState.logger)
+            if (savedSettings.isEmpty || savedSettings.exists(_ != settings)) {
+              BuildSettings.write(configDir, settings)
+            }
+          case _ =>
+        }
+      }
     }
     /*------*/
-
-    reloadState(configDir, client).map { state =>
-      callSiteState.logger.info(s"request received: build/initialize")
-      clientInfo.success(client)
-      connectedBspClients.put(client, configDir)
-      observer.foreach(_.onNext(state.copy(client = client)))
-      Right(
-        bsp.InitializeBuildResult(
-          BuildInfo.bloopName,
-          BuildInfo.version,
-          BuildInfo.bspVersion,
-          bsp.BuildServerCapabilities(
-            compileProvider = Some(BloopBspServices.DefaultCompileProvider),
-            testProvider = Some(BloopBspServices.DefaultTestProvider),
-            runProvider = Some(BloopBspServices.DefaultRunProvider),
-            inverseSourcesProvider = Some(true),
-            dependencySourcesProvider = Some(true),
-            resourcesProvider = Some(true),
-            buildTargetChangedProvider = Some(false)
-          ),
-          None
+    saveSettings.flatMap { _ =>
+      reloadState(configDir, client).map { state =>
+        callSiteState.logger.info(s"request received: build/initialize")
+        clientInfo.success(client)
+        connectedBspClients.put(client, configDir)
+        observer.foreach(_.onNext(state.copy(client = client)))
+        Right(
+          bsp.InitializeBuildResult(
+            BuildInfo.bloopName,
+            BuildInfo.version,
+            BuildInfo.bspVersion,
+            bsp.BuildServerCapabilities(
+              compileProvider = Some(BloopBspServices.DefaultCompileProvider),
+              testProvider = Some(BloopBspServices.DefaultTestProvider),
+              runProvider = Some(BloopBspServices.DefaultRunProvider),
+              inverseSourcesProvider = Some(true),
+              dependencySourcesProvider = Some(true),
+              resourcesProvider = Some(true),
+              buildTargetChangedProvider = Some(false)
+            ),
+            None
+          )
         )
-      )
+      }
     }
   }
 

frontend/src/main/scala/bloop/data/BuildSettings.scala

@@ -0,0 +1,70 @@
+package bloop.data
+
+import bloop.engine.BuildLoader
+import bloop.logging.Logger
+import bloop.logging.DebugFilter
+import java.nio.charset.StandardCharsets
+import bloop.config.ConfigEncoderDecoders
+import io.circe.Printer
+import io.circe.Json
+import io.circe.parser
+import bloop.io.AbsolutePath
+import java.nio.file.Files
+import io.circe.JsonObject
+import bloop.DependencyResolution
+import scala.util.Try
+import io.circe.ObjectEncoder
+import io.circe.Decoder
+import io.circe.derivation._
+import java.nio.file.Path
+import scala.util.Failure
+import scala.util.Success
+
+case class BuildSettings(semanticDBVersion: Option[String])
+
+object BuildSettings {
+
+  /** File to store Metals specific settings*/
+  val settingsFileName = "bloop.settings.json"
+  private val settingsEncoder: ObjectEncoder[BuildSettings] = deriveEncoder
+  private val settingsDecoder: Decoder[BuildSettings] = deriveDecoder
+
+  def fromFile(configPath: AbsolutePath, logger: Logger): Option[BuildSettings] = {
+    val settingsPath = configPath.resolve(settingsFileName)
+    if (settingsPath.isFile) {
+      val bytes = Files.readAllBytes(settingsPath.underlying)
+      logger.debug(s"Loading workspace settings from $settingsFileName")(
+        DebugFilter.All
+      )
+      val contents = new String(bytes, StandardCharsets.UTF_8)
+      parser.parse(contents) match {
+        case Left(failure) => throw failure
+        case Right(json) => Option(fromJson(json))
+      }
+    } else {
+      None
+    }
+  }
+
+  def fromJson(json: Json): BuildSettings = {
+    settingsDecoder.decodeJson(json) match {
+      case Right(settings) => settings
+      case Left(failure) => throw failure
+    }
+  }
+
+  def write(configDir: AbsolutePath, settings: BuildSettings): Either[Throwable, Path] = {
+    Try {
+      val jsonObject = settingsEncoder(settings)
+      val output = Printer.spaces4.copy(dropNullValues = true).pretty(jsonObject)
+      Files.write(
+        configDir.resolve(settingsFileName).underlying,
+        output.getBytes(StandardCharsets.UTF_8)
+      )
+    } match {
+      case Failure(exception) => Left(exception)
+      case Success(value) => Right(value)
+    }
+  }
+
+}

frontend/src/main/scala/bloop/engine/Build.scala

@@ -7,9 +7,11 @@ import bloop.logging.Logger
 import bloop.util.CacheHashCode
 import bloop.io.ByteHasher
 import monix.eval.Task
+import bloop.data.BuildSettings
 
 final case class Build private (
     origin: AbsolutePath,
+    settings: Option[BuildSettings],
     projects: List[Project]
 ) extends CacheHashCode {
   private val stringToProjects: Map[String, Project] = projects.map(p => p.name -> p).toMap
@@ -32,8 +34,11 @@ final case class Build private (
     val files = projects.iterator.map(p => p.origin.toAttributedPath).toSet
     val newFiles = BuildLoader.readConfigurationFilesInBase(origin, logger).toSet
 
+    val loadedSettings = BuildSettings.fromFile(origin, logger)
+    val settingsChanged = loadedSettings == settings
+
     // This is the fast path to short circuit quickly if they are the same
-    if (newFiles == files) Task.now(Build.ReturnPreviousState)
+    if (newFiles == files && !settingsChanged) Task.now(Build.ReturnPreviousState)
     else {
       val filesToAttributed = projects.iterator.map(p => p.origin.path -> p).toMap
       // There has been at least either one addition, one removal or one change in a file time
@@ -58,7 +63,7 @@ final case class Build private (
         val deleted = files.toList.collect { case f if !newToAttributed.contains(f.path) => f.path }
         (newOrModified, deleted) match {
           case (Nil, Nil) => Build.ReturnPreviousState
-          case _ => Build.UpdateState(newOrModified, deleted)
+          case _ => Build.UpdateState(newOrModified, deleted, loadedSettings)
         }
       }
     }
@@ -70,7 +75,8 @@ object Build {
   case object ReturnPreviousState extends ReloadAction
   case class UpdateState(
       createdOrModified: List[ReadConfiguration],
-      deleted: List[AbsolutePath]
+      deleted: List[AbsolutePath],
+      settingsChanged: Option[BuildSettings]
   ) extends ReloadAction
 
   /** A configuration file is a combination of an absolute path and a file time. */