From 0dcb57b5874763292a71fec95c7a4095b180f9e4 Mon Sep 17 00:00:00 2001 From: Dale Wijnand Date: Wed, 29 Mar 2017 14:43:38 +0100 Subject: [PATCH] Remove warnings in the build setup --- project/Docs.scala | 11 +++++----- project/NightlyPlugin.scala | 18 ++++++--------- project/Sxr.scala | 16 +++++++------- project/Transform.scala | 44 +++++++++++++++++++++++-------------- project/Util.scala | 44 ++++++++++++++++++++++--------------- project/plugins.sbt | 1 + 6 files changed, 76 insertions(+), 58 deletions(-) diff --git a/project/Docs.scala b/project/Docs.scala index 7fcfb8541..411a8f64f 100644 --- a/project/Docs.scala +++ b/project/Docs.scala @@ -23,7 +23,7 @@ object Docs { def ghPagesSettings = ghpages.settings ++ Seq( git.remoteRepo := "git@github.com:sbt/sbt.github.com.git", localRepoDirectory, - ghkeys.synchLocal <<= synchLocalImpl, + ghkeys.synchLocal := synchLocalImpl.value, GitKeys.gitBranch in ghkeys.updatedRepository := Some("master") ) @@ -35,14 +35,15 @@ object Docs { } def siteIncludeSxr(prefix: String) = Seq( - mappings in sxr <<= sxr.map(dir => Path.allSubpaths(dir).toSeq) + mappings in sxr := Path.allSubpaths(sxr.value).toSeq ) ++ site.addMappingsToSiteDir(mappings in sxr, prefix) - def synchLocalImpl = (ghkeys.privateMappings, ghkeys.updatedRepository, version, streams) map { - (mappings, repo, v, s) => - val versioned = repo / v + def synchLocalImpl = Def task { + val repo = ghkeys.updatedRepository.value + val versioned = repo / version.value IO.delete(versioned / "sxr") IO.delete(versioned / "api") + val mappings = ghkeys.privateMappings.value val toCopy = for ((file, target) <- mappings if siteInclude(file)) yield (file, versioned / target) IO.copy(toCopy) repo diff --git a/project/NightlyPlugin.scala b/project/NightlyPlugin.scala index 5ab480cf2..46e6f4f70 100644 --- a/project/NightlyPlugin.scala +++ b/project/NightlyPlugin.scala @@ -3,22 +3,18 @@ import Keys._ import Dependencies._ object NightlyPlugin extends AutoPlugin { - import autoImport._ - override def trigger = allRequirements override def requires = plugins.JvmPlugin - object autoImport { - lazy val includeTestDependencies = SettingKey[Boolean]("includeTestDependencies", "Doesn't declare test dependencies.") - def testDependencies = libraryDependencies <++= includeTestDependencies { incl => - if (incl) Seq( - scalaCheck % Test, - specs2 % Test, - junit % Test - ) + object autoImport { + val includeTestDependencies = settingKey[Boolean]("Doesn't declare test dependencies.") + + def testDependencies = libraryDependencies ++= ( + if (includeTestDependencies.value) Seq(scalaCheck % Test, specs2 % Test, junit % Test) else Seq() - } + ) } + import autoImport._ override def buildSettings: Seq[Setting[_]] = Seq( // Avoid 2.12.x nightlies diff --git a/project/Sxr.scala b/project/Sxr.scala index 4fcc5fe91..e85488afe 100644 --- a/project/Sxr.scala +++ b/project/Sxr.scala @@ -18,21 +18,21 @@ object Sxr { scalacOptions += "-Xplugin:" + managedClasspath.value.files.filter(_.getName.contains("sxr")).absString, scalacOptions += "-Ystop-after:sxr", target := target.in(taskGlobal).value / "browse", - sxr in taskGlobal <<= sxrTask + sxr in taskGlobal := sxrTask.value ) def taskGlobal = ThisScope.copy(task = Global) - def sxrTask = (sources, target, scalacOptions, classpathOptions, scalaInstance, fullClasspath, streams) map { (srcs, out, opts, cpOpts, si, cp, s) => - val cache = s.cacheDirectory + def sxrTask = Def task { + val out = target.value val outputDir = out.getParentFile / (out.getName + ".sxr") - val f = FileFunction.cached(cache / "sxr", FilesInfo.hash) { in => - s.log.info("Generating sxr output in " + outputDir.getAbsolutePath + "...") + val f = FileFunction.cached(streams.value.cacheDirectory / "sxr", FilesInfo.hash) { in => + streams.value.log.info("Generating sxr output in " + outputDir.getAbsolutePath + "...") IO.delete(out) IO.createDirectory(out) - val comp = new compiler.RawCompiler(si, cpOpts, s.log) - comp(in.toSeq.sorted, cp.files, out, opts) + val comp = new compiler.RawCompiler(scalaInstance.value, classpathOptions.value, streams.value.log) + comp(in.toSeq.sorted, fullClasspath.value.files, out, scalacOptions.value) Set(outputDir) } - f(srcs.toSet) + f(sources.value.toSet) outputDir } } diff --git a/project/Transform.scala b/project/Transform.scala index 521397cb1..7f01d062c 100644 --- a/project/Transform.scala +++ b/project/Transform.scala @@ -17,12 +17,15 @@ object Transform { lazy val conscriptConfigs = TaskKey[Unit]("conscript-configs") def conscriptSettings(launch: Reference) = Seq( - conscriptConfigs <<= (managedResources in launch in Compile, sourceDirectory in Compile).map { (res, src) => + conscriptConfigs := { + val res = (managedResources in launch in Compile).value + val src = (sourceDirectory in Compile).value val source = res.find(_.getName == "sbt.boot.properties") getOrElse sys.error("No managed boot.properties file.") copyConscriptProperties(source, src / "conscript") () } ) + def copyConscriptProperties(source: File, conscriptBase: File): Seq[File] = { IO.delete(conscriptBase) @@ -47,33 +50,42 @@ object Transform { ) def transSourceSettings = Seq( inputSourceDirectory := sourceDirectory.value / "input_sources", - inputSourceDirectories <<= Seq(inputSourceDirectory).join, - inputSources <<= inputSourceDirectories.map(dirs => (dirs ** (-DirectoryFilter)).get), - fileMappings in transformSources <<= transformSourceMappings, - transformSources <<= (fileMappings in transformSources, sourceProperties) map { (rs, props) => + inputSourceDirectories := Seq(inputSourceDirectory.value), + inputSources := (inputSourceDirectories.value ** (-DirectoryFilter)).get, + fileMappings in transformSources := transformSourceMappings.value, + transformSources := { + val rs = (fileMappings in transformSources).value + val props = sourceProperties.value rs map { case (in, out) => transform(in, out, props) } }, - sourceGenerators <+= transformSources + sourceGenerators += transformSources.taskValue ) - def transformSourceMappings = (inputSources, inputSourceDirectories, sourceManaged) map { (ss, sdirs, sm) => + def transformSourceMappings = Def task { + val ss = inputSources.value + val sdirs = inputSourceDirectories.value + val sm = sourceManaged.value ((ss --- sdirs) pair (rebase(sdirs, sm) | flat(sm))).toSeq } def configSettings = transResourceSettings ++ Seq( - resourceProperties <<= (organization, version, scalaVersion, isSnapshot) map { (org, v, sv, isSnapshot) => - Map("org" -> org, "sbt.version" -> v, "scala.version" -> sv) - } + resourceProperties := + Map("org" -> organization.value, "sbt.version" -> version.value, "scala.version" -> scalaVersion.value) ) def transResourceSettings = Seq( inputResourceDirectory := sourceDirectory.value / "input_resources", - inputResourceDirectories <<= Seq(inputResourceDirectory).join, - inputResources <<= inputResourceDirectories.map(dirs => (dirs ** (-DirectoryFilter)).get), - fileMappings in transformResources <<= transformResourceMappings, - transformResources <<= (fileMappings in transformResources, resourceProperties) map { (rs, props) => + inputResourceDirectories := Seq(inputResourceDirectory.value), + inputResources := (inputResourceDirectories.value ** (-DirectoryFilter)).get, + fileMappings in transformResources := transformResourceMappings.value, + transformResources := { + val rs = (fileMappings in transformResources).value + val props = resourceProperties.value rs map { case (in, out) => transform(in, out, props) } }, - resourceGenerators <+= transformResources + resourceGenerators += transformResources.taskValue ) - def transformResourceMappings = (inputResources, inputResourceDirectories, resourceManaged) map { (rs, rdirs, rm) => + def transformResourceMappings = Def task { + val rs = inputResources.value + val rdirs = inputResourceDirectories.value + val rm = resourceManaged.value ((rs --- rdirs) pair (rebase(rdirs, rm) | flat(rm))).toSeq } diff --git a/project/Util.scala b/project/Util.scala index 4be2870fa..f0bc180a8 100644 --- a/project/Util.scala +++ b/project/Util.scala @@ -1,13 +1,13 @@ import scala.util.control.NonFatal import sbt._ import Keys._ -import StringUtilities.normalize object Util { - val ExclusiveTest = Tags.Tag("exclusive-test") - lazy val componentID = SettingKey[Option[String]]("component-id") - lazy val scalaKeywords = TaskKey[Set[String]]("scala-keywords") - lazy val generateKeywords = TaskKey[File]("generateKeywords") + val ExclusiveTest: Tags.Tag = Tags.Tag("exclusive-test") + + val componentID: SettingKey[Option[String]] = settingKey[Option[String]]("") + val scalaKeywords: TaskKey[Set[String]] = taskKey[Set[String]]("") + val generateKeywords: TaskKey[File] = taskKey[File]("") def noPublishSettings: Seq[Setting[_]] = Seq(publish := {}) @@ -19,10 +19,15 @@ object Util { }) ) - lazy val javaOnlySettings = Seq[Setting[_]]( /*crossPaths := false, */ compileOrder := CompileOrder.JavaThenScala, unmanagedSourceDirectories in Compile <<= Seq(javaSource in Compile).join) + lazy val javaOnlySettings: Seq[Setting[_]] = Seq( + // crossPaths := false, + compileOrder := CompileOrder.JavaThenScala, + unmanagedSourceDirectories in Compile := Seq((javaSource in Compile).value) + ) + lazy val baseScalacOptions = Seq( scalacOptions ++= Seq("-Xelide-below", "0"), - scalacOptions <++= scalaVersion map CrossVersion.partialVersion map { + scalacOptions ++= (CrossVersion partialVersion scalaVersion.value match { case Some((2, 9)) | Some((2, 8)) => Nil // support 2.9 for some subprojects for the Scala Eclipse IDE case _ => Seq( "-encoding", "utf8", @@ -38,16 +43,17 @@ object Util { "-Ywarn-unused", "-Ywarn-unused-import" ) - }, - scalacOptions <++= scalaVersion map CrossVersion.partialVersion map { + }), + scalacOptions ++= (CrossVersion partialVersion scalaVersion.value match { case Some((2, 10)) => Seq("-deprecation", "-Xlint") case _ => Seq() - } + }) ) - def projectComponent = projectID <<= (projectID, componentID) { (pid, cid) => - cid match { case Some(id) => pid extra ("e:component" -> id); case None => pid } - } + def projectComponent: Setting[_] = projectID := (componentID.value match { + case Some(id) => projectID.value extra ("e:component" -> id) + case None => projectID.value + }) lazy val apiDefinitions = TaskKey[Seq[File]]("api-definitions") @@ -129,6 +135,7 @@ object Util { val g = new scala.tools.nsc.Global(new scala.tools.nsc.Settings) g.nme.keywords.map(_.toString) } + def writeScalaKeywords(base: File, keywords: Set[String]): File = { val init = keywords.map(tn => '"' + tn + '"').mkString("Set(", ", ", ")") @@ -143,10 +150,11 @@ object %s { IO.write(out, keywordsSrc) out } + def keywordsSettings: Seq[Setting[_]] = inConfig(Compile)(Seq( scalaKeywords := getScalaKeywords, - generateKeywords <<= (sourceManaged, scalaKeywords) map writeScalaKeywords, - sourceGenerators <+= generateKeywords map (x => Seq(x)) + generateKeywords := writeScalaKeywords(sourceManaged.value, scalaKeywords.value), + sourceGenerators += Def.task(Seq(generateKeywords.value)).taskValue )) } @@ -159,9 +167,9 @@ object Licensed { def seePaths(base: File, noticeString: String): Seq[File] = seeRegex.findAllIn(noticeString).matchData.map(d => licensePath(base, d.group(1))).toList def settings: Seq[Setting[_]] = Seq( - notice <<= baseDirectory(_ / "NOTICE"), - unmanagedResources in Compile <++= (notice, extractLicenses) map { _ +: _ }, - extractLicenses <<= (baseDirectory in ThisBuild, notice, streams) map extractLicenses0 + notice := (baseDirectory.value / "NOTICE"), + unmanagedResources in Compile ++= notice.value +: extractLicenses.value, + extractLicenses := extractLicenses0((baseDirectory in ThisBuild).value, notice.value, streams.value) ) def extractLicenses0(base: File, note: File, s: TaskStreams): Seq[File] = if (!note.exists) Nil else diff --git a/project/plugins.sbt b/project/plugins.sbt index 841f96856..27d89b44e 100644 --- a/project/plugins.sbt +++ b/project/plugins.sbt @@ -1,4 +1,5 @@ scalaVersion := "2.10.6" +scalacOptions ++= Seq("-feature", "-language:postfixOps") addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.5") addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "0.1.11")