2014-12-18 13:57:05 +01:00
|
|
|
import Dependencies._
|
2014-12-18 05:38:10 +01:00
|
|
|
import Sxr.sxr
|
2019-12-08 00:39:30 +01:00
|
|
|
import Util._
|
|
|
|
|
import com.typesafe.tools.mima.core.ProblemFilters._
|
|
|
|
|
import com.typesafe.tools.mima.core._
|
2018-07-31 02:28:42 +02:00
|
|
|
import local.Scripted
|
2020-06-22 01:48:33 +02:00
|
|
|
import java.nio.file.{ Files, Path => JPath }
|
2019-12-08 00:39:30 +01:00
|
|
|
|
2019-07-27 21:47:00 +02:00
|
|
|
import scala.util.Try
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2019-05-13 19:59:58 +02:00
|
|
|
ThisBuild / version := {
|
2019-09-05 19:38:57 +02:00
|
|
|
val v = "1.4.0-SNAPSHOT"
|
2019-05-13 19:59:58 +02:00
|
|
|
nightlyVersion.getOrElse(v)
|
|
|
|
|
}
|
2019-05-17 20:51:07 +02:00
|
|
|
ThisBuild / scalafmtOnCompile := !(Global / insideCI).value
|
|
|
|
|
ThisBuild / Test / scalafmtOnCompile := !(Global / insideCI).value
|
2019-08-31 22:37:01 +02:00
|
|
|
ThisBuild / turbo := true
|
2019-05-13 19:59:58 +02:00
|
|
|
|
2015-02-06 19:48:12 +01:00
|
|
|
// ThisBuild settings take lower precedence,
|
|
|
|
|
// but can be shared across the multi projects.
|
2017-04-21 09:14:31 +02:00
|
|
|
def buildLevelSettings: Seq[Setting[_]] =
|
|
|
|
|
inThisBuild(
|
|
|
|
|
Seq(
|
|
|
|
|
organization := "org.scala-sbt",
|
|
|
|
|
description := "sbt is an interactive build tool",
|
|
|
|
|
bintrayOrganization := Some("sbt"),
|
|
|
|
|
bintrayRepository := {
|
|
|
|
|
if (publishStatus.value == "releases") "maven-releases"
|
|
|
|
|
else "maven-snapshots"
|
|
|
|
|
},
|
|
|
|
|
bintrayPackage := "sbt",
|
|
|
|
|
bintrayReleaseOnPublish := false,
|
2019-11-23 08:09:13 +01:00
|
|
|
licenses := List("Apache-2.0" -> url("https://github.com/sbt/sbt/blob/develop/LICENSE")),
|
2019-06-04 00:03:22 +02:00
|
|
|
javacOptions ++= Seq("-source", "1.8", "-target", "1.8"),
|
|
|
|
|
Compile / doc / javacOptions := Nil,
|
2017-04-21 09:14:31 +02:00
|
|
|
developers := List(
|
|
|
|
|
Developer("harrah", "Mark Harrah", "@harrah", url("https://github.com/harrah")),
|
|
|
|
|
Developer("eed3si9n", "Eugene Yokota", "@eed3si9n", url("https://github.com/eed3si9n")),
|
|
|
|
|
Developer("jsuereth", "Josh Suereth", "@jsuereth", url("https://github.com/jsuereth")),
|
|
|
|
|
Developer("dwijnand", "Dale Wijnand", "@dwijnand", url("https://github.com/dwijnand")),
|
2019-03-22 20:14:52 +01:00
|
|
|
Developer("eatkins", "Ethan Atkins", "@eatkins", url("https://github.com/eatkins")),
|
2018-01-26 15:19:14 +01:00
|
|
|
Developer(
|
|
|
|
|
"gkossakowski",
|
|
|
|
|
"Grzegorz Kossakowski",
|
|
|
|
|
"@gkossakowski",
|
|
|
|
|
url("https://github.com/gkossakowski")
|
|
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
Developer("Duhemm", "Martin Duhem", "@Duhemm", url("https://github.com/Duhemm"))
|
|
|
|
|
),
|
|
|
|
|
homepage := Some(url("https://github.com/sbt/sbt")),
|
|
|
|
|
scmInfo := Some(ScmInfo(url("https://github.com/sbt/sbt"), "git@github.com:sbt/sbt.git")),
|
2017-06-16 22:11:33 +02:00
|
|
|
resolvers += Resolver.mavenLocal,
|
2019-05-11 09:42:06 +02:00
|
|
|
)
|
|
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
|
2019-12-08 00:49:13 +01:00
|
|
|
def commonBaseSettings: Seq[Setting[_]] = Def.settings(
|
2019-05-11 09:42:06 +02:00
|
|
|
headerLicense := Some(
|
|
|
|
|
HeaderLicense.Custom(
|
|
|
|
|
"""|sbt
|
2018-09-14 09:38:58 +02:00
|
|
|
|Copyright 2011 - 2018, Lightbend, Inc.
|
2018-02-01 15:53:05 +01:00
|
|
|
|Copyright 2008 - 2010, Mark Harrah
|
2018-09-14 09:38:58 +02:00
|
|
|
|Licensed under Apache License 2.0 (see LICENSE)
|
2018-02-01 15:53:05 +01:00
|
|
|
|""".stripMargin
|
2019-05-11 09:42:06 +02:00
|
|
|
)
|
|
|
|
|
),
|
2018-02-01 15:53:05 +01:00
|
|
|
scalaVersion := baseScalaVersion,
|
|
|
|
|
componentID := None,
|
2019-07-09 22:55:04 +02:00
|
|
|
resolvers += Resolver.typesafeIvyRepo("releases").withName("typesafe-sbt-build-ivy-releases"),
|
2018-02-01 15:53:05 +01:00
|
|
|
resolvers += Resolver.sonatypeRepo("snapshots"),
|
|
|
|
|
resolvers += "bintray-sbt-maven-releases" at "https://dl.bintray.com/sbt/maven-releases/",
|
2019-11-30 23:18:41 +01:00
|
|
|
resolvers += Resolver.url(
|
|
|
|
|
"bintray-scala-hedgehog",
|
|
|
|
|
url("https://dl.bintray.com/hedgehogqa/scala-hedgehog")
|
|
|
|
|
)(Resolver.ivyStylePatterns),
|
2019-04-21 04:06:52 +02:00
|
|
|
testFrameworks += TestFramework("hedgehog.sbt.Framework"),
|
2019-10-21 02:42:52 +02:00
|
|
|
testFrameworks += TestFramework("verify.runner.Framework"),
|
2018-02-01 15:53:05 +01:00
|
|
|
concurrentRestrictions in Global += Util.testExclusiveRestriction,
|
|
|
|
|
testOptions in Test += Tests.Argument(TestFrameworks.ScalaCheck, "-w", "1"),
|
|
|
|
|
testOptions in Test += Tests.Argument(TestFrameworks.ScalaCheck, "-verbosity", "2"),
|
|
|
|
|
javacOptions in compile ++= Seq("-Xlint", "-Xlint:-serial"),
|
2019-03-22 07:28:14 +01:00
|
|
|
Compile / doc / scalacOptions ++= {
|
|
|
|
|
import scala.sys.process._
|
|
|
|
|
val devnull = ProcessLogger(_ => ())
|
|
|
|
|
val tagOrSha = ("git describe --exact-match" #|| "git rev-parse HEAD").lineStream(devnull).head
|
2018-02-22 02:33:45 +01:00
|
|
|
Seq(
|
|
|
|
|
"-sourcepath",
|
|
|
|
|
(baseDirectory in LocalRootProject).value.getAbsolutePath,
|
|
|
|
|
"-doc-source-url",
|
2019-03-22 07:28:14 +01:00
|
|
|
s"https://github.com/sbt/sbt/tree/$tagOrSha€{FILE_PATH}.scala"
|
2018-02-22 02:33:45 +01:00
|
|
|
)
|
|
|
|
|
},
|
2020-01-14 23:01:17 +01:00
|
|
|
Compile / javafmtOnCompile := Def
|
|
|
|
|
.taskDyn(if ((scalafmtOnCompile).value) Compile / javafmt else Def.task(()))
|
|
|
|
|
.value,
|
|
|
|
|
Test / javafmtOnCompile := Def
|
|
|
|
|
.taskDyn(if ((Test / scalafmtOnCompile).value) Test / javafmt else Def.task(()))
|
|
|
|
|
.value,
|
|
|
|
|
Compile / unmanagedSources / inputFileStamps :=
|
|
|
|
|
(Compile / unmanagedSources / inputFileStamps).dependsOn(Compile / javafmtOnCompile).value,
|
|
|
|
|
Test / unmanagedSources / inputFileStamps :=
|
|
|
|
|
(Test / unmanagedSources / inputFileStamps).dependsOn(Test / javafmtOnCompile).value,
|
2018-02-01 15:53:05 +01:00
|
|
|
crossScalaVersions := Seq(baseScalaVersion),
|
|
|
|
|
bintrayPackage := (bintrayPackage in ThisBuild).value,
|
|
|
|
|
bintrayRepository := (bintrayRepository in ThisBuild).value,
|
|
|
|
|
publishArtifact in Test := false,
|
|
|
|
|
fork in compile := true,
|
|
|
|
|
fork in run := true
|
|
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
def commonSettings: Seq[Setting[_]] =
|
|
|
|
|
commonBaseSettings :+
|
|
|
|
|
addCompilerPlugin("org.spire-math" % "kind-projector" % "0.9.4" cross CrossVersion.binary)
|
|
|
|
|
def utilCommonSettings: Seq[Setting[_]] =
|
|
|
|
|
commonBaseSettings :+ (crossScalaVersions := (scala212 :: scala213 :: Nil))
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
def minimalSettings: Seq[Setting[_]] =
|
2015-02-15 04:29:24 +01:00
|
|
|
commonSettings ++ customCommands ++
|
2017-04-21 09:14:31 +02:00
|
|
|
publishPomSettings ++ Release.javaVersionCheckSettings
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
def baseSettings: Seq[Setting[_]] =
|
2017-04-20 01:56:35 +02:00
|
|
|
minimalSettings ++ Seq(projectComponent) ++ baseScalacOptions ++ Licensed.settings
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
def testedBaseSettings: Seq[Setting[_]] =
|
|
|
|
|
baseSettings ++ testDependencies
|
|
|
|
|
|
2019-12-08 00:49:13 +01:00
|
|
|
val sbt13Plus = Seq("1.3.0")
|
|
|
|
|
val sbt10Plus =
|
2019-05-11 09:42:06 +02:00
|
|
|
Seq(
|
|
|
|
|
"1.0.0",
|
|
|
|
|
"1.0.1",
|
|
|
|
|
"1.0.2",
|
|
|
|
|
"1.0.3",
|
|
|
|
|
"1.0.4",
|
|
|
|
|
"1.1.0",
|
|
|
|
|
"1.1.1",
|
|
|
|
|
"1.1.2",
|
|
|
|
|
"1.1.3",
|
|
|
|
|
"1.1.4",
|
|
|
|
|
"1.1.5",
|
|
|
|
|
"1.1.6",
|
|
|
|
|
"1.2.0",
|
2019-12-08 00:49:13 +01:00
|
|
|
"1.2.1",
|
|
|
|
|
/*DOA,*/ "1.2.3",
|
|
|
|
|
"1.2.4",
|
|
|
|
|
/*DOA,*/ "1.2.6",
|
2019-05-11 09:42:06 +02:00
|
|
|
"1.2.7",
|
|
|
|
|
"1.2.8",
|
|
|
|
|
) ++ sbt13Plus
|
2019-12-08 00:49:13 +01:00
|
|
|
val noUtilVersion =
|
|
|
|
|
Set("1.0.4", "1.1.4", "1.1.5", "1.1.6", "1.2.3", "1.2.4", "1.2.6", "1.2.7", "1.2.8")
|
2019-04-18 09:14:04 +02:00
|
|
|
|
2019-12-08 00:49:13 +01:00
|
|
|
val mimaSettings = mimaSettingsSince(sbt10Plus)
|
|
|
|
|
val utilMimaSettings = mimaSettingsSince(sbt10Plus.filterNot(noUtilVersion))
|
|
|
|
|
def mimaSettingsSince(versions: Seq[String]): Seq[Def.Setting[_]] = Def settings (
|
2018-01-10 04:48:07 +01:00
|
|
|
mimaPreviousArtifacts := {
|
2019-04-18 09:14:04 +02:00
|
|
|
val crossVersion = if (crossPaths.value) CrossVersion.binary else CrossVersion.disabled
|
|
|
|
|
versions.map(v => organization.value % moduleName.value % v cross crossVersion).toSet
|
2018-03-12 18:21:22 +01:00
|
|
|
},
|
|
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
2018-08-08 08:57:34 +02:00
|
|
|
// Changes in the internal package
|
2018-03-12 18:21:22 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.*"),
|
|
|
|
|
exclude[FinalClassProblem]("sbt.internal.*"),
|
|
|
|
|
exclude[FinalMethodProblem]("sbt.internal.*"),
|
|
|
|
|
exclude[IncompatibleResultTypeProblem]("sbt.internal.*"),
|
2018-10-02 16:51:20 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.*")
|
2018-03-12 18:21:22 +01:00
|
|
|
),
|
2017-07-20 18:31:39 +02:00
|
|
|
)
|
|
|
|
|
|
2019-12-08 00:49:13 +01:00
|
|
|
val scriptedSbtReduxMimaSettings = Def.settings(mimaPreviousArtifacts := Set())
|
2018-07-10 06:58:45 +02:00
|
|
|
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val sbtRoot: Project = (project in file("."))
|
2017-05-03 16:52:36 +02:00
|
|
|
.enablePlugins(ScriptedPlugin) // , SiteScaladocPlugin, GhpagesPlugin)
|
2017-07-20 04:00:42 +02:00
|
|
|
.configs(Sxr.SxrConf)
|
|
|
|
|
.aggregate(nonRoots: _*)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
buildLevelSettings,
|
|
|
|
|
minimalSettings,
|
2018-10-05 09:04:22 +02:00
|
|
|
onLoadMessage := {
|
2019-03-23 17:31:22 +01:00
|
|
|
val version = sys.props("java.specification.version")
|
2018-10-05 09:04:22 +02:00
|
|
|
""" __ __
|
|
|
|
|
| _____/ /_ / /_
|
|
|
|
|
| / ___/ __ \/ __/
|
|
|
|
|
| (__ ) /_/ / /_
|
|
|
|
|
| /____/_.___/\__/
|
|
|
|
|
|Welcome to the build for sbt.
|
|
|
|
|
|""".stripMargin +
|
2019-05-11 09:42:06 +02:00
|
|
|
(if (version != "1.8")
|
|
|
|
|
s"""!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
2019-03-23 17:31:22 +01:00
|
|
|
| Java version is $version. We recommend java 8.
|
2018-10-05 09:04:22 +02:00
|
|
|
|!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!""".stripMargin
|
2019-05-11 09:42:06 +02:00
|
|
|
else "")
|
2018-10-05 09:04:22 +02:00
|
|
|
},
|
2017-05-08 15:34:41 +02:00
|
|
|
Util.baseScalacOptions,
|
|
|
|
|
Docs.settings,
|
|
|
|
|
Sxr.settings,
|
|
|
|
|
scalacOptions += "-Ymacro-expand:none", // for both sxr and doc
|
|
|
|
|
sources in sxr := {
|
|
|
|
|
val allSources = (sources ?? Nil).all(docProjects).value
|
|
|
|
|
allSources.flatten.distinct
|
|
|
|
|
}, //sxr
|
|
|
|
|
sources in (Compile, doc) := (sources in sxr).value, // doc
|
|
|
|
|
Sxr.sourceDirectories := {
|
|
|
|
|
val allSourceDirectories = (sourceDirectories ?? Nil).all(docProjects).value
|
|
|
|
|
allSourceDirectories.flatten
|
|
|
|
|
},
|
|
|
|
|
fullClasspath in sxr := (externalDependencyClasspath in Compile in sbtProj).value,
|
|
|
|
|
dependencyClasspath in (Compile, doc) := (fullClasspath in sxr).value,
|
|
|
|
|
Util.publishPomSettings,
|
|
|
|
|
otherRootSettings,
|
|
|
|
|
Transform.conscriptSettings(bundledLauncherProj),
|
2015-02-06 20:35:32 +01:00
|
|
|
publish := {},
|
2017-05-30 08:44:13 +02:00
|
|
|
publishLocal := {},
|
2017-11-29 22:45:02 +01:00
|
|
|
skip in publish := true,
|
2019-05-11 09:42:06 +02:00
|
|
|
commands in Global += Command
|
|
|
|
|
.single("sbtOn")((state, dir) => s"sbtProj/test:runMain sbt.RunFromSourceMain $dir" :: state),
|
2019-10-17 23:27:43 +02:00
|
|
|
mimaSettings,
|
2019-10-20 06:41:53 +02:00
|
|
|
mimaPreviousArtifacts := Set.empty,
|
2020-06-22 01:48:33 +02:00
|
|
|
genExecutable := (sbtClientProj / genExecutable).evaluated,
|
|
|
|
|
genNativeExecutable := (sbtClientProj / genNativeExecutable).value,
|
2015-03-24 21:12:51 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// This is used to configure an sbt-launcher for this version of sbt.
|
|
|
|
|
lazy val bundledLauncherProj =
|
2017-04-21 09:14:31 +02:00
|
|
|
(project in file("launch"))
|
|
|
|
|
.settings(
|
|
|
|
|
minimalSettings,
|
|
|
|
|
inConfig(Compile)(Transform.configSettings),
|
|
|
|
|
Release.launcherSettings(sbtLaunchJar)
|
|
|
|
|
)
|
|
|
|
|
.enablePlugins(SbtLauncherPlugin)
|
|
|
|
|
.settings(
|
|
|
|
|
name := "sbt-launch",
|
|
|
|
|
moduleName := "sbt-launch",
|
|
|
|
|
description := "sbt application launcher",
|
|
|
|
|
autoScalaLibrary := false,
|
|
|
|
|
crossPaths := false,
|
2017-07-20 18:31:39 +02:00
|
|
|
// mimaSettings, // TODO: Configure MiMa, deal with Proguard
|
2017-04-21 09:14:31 +02:00
|
|
|
publish := Release.deployLauncher.value,
|
|
|
|
|
publishLauncher := Release.deployLauncher.value,
|
2019-10-17 23:27:43 +02:00
|
|
|
packageBin in Compile := sbtLaunchJar.value,
|
|
|
|
|
mimaSettings,
|
|
|
|
|
mimaPreviousArtifacts := Set()
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2014-12-18 19:14:04 +01:00
|
|
|
/* ** subproject declarations ** */
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2017-06-26 12:38:37 +02:00
|
|
|
val collectionProj = (project in file("internal") / "util-collection")
|
|
|
|
|
.settings(
|
|
|
|
|
testedBaseSettings,
|
|
|
|
|
Util.keywordsSettings,
|
|
|
|
|
name := "Collections",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies ++= Seq(sjsonNewScalaJson.value),
|
|
|
|
|
mimaSettings,
|
2017-09-22 05:05:48 +02:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// Added private[sbt] method to capture State attributes.
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.util.AttributeMap.setCond"),
|
2017-10-19 02:10:29 +02:00
|
|
|
// Dropped in favour of kind-projector's inline type lambda syntax
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.util.TypeFunctions$P1of2"),
|
2017-10-20 00:19:16 +02:00
|
|
|
// Dropped in favour of kind-projector's polymorphic lambda literals
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.util.Param"),
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.util.Param$"),
|
2017-10-20 05:18:43 +02:00
|
|
|
// Dropped in favour of plain scala.Function, and its compose method
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.util.Fn1"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.TypeFunctions.toFn1"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.Types.toFn1"),
|
2017-12-04 16:50:45 +01:00
|
|
|
// Instead of defining foldr in KList & overriding in KCons,
|
|
|
|
|
// it's now abstract in KList and defined in both KCons & KNil.
|
|
|
|
|
exclude[FinalMethodProblem]("sbt.internal.util.KNil.foldr"),
|
|
|
|
|
exclude[DirectAbstractMethodProblem]("sbt.internal.util.KList.foldr"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.Init*.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.Settings0.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#INode.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.TypeFunctions.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.Settings.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#MixedNode.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.EvaluateSettings#BindNode.this"),
|
2019-11-30 23:18:41 +01:00
|
|
|
exclude[IncompatibleSignatureProblem](
|
|
|
|
|
"sbt.internal.util.EvaluateSettings#BindNode.dependsOn"
|
|
|
|
|
),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.Types.some")
|
2017-09-22 05:05:48 +02:00
|
|
|
),
|
2017-06-26 12:38:37 +02:00
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(utilPosition)
|
2017-06-26 12:38:37 +02:00
|
|
|
|
|
|
|
|
// Command line-related utilities.
|
|
|
|
|
val completeProj = (project in file("internal") / "util-complete")
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilControl, utilLogging)
|
2017-06-26 12:38:37 +02:00
|
|
|
.settings(
|
|
|
|
|
testedBaseSettings,
|
|
|
|
|
name := "Completion",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies += jline,
|
2020-06-30 17:57:57 +02:00
|
|
|
libraryDependencies += jline3,
|
2017-07-20 18:31:39 +02:00
|
|
|
mimaSettings,
|
2018-07-16 04:28:55 +02:00
|
|
|
// Parser is used publicly, so we can't break bincompat.
|
|
|
|
|
mimaBinaryIssueFilters := Seq(
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.SoftInvalid.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Invalid.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Finite.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.Infinite.decrement"),
|
2018-07-16 04:28:55 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.complete.History.this"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.suggestion"),
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.token"),
|
2019-11-22 20:37:07 +01:00
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.util.complete.Completion.displayOnly"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.util.complete.*"),
|
2017-12-04 17:18:08 +01:00
|
|
|
),
|
2017-06-26 12:38:37 +02:00
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.configure(addSbtIO)
|
2017-06-26 12:38:37 +02:00
|
|
|
|
|
|
|
|
// A logic with restricted negation as failure for a unique, stable model
|
|
|
|
|
val logicProj = (project in file("internal") / "util-logic")
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilRelation)
|
2017-06-26 12:38:37 +02:00
|
|
|
.settings(
|
|
|
|
|
testedBaseSettings,
|
2017-07-20 18:31:39 +02:00
|
|
|
name := "Logic",
|
|
|
|
|
mimaSettings,
|
2017-06-26 12:38:37 +02:00
|
|
|
)
|
|
|
|
|
|
2019-12-08 00:49:13 +01:00
|
|
|
// defines Java structures used across Scala versions, such as the API structures and relationships extracted by
|
|
|
|
|
// the analysis compiler phases and passed back to sbt. The API structures are defined in a simple
|
|
|
|
|
// format from which Java sources are generated by the datatype generator Projproject
|
|
|
|
|
lazy val utilInterface = (project in file("internal") / "util-interface").settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
javaOnlySettings,
|
|
|
|
|
crossPaths := false,
|
|
|
|
|
name := "Util Interface",
|
|
|
|
|
exportJars := true,
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lazy val utilControl = (project in file("internal") / "util-control").settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Control",
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lazy val utilPosition = (project in file("internal") / "util-position")
|
|
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Position",
|
|
|
|
|
scalacOptions += "-language:experimental.macros",
|
|
|
|
|
libraryDependencies ++= Seq(scalaReflect.value, scalatest % "test"),
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lazy val utilLogging = (project in file("internal") / "util-logging")
|
|
|
|
|
.enablePlugins(ContrabandPlugin, JsonCodecPlugin)
|
2020-06-30 17:57:57 +02:00
|
|
|
.dependsOn(utilInterface, collectionProj)
|
2019-12-08 00:49:13 +01:00
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Logging",
|
|
|
|
|
libraryDependencies ++=
|
2020-06-30 17:57:57 +02:00
|
|
|
Seq(
|
|
|
|
|
jline,
|
|
|
|
|
jline3,
|
|
|
|
|
log4jApi,
|
|
|
|
|
log4jCore,
|
|
|
|
|
disruptor,
|
|
|
|
|
sjsonNewScalaJson.value,
|
|
|
|
|
scalaReflect.value
|
|
|
|
|
),
|
2019-12-08 00:49:13 +01:00
|
|
|
libraryDependencies ++= Seq(scalacheck % "test", scalatest % "test"),
|
|
|
|
|
libraryDependencies ++= (scalaVersion.value match {
|
|
|
|
|
case v if v.startsWith("2.12.") => List(compilerPlugin(silencerPlugin))
|
|
|
|
|
case _ => List()
|
|
|
|
|
}),
|
|
|
|
|
Compile / scalacOptions ++= (scalaVersion.value match {
|
|
|
|
|
case v if v.startsWith("2.12.") => List("-Ywarn-unused:-locals,-explicits,-privates")
|
|
|
|
|
case _ => List()
|
|
|
|
|
}),
|
|
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
2019-12-13 03:10:45 +01:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2019-12-08 00:49:13 +01:00
|
|
|
contrabandFormatsForType in generateContrabands in Compile := { tpe =>
|
|
|
|
|
val old = (contrabandFormatsForType in generateContrabands in Compile).value
|
|
|
|
|
val name = tpe.removeTypeParameters.name
|
|
|
|
|
if (name == "Throwable") Nil
|
|
|
|
|
else old(tpe)
|
|
|
|
|
},
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.SuccessEvent.copy*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.TraceEvent.copy*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.util.StringEvent.copy*"),
|
|
|
|
|
// Private final class constructors changed
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.util.InterfaceUtil#ConcretePosition.this"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.util.InterfaceUtil#ConcreteProblem.this"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.util.ConsoleOut.flush"),
|
|
|
|
|
// This affects Scala 2.11 only it seems, so it's ok?
|
|
|
|
|
exclude[InheritedNewAbstractMethodProblem](
|
|
|
|
|
"sbt.internal.util.codec.JsonProtocol.LogOptionFormat"
|
|
|
|
|
),
|
|
|
|
|
exclude[InheritedNewAbstractMethodProblem](
|
|
|
|
|
"sbt.internal.util.codec.JsonProtocol.ProgressItemFormat"
|
|
|
|
|
),
|
|
|
|
|
exclude[InheritedNewAbstractMethodProblem](
|
|
|
|
|
"sbt.internal.util.codec.JsonProtocol.ProgressEventFormat"
|
|
|
|
|
),
|
|
|
|
|
),
|
|
|
|
|
)
|
|
|
|
|
.configure(addSbtIO)
|
|
|
|
|
|
|
|
|
|
lazy val utilRelation = (project in file("internal") / "util-relation")
|
|
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Relation",
|
|
|
|
|
libraryDependencies ++= Seq(scalacheck % "test"),
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
// Persisted caching based on sjson-new
|
|
|
|
|
lazy val utilCache = (project in file("util-cache"))
|
|
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Cache",
|
|
|
|
|
libraryDependencies ++=
|
|
|
|
|
Seq(sjsonNewScalaJson.value, sjsonNewMurmurhash.value, scalaReflect.value),
|
|
|
|
|
libraryDependencies ++= Seq(scalatest % "test"),
|
|
|
|
|
utilMimaSettings,
|
|
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// Added a method to a sealed trait, technically not a problem for Scala
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.util.HashFileInfo.hashArray"),
|
|
|
|
|
)
|
|
|
|
|
)
|
|
|
|
|
.configure(addSbtIO)
|
|
|
|
|
|
|
|
|
|
// Builds on cache to provide caching for filesystem-related operations
|
|
|
|
|
lazy val utilTracking = (project in file("util-tracking"))
|
|
|
|
|
.dependsOn(utilCache)
|
|
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Tracking",
|
|
|
|
|
libraryDependencies ++= Seq(scalatest % "test"),
|
|
|
|
|
utilMimaSettings,
|
2020-04-24 11:53:38 +02:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// Private final class constructors changed
|
|
|
|
|
ProblemFilters.exclude[IncompatibleMethTypeProblem]("sbt.util.Tracked#CacheHelp.this"),
|
|
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
)
|
|
|
|
|
.configure(addSbtIO)
|
|
|
|
|
|
|
|
|
|
lazy val utilScripted = (project in file("internal") / "util-scripted")
|
|
|
|
|
.dependsOn(utilLogging, utilInterface)
|
|
|
|
|
.settings(
|
|
|
|
|
utilCommonSettings,
|
|
|
|
|
name := "Util Scripted",
|
2020-01-10 14:41:55 +01:00
|
|
|
libraryDependencies += scalaParsers,
|
2019-12-08 00:49:13 +01:00
|
|
|
utilMimaSettings,
|
|
|
|
|
)
|
|
|
|
|
.configure(addSbtIO)
|
2014-12-18 05:38:10 +01:00
|
|
|
/* **** Intermediate-level Modules **** */
|
|
|
|
|
|
|
|
|
|
// Runner for uniform test interface
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val testingProj = (project in file("testing"))
|
|
|
|
|
.enablePlugins(ContrabandPlugin, JsonCodecPlugin)
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(testAgentProj, utilLogging)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
baseSettings,
|
2014-12-18 05:38:10 +01:00
|
|
|
name := "Testing",
|
2020-01-10 14:41:55 +01:00
|
|
|
libraryDependencies ++= Seq(
|
|
|
|
|
scalaXml,
|
2019-05-11 09:42:06 +02:00
|
|
|
testInterface,
|
|
|
|
|
launcherInterface,
|
|
|
|
|
sjsonNewScalaJson.value
|
|
|
|
|
),
|
2018-09-18 17:47:55 +02:00
|
|
|
Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
|
2017-04-19 07:50:18 +02:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-04-01 23:19:45 +02:00
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-07-20 18:31:39 +02:00
|
|
|
contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
|
|
|
|
|
mimaSettings,
|
2018-03-07 21:31:24 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// private[sbt]
|
2018-03-27 15:12:01 +02:00
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.TestStatus.write"),
|
|
|
|
|
exclude[IncompatibleResultTypeProblem]("sbt.TestStatus.read"),
|
2018-03-12 16:18:42 +01:00
|
|
|
// copy method was never meant to be public
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupErrorEvent.copy"),
|
2019-05-11 09:42:06 +02:00
|
|
|
exclude[DirectMissingMethodProblem](
|
|
|
|
|
"sbt.protocol.testing.EndTestGroupErrorEvent.copy$default$*"
|
|
|
|
|
),
|
2018-03-12 16:18:42 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.EndTestGroupEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.StartTestGroupEvent.copy"),
|
2019-05-11 09:42:06 +02:00
|
|
|
exclude[DirectMissingMethodProblem](
|
|
|
|
|
"sbt.protocol.testing.StartTestGroupEvent.copy$default$*"
|
|
|
|
|
),
|
2018-03-12 16:18:42 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestCompleteEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestInitEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemDetail.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestItemEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.testing.TestStringEvent.copy$default$1"),
|
2018-04-23 19:46:08 +02:00
|
|
|
//no reason to use
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.JUnitXmlTestsListener.testSuite"),
|
2018-03-12 16:18:42 +01:00
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.configure(addSbtIO, addSbtCompilerClasspath)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Testing agent for running tests in a separate process.
|
2017-05-24 11:15:22 +02:00
|
|
|
lazy val testAgentProj = (project in file("testing") / "agent")
|
|
|
|
|
.settings(
|
|
|
|
|
minimalSettings,
|
|
|
|
|
crossScalaVersions := Seq(baseScalaVersion),
|
|
|
|
|
crossPaths := false,
|
|
|
|
|
autoScalaLibrary := false,
|
|
|
|
|
name := "Test Agent",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies += testInterface,
|
|
|
|
|
mimaSettings,
|
2017-05-24 11:15:22 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Basic task engine
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val taskProj = (project in file("tasks"))
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilControl)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2017-07-20 18:31:39 +02:00
|
|
|
name := "Tasks",
|
|
|
|
|
mimaSettings,
|
2019-03-08 21:26:15 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Triggers.this"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Triggers.runBefore"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Triggers.injectFor"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Triggers.onComplete"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Inc.apply"),
|
2019-03-18 02:17:39 +01:00
|
|
|
// ok because sbt.ExecuteProgress has been under private[sbt]
|
|
|
|
|
exclude[IncompatibleResultTypeProblem]("sbt.ExecuteProgress.initial"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ExecuteProgress.*"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.ExecuteProgress.*"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ExecuteProgress.*"),
|
|
|
|
|
// ok because sbt.Execute has been under private[sbt]
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Execute.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Execute#CyclicException.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.NodeView.*"),
|
2019-03-08 21:26:15 +01:00
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Standard task system. This provides map, flatMap, join, and more on top of the basic task model.
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val stdTaskProj = (project in file("tasks-standard"))
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilLogging, utilCache)
|
2017-04-21 09:14:31 +02:00
|
|
|
.dependsOn(taskProj % "compile;test->test")
|
|
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2014-12-18 05:38:10 +01:00
|
|
|
name := "Task System",
|
2017-07-20 18:31:39 +02:00
|
|
|
testExclusive,
|
|
|
|
|
mimaSettings,
|
2019-05-29 15:43:14 +02:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// unused private[sbt]
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Task.mapTask"),
|
|
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.configure(addSbtIO)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Embedded Scala code runner
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val runProj = (project in file("run"))
|
2017-06-16 22:11:33 +02:00
|
|
|
.enablePlugins(ContrabandPlugin)
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilLogging, utilControl)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2017-05-12 00:33:12 +02:00
|
|
|
name := "Run",
|
2018-09-18 17:47:55 +02:00
|
|
|
Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
|
2017-05-12 00:33:12 +02:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-07-20 18:31:39 +02:00
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
|
|
|
|
mimaSettings,
|
2018-03-12 16:18:42 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// copy method was never meant to be public
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ForkOptions.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#BufferedOutput.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy$default$*"),
|
|
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.configure(addSbtIO, addSbtCompilerClasspath)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2018-02-01 15:53:11 +01:00
|
|
|
val sbtProjDepsCompileScopeFilter =
|
2019-05-11 09:42:06 +02:00
|
|
|
ScopeFilter(
|
|
|
|
|
inDependencies(LocalProject("sbtProj"), includeRoot = false),
|
|
|
|
|
inConfigurations(Compile)
|
|
|
|
|
)
|
2018-02-01 15:53:11 +01:00
|
|
|
|
2018-07-10 06:58:45 +02:00
|
|
|
lazy val scriptedSbtReduxProj = (project in file("scripted-sbt-redux"))
|
2020-01-12 04:52:36 +01:00
|
|
|
.dependsOn(sbtProj % "compile;test->test", commandProj, utilLogging, utilScripted)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
baseSettings,
|
2018-07-10 06:58:45 +02:00
|
|
|
name := "Scripted sbt Redux",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies ++= Seq(launcherInterface % "provided"),
|
|
|
|
|
mimaSettings,
|
2018-07-10 06:58:45 +02:00
|
|
|
scriptedSbtReduxMimaSettings,
|
|
|
|
|
)
|
2019-12-08 00:49:13 +01:00
|
|
|
.configure(addSbtIO, addSbtCompilerInterface, addSbtLmCore)
|
2018-07-10 06:58:45 +02:00
|
|
|
|
|
|
|
|
lazy val scriptedSbtOldProj = (project in file("scripted-sbt-old"))
|
|
|
|
|
.dependsOn(scriptedSbtReduxProj)
|
|
|
|
|
.settings(
|
|
|
|
|
baseSettings,
|
|
|
|
|
name := "Scripted sbt",
|
|
|
|
|
mimaSettings,
|
2018-01-13 23:08:48 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// sbt.test package is renamed to sbt.scriptedtest.
|
|
|
|
|
exclude[MissingClassProblem]("sbt.test.*"),
|
2018-07-10 06:58:45 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.test.*"),
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.test.*"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.test.*"),
|
2018-01-13 23:08:48 +01:00
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2018-07-10 06:58:45 +02:00
|
|
|
lazy val scriptedPluginProj = (project in file("scripted-plugin"))
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
baseSettings,
|
2017-07-20 18:31:39 +02:00
|
|
|
name := "Scripted Plugin",
|
|
|
|
|
mimaSettings,
|
2018-01-13 20:28:06 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
2018-01-13 23:08:48 +01:00
|
|
|
// scripted plugin has moved into sbt mothership.
|
|
|
|
|
exclude[MissingClassProblem]("sbt.ScriptedPlugin*")
|
2018-01-13 20:28:06 +01:00
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Implementation and support code for defining actions.
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val actionsProj = (project in file("main-actions"))
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(
|
|
|
|
|
completeProj,
|
|
|
|
|
runProj,
|
|
|
|
|
stdTaskProj,
|
|
|
|
|
taskProj,
|
|
|
|
|
testingProj,
|
|
|
|
|
utilLogging,
|
|
|
|
|
utilRelation,
|
|
|
|
|
utilTracking,
|
|
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2016-11-30 14:42:51 +01:00
|
|
|
name := "Actions",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies += sjsonNewScalaJson.value,
|
|
|
|
|
mimaSettings,
|
2017-12-05 17:16:26 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// Removed unused private[sbt] nested class
|
|
|
|
|
exclude[MissingClassProblem]("sbt.Doc$Scaladoc"),
|
|
|
|
|
// Removed no longer used private[sbt] method
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Doc.generate"),
|
2018-04-05 08:14:00 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.compiler.Eval.filesModifiedBytes"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.compiler.Eval.fileModifiedBytes"),
|
2017-12-05 17:16:26 +01:00
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
|
|
|
|
.configure(
|
|
|
|
|
addSbtIO,
|
2017-06-26 12:38:37 +02:00
|
|
|
addSbtCompilerInterface,
|
|
|
|
|
addSbtCompilerClasspath,
|
|
|
|
|
addSbtCompilerApiInfo,
|
2017-07-16 00:09:40 +02:00
|
|
|
addSbtLmCore,
|
2017-06-26 12:38:37 +02:00
|
|
|
addSbtZinc
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lazy val protocolProj = (project in file("protocol"))
|
2017-06-16 22:11:33 +02:00
|
|
|
.enablePlugins(ContrabandPlugin, JsonCodecPlugin)
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(collectionProj, utilLogging)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2016-12-01 09:14:07 +01:00
|
|
|
testedBaseSettings,
|
|
|
|
|
name := "Protocol",
|
2018-01-30 06:43:30 +01:00
|
|
|
libraryDependencies ++= Seq(sjsonNewScalaJson.value, ipcSocket),
|
2018-09-18 17:47:55 +02:00
|
|
|
Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
|
2017-04-19 07:50:18 +02:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-03-20 17:44:57 +01:00
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-07-20 18:31:39 +02:00
|
|
|
contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
|
|
|
|
|
mimaSettings,
|
2018-03-12 16:18:42 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
// copy method was never meant to be public
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ChannelAcceptedEvent.copy$default$1"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$1"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecCommand.copy$default$2"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecStatusEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.ExecutionEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.InitCommand.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.LogEvent.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuery.copy$default$1"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQueryFailure.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.protocol.SettingQuerySuccess.copy$default$*"),
|
2020-05-12 17:34:34 +02:00
|
|
|
// ignore missing or incompatible methods in sbt.internal
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.*"),
|
2018-03-12 16:18:42 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.*"),
|
2019-10-21 04:33:02 +02:00
|
|
|
exclude[MissingTypesProblem]("sbt.internal.protocol.JsonRpcResponseError"),
|
2018-03-12 16:18:42 +01:00
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2016-12-01 09:14:07 +01:00
|
|
|
|
2014-12-18 05:38:10 +01:00
|
|
|
// General command support and core commands not specific to a build system
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val commandProj = (project in file("main-command"))
|
2017-06-16 22:11:33 +02:00
|
|
|
.enablePlugins(ContrabandPlugin, JsonCodecPlugin)
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(protocolProj, completeProj, utilLogging)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2015-03-24 16:14:13 +01:00
|
|
|
name := "Command",
|
2017-12-19 06:44:31 +01:00
|
|
|
libraryDependencies ++= Seq(launcherInterface, sjsonNewScalaJson.value, templateResolverApi),
|
2020-01-08 15:41:29 +01:00
|
|
|
libraryDependencies ++= (scalaVersion.value match {
|
|
|
|
|
case v if v.startsWith("2.12.") => List(compilerPlugin(silencerPlugin))
|
|
|
|
|
case _ => List()
|
|
|
|
|
}),
|
2018-09-18 17:47:55 +02:00
|
|
|
Compile / scalacOptions += "-Ywarn-unused:-locals,-explicits,-privates",
|
2017-04-19 07:50:18 +02:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2016-11-30 14:42:51 +01:00
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-07-20 18:31:39 +02:00
|
|
|
contrabandFormatsForType in generateContrabands in Compile := ContrabandConfig.getFormats,
|
|
|
|
|
mimaSettings,
|
2017-09-18 01:08:45 +02:00
|
|
|
mimaBinaryIssueFilters ++= Vector(
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Exit.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Reboot.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.TemplateResolverInfo.apply"),
|
2018-04-26 15:03:35 +02:00
|
|
|
// dropped private[sbt] method
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.BasicCommands.compatCommands"),
|
|
|
|
|
// dropped mainly internal command strings holder
|
|
|
|
|
exclude[MissingClassProblem]("sbt.BasicCommandStrings$Compat$"),
|
2018-01-10 04:48:07 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.BasicCommands.rebootOptionParser"),
|
2017-09-18 01:08:45 +02:00
|
|
|
// Changed the signature of Server method. nacho cheese.
|
2017-09-22 05:05:48 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.internal.server.Server.*"),
|
|
|
|
|
// Added method to ServerInstance. This is also internal.
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.server.ServerInstance.*"),
|
2017-10-02 21:52:02 +02:00
|
|
|
// Added method to CommandChannel. internal.
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.CommandChannel.*"),
|
2017-10-21 08:27:40 +02:00
|
|
|
// Added an overload to reboot. The overload is private[sbt].
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.StateOps.reboot"),
|
2018-01-30 06:43:30 +01:00
|
|
|
// Replace nailgun socket stuff
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.NG*"),
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.ReferenceCountedFileDescriptor"),
|
2018-03-12 18:13:17 +01:00
|
|
|
// made private[sbt] method private[this]
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.State.handleException"),
|
2018-03-12 16:18:42 +01:00
|
|
|
// copy method was never meant to be public
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.CommandSource.copy$default$*"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Exec.copy"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Exec.copy$default$*"),
|
2018-06-26 04:34:55 +02:00
|
|
|
// internal
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.client.ServerConnection.*"),
|
2020-05-22 14:39:45 +02:00
|
|
|
exclude[MissingTypesProblem]("sbt.internal.server.ServerConnection*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.server.ServerConnection.*")
|
2017-11-28 03:37:31 +01:00
|
|
|
),
|
|
|
|
|
unmanagedSources in (Compile, headerCreate) := {
|
|
|
|
|
val old = (unmanagedSources in (Compile, headerCreate)).value
|
2019-05-11 09:42:06 +02:00
|
|
|
old filterNot { x =>
|
|
|
|
|
(x.getName startsWith "NG") || (x.getName == "ReferenceCountedFileDescriptor.java")
|
|
|
|
|
}
|
2017-11-28 03:37:31 +01:00
|
|
|
},
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2017-06-23 18:58:00 +02:00
|
|
|
.configure(
|
|
|
|
|
addSbtIO,
|
2017-06-26 12:38:37 +02:00
|
|
|
addSbtCompilerInterface,
|
2017-06-23 18:58:00 +02:00
|
|
|
addSbtCompilerClasspath,
|
Add global file repository task
Every time that the compile task is run, there are potentially a large
number of iops that must occur in order for sbt to generate the source
file list as well as for zinc to check which files have changed since
the last build. This can lead to a noticeable delay between when a build
is started (either manually or by triggered execution) and when
compilation actually begins. To reduce this latency, I am adding a
global view of the file system that will be stored in
BasicKeys.globalFileTreeView.
To make this work, I introduce the StampedFile trait, which augments the
java.io.File class with a stamp method that returns the zinc stamp for
the file. For source files, this will be a hash of the file, while for
binaries, it is just the last modified time. In order to gain access to
the sbt.internal.inc.Stamper class, I had to append addSbtZinc to the
commandProj configurations.
This view may or may not use an in-memory cache of the file system tree
to return the results. Because there is always the risk of the cache
getting out of sync with the actual file system, I both make it optional
to use a cache and provide a mechanism for flushing the cache. Moreover,
the in-memory cache implementation in sbt.io, which is backed by a
swoval FileTreeRepository, has the property that touching a monitored
directory invalidates the entire directory within the cache, so the
flush command isn't even strictly needed in general.
Because caching is optional, the global is of a FileTreeDataView, which
doesn't specify a caching strategy. Subsequent commits will make use of
this to potentially speed up incremental compilation by caching the
Stamps of the source files so that zinc does not need to compute the
hashes itself and will allow for continuous builds to use the cache to
monitor events instead of creating a new, standalone FileEventMonitor.
2018-08-26 01:43:48 +02:00
|
|
|
addSbtLmCore,
|
|
|
|
|
addSbtZinc
|
2017-06-23 18:58:00 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2017-05-23 23:48:20 +02:00
|
|
|
// The core macro project defines the main logic of the DSL, abstracted
|
2019-07-28 05:49:24 +02:00
|
|
|
// away from several sbt implementors (tasks, settings, et cetera).
|
2017-05-23 23:53:04 +02:00
|
|
|
lazy val coreMacrosProj = (project in file("core-macros"))
|
2017-06-26 12:38:37 +02:00
|
|
|
.dependsOn(collectionProj)
|
2017-05-23 23:53:04 +02:00
|
|
|
.settings(
|
2017-12-04 16:56:07 +01:00
|
|
|
baseSettings,
|
2017-05-23 23:48:20 +02:00
|
|
|
name := "Core Macros",
|
2017-07-20 18:31:39 +02:00
|
|
|
libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value,
|
|
|
|
|
mimaSettings,
|
2017-05-23 23:48:20 +02:00
|
|
|
)
|
|
|
|
|
|
2014-12-18 05:38:10 +01:00
|
|
|
// Fixes scope=Scope for Setting (core defined in collectionProj) to define the settings system used in build definitions
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val mainSettingsProj = (project in file("main-settings"))
|
2019-12-08 00:49:13 +01:00
|
|
|
.dependsOn(
|
|
|
|
|
completeProj,
|
|
|
|
|
commandProj,
|
|
|
|
|
stdTaskProj,
|
|
|
|
|
coreMacrosProj,
|
|
|
|
|
utilLogging,
|
|
|
|
|
utilCache,
|
|
|
|
|
utilRelation,
|
|
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2017-05-24 10:27:51 +02:00
|
|
|
name := "Main Settings",
|
2020-01-12 04:52:36 +01:00
|
|
|
testOptions in Test ++= {
|
|
|
|
|
val cp = (Test / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
|
|
|
|
|
val framework = TestFrameworks.ScalaTest
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.classpath=$cp") ::
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.version=${version.value}") ::
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.scala.version=${scalaVersion.value}") :: Nil
|
|
|
|
|
},
|
2017-07-20 18:31:39 +02:00
|
|
|
mimaSettings,
|
2018-01-10 04:48:07 +01:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Previous#References.getReferences"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Def.delegate"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Def.add"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Def.grouped"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Def.compile"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Def.asTransform"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Def.StaticScopes"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Previous.this"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.BuildRef.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ScopeMask.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Def.intersect"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.LocalProject.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.pure"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.flatten"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.map"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.InitializeInstance.app"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.pure"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.map"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.app"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.ParserInstance.pure"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.pure"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.flatten"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.map"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.TaskInstance.app"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.std.FullInstance.flatten"),
|
2018-01-10 04:48:07 +01:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Scope.display012StyleMasked"),
|
2018-03-27 02:36:41 +02:00
|
|
|
// added a method to a sealed trait
|
|
|
|
|
exclude[InheritedNewAbstractMethodProblem]("sbt.Scoped.canEqual"),
|
|
|
|
|
exclude[InheritedNewAbstractMethodProblem]("sbt.ScopedTaskable.canEqual"),
|
2020-02-16 20:51:53 +01:00
|
|
|
// widened ScopedTaskable parameter to (new) supertype Taskable
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Scoped#RichTaskable*.this"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.TupleSyntax.t*ToTable*"),
|
2018-01-10 04:48:07 +01:00
|
|
|
),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
|
|
|
|
.configure(
|
2017-06-26 12:38:37 +02:00
|
|
|
addSbtIO,
|
|
|
|
|
addSbtCompilerInterface,
|
2017-04-21 09:14:31 +02:00
|
|
|
addSbtCompilerClasspath,
|
2017-07-16 00:09:40 +02:00
|
|
|
addSbtLmCore
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2019-04-18 09:14:04 +02:00
|
|
|
lazy val zincLmIntegrationProj = (project in file("zinc-lm-integration"))
|
|
|
|
|
.settings(
|
|
|
|
|
name := "Zinc LM Integration",
|
|
|
|
|
testedBaseSettings,
|
2020-01-12 04:52:36 +01:00
|
|
|
testOptions in Test +=
|
|
|
|
|
Tests.Argument(TestFrameworks.ScalaTest, s"-Dsbt.zinc.version=$zincVersion"),
|
2019-04-18 09:14:04 +02:00
|
|
|
mimaSettingsSince(sbt13Plus),
|
2020-04-24 23:43:07 +02:00
|
|
|
mimaBinaryIssueFilters ++= Seq(
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.inc.ZincComponentCompiler*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.inc.ZincComponentCompiler*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.inc.ZincLMHelper.update"),
|
|
|
|
|
),
|
2019-05-09 03:26:15 +02:00
|
|
|
libraryDependencies += launcherInterface,
|
2019-04-18 09:14:04 +02:00
|
|
|
)
|
|
|
|
|
.configure(addSbtZincCompileCore, addSbtLmCore, addSbtLmIvyTest)
|
|
|
|
|
|
2016-11-23 16:17:34 +01:00
|
|
|
// The main integration project for sbt. It brings all of the projects together, configures them, and provides for overriding conventions.
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val mainProj = (project in file("main"))
|
2017-06-16 22:11:33 +02:00
|
|
|
.enablePlugins(ContrabandPlugin)
|
2019-05-11 09:42:06 +02:00
|
|
|
.dependsOn(
|
|
|
|
|
logicProj,
|
|
|
|
|
actionsProj,
|
|
|
|
|
mainSettingsProj,
|
|
|
|
|
runProj,
|
|
|
|
|
commandProj,
|
|
|
|
|
collectionProj,
|
|
|
|
|
scriptedPluginProj,
|
2019-12-08 00:49:13 +01:00
|
|
|
zincLmIntegrationProj,
|
|
|
|
|
utilLogging,
|
2019-05-11 09:42:06 +02:00
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2015-03-27 00:22:24 +01:00
|
|
|
testedBaseSettings,
|
2014-12-18 05:38:10 +01:00
|
|
|
name := "Main",
|
2018-10-05 19:32:40 +02:00
|
|
|
checkPluginCross := {
|
|
|
|
|
val sv = scalaVersion.value
|
2020-01-10 14:41:55 +01:00
|
|
|
val f = baseDirectory.value / "src" / "main" / "scala" / "sbt" / "PluginCross.scala"
|
|
|
|
|
if (!IO.readLines(f).exists(_.contains(s""""$sv"""")))
|
|
|
|
|
sys.error(s"PluginCross.scala does not match up with the scalaVersion $sv")
|
2019-03-09 02:15:04 +01:00
|
|
|
},
|
2020-01-10 14:41:55 +01:00
|
|
|
libraryDependencies ++=
|
|
|
|
|
(Seq(scalaXml, launcherInterface, scalaCacheCaffeine, lmCoursierShaded) ++ log4jModules),
|
2020-01-08 15:41:29 +01:00
|
|
|
libraryDependencies ++= (scalaVersion.value match {
|
|
|
|
|
case v if v.startsWith("2.12.") => List(compilerPlugin(silencerPlugin))
|
|
|
|
|
case _ => List()
|
|
|
|
|
}),
|
2017-05-13 14:01:51 +02:00
|
|
|
managedSourceDirectories in Compile +=
|
|
|
|
|
baseDirectory.value / "src" / "main" / "contraband-scala",
|
2017-07-20 18:31:39 +02:00
|
|
|
sourceManaged in (Compile, generateContrabands) := baseDirectory.value / "src" / "main" / "contraband-scala",
|
2019-05-11 09:41:41 +02:00
|
|
|
testOptions in Test += Tests
|
2019-05-11 10:52:42 +02:00
|
|
|
.Argument(TestFrameworks.ScalaCheck, "-minSuccessfulTests", "1000"),
|
2017-07-20 18:31:39 +02:00
|
|
|
mimaSettings,
|
2017-09-22 05:05:48 +02:00
|
|
|
mimaBinaryIssueFilters ++= Vector(
|
2017-09-27 08:21:56 +02:00
|
|
|
// New and changed methods on KeyIndex. internal.
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.internal.KeyIndex.*"),
|
2019-01-04 15:55:28 +01:00
|
|
|
// internal
|
2020-05-12 17:34:34 +02:00
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.*"),
|
2017-12-14 14:41:40 +01:00
|
|
|
// Changed signature or removed private[sbt] methods
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Classpaths.unmanagedLibs0"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Defaults.allTestGroupsTask"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Plugins.topologicalSort"),
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.Defaults.allTestGroupsTask"),
|
2019-09-13 19:49:09 +02:00
|
|
|
exclude[DirectMissingMethodProblem]("sbt.StandardMain.shutdownHook"),
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.ResourceLoaderImpl"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.ConfigIndex.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.Inspect.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.ProjectIndex.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.BuildIndex.*"),
|
2020-05-01 13:41:13 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.server.BuildServerReporter.*"),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[VirtualStaticMemberProblem]("sbt.internal.server.LanguageServerProtocol.*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.librarymanagement.IvyXml.*"),
|
2019-10-19 10:38:54 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ScriptedPlugin.*Settings"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.plugins.SbtPlugin.*Settings"),
|
2019-09-27 19:25:48 +02:00
|
|
|
// Removed private internal classes
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.ReverseLookupClassLoaderHolder$BottomClassLoader"),
|
2019-11-30 23:18:41 +01:00
|
|
|
exclude[MissingClassProblem](
|
|
|
|
|
"sbt.internal.ReverseLookupClassLoaderHolder$ReverseLookupClassLoader$ResourceLoader"
|
|
|
|
|
),
|
2019-09-27 19:25:48 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.ReverseLookupClassLoaderHolder$ClassLoadingLock"),
|
2019-11-30 23:18:41 +01:00
|
|
|
exclude[MissingClassProblem](
|
|
|
|
|
"sbt.internal.ReverseLookupClassLoaderHolder$ReverseLookupClassLoader"
|
|
|
|
|
),
|
2019-09-27 19:25:48 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.LayeredClassLoaderImpl"),
|
2020-05-05 23:39:22 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.FileManagement"),
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.FileManagement$"),
|
|
|
|
|
exclude[MissingClassProblem]("sbt.internal.FileManagement$CopiedFileTreeRepository"),
|
2020-05-22 14:39:45 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.server.LanguageServerReporter*"),
|
2019-10-17 23:27:43 +02:00
|
|
|
// false positives
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.plugins.IvyPlugin.requires"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.plugins.JUnitXmlReportPlugin.requires"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.plugins.Giter8TemplatePlugin.requires"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.plugins.JvmPlugin.requires"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.plugins.SbtPlugin.requires"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ResolvedClasspathDependency.apply"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.ClasspathDependency.apply"),
|
2019-10-18 19:39:39 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.plugins.SemanticdbPlugin.globalSettings"),
|
2019-10-17 23:27:43 +02:00
|
|
|
// File -> Source
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Defaults.cleanFilesTask"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Defaults.resourceConfigPaths"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Defaults.sourceConfigPaths"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Defaults.configPaths"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Defaults.paths"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Keys.csrPublications"),
|
2019-11-30 23:18:41 +01:00
|
|
|
exclude[IncompatibleSignatureProblem](
|
|
|
|
|
"sbt.coursierint.CoursierArtifactsTasks.coursierPublicationsTask"
|
|
|
|
|
),
|
|
|
|
|
exclude[IncompatibleSignatureProblem](
|
|
|
|
|
"sbt.coursierint.CoursierArtifactsTasks.coursierPublicationsTask"
|
|
|
|
|
),
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.coursierint.LMCoursier.coursierConfiguration"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.coursierint.LMCoursier.publicationsSetting"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Project.inThisBuild"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Project.inConfig"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Project.inTask"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Project.inScope"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inThisBuild"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inConfig"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inTask"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.ProjectExtra.inScope"),
|
2019-11-10 09:01:28 +01:00
|
|
|
exclude[MissingTypesProblem]("sbt.internal.Load*"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.Load*"),
|
2020-05-22 14:39:45 +02:00
|
|
|
exclude[MissingTypesProblem]("sbt.internal.server.NetworkChannel"),
|
2019-12-05 17:45:33 +01:00
|
|
|
// IvyConfiguration was replaced by InlineIvyConfiguration in the generic
|
|
|
|
|
// signature, this does not break compatibility regardless of what
|
|
|
|
|
// cast a compiler might have inserted based on the old signature
|
|
|
|
|
// since we're returning the same values as before.
|
2020-04-24 23:43:07 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.Classpaths.mkIvyConfiguration"),
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.server.Definition*"),
|
2020-06-07 05:01:39 +02:00
|
|
|
exclude[IncompatibleTemplateDefProblem]("sbt.internal.server.LanguageServerProtocol"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Classpaths.warnInsecureProtocol"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Classpaths.warnInsecureProtocolInModules"),
|
2020-06-14 21:55:37 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.ExternalHooks*"),
|
Add multi-client ui to server
This commit makes it possible for the sbt server to render the same ui
to multiple clients. The network client ui should look nearly identical
to the console ui except for the log messages about the experimental
client.
The way that it works is that it associates a ui thread with each
terminal. Whenever a command starts or completes, callbacks are invoked
on the various channels to update their ui state. For example, if there
are two clients and one of them runs compile, then the prompt is changed
from AskUser to Running for the terminal that initiated the command
while the other client remains in the AskUser state. Whenever the client
changes uses ui states, the existing thread is terminated if it is
running and a new thread is begun.
The UITask formalizes this process. It is based on the AskUser class
from older versions of sbt. In fact, there is an AskUserTask which is
very similar. It uses jline to read input from the terminal (which could
be a network terminal). When it gets a line, it submits it to the
CommandExchange and exits. Once the next command is run (which may or
may not be the command it submitted), the ui state will be reset.
The debug, info, warn and error commands should work with the multi
client ui. When run, they set the log level globally, not just for the
client that set the level.
2019-12-18 19:24:32 +01:00
|
|
|
// This seems to be a mima problem. The older constructor still exists but
|
|
|
|
|
// mima seems to incorrectly miss the secondary constructor that provides
|
|
|
|
|
// the binary compatible version.
|
|
|
|
|
exclude[IncompatibleMethTypeProblem]("sbt.internal.server.NetworkChannel.this"),
|
Refactor watch
The existing implementation of watch did not work with the thin client.
In sbt 1.3.0, watch was changed to be a blocking command that performed
manual task evaluation. This commit makes the implementation more
similar to < 1.3.0 where watch modifies the state and after running the
user specified command(s), it enters a blocking command. The new
blocking command is very similar to the shell command.
As part of this change, I also reworked some of the internals of watch
so that a number of threads are spawned for reading file and input
events. By using background threads that write to a single event queue,
we are able to block on the file events and terminal input stream rather
than polling. After this change, the cpu utilization as measured by ps
drops from roughly 2% of a cpu to 0.
To integrate with the network client, we introduce a new UITask that is
similar to the AskUserTask but instead of reading lines and adding execs
to the command queue, it reads characters and converts them into watch
commands that we also append to the command queue.
With this new implementation, the watch task that was added in 1.3.0 no
longer works. My guess is that no one was really using it. It wasn't
documented anywhere. The motivation for the task implementation was that
it could be called within another task which would let users define a
task that monitors for file changes before running. Since this had never
been advertised and is only of limited utility anyway, I think it's fine
to break it.
I also had to disable the input-parser and symlinks tests. I'm not 100%
sure why the symlinks test was failing. It would tend to work on my
machine but fail in CI. I gave up on debugging it. The input-parser test
also fails but would be a good candidate to be moved to the client test
in the serverTestProj. At any rate, it was testing a code path that was
only exercised if the user changed the watchInputStream method which is
highly unlikely to have been done in any user builds.
The WatchSpec had become a nuisance and wasn't really preventing from
any regressions so I removed it. The scripted tests are how we test
watch.
2020-06-22 02:10:20 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.internal.DeprecatedContinuous.taskDefinitions"),
|
2020-07-03 21:02:38 +02:00
|
|
|
exclude[MissingClassProblem]("sbt.internal.SettingsGraph*")
|
2017-09-22 05:05:48 +02:00
|
|
|
)
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2017-06-23 18:58:00 +02:00
|
|
|
.configure(
|
|
|
|
|
addSbtIO,
|
2017-07-16 00:09:40 +02:00
|
|
|
addSbtLmCore,
|
2019-10-16 20:27:32 +02:00
|
|
|
addSbtLmIvy,
|
2017-06-26 12:38:37 +02:00
|
|
|
addSbtCompilerInterface,
|
2017-08-10 17:23:15 +02:00
|
|
|
addSbtZincCompile
|
|
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
|
|
|
|
|
// Strictly for bringing implicits and aliases from subsystems into the top-level sbt namespace through a single package object
|
|
|
|
|
// technically, we need a dependency on all of mainProj's dependencies, but we don't do that since this is strictly an integration project
|
|
|
|
|
// with the sole purpose of providing certain identifiers without qualification (with a package object)
|
2017-04-21 09:14:31 +02:00
|
|
|
lazy val sbtProj = (project in file("sbt"))
|
2020-01-12 04:52:36 +01:00
|
|
|
.dependsOn(mainProj)
|
2017-04-21 09:14:31 +02:00
|
|
|
.settings(
|
2018-01-24 09:56:42 +01:00
|
|
|
testedBaseSettings,
|
2014-12-18 05:38:10 +01:00
|
|
|
name := "sbt",
|
2015-09-14 09:27:22 +02:00
|
|
|
normalizedName := "sbt",
|
2017-01-15 07:44:05 +01:00
|
|
|
crossScalaVersions := Seq(baseScalaVersion),
|
2017-07-20 18:31:39 +02:00
|
|
|
crossPaths := false,
|
2017-11-23 15:58:26 +01:00
|
|
|
javaOptions ++= Seq("-Xdebug", "-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005"),
|
2017-07-20 18:31:39 +02:00
|
|
|
mimaSettings,
|
2017-08-28 06:42:26 +02:00
|
|
|
mimaBinaryIssueFilters ++= sbtIgnoredProblems,
|
2019-10-21 02:42:52 +02:00
|
|
|
)
|
2020-02-14 15:01:11 +01:00
|
|
|
.settings(
|
|
|
|
|
Test / run / connectInput := true,
|
|
|
|
|
Test / run / outputStrategy := Some(StdoutOutput),
|
|
|
|
|
Test / run / fork := true,
|
|
|
|
|
testOptions in Test ++= {
|
|
|
|
|
val cp = (Test / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
|
|
|
|
|
val framework = TestFrameworks.ScalaTest
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.classpath=$cp") ::
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.version=${version.value}") ::
|
|
|
|
|
Tests.Argument(framework, s"-Dsbt.server.scala.version=${scalaVersion.value}") :: Nil
|
|
|
|
|
},
|
|
|
|
|
)
|
2019-10-21 02:42:52 +02:00
|
|
|
.configure(addSbtIO, addSbtCompilerBridge)
|
|
|
|
|
|
|
|
|
|
lazy val serverTestProj = (project in file("server-test"))
|
|
|
|
|
.dependsOn(sbtProj % "test->test", scriptedSbtReduxProj % "test->test")
|
|
|
|
|
.settings(
|
|
|
|
|
testedBaseSettings,
|
|
|
|
|
crossScalaVersions := Seq(baseScalaVersion),
|
|
|
|
|
publish / skip := true,
|
|
|
|
|
// make server tests serial
|
2020-06-22 00:46:18 +02:00
|
|
|
Test / watchTriggers += baseDirectory.value.toGlob / "src" / "server-test" / **,
|
2019-10-21 02:42:52 +02:00
|
|
|
Test / parallelExecution := false,
|
2018-03-26 16:37:25 +02:00
|
|
|
Test / run / connectInput := true,
|
|
|
|
|
Test / run / outputStrategy := Some(StdoutOutput),
|
|
|
|
|
Test / run / fork := true,
|
2019-10-21 02:42:52 +02:00
|
|
|
Test / fork := true,
|
|
|
|
|
Test / javaOptions ++= {
|
2020-01-12 04:52:36 +01:00
|
|
|
val cp = (Test / fullClasspathAsJars).value.map(_.data).mkString(java.io.File.pathSeparator)
|
2020-02-14 06:06:34 +01:00
|
|
|
List(
|
|
|
|
|
s"-Dsbt.server.classpath=$cp",
|
2019-10-21 02:42:52 +02:00
|
|
|
s"-Dsbt.server.version=${version.value}",
|
2020-06-22 00:46:18 +02:00
|
|
|
s"-Dsbt.server.scala.version=${scalaVersion.value}",
|
|
|
|
|
s"-Dsbt.supershell=false",
|
2020-02-14 06:06:34 +01:00
|
|
|
)
|
2020-01-12 04:52:36 +01:00
|
|
|
},
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2017-10-20 05:18:43 +02:00
|
|
|
|
2020-06-22 01:48:33 +02:00
|
|
|
val isWin = scala.util.Properties.isWin
|
|
|
|
|
val generateReflectionConfig = taskKey[Unit]("generate the graalvm reflection config")
|
|
|
|
|
val genExecutable =
|
|
|
|
|
inputKey[JPath]("generate a java implementation of the thin client")
|
|
|
|
|
val graalClasspath = taskKey[String]("Generate the classpath for graal (compacted for windows)")
|
|
|
|
|
val graalNativeImageCommand = taskKey[String]("The native image command")
|
|
|
|
|
val graalNativeImageOptions = settingKey[Seq[String]]("The native image options")
|
|
|
|
|
val graalNativeImageClass = settingKey[String]("The class for the native image")
|
|
|
|
|
val genNativeExecutable = taskKey[JPath]("Generate a native executable")
|
|
|
|
|
val nativeExecutablePath = settingKey[JPath]("The location of the native executable")
|
|
|
|
|
lazy val sbtClientProj = (project in file("client"))
|
|
|
|
|
.dependsOn(commandProj)
|
|
|
|
|
.settings(
|
|
|
|
|
commonBaseSettings,
|
|
|
|
|
publish / skip := true,
|
|
|
|
|
name := "sbt-client",
|
|
|
|
|
mimaPreviousArtifacts := Set.empty,
|
|
|
|
|
crossPaths := false,
|
|
|
|
|
exportJars := true,
|
|
|
|
|
libraryDependencies += jansi,
|
2020-06-30 17:57:57 +02:00
|
|
|
libraryDependencies += jline3Jansi,
|
2020-06-22 01:48:33 +02:00
|
|
|
libraryDependencies += scalatest % "test",
|
|
|
|
|
/*
|
|
|
|
|
* On windows, the raw classpath is too large to be a command argument to an
|
|
|
|
|
* external process so we create symbolic links with short names to get the
|
|
|
|
|
* classpath length under the limit.
|
|
|
|
|
*/
|
|
|
|
|
graalClasspath := {
|
|
|
|
|
val original = (Compile / fullClasspathAsJars).value.map(_.data)
|
|
|
|
|
val outputDir = target.value / "graalcp"
|
|
|
|
|
IO.createDirectory(outputDir)
|
|
|
|
|
Files.walk(outputDir.toPath).forEach {
|
|
|
|
|
case f if f.getFileName.toString.endsWith(".jar") => Files.deleteIfExists(f)
|
|
|
|
|
case _ =>
|
|
|
|
|
}
|
|
|
|
|
original.zipWithIndex
|
|
|
|
|
.map {
|
|
|
|
|
case (f, i) =>
|
|
|
|
|
Files.createSymbolicLink(outputDir.toPath / s"$i.jar", f.toPath)
|
|
|
|
|
s"$i.jar"
|
|
|
|
|
}
|
|
|
|
|
.mkString(java.io.File.pathSeparator)
|
|
|
|
|
},
|
|
|
|
|
graalNativeImageCommand := System.getProperty("sbt.native-image", "native-image").toString,
|
|
|
|
|
genNativeExecutable / name := s"sbtc${if (isWin) ".exe" else ""}",
|
|
|
|
|
nativeExecutablePath := target.value.toPath / "bin" / (genNativeExecutable / name).value,
|
|
|
|
|
graalNativeImageClass := "sbt.client.Client",
|
|
|
|
|
genNativeExecutable := {
|
|
|
|
|
val prefix = Seq(graalNativeImageCommand.value, "-cp", graalClasspath.value)
|
|
|
|
|
val full = prefix ++ graalNativeImageOptions.value :+ graalNativeImageClass.value
|
|
|
|
|
val pb = new java.lang.ProcessBuilder(full: _*)
|
|
|
|
|
pb.directory(target.value / "graalcp")
|
|
|
|
|
val proc = pb.start()
|
|
|
|
|
val thread = new Thread {
|
|
|
|
|
setDaemon(true)
|
|
|
|
|
val is = proc.getInputStream
|
|
|
|
|
val es = proc.getErrorStream
|
|
|
|
|
|
|
|
|
|
override def run(): Unit = {
|
|
|
|
|
Thread.sleep(100)
|
|
|
|
|
while (proc.isAlive) {
|
|
|
|
|
if (is.available > 0 || es.available > 0) {
|
|
|
|
|
while (is.available > 0) System.out.print(is.read.toChar)
|
|
|
|
|
while (es.available > 0) System.err.print(es.read.toChar)
|
|
|
|
|
}
|
|
|
|
|
if (proc.isAlive) Thread.sleep(10)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
thread.start()
|
|
|
|
|
proc.waitFor(5, java.util.concurrent.TimeUnit.MINUTES)
|
2020-07-07 22:10:56 +02:00
|
|
|
assert(proc.exitValue == 0, s"Exit value ${proc.exitValue} was nonzero")
|
2020-06-22 01:48:33 +02:00
|
|
|
nativeExecutablePath.value
|
|
|
|
|
},
|
|
|
|
|
graalNativeImageOptions := Seq(
|
|
|
|
|
"--no-fallback",
|
|
|
|
|
s"--initialize-at-run-time=sbt.client",
|
|
|
|
|
"--verbose",
|
|
|
|
|
"-H:IncludeResourceBundles=jline.console.completer.CandidateListCompletionHandler",
|
|
|
|
|
"-H:+ReportExceptionStackTraces",
|
2020-07-01 23:29:50 +02:00
|
|
|
"-H:-ParseRuntimeOptions",
|
2020-06-22 01:48:33 +02:00
|
|
|
s"-H:Name=${target.value / "bin" / "sbtc"}",
|
|
|
|
|
),
|
|
|
|
|
genExecutable := {
|
|
|
|
|
val isFish = Def.spaceDelimited("").parsed.headOption.fold(false)(_ == "--fish")
|
|
|
|
|
val ext = if (isWin) ".bat" else if (isFish) ".fish" else ".sh"
|
|
|
|
|
val output = target.value.toPath / "bin" / s"${if (isFish) "fish-" else ""}client$ext"
|
|
|
|
|
java.nio.file.Files.createDirectories(output.getParent)
|
|
|
|
|
val cp = (Compile / fullClasspathAsJars).value.map(_.data)
|
|
|
|
|
val args =
|
|
|
|
|
if (isWin) "%*" else if (isFish) s"$$argv" else s"$$*"
|
|
|
|
|
java.nio.file.Files.write(
|
|
|
|
|
output,
|
|
|
|
|
s"""
|
|
|
|
|
|${if (isWin) "@echo off" else s"#!/usr/bin/env ${if (isFish) "fish" else "sh"}"}
|
|
|
|
|
|
|
|
|
|
|
|java -cp ${cp.mkString(java.io.File.pathSeparator)} sbt.client.Client --jna $args
|
|
|
|
|
""".stripMargin.linesIterator.toSeq.tail.mkString("\n").getBytes
|
|
|
|
|
)
|
|
|
|
|
output.toFile.setExecutable(true)
|
|
|
|
|
output
|
|
|
|
|
},
|
|
|
|
|
)
|
|
|
|
|
|
2019-03-09 02:15:04 +01:00
|
|
|
/*
|
2018-10-24 17:19:28 +02:00
|
|
|
lazy val sbtBig = (project in file(".big"))
|
|
|
|
|
.dependsOn(sbtProj)
|
|
|
|
|
.settings(
|
|
|
|
|
name := "sbt-big",
|
|
|
|
|
normalizedName := "sbt-big",
|
|
|
|
|
crossPaths := false,
|
|
|
|
|
assemblyShadeRules.in(assembly) := {
|
|
|
|
|
val packagesToBeShaded = Seq(
|
|
|
|
|
"fastparse",
|
|
|
|
|
"jawn",
|
|
|
|
|
"scalapb",
|
|
|
|
|
)
|
|
|
|
|
packagesToBeShaded.map( prefix => {
|
|
|
|
|
ShadeRule.rename(s"$prefix.**" -> s"sbt.internal.$prefix.@1").inAll
|
|
|
|
|
})
|
|
|
|
|
},
|
|
|
|
|
assemblyMergeStrategy in assembly := {
|
|
|
|
|
case "LICENSE" | "NOTICE" => MergeStrategy.first
|
|
|
|
|
case x => (assemblyMergeStrategy in assembly).value(x)
|
|
|
|
|
},
|
|
|
|
|
artifact.in(Compile, packageBin) := artifact.in(Compile, assembly).value,
|
|
|
|
|
assemblyOption.in(assembly) ~= { _.copy(includeScala = false) },
|
|
|
|
|
addArtifact(artifact.in(Compile, packageBin), assembly),
|
|
|
|
|
pomPostProcess := { node =>
|
|
|
|
|
new RuleTransformer(new RewriteRule {
|
|
|
|
|
override def transform(node: XmlNode): XmlNodeSeq = node match {
|
|
|
|
|
case e: Elem if node.label == "dependency" =>
|
|
|
|
|
Comment(
|
|
|
|
|
"the dependency that was here has been absorbed via sbt-assembly"
|
|
|
|
|
)
|
|
|
|
|
case _ => node
|
|
|
|
|
}
|
|
|
|
|
}).transform(node).head
|
|
|
|
|
},
|
|
|
|
|
)
|
2019-05-11 09:42:06 +02:00
|
|
|
*/
|
2018-10-24 17:19:28 +02:00
|
|
|
|
2019-12-27 06:24:03 +01:00
|
|
|
// util projects used by Zinc and Lm
|
|
|
|
|
lazy val lowerUtils = (project in (file("internal") / "lower"))
|
|
|
|
|
.aggregate(lowerUtilProjects.map(p => LocalProject(p.id)): _*)
|
|
|
|
|
.settings(
|
|
|
|
|
publish / skip := true,
|
|
|
|
|
crossScalaVersions := Nil,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
lazy val upperModules = (project in (file("internal") / "upper"))
|
|
|
|
|
.aggregate((allProjects diff lowerUtilProjects).map(p => LocalProject(p.id)): _*)
|
|
|
|
|
.settings(
|
|
|
|
|
publish / skip := true,
|
|
|
|
|
crossScalaVersions := Nil,
|
|
|
|
|
)
|
|
|
|
|
|
2017-08-28 06:42:26 +02:00
|
|
|
lazy val sbtIgnoredProblems = {
|
2017-11-29 22:45:02 +01:00
|
|
|
Vector(
|
2019-10-17 23:27:43 +02:00
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.package.some"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.package.inThisBuild"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.package.inConfig"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.package.inTask"),
|
|
|
|
|
exclude[IncompatibleSignatureProblem]("sbt.package.inScope"),
|
2018-01-10 04:48:07 +01:00
|
|
|
exclude[MissingClassProblem]("buildinfo.BuildInfo"),
|
|
|
|
|
exclude[MissingClassProblem]("buildinfo.BuildInfo$"),
|
2017-08-28 06:42:26 +02:00
|
|
|
// Added more items to Import trait.
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$WatchSource_="),
|
2017-11-29 22:45:02 +01:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.WatchSource"),
|
Add support for managed task inputs
In my recent changes to watch, I have been moving towards a world in
which sbt manages the file inputs and outputs at the task level. The
main idea is that we want to enable a user to specify the inputs and
outputs of a task and have sbt able to track those inputs across
multiple task evaluations. Sbt should be able to automatically trigger a
build when the inputs change and it also should be able to avoid task
evaluation if non of the inputs have changed.
The former case of having sbt automatically watch the file inputs of a
task has been present since watch was refactored. In this commit, I
make it possible for the user to retrieve the lists of new, modified and
deleted files. The user can then avoid task evaluation if none of the
inputs have changed.
To implement this, I inject a number of new settings during project
load if the fileInputs setting is defined for a task. The injected
settings are:
allPathsAndAttributes -- this retrieves all of the paths described by
the fileInputs for the task along with their attributes
fileStamps -- this retrieves all of the file stamps for the files
returned by allPathsAndAttributes
Using these two injected tasks, I also inject a number of derived tasks,
such as allFiles, which returns all of the regular files returned by
allPathsAndAttributes and changedFiles, which returns all of the regular
files that have been modified since the last run.
Using these injected settings, the user is able to write tasks that
avoid evaluation if the inputs haven't changed.
foo / fileInputs += baseDirectory.value.toGlob / ** / "*.scala"
foo := {
foo.previous match {
case Some(p) if (foo / changedFiles).value.isEmpty => p
case _ => fooImpl((foo / allFiles).value
}
}
To make this whole mechanism work, I add a private task key:
val fileAttributeMap = taskKey[java.util.HashMap[Path, Stamp]]("...")
This keeps track of the stamps for all of the files that are managed by
sbt. The fileStamps task will first look for the stamp in the attribute
map and, only if it is not present, it will update the cache. This
allows us to ensure that a given file will only be stamped once per task
evaluation run no matter how the file inputs are specified. Moreover, in
a continuous build, I'm able to reuse the attribute map which can
significantly reduce latency because the default file stamping
implementation used by zinc is fairly expensive (it can take anywhere
between 300-1500ms to stamp 5000 8kb source files on my mac).
I also renamed some of the watch related keys to be a bit more clear.
2019-04-24 02:00:13 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.AnyPath"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$**_="),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$*_="),
|
2019-04-30 21:02:28 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$ChangedFiles_="),
|
Add support for managed task inputs
In my recent changes to watch, I have been moving towards a world in
which sbt manages the file inputs and outputs at the task level. The
main idea is that we want to enable a user to specify the inputs and
outputs of a task and have sbt able to track those inputs across
multiple task evaluations. Sbt should be able to automatically trigger a
build when the inputs change and it also should be able to avoid task
evaluation if non of the inputs have changed.
The former case of having sbt automatically watch the file inputs of a
task has been present since watch was refactored. In this commit, I
make it possible for the user to retrieve the lists of new, modified and
deleted files. The user can then avoid task evaluation if none of the
inputs have changed.
To implement this, I inject a number of new settings during project
load if the fileInputs setting is defined for a task. The injected
settings are:
allPathsAndAttributes -- this retrieves all of the paths described by
the fileInputs for the task along with their attributes
fileStamps -- this retrieves all of the file stamps for the files
returned by allPathsAndAttributes
Using these two injected tasks, I also inject a number of derived tasks,
such as allFiles, which returns all of the regular files returned by
allPathsAndAttributes and changedFiles, which returns all of the regular
files that have been modified since the last run.
Using these injected settings, the user is able to write tasks that
avoid evaluation if the inputs haven't changed.
foo / fileInputs += baseDirectory.value.toGlob / ** / "*.scala"
foo := {
foo.previous match {
case Some(p) if (foo / changedFiles).value.isEmpty => p
case _ => fooImpl((foo / allFiles).value
}
}
To make this whole mechanism work, I add a private task key:
val fileAttributeMap = taskKey[java.util.HashMap[Path, Stamp]]("...")
This keeps track of the stamps for all of the files that are managed by
sbt. The fileStamps task will first look for the stamp in the attribute
map and, only if it is not present, it will update the cache. This
allows us to ensure that a given file will only be stamped once per task
evaluation run no matter how the file inputs are specified. Moreover, in
a continuous build, I'm able to reuse the attribute map which can
significantly reduce latency because the default file stamping
implementation used by zinc is fairly expensive (it can take anywhere
between 300-1500ms to stamp 5000 8kb source files on my mac).
I also renamed some of the watch related keys to be a bit more clear.
2019-04-24 02:00:13 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$AnyPath_="),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$Glob_="),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$RecursiveGlob_="),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$RelativeGlob_="),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.*"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.**"),
|
2019-04-30 21:02:28 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.ChangedFiles"),
|
Add support for managed task inputs
In my recent changes to watch, I have been moving towards a world in
which sbt manages the file inputs and outputs at the task level. The
main idea is that we want to enable a user to specify the inputs and
outputs of a task and have sbt able to track those inputs across
multiple task evaluations. Sbt should be able to automatically trigger a
build when the inputs change and it also should be able to avoid task
evaluation if non of the inputs have changed.
The former case of having sbt automatically watch the file inputs of a
task has been present since watch was refactored. In this commit, I
make it possible for the user to retrieve the lists of new, modified and
deleted files. The user can then avoid task evaluation if none of the
inputs have changed.
To implement this, I inject a number of new settings during project
load if the fileInputs setting is defined for a task. The injected
settings are:
allPathsAndAttributes -- this retrieves all of the paths described by
the fileInputs for the task along with their attributes
fileStamps -- this retrieves all of the file stamps for the files
returned by allPathsAndAttributes
Using these two injected tasks, I also inject a number of derived tasks,
such as allFiles, which returns all of the regular files returned by
allPathsAndAttributes and changedFiles, which returns all of the regular
files that have been modified since the last run.
Using these injected settings, the user is able to write tasks that
avoid evaluation if the inputs haven't changed.
foo / fileInputs += baseDirectory.value.toGlob / ** / "*.scala"
foo := {
foo.previous match {
case Some(p) if (foo / changedFiles).value.isEmpty => p
case _ => fooImpl((foo / allFiles).value
}
}
To make this whole mechanism work, I add a private task key:
val fileAttributeMap = taskKey[java.util.HashMap[Path, Stamp]]("...")
This keeps track of the stamps for all of the files that are managed by
sbt. The fileStamps task will first look for the stamp in the attribute
map and, only if it is not present, it will update the cache. This
allows us to ensure that a given file will only be stamped once per task
evaluation run no matter how the file inputs are specified. Moreover, in
a continuous build, I'm able to reuse the attribute map which can
significantly reduce latency because the default file stamping
implementation used by zinc is fairly expensive (it can take anywhere
between 300-1500ms to stamp 5000 8kb source files on my mac).
I also renamed some of the watch related keys to be a bit more clear.
2019-04-24 02:00:13 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.RecursiveGlob"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.Glob"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.RelativeGlob"),
|
2017-11-29 22:45:02 +01:00
|
|
|
// Dropped in favour of kind-projector's polymorphic lambda literals
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.Import.Param"),
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.package.Param"),
|
2018-07-01 09:13:09 +02:00
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.SemanticSelector"),
|
|
|
|
|
exclude[ReversedMissingMethodProblem]("sbt.Import.sbt$Import$_setter_$SemanticSelector_="),
|
2017-11-29 22:45:02 +01:00
|
|
|
// Dropped in favour of plain scala.Function, and its compose method
|
|
|
|
|
exclude[DirectMissingMethodProblem]("sbt.package.toFn1"),
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2017-08-28 06:42:26 +02:00
|
|
|
}
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2017-10-29 14:37:53 +01:00
|
|
|
def runNpm(command: String, base: File, log: sbt.internal.util.ManagedLogger) = {
|
|
|
|
|
import scala.sys.process._
|
|
|
|
|
try {
|
2017-12-19 06:17:46 +01:00
|
|
|
val exitCode = Process(s"npm $command", Option(base)) ! log
|
2017-10-29 14:37:53 +01:00
|
|
|
if (exitCode != 0) throw new Exception("Process returned exit code: " + exitCode)
|
|
|
|
|
} catch {
|
|
|
|
|
case e: java.io.IOException => log.warn("failed to run npm " + e.getMessage)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-02 09:33:29 +02:00
|
|
|
lazy val vscodePlugin = (project in file("vscode-sbt-scala"))
|
|
|
|
|
.settings(
|
|
|
|
|
crossPaths := false,
|
|
|
|
|
crossScalaVersions := Seq(baseScalaVersion),
|
|
|
|
|
skip in publish := true,
|
|
|
|
|
compile in Compile := {
|
2019-11-28 19:05:49 +01:00
|
|
|
update.value: Unit
|
2017-10-29 14:37:53 +01:00
|
|
|
runNpm("run compile", baseDirectory.value, streams.value.log)
|
|
|
|
|
sbt.internal.inc.Analysis.empty
|
2017-10-02 09:33:29 +02:00
|
|
|
},
|
|
|
|
|
update := {
|
|
|
|
|
val old = update.value
|
|
|
|
|
val t = target.value / "updated"
|
|
|
|
|
val base = baseDirectory.value
|
2017-10-06 02:26:59 +02:00
|
|
|
val log = streams.value.log
|
2017-10-02 09:33:29 +02:00
|
|
|
if (t.exists) ()
|
|
|
|
|
else {
|
2017-10-29 14:37:53 +01:00
|
|
|
runNpm("install", base, log)
|
2017-10-02 09:33:29 +02:00
|
|
|
IO.touch(t)
|
|
|
|
|
}
|
|
|
|
|
old
|
|
|
|
|
},
|
|
|
|
|
cleanFiles ++= {
|
|
|
|
|
val base = baseDirectory.value
|
|
|
|
|
Vector(
|
|
|
|
|
target.value / "updated",
|
2019-05-11 09:42:06 +02:00
|
|
|
base / "node_modules",
|
|
|
|
|
base / "client" / "node_modules",
|
2017-10-02 09:33:29 +02:00
|
|
|
base / "client" / "server",
|
|
|
|
|
base / "client" / "out",
|
2019-05-11 09:42:06 +02:00
|
|
|
base / "server" / "node_modules"
|
|
|
|
|
) filter { _.exists }
|
2017-10-02 09:33:29 +02:00
|
|
|
}
|
|
|
|
|
)
|
|
|
|
|
|
2020-01-13 01:50:29 +01:00
|
|
|
def scriptedTask(launch: Boolean): Def.Initialize[InputTask[Unit]] = Def.inputTask {
|
2020-01-12 04:52:36 +01:00
|
|
|
publishLocalBinAll.value
|
2020-01-13 01:50:29 +01:00
|
|
|
val launchJar = s"-Dsbt.launch.jar=${(bundledLauncherProj / Compile / packageBin).value}"
|
2017-04-21 09:14:31 +02:00
|
|
|
Scripted.doScripted(
|
2018-07-10 06:58:45 +02:00
|
|
|
(scalaInstance in scriptedSbtReduxProj).value,
|
2017-04-21 09:14:31 +02:00
|
|
|
scriptedSource.value,
|
|
|
|
|
scriptedBufferLog.value,
|
2018-01-24 14:42:18 +01:00
|
|
|
Def.setting(Scripted.scriptedParser(scriptedSource.value)).parsed,
|
2017-04-21 09:14:31 +02:00
|
|
|
scriptedPrescripted.value,
|
2020-01-13 01:50:29 +01:00
|
|
|
scriptedLaunchOpts.value ++ (if (launch) Some(launchJar) else None),
|
2020-01-12 04:52:36 +01:00
|
|
|
scalaVersion.value,
|
|
|
|
|
version.value,
|
|
|
|
|
(scriptedSbtReduxProj / Test / fullClasspathAsJars).value.map(_.data),
|
2019-11-17 21:34:19 +01:00
|
|
|
streams.value.log
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2014-12-18 05:38:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
lazy val publishLauncher = TaskKey[Unit]("publish-launcher")
|
|
|
|
|
|
2017-04-21 09:14:31 +02:00
|
|
|
def allProjects =
|
|
|
|
|
Seq(
|
2017-06-26 12:38:37 +02:00
|
|
|
collectionProj,
|
|
|
|
|
logicProj,
|
|
|
|
|
completeProj,
|
2017-04-21 09:14:31 +02:00
|
|
|
testingProj,
|
|
|
|
|
testAgentProj,
|
|
|
|
|
taskProj,
|
|
|
|
|
stdTaskProj,
|
|
|
|
|
runProj,
|
2018-07-10 06:58:45 +02:00
|
|
|
scriptedSbtReduxProj,
|
|
|
|
|
scriptedSbtOldProj,
|
2017-04-21 09:14:31 +02:00
|
|
|
scriptedPluginProj,
|
|
|
|
|
protocolProj,
|
|
|
|
|
actionsProj,
|
|
|
|
|
commandProj,
|
|
|
|
|
mainSettingsProj,
|
2019-04-18 09:14:04 +02:00
|
|
|
zincLmIntegrationProj,
|
2017-04-21 09:14:31 +02:00
|
|
|
mainProj,
|
|
|
|
|
sbtProj,
|
2017-05-26 06:59:49 +02:00
|
|
|
bundledLauncherProj,
|
2020-06-22 01:48:33 +02:00
|
|
|
coreMacrosProj,
|
|
|
|
|
sbtClientProj,
|
2019-12-27 06:24:03 +01:00
|
|
|
) ++ lowerUtilProjects
|
|
|
|
|
|
|
|
|
|
lazy val lowerUtilProjects =
|
|
|
|
|
Seq(
|
2019-12-08 00:49:13 +01:00
|
|
|
utilCache,
|
|
|
|
|
utilControl,
|
|
|
|
|
utilInterface,
|
|
|
|
|
utilLogging,
|
|
|
|
|
utilPosition,
|
|
|
|
|
utilRelation,
|
|
|
|
|
utilScripted,
|
2019-12-27 06:24:03 +01:00
|
|
|
utilTracking
|
2017-04-21 09:14:31 +02:00
|
|
|
)
|
2015-02-03 04:44:02 +01:00
|
|
|
|
2017-05-08 15:08:40 +02:00
|
|
|
lazy val nonRoots = allProjects.map(p => LocalProject(p.id))
|
2014-12-18 05:38:10 +01:00
|
|
|
|
2018-07-31 02:28:42 +02:00
|
|
|
ThisBuild / scriptedBufferLog := true
|
2019-05-11 09:42:06 +02:00
|
|
|
ThisBuild / scriptedPrescripted := { _ =>
|
|
|
|
|
}
|
2018-07-31 02:28:42 +02:00
|
|
|
|
2017-04-21 09:14:31 +02:00
|
|
|
def otherRootSettings =
|
|
|
|
|
Seq(
|
2020-01-13 01:50:29 +01:00
|
|
|
scripted := scriptedTask(false).evaluated,
|
|
|
|
|
scriptedUnpublished := scriptedTask(false).evaluated,
|
2017-04-21 09:14:31 +02:00
|
|
|
scriptedSource := (sourceDirectory in sbtProj).value / "sbt-test",
|
2019-05-25 20:28:34 +02:00
|
|
|
watchTriggers in scripted += scriptedSource.value.toGlob / **,
|
2020-01-12 04:52:36 +01:00
|
|
|
watchTriggers in scriptedUnpublished := (watchTriggers in scripted).value,
|
2019-12-30 01:26:05 +01:00
|
|
|
scriptedLaunchOpts := List("-Xmx1500M", "-Xms512M", "-server") :::
|
|
|
|
|
(sys.props.get("sbt.ivy.home") match {
|
|
|
|
|
case Some(home) => List(s"-Dsbt.ivy.home=$home")
|
|
|
|
|
case _ => Nil
|
|
|
|
|
}),
|
2020-01-12 04:52:36 +01:00
|
|
|
publishLocalBinAll := (Compile / publishLocalBin).all(scriptedProjects).value,
|
|
|
|
|
aggregate in bintrayRelease := false,
|
2017-04-21 09:14:31 +02:00
|
|
|
) ++ inConfig(Scripted.RepoOverrideTest)(
|
|
|
|
|
Seq(
|
2017-06-23 18:58:00 +02:00
|
|
|
scriptedLaunchOpts := List(
|
|
|
|
|
"-Xmx1500M",
|
|
|
|
|
"-Xms512M",
|
|
|
|
|
"-server",
|
|
|
|
|
"-Dsbt.override.build.repos=true",
|
|
|
|
|
s"""-Dsbt.repository.config=${scriptedSource.value / "repo.config"}"""
|
2019-12-30 01:26:05 +01:00
|
|
|
) :::
|
|
|
|
|
(sys.props.get("sbt.ivy.home") match {
|
|
|
|
|
case Some(home) => List(s"-Dsbt.ivy.home=$home")
|
|
|
|
|
case _ => Nil
|
|
|
|
|
}),
|
2020-01-13 01:50:29 +01:00
|
|
|
scripted := scriptedTask(true).evaluated,
|
|
|
|
|
scriptedUnpublished := scriptedTask(true).evaluated,
|
2017-04-21 09:14:31 +02:00
|
|
|
scriptedSource := (sourceDirectory in sbtProj).value / "repo-override-test"
|
2019-05-11 09:42:06 +02:00
|
|
|
)
|
|
|
|
|
)
|
2016-04-24 20:23:48 +02:00
|
|
|
|
2014-12-18 19:14:04 +01:00
|
|
|
lazy val docProjects: ScopeFilter = ScopeFilter(
|
2019-05-11 09:42:06 +02:00
|
|
|
inAnyProject -- inProjects(
|
|
|
|
|
sbtRoot,
|
|
|
|
|
sbtProj,
|
|
|
|
|
scriptedSbtReduxProj,
|
|
|
|
|
scriptedSbtOldProj,
|
2019-12-27 06:24:03 +01:00
|
|
|
scriptedPluginProj,
|
|
|
|
|
upperModules,
|
|
|
|
|
lowerUtils,
|
2019-05-11 09:42:06 +02:00
|
|
|
),
|
2014-12-18 19:14:04 +01:00
|
|
|
inConfigurations(Compile)
|
2014-12-18 05:38:10 +01:00
|
|
|
)
|
2020-01-14 23:01:17 +01:00
|
|
|
lazy val javafmtOnCompile = taskKey[Unit]("Formats java sources before compile")
|
2020-01-12 04:52:36 +01:00
|
|
|
lazy val scriptedProjects = ScopeFilter(inAnyProject -- inProjects(vscodePlugin))
|
2014-12-18 23:40:20 +01:00
|
|
|
|
|
|
|
|
def customCommands: Seq[Setting[_]] = Seq(
|
2017-01-15 07:44:05 +01:00
|
|
|
commands += Command.command("setupBuildScala212") { state =>
|
|
|
|
|
s"""set scalaVersion in ThisBuild := "$scala212" """ ::
|
2014-12-18 23:40:20 +01:00
|
|
|
state
|
|
|
|
|
},
|
2018-12-14 01:31:56 +01:00
|
|
|
commands += Command.command("whitesourceOnPush") { state =>
|
|
|
|
|
sys.env.get("TRAVIS_EVENT_TYPE") match {
|
|
|
|
|
case Some("push") =>
|
|
|
|
|
"whitesourceCheckPolicies" ::
|
2019-05-11 09:42:06 +02:00
|
|
|
"whitesourceUpdate" ::
|
|
|
|
|
state
|
2018-12-14 01:31:56 +01:00
|
|
|
case _ => state
|
|
|
|
|
}
|
|
|
|
|
},
|
2014-12-18 23:40:20 +01:00
|
|
|
commands += Command.command("release-sbt-local") { state =>
|
2015-02-25 18:31:21 +01:00
|
|
|
"clean" ::
|
2017-04-21 09:14:31 +02:00
|
|
|
"so compile" ::
|
|
|
|
|
"so publishLocal" ::
|
|
|
|
|
"reload" ::
|
|
|
|
|
state
|
2014-12-18 23:40:20 +01:00
|
|
|
},
|
2018-02-21 08:28:33 +01:00
|
|
|
commands += Command.command("publishLocalAllModule") { state =>
|
|
|
|
|
val extracted = Project.extract(state)
|
|
|
|
|
import extracted._
|
2019-05-11 09:42:06 +02:00
|
|
|
val sv = get(scalaVersion)
|
|
|
|
|
val projs = structure.allProjectRefs
|
|
|
|
|
val ioOpt = projs find { case ProjectRef(_, id) => id == "ioRoot"; case _ => false }
|
2018-02-21 08:28:33 +01:00
|
|
|
val utilOpt = projs find { case ProjectRef(_, id) => id == "utilRoot"; case _ => false }
|
2019-05-11 09:42:06 +02:00
|
|
|
val lmOpt = projs find { case ProjectRef(_, id) => id == "lmRoot"; case _ => false }
|
2018-02-21 08:28:33 +01:00
|
|
|
val zincOpt = projs find { case ProjectRef(_, id) => id == "zincRoot"; case _ => false }
|
2019-05-11 09:42:06 +02:00
|
|
|
(ioOpt map { case ProjectRef(build, _) => "{" + build.toString + "}/publishLocal" }).toList :::
|
|
|
|
|
(utilOpt map { case ProjectRef(build, _) => "{" + build.toString + "}/publishLocal" }).toList :::
|
|
|
|
|
(lmOpt map { case ProjectRef(build, _) => "{" + build.toString + "}/publishLocal" }).toList :::
|
|
|
|
|
(zincOpt map {
|
|
|
|
|
case ProjectRef(build, _) =>
|
|
|
|
|
val zincSv = get(scalaVersion in ProjectRef(build, "zinc"))
|
|
|
|
|
val csv = get(crossScalaVersions in ProjectRef(build, "compilerBridge")).toList
|
|
|
|
|
(csv flatMap { bridgeSv =>
|
|
|
|
|
s"++$bridgeSv" :: ("{" + build.toString + "}compilerBridge/publishLocal") :: Nil
|
|
|
|
|
}) :::
|
|
|
|
|
List(s"++$zincSv", "{" + build.toString + "}/publishLocal")
|
|
|
|
|
}).getOrElse(Nil) :::
|
|
|
|
|
List(s"++$sv", "publishLocal") :::
|
|
|
|
|
state
|
2018-02-21 08:28:33 +01:00
|
|
|
},
|
2015-02-17 19:33:54 +01:00
|
|
|
/** There are several complications with sbt's build.
|
|
|
|
|
* First is the fact that interface project is a Java-only project
|
2015-12-14 11:26:34 +01:00
|
|
|
* that uses source generator from datatype subproject in Scala 2.10.6.
|
2015-02-17 19:33:54 +01:00
|
|
|
*
|
2015-07-16 13:53:10 +02:00
|
|
|
* Second is the fact that all subprojects are released with crossPaths
|
2015-12-14 11:26:34 +01:00
|
|
|
* turned off for the sbt's Scala version 2.10.6, but some of them are also
|
2015-02-17 19:33:54 +01:00
|
|
|
* cross published against 2.11.1 with crossPaths turned on.
|
|
|
|
|
*
|
2015-07-16 13:53:10 +02:00
|
|
|
* `so compile` handles 2.10.x/2.11.x cross building.
|
2015-02-17 19:33:54 +01:00
|
|
|
*/
|
2014-12-18 23:40:20 +01:00
|
|
|
commands += Command.command("release-sbt") { state =>
|
|
|
|
|
// TODO - Any sort of validation
|
2015-02-25 18:31:21 +01:00
|
|
|
"clean" ::
|
2017-05-30 08:44:13 +02:00
|
|
|
"conscriptConfigs" ::
|
|
|
|
|
"compile" ::
|
|
|
|
|
"publishSigned" ::
|
2015-03-24 23:32:56 +01:00
|
|
|
"bundledLauncherProj/publishLauncher" ::
|
2015-02-21 03:09:43 +01:00
|
|
|
state
|
|
|
|
|
},
|
2015-02-25 18:31:21 +01:00
|
|
|
// stamp-version doesn't work with ++ or "so".
|
2015-02-21 03:09:43 +01:00
|
|
|
commands += Command.command("release-nightly") { state =>
|
|
|
|
|
"stamp-version" ::
|
2015-02-25 18:31:21 +01:00
|
|
|
"clean" ::
|
|
|
|
|
"compile" ::
|
|
|
|
|
"publish" ::
|
2015-04-22 06:28:47 +02:00
|
|
|
"bintrayRelease" ::
|
2014-12-18 23:40:20 +01:00
|
|
|
state
|
|
|
|
|
}
|
|
|
|
|
)
|
2018-01-11 15:13:21 +01:00
|
|
|
|
2019-12-27 08:43:46 +01:00
|
|
|
ThisBuild / publishTo := {
|
|
|
|
|
val old = (ThisBuild / publishTo).value
|
|
|
|
|
sys.props.get("sbt.build.localmaven") match {
|
|
|
|
|
case Some(path) => Some(MavenCache("local-maven", file(path)))
|
|
|
|
|
case _ => old
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-05-11 09:42:06 +02:00
|
|
|
ThisBuild / whitesourceProduct := "Lightbend Reactive Platform"
|
2018-12-14 01:31:56 +01:00
|
|
|
ThisBuild / whitesourceAggregateProjectName := {
|
|
|
|
|
// note this can get detached on tag build etc
|
2020-01-15 23:45:27 +01:00
|
|
|
val b = sys.process.Process("git rev-parse --abbrev-ref HEAD").!!.trim
|
2018-12-14 01:31:56 +01:00
|
|
|
val Stable = """1\.([0-9]+)\.x""".r
|
|
|
|
|
b match {
|
|
|
|
|
case Stable(y) => "sbt-1." + y.toString + "-stable"
|
|
|
|
|
case _ => "sbt-master"
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
ThisBuild / whitesourceAggregateProjectToken := {
|
|
|
|
|
(ThisBuild / whitesourceAggregateProjectName).value match {
|
|
|
|
|
case "sbt-master" => "e7a1e55518c0489a98e9c7430c8b2ccd53d9f97c12ed46148b592ebe4c8bf128"
|
2020-01-15 23:45:27 +01:00
|
|
|
case "sbt-1.3-stable" => "7e38cbb4d2fc4599835cd5d2cfb41b150597a4147b15424bb65841664ab2ec0d"
|
2018-12-14 01:31:56 +01:00
|
|
|
case "sbt-1.2-stable" => "54f2313767aa47198971e65595670ee16e1ad0000d20458588e72d3ac2c34763"
|
|
|
|
|
case _ => "" // it's ok to fail here
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-05-11 09:42:06 +02:00
|
|
|
ThisBuild / whitesourceIgnoredScopes ++= Seq("plugin", "scalafmt", "sxr")
|
|
|
|
|
ThisBuild / whitesourceFailOnError := sys.env.contains("WHITESOURCE_PASSWORD") // fail if pwd is present
|
2018-12-14 01:31:56 +01:00
|
|
|
ThisBuild / whitesourceForceCheckAllDependencies := true
|
