From f65712e90d038df892e1863dc43a2533b328c022 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 2 Feb 2015 22:44:02 -0500 Subject: [PATCH 1/6] Fix build --- build.sbt | 59 +++++++++++++++++++++++++++---------- project/Dependencies.scala | 3 ++ project/NightlyPlugin.scala | 10 +++++-- project/Util.scala | 4 +-- project/p.sbt | 2 +- 5 files changed, 56 insertions(+), 22 deletions(-) diff --git a/build.sbt b/build.sbt index 2cffb3cd8..ecf602e70 100644 --- a/build.sbt +++ b/build.sbt @@ -11,7 +11,7 @@ import Sxr.sxr def commonSettings: Seq[Setting[_]] = Seq( organization := "org.scala-sbt", version := "0.13.8-SNAPSHOT", - scalaVersion in ThisBuild := "2.10.4", + scalaVersion := "2.10.4", publishArtifact in packageDoc := false, publishMavenStyle := false, componentID := None, @@ -20,7 +20,8 @@ def commonSettings: Seq[Setting[_]] = Seq( concurrentRestrictions in Global += Util.testExclusiveRestriction, testOptions += Tests.Argument(TestFrameworks.ScalaCheck, "-w", "1"), javacOptions in compile ++= Seq("-target", "6", "-source", "6", "-Xlint", "-Xlint:-serial"), - incOptions := incOptions.value.withNameHashing(true) + incOptions := incOptions.value.withNameHashing(true), + crossScalaVersions := Seq(scala210) ) def minimalSettings: Seq[Setting[_]] = @@ -84,7 +85,13 @@ lazy val interfaceProj = (project in file("interface")). watchSources <++= apiDefinitions, resourceGenerators in Compile <+= (version, resourceManaged, streams, compile in Compile) map generateVersionFile, apiDefinitions <<= baseDirectory map { base => (base / "definition") :: (base / "other") :: (base / "type") :: Nil }, - sourceGenerators in Compile <+= (cacheDirectory, apiDefinitions, fullClasspath in Compile in datatypeProj, sourceManaged in Compile, mainClass in datatypeProj in Compile, runner, streams) map generateAPICached + sourceGenerators in Compile <+= (cacheDirectory, + apiDefinitions, + fullClasspath in Compile in datatypeProj, + sourceManaged in Compile, + mainClass in datatypeProj in Compile, + runner, + streams) map generateAPICached ) // defines operations on the API of a source, including determining whether it has changed and converting it to a string @@ -101,15 +108,15 @@ lazy val apiProj = (project in compilePath / "api"). lazy val controlProj = (project in utilPath / "control"). settings(baseSettings ++ Util.crossBuild: _*). settings( - name := "Control", - crossScalaVersions := Seq(scala210, scala211) + name := "Control" + // crossScalaVersions := Seq(scala210, scala211) ) lazy val collectionProj = (project in utilPath / "collection"). settings(testedBaseSettings ++ Util.keywordsSettings ++ Util.crossBuild: _*). settings( - name := "Collections", - crossScalaVersions := Seq(scala210, scala211) + name := "Collections" + // crossScalaVersions := Seq(scala210, scala211) ) lazy val applyMacroProj = (project in utilPath / "appmacro"). @@ -135,8 +142,8 @@ lazy val ioProj = (project in utilPath / "io"). settings(testedBaseSettings ++ Util.crossBuild: _*). settings( name := "IO", - libraryDependencies += scalaCompiler.value % Test, - crossScalaVersions := Seq(scala210, scala211) + libraryDependencies += scalaCompiler.value % Test + // crossScalaVersions := Seq(scala210, scala211) ) // Utilities related to reflection, managing Scala versions, and custom class loaders @@ -154,8 +161,8 @@ lazy val completeProj = (project in utilPath / "complete"). settings(testedBaseSettings ++ Util.crossBuild: _*). settings( name := "Completion", - libraryDependencies += jline, - crossScalaVersions := Seq(scala210, scala211) + libraryDependencies += jline + // crossScalaVersions := Seq(scala210, scala211) ) // logging @@ -295,9 +302,9 @@ lazy val compileInterfaceProj = (project in compilePath / "interface"). artifact in (Compile, packageSrc) := Artifact(srcID).copy(configurations = Compile :: Nil).extra("e:component" -> srcID) ) -lazy val precompiled282 = precompiled("2.8.2") -lazy val precompiled292 = precompiled("2.9.2") -lazy val precompiled293 = precompiled("2.9.3") +lazy val precompiled282 = precompiled(scala282) +lazy val precompiled292 = precompiled(scala292) +lazy val precompiled293 = precompiled(scala293) // Implements the core functionality of detecting and propagating changes incrementally. // Defines the data structures for representing file fingerprints and relationships and the overall source analysis @@ -447,6 +454,7 @@ def allProjects = Seq(launchInterfaceProj, launchProj, testSamples, interfacePro compilerIntegrationProj, compilerIvyProj, scriptedBaseProj, scriptedSbtProj, scriptedPluginProj, actionsProj, commandProj, mainSettingsProj, mainProj, sbtProj, mavenResolverPluginProj) + def projectsWithMyProvided = allProjects.map(p => p.copy(configurations = (p.configurations.filter(_ != Provided)) :+ myProvided)) lazy val nonRoots = projectsWithMyProvided.map(p => LocalProject(p.id)) @@ -460,7 +468,7 @@ def otherRootSettings = Seq( Scripted.scriptedUnpublished <<= scriptedUnpublishedTask, Scripted.scriptedSource <<= (sourceDirectory in sbtProj) / "sbt-test", publishAll := { - (publishLocal).all(ScopeFilter(inAnyProject)).value + val _ = (publishLocal).all(ScopeFilter(inAnyProject)).value } ) ++ inConfig(Scripted.MavenResolverPluginTest)(Seq( Scripted.scripted <<= scriptedTask, @@ -535,6 +543,7 @@ def precompiled(scalav: String): Project = Project(id = normalize("Precompiled " assert(sbtScalaV != scalav, "Precompiled compiler interface cannot have the same Scala version (" + scalav + ") as sbt.") scalav }, + crossScalaVersions := Seq(scalav), // we disable compiling and running tests in precompiled Projprojects of compiler interface // so we do not need to worry about cross-versioning testing dependencies sources in Test := Nil @@ -567,7 +576,14 @@ def customCommands: Seq[Setting[_]] = Seq( }, commands += Command.command("release-sbt-local") { state => "clean" :: + "interfaceProj/compile" :: // Java project needs to compile first + "precompiled-2_8_2/compile" :: + "precompiled-2_9_2/compile" :: + "precompiled-2_9_3/compile" :: "so compile" :: + "precompiled-2_8_2/publishLocal" :: + "precompiled-2_9_2/publishLocal" :: + "precompiled-2_9_3/publishLocal" :: "so publishLocal" :: "reload" :: state @@ -577,10 +593,21 @@ def customCommands: Seq[Setting[_]] = Seq( "clean" :: "checkCredentials" :: "conscript-configs" :: + "interfaceProj/compile" :: // Java project needs to compile first + "precompiled-2_8_2/compile" :: + "precompiled-2_9_2/compile" :: + "precompiled-2_9_3/compile" :: "so compile" :: "so publishSigned" :: + "precompiled-2_8_2/publishSigned" :: + "precompiled-2_9_2/publishSigned" :: + "precompiled-2_9_3/publishSigned" :: "publishLauncher" :: - "release-libs-211" :: + "++2.11.1" :: + "controlProj/publishSigned" :: + "collectionProj/publishSigned" :: + "ioProj/publishSigned" :: + "completeProj/publishSigned" :: state } ) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index cefb127ad..5be547f47 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -2,6 +2,9 @@ import sbt._ import Keys._ object Dependencies { + lazy val scala282 = "2.8.2" + lazy val scala292 = "2.9.2" + lazy val scala293 = "2.9.3" lazy val scala210 = "2.10.4" lazy val scala211 = "2.11.1" diff --git a/project/NightlyPlugin.scala b/project/NightlyPlugin.scala index bddc7cafc..5ab480cf2 100644 --- a/project/NightlyPlugin.scala +++ b/project/NightlyPlugin.scala @@ -8,7 +8,6 @@ object NightlyPlugin extends AutoPlugin { override def trigger = allRequirements override def requires = plugins.JvmPlugin object autoImport { - lazy val nightly212 = SettingKey[Boolean]("nightly212") lazy val includeTestDependencies = SettingKey[Boolean]("includeTestDependencies", "Doesn't declare test dependencies.") def testDependencies = libraryDependencies <++= includeTestDependencies { incl => @@ -22,8 +21,13 @@ object NightlyPlugin extends AutoPlugin { } override def buildSettings: Seq[Setting[_]] = Seq( - nightly212 <<= scalaVersion(v => v.startsWith("2.12.")), - includeTestDependencies <<= nightly212(x => !x) + // Avoid 2.12.x nightlies + // Avoid 2.9.x precompiled + // Avoid 2.8.x precompiled + includeTestDependencies := { + val v = scalaVersion.value + v.startsWith("2.10.") || v.startsWith("2.11.") + } ) override def projectSettings: Seq[Setting[_]] = Seq( diff --git a/project/Util.scala b/project/Util.scala index f299fb299..453dd7b1e 100644 --- a/project/Util.scala +++ b/project/Util.scala @@ -22,8 +22,8 @@ object Util { lazy val baseScalacOptions = Seq( scalacOptions ++= Seq("-Xelide-below", "0"), scalacOptions <++= scalaVersion map CrossVersion.partialVersion map { - case Some((2, 9)) => Nil // support 2.9 for some subprojects for the Scala Eclipse IDE - case _ => Seq("-feature", "-language:implicitConversions", "-language:postfixOps", "-language:higherKinds", "-language:existentials") + case Some((2, 9)) | Some((2, 8)) => Nil // support 2.9 for some subprojects for the Scala Eclipse IDE + case _ => Seq("-feature", "-language:implicitConversions", "-language:postfixOps", "-language:higherKinds", "-language:existentials") }, scalacOptions <++= scalaVersion map CrossVersion.partialVersion map { case Some((2, 10)) => Seq("-deprecation", "-Xlint") diff --git a/project/p.sbt b/project/p.sbt index 5ea1b55b1..60068c426 100644 --- a/project/p.sbt +++ b/project/p.sbt @@ -13,4 +13,4 @@ addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0") addSbtPlugin("com.typesafe.sbt" % "sbt-javaversioncheck" % "0.1.0") -addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.1") +addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.2") From 883792e3c32dfb328e641d9f764821c1740dc50b Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 3 Feb 2015 00:40:19 -0500 Subject: [PATCH 2/6] sbt-doge 0.1.3 --- build.sbt | 21 ++++++++------------- project/p.sbt | 2 +- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/build.sbt b/build.sbt index ecf602e70..8eecd222c 100644 --- a/build.sbt +++ b/build.sbt @@ -108,15 +108,15 @@ lazy val apiProj = (project in compilePath / "api"). lazy val controlProj = (project in utilPath / "control"). settings(baseSettings ++ Util.crossBuild: _*). settings( - name := "Control" - // crossScalaVersions := Seq(scala210, scala211) + name := "Control", + crossScalaVersions := Seq(scala210, scala211) ) lazy val collectionProj = (project in utilPath / "collection"). settings(testedBaseSettings ++ Util.keywordsSettings ++ Util.crossBuild: _*). settings( - name := "Collections" - // crossScalaVersions := Seq(scala210, scala211) + name := "Collections", + crossScalaVersions := Seq(scala210, scala211) ) lazy val applyMacroProj = (project in utilPath / "appmacro"). @@ -142,8 +142,8 @@ lazy val ioProj = (project in utilPath / "io"). settings(testedBaseSettings ++ Util.crossBuild: _*). settings( name := "IO", - libraryDependencies += scalaCompiler.value % Test - // crossScalaVersions := Seq(scala210, scala211) + libraryDependencies += scalaCompiler.value % Test, + crossScalaVersions := Seq(scala210, scala211) ) // Utilities related to reflection, managing Scala versions, and custom class loaders @@ -161,8 +161,8 @@ lazy val completeProj = (project in utilPath / "complete"). settings(testedBaseSettings ++ Util.crossBuild: _*). settings( name := "Completion", - libraryDependencies += jline - // crossScalaVersions := Seq(scala210, scala211) + libraryDependencies += jline, + crossScalaVersions := Seq(scala210, scala211) ) // logging @@ -603,11 +603,6 @@ def customCommands: Seq[Setting[_]] = Seq( "precompiled-2_9_2/publishSigned" :: "precompiled-2_9_3/publishSigned" :: "publishLauncher" :: - "++2.11.1" :: - "controlProj/publishSigned" :: - "collectionProj/publishSigned" :: - "ioProj/publishSigned" :: - "completeProj/publishSigned" :: state } ) diff --git a/project/p.sbt b/project/p.sbt index 60068c426..1524ca243 100644 --- a/project/p.sbt +++ b/project/p.sbt @@ -13,4 +13,4 @@ addSbtPlugin("com.typesafe.sbt" % "sbt-scalariform" % "1.3.0") addSbtPlugin("com.typesafe.sbt" % "sbt-javaversioncheck" % "0.1.0") -addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.2") +addSbtPlugin("com.eed3si9n" % "sbt-doge" % "0.1.3") From adddf3ed49943110445e2ef2ad3273d26ab16b4b Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 3 Feb 2015 11:48:30 -0500 Subject: [PATCH 3/6] Removes interfaceProj/compile and adds comment. --- build.sbt | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index 8eecd222c..9a8c1ca75 100644 --- a/build.sbt +++ b/build.sbt @@ -576,7 +576,6 @@ def customCommands: Seq[Setting[_]] = Seq( }, commands += Command.command("release-sbt-local") { state => "clean" :: - "interfaceProj/compile" :: // Java project needs to compile first "precompiled-2_8_2/compile" :: "precompiled-2_9_2/compile" :: "precompiled-2_9_3/compile" :: @@ -588,12 +587,27 @@ def customCommands: Seq[Setting[_]] = Seq( "reload" :: state }, + /** There are several complications with sbt's build. + * First is the fact that interface project is a Java-only project + * that uses source generator from datatype subproject in Scala 2.10.4, + * which is depended on by Scala 2.8.2, Scala 2.9.2, and Scala 2.9.3 precompiled project. + * + * Second is the fact that sbt project (currently using Scala 2.10.4) depends on + * the precompiled projects (that uses Scala 2.8.2 etc.) + * + * Finally, there's the fact that all subprojects are released with crossPaths + * turned off for the sbt's Scala version 2.10.4, but some of them are also + * cross published against 2.11.1 with crossPaths turned on. + * + * Because of the way ++ (and its improved version wow) is implemented + * precompiled compiler briges are handled outside of doge aggregation on root. + * `so compile` handles 2.10.x/2.11.x cross building. + */ commands += Command.command("release-sbt") { state => // TODO - Any sort of validation "clean" :: "checkCredentials" :: "conscript-configs" :: - "interfaceProj/compile" :: // Java project needs to compile first "precompiled-2_8_2/compile" :: "precompiled-2_9_2/compile" :: "precompiled-2_9_3/compile" :: From f2e5d48b6b6d9aba7dc24f14b0bc5c9a84c2997f Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Tue, 3 Feb 2015 19:36:45 -0500 Subject: [PATCH 4/6] remove precompiled compiler bridges - Scala 2.8.x or 2.9.x are no longer used that often. - Precompiled is a cross build liability as sbt (2.10.4) depends on 2.8.x/2.9.x code. - Scripted test was modified to check 2.8 and 2.9 compilation --- build.sbt | 74 ++++--------------- project/Dependencies.scala | 3 - .../compiler-project/run2.8-2.9/build.sbt | 13 ++++ .../src/main/scala/Foo.scala | 0 .../src/test/scala/ATest.scala | 0 .../sbt-test/compiler-project/run2.8-2.9/test | 6 ++ .../compiler-project/run2.8/build.sbt | 5 -- sbt/src/sbt-test/compiler-project/run2.8/test | 1 - 8 files changed, 32 insertions(+), 70 deletions(-) create mode 100644 sbt/src/sbt-test/compiler-project/run2.8-2.9/build.sbt rename sbt/src/sbt-test/compiler-project/{run2.8 => run2.8-2.9}/src/main/scala/Foo.scala (100%) rename sbt/src/sbt-test/compiler-project/{run2.8 => run2.8-2.9}/src/test/scala/ATest.scala (100%) create mode 100644 sbt/src/sbt-test/compiler-project/run2.8-2.9/test delete mode 100644 sbt/src/sbt-test/compiler-project/run2.8/build.sbt delete mode 100644 sbt/src/sbt-test/compiler-project/run2.8/test diff --git a/build.sbt b/build.sbt index 9a8c1ca75..47417d5f6 100644 --- a/build.sbt +++ b/build.sbt @@ -302,9 +302,18 @@ lazy val compileInterfaceProj = (project in compilePath / "interface"). artifact in (Compile, packageSrc) := Artifact(srcID).copy(configurations = Compile :: Nil).extra("e:component" -> srcID) ) -lazy val precompiled282 = precompiled(scala282) -lazy val precompiled292 = precompiled(scala292) -lazy val precompiled293 = precompiled(scala293) +def precompiledSettings = Seq( + artifact in packageBin <<= (appConfiguration, scalaVersion) { (app, sv) => + val launcher = app.provider.scalaProvider.launcher + val bincID = binID + "_" + ScalaInstance(sv, launcher).actualVersion + Artifact(binID) extra ("e:component" -> bincID) + }, + target <<= (target, scalaVersion) { (base, sv) => base / ("precompiled_" + sv) }, + scalacOptions := Nil, + ivyScala ~= { _.map(_.copy(checkExplicit = false, overrideScalaVersion = false)) }, + exportedProducts in Compile := Nil, + libraryDependencies += scalaCompiler.value % "provided" +) // Implements the core functionality of detecting and propagating changes incrementally. // Defines the data structures for representing file fingerprints and relationships and the overall source analysis @@ -412,7 +421,7 @@ lazy val mainProj = (project in mainPath). // 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) lazy val sbtProj = (project in sbtPath). - dependsOn(mainProj, compileInterfaceProj, precompiled282, precompiled292, precompiled293, scriptedSbtProj % "test->test"). + dependsOn(mainProj, compileInterfaceProj, scriptedSbtProj % "test->test"). settings(baseSettings: _*). settings( name := "sbt", @@ -520,35 +529,6 @@ def utilPath = file("util") def compilePath = file("compile") def mainPath = file("main") -def precompiledSettings = Seq( - artifact in packageBin <<= (appConfiguration, scalaVersion) { (app, sv) => - val launcher = app.provider.scalaProvider.launcher - val bincID = binID + "_" + ScalaInstance(sv, launcher).actualVersion - Artifact(binID) extra ("e:component" -> bincID) - }, - target <<= (target, scalaVersion) { (base, sv) => base / ("precompiled_" + sv) }, - scalacOptions := Nil, - ivyScala ~= { _.map(_.copy(checkExplicit = false, overrideScalaVersion = false)) }, - exportedProducts in Compile := Nil, - libraryDependencies += scalaCompiler.value % "provided" -) - -def precompiled(scalav: String): Project = Project(id = normalize("Precompiled " + scalav.replace('.', '_')), base = compilePath / "interface"). - dependsOn(interfaceProj). - settings(baseSettings ++ precompiledSettings: _*). - settings( - name := "Precompiled " + scalav.replace('.', '_'), - scalaHome := None, - scalaVersion <<= (scalaVersion in ThisBuild) { sbtScalaV => - assert(sbtScalaV != scalav, "Precompiled compiler interface cannot have the same Scala version (" + scalav + ") as sbt.") - scalav - }, - crossScalaVersions := Seq(scalav), - // we disable compiling and running tests in precompiled Projprojects of compiler interface - // so we do not need to worry about cross-versioning testing dependencies - sources in Test := Nil - ) - lazy val safeUnitTests = taskKey[Unit]("Known working tests (for both 2.10 and 2.11)") lazy val safeProjects: ScopeFilter = ScopeFilter( inProjects(launchProj, mainSettingsProj, mainProj, ivyProj, completeProj, @@ -576,46 +556,18 @@ def customCommands: Seq[Setting[_]] = Seq( }, commands += Command.command("release-sbt-local") { state => "clean" :: - "precompiled-2_8_2/compile" :: - "precompiled-2_9_2/compile" :: - "precompiled-2_9_3/compile" :: "so compile" :: - "precompiled-2_8_2/publishLocal" :: - "precompiled-2_9_2/publishLocal" :: - "precompiled-2_9_3/publishLocal" :: "so publishLocal" :: "reload" :: state }, - /** There are several complications with sbt's build. - * First is the fact that interface project is a Java-only project - * that uses source generator from datatype subproject in Scala 2.10.4, - * which is depended on by Scala 2.8.2, Scala 2.9.2, and Scala 2.9.3 precompiled project. - * - * Second is the fact that sbt project (currently using Scala 2.10.4) depends on - * the precompiled projects (that uses Scala 2.8.2 etc.) - * - * Finally, there's the fact that all subprojects are released with crossPaths - * turned off for the sbt's Scala version 2.10.4, but some of them are also - * cross published against 2.11.1 with crossPaths turned on. - * - * Because of the way ++ (and its improved version wow) is implemented - * precompiled compiler briges are handled outside of doge aggregation on root. - * `so compile` handles 2.10.x/2.11.x cross building. - */ commands += Command.command("release-sbt") { state => // TODO - Any sort of validation "clean" :: "checkCredentials" :: "conscript-configs" :: - "precompiled-2_8_2/compile" :: - "precompiled-2_9_2/compile" :: - "precompiled-2_9_3/compile" :: "so compile" :: "so publishSigned" :: - "precompiled-2_8_2/publishSigned" :: - "precompiled-2_9_2/publishSigned" :: - "precompiled-2_9_3/publishSigned" :: "publishLauncher" :: state } diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 5be547f47..cefb127ad 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -2,9 +2,6 @@ import sbt._ import Keys._ object Dependencies { - lazy val scala282 = "2.8.2" - lazy val scala292 = "2.9.2" - lazy val scala293 = "2.9.3" lazy val scala210 = "2.10.4" lazy val scala211 = "2.11.1" diff --git a/sbt/src/sbt-test/compiler-project/run2.8-2.9/build.sbt b/sbt/src/sbt-test/compiler-project/run2.8-2.9/build.sbt new file mode 100644 index 000000000..c4ad9ed83 --- /dev/null +++ b/sbt/src/sbt-test/compiler-project/run2.8-2.9/build.sbt @@ -0,0 +1,13 @@ +lazy val specs = Def.setting { + "org.scala-tools.testing" %% "specs" % (scalaVersion.value match { + case "2.8.1" | "2.8.2" | "2.9.0" => "1.6.8" + case "2.9.3" => "1.6.9" + }) +} + +lazy val root = (project in file(".")). + settings( + scalaVersion := "2.8.1", + libraryDependencies += specs.value % Test, + libraryDependencies <+= scalaVersion("org.scala-lang" % "scala-compiler" % _) + ) diff --git a/sbt/src/sbt-test/compiler-project/run2.8/src/main/scala/Foo.scala b/sbt/src/sbt-test/compiler-project/run2.8-2.9/src/main/scala/Foo.scala similarity index 100% rename from sbt/src/sbt-test/compiler-project/run2.8/src/main/scala/Foo.scala rename to sbt/src/sbt-test/compiler-project/run2.8-2.9/src/main/scala/Foo.scala diff --git a/sbt/src/sbt-test/compiler-project/run2.8/src/test/scala/ATest.scala b/sbt/src/sbt-test/compiler-project/run2.8-2.9/src/test/scala/ATest.scala similarity index 100% rename from sbt/src/sbt-test/compiler-project/run2.8/src/test/scala/ATest.scala rename to sbt/src/sbt-test/compiler-project/run2.8-2.9/src/test/scala/ATest.scala diff --git a/sbt/src/sbt-test/compiler-project/run2.8-2.9/test b/sbt/src/sbt-test/compiler-project/run2.8-2.9/test new file mode 100644 index 000000000..fbea7588f --- /dev/null +++ b/sbt/src/sbt-test/compiler-project/run2.8-2.9/test @@ -0,0 +1,6 @@ +> ++2.8.1 +> test:test +> ++2.9.0 +> test:test +> ++2.9.3 +> test:test diff --git a/sbt/src/sbt-test/compiler-project/run2.8/build.sbt b/sbt/src/sbt-test/compiler-project/run2.8/build.sbt deleted file mode 100644 index 159ac76e6..000000000 --- a/sbt/src/sbt-test/compiler-project/run2.8/build.sbt +++ /dev/null @@ -1,5 +0,0 @@ -scalaVersion := "2.8.1" - -libraryDependencies += "org.scala-tools.testing" %% "specs" % "1.6.7.2" % "test" - -libraryDependencies <+= scalaVersion("org.scala-lang" % "scala-compiler" % _) \ No newline at end of file diff --git a/sbt/src/sbt-test/compiler-project/run2.8/test b/sbt/src/sbt-test/compiler-project/run2.8/test deleted file mode 100644 index 7c6f9c539..000000000 --- a/sbt/src/sbt-test/compiler-project/run2.8/test +++ /dev/null @@ -1 +0,0 @@ -> test:test \ No newline at end of file From ea9e6b0a73e343627601dba4e2db55a2d3d6a069 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 6 Feb 2015 13:48:12 -0500 Subject: [PATCH 5/6] Fix stamp-version for nightlies --- build.sbt | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index 47417d5f6..afff6b2f9 100644 --- a/build.sbt +++ b/build.sbt @@ -8,9 +8,14 @@ import Scripted._ import StringUtilities.normalize import Sxr.sxr +// ThisBuild settings take lower precedence, +// but can be shared across the multi projects. +def buildLevelSettings: Seq[Setting[_]] = Seq( + organization in ThisBuild := "org.scala-sbt", + version in ThisBuild := "0.13.8-SNAPSHOT" +) + def commonSettings: Seq[Setting[_]] = Seq( - organization := "org.scala-sbt", - version := "0.13.8-SNAPSHOT", scalaVersion := "2.10.4", publishArtifact in packageDoc := false, publishMavenStyle := false, @@ -37,6 +42,7 @@ def testedBaseSettings: Seq[Setting[_]] = lazy val root: Project = (project in file(".")). configs(Sxr.sxrConf, Proguard). aggregate(nonRoots: _*). + settings(buildLevelSettings: _*). settings(minimalSettings ++ rootSettings: _*) /* ** subproject declarations ** */ From 8dbed8ad885646fe7653fbe4ae33cb92b5d4a168 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 6 Feb 2015 14:35:32 -0500 Subject: [PATCH 6/6] Split proguarded launcher out to a subproject --- build.sbt | 52 +++++++++++++++++++++++++++---------------- project/Release.scala | 15 ++++++------- 2 files changed, 40 insertions(+), 27 deletions(-) diff --git a/build.sbt b/build.sbt index afff6b2f9..086c0e361 100644 --- a/build.sbt +++ b/build.sbt @@ -40,10 +40,17 @@ def testedBaseSettings: Seq[Setting[_]] = baseSettings ++ testDependencies lazy val root: Project = (project in file(".")). - configs(Sxr.sxrConf, Proguard). + configs(Sxr.sxrConf). aggregate(nonRoots: _*). settings(buildLevelSettings: _*). - settings(minimalSettings ++ rootSettings: _*) + settings(minimalSettings ++ rootSettings: _*). + settings( + publish := {}, + publishLocal := { + val p = (proguard in (proguardedLauncherProj, Proguard)).value + IO.copyFile(p, target.value / p.getName) + } + ) /* ** subproject declarations ** */ @@ -69,6 +76,24 @@ lazy val launchProj = (project in launchPath). Transform.sourceProperties := Map("cross.package0" -> "xsbt", "cross.package1" -> "boot") )): _*) +// the proguarded launcher +// the launcher is published with metadata so that the scripted plugin can pull it in +// being proguarded, it shouldn't ever be on a classpath with other jars, however +lazy val proguardedLauncherProj = (project in file("sbt-launch")). + configs(Proguard). + settings(minimalSettings ++ LaunchProguard.settings ++ LaunchProguard.specific(launchProj) ++ + Release.launcherSettings(proguard in Proguard): _*). + settings( + name := "sbt-launch", + moduleName := "sbt-launch", + description := "sbt application launcher", + publishArtifact in packageSrc := false, + autoScalaLibrary := false, + publish <<= Seq(publish, Release.deployLauncher).dependOn, + publishLauncher <<= Release.deployLauncher, + packageBin in Compile <<= proguard in Proguard + ) + // used to test the retrieving and loading of an application: sample app is packaged and published to the local repository lazy val testSamples = (project in launchPath / "test-sample"). dependsOn(interfaceProj, launchInterfaceProj). @@ -446,13 +471,13 @@ lazy val mavenResolverPluginProj = (project in file("sbt-maven-resolver")). def scriptedTask: Initialize[InputTask[Unit]] = Def.inputTask { val result = scriptedSource(dir => (s: State) => scriptedParser(dir)).parsed publishAll.value - doScripted((proguard in Proguard).value, (fullClasspath in scriptedSbtProj in Test).value, + doScripted((proguard in Proguard in proguardedLauncherProj).value, (fullClasspath in scriptedSbtProj in Test).value, (scalaInstance in scriptedSbtProj).value, scriptedSource.value, result, scriptedPrescripted.value) } def scriptedUnpublishedTask: Initialize[InputTask[Unit]] = Def.inputTask { val result = scriptedSource(dir => (s: State) => scriptedParser(dir)).parsed - doScripted((proguard in Proguard).value, (fullClasspath in scriptedSbtProj in Test).value, + doScripted((proguard in Proguard in proguardedLauncherProj).value, (fullClasspath in scriptedSbtProj in Test).value, (scalaInstance in scriptedSbtProj).value, scriptedSource.value, result, scriptedPrescripted.value) } @@ -461,7 +486,8 @@ lazy val publishLauncher = TaskKey[Unit]("publish-launcher") lazy val myProvided = config("provided") intransitive -def allProjects = Seq(launchInterfaceProj, launchProj, testSamples, interfaceProj, apiProj, +def allProjects = Seq(launchInterfaceProj, launchProj, proguardedLauncherProj, + testSamples, interfaceProj, apiProj, controlProj, collectionProj, applyMacroProj, processProj, ioProj, classpathProj, completeProj, logProj, relationProj, classfileProj, datatypeProj, crossProj, logicProj, ivyProj, testingProj, testAgentProj, taskProj, stdTaskProj, cacheProj, trackingProj, runProj, @@ -473,9 +499,8 @@ def allProjects = Seq(launchInterfaceProj, launchProj, testSamples, interfacePro def projectsWithMyProvided = allProjects.map(p => p.copy(configurations = (p.configurations.filter(_ != Provided)) :+ myProvided)) lazy val nonRoots = projectsWithMyProvided.map(p => LocalProject(p.id)) -def releaseSettings = Release.settings(nonRoots, proguard in Proguard) -def rootSettings = releaseSettings ++ fullDocSettings ++ LaunchProguard.settings ++ LaunchProguard.specific(launchProj) ++ - Util.publishPomSettings ++ otherRootSettings ++ proguardedLauncherSettings ++ Formatting.sbtFilesSettings ++ +def rootSettings = Release.releaseSettings ++ fullDocSettings ++ + Util.publishPomSettings ++ otherRootSettings ++ Formatting.sbtFilesSettings ++ Transform.conscriptSettings(launchProj) def otherRootSettings = Seq( Scripted.scriptedPrescripted := { _ => }, @@ -515,17 +540,6 @@ def fullDocSettings = Util.baseScalacOptions ++ Docs.settings ++ Sxr.settings ++ dependencyClasspath in (Compile, doc) := (fullClasspath in sxr).value ) -// the launcher is published with metadata so that the scripted plugin can pull it in -// being proguarded, it shouldn't ever be on a classpath with other jars, however -def proguardedLauncherSettings = Seq( - publishArtifact in packageSrc := false, - moduleName := "sbt-launch", - autoScalaLibrary := false, - description := "sbt application launcher", - publishLauncher <<= Release.deployLauncher, - packageBin in Compile <<= proguard in Proguard -) - /* Nested Projproject paths */ def sbtPath = file("sbt") def cachePath = file("cache") diff --git a/project/Release.scala b/project/Release.scala index 1aef1a9ef..5fe2dd5bd 100644 --- a/project/Release.scala +++ b/project/Release.scala @@ -13,20 +13,19 @@ object Release extends Build { val PublishRepoHost = "private-repo.typesafe.com" - def settings(nonRoots: => Seq[ProjectReference], launcher: TaskKey[File]): Seq[Setting[_]] = - releaseSettings(nonRoots, launcher) + def launcherSettings(launcher: TaskKey[File]): Seq[Setting[_]] = Seq( + launcherRemotePath <<= (organization, version, moduleName) { (org, v, n) => List(org, n, v, n + ".jar").mkString("/") }, + deployLauncher <<= deployLauncher(launcher) + ) // Add credentials if they exist. def lameCredentialSettings: Seq[Setting[_]] = if (CredentialsFile.exists) Seq(credentials in ThisBuild += Credentials(CredentialsFile)) else Nil - def releaseSettings(nonRoots: => Seq[ProjectReference], launcher: TaskKey[File]): Seq[Setting[_]] = Seq( + def releaseSettings: Seq[Setting[_]] = Seq( publishTo in ThisBuild <<= publishResolver, - remoteID <<= publishStatus("typesafe-ivy-" + _), - remoteBase <<= publishStatus("https://" + PublishRepoHost + "/typesafe/ivy-" + _), - launcherRemotePath <<= (organization, version, moduleName) { (org, v, n) => List(org, n, v, n + ".jar").mkString("/") }, - publish <<= Seq(publish, Release.deployLauncher).dependOn, - deployLauncher <<= deployLauncher(launcher), + remoteID in ThisBuild <<= publishStatus("typesafe-ivy-" + _), + remoteBase in ThisBuild <<= publishStatus("https://" + PublishRepoHost + "/typesafe/ivy-" + _), checkCredentials := { // Note - This will eitehr issue a failure or succeed. getCredentials(credentials.value, streams.value.log)