diff options
Diffstat (limited to 'examples/scala-js/project/ScalaJSBuild.scala')
| -rw-r--r-- | examples/scala-js/project/ScalaJSBuild.scala | 891 |
1 files changed, 0 insertions, 891 deletions
diff --git a/examples/scala-js/project/ScalaJSBuild.scala b/examples/scala-js/project/ScalaJSBuild.scala deleted file mode 100644 index 5cbc405..0000000 --- a/examples/scala-js/project/ScalaJSBuild.scala +++ /dev/null @@ -1,891 +0,0 @@ -import sbt._ -import Keys._ - -import bintray.Plugin.bintrayPublishSettings -import bintray.Keys.{repository, bintrayOrganization, bintray} - -import java.io.{ - BufferedOutputStream, - FileOutputStream, - BufferedWriter, - FileWriter -} - -import scala.collection.mutable -import scala.util.Properties - -import scala.scalajs.ir -import scala.scalajs.sbtplugin._ -import scala.scalajs.sbtplugin.env.rhino.RhinoJSEnv -import ScalaJSPlugin.autoImport._ -import ExternalCompile.scalaJSExternalCompileSettings -import Implicits._ - -import scala.scalajs.tools.sourcemap._ -import scala.scalajs.tools.io.MemVirtualJSFile - -import sbtassembly.Plugin.{AssemblyKeys, assemblySettings} -import AssemblyKeys.{assembly, assemblyOption} - -object ScalaJSBuild extends Build { - - val fetchedScalaSourceDir = settingKey[File]( - "Directory the scala source is fetched to") - val fetchScalaSource = taskKey[File]( - "Fetches the scala source for the current scala version") - val shouldPartest = settingKey[Boolean]( - "Whether we should partest the current scala version (and fail if we can't)") - - val commonSettings = Seq( - organization := "org.scala-lang.modules.scalajs", - version := scalaJSVersion, - - normalizedName ~= { - _.replace("scala.js", "scalajs").replace("scala-js", "scalajs") - }, - - homepage := Some(url("http://scala-js.org/")), - licenses += ("BSD New", - url("https://github.com/scala-js/scala-js/blob/master/LICENSE")), - - shouldPartest := { - val testListDir = ( - (resourceDirectory in (partestSuite, Test)).value / "scala" - / "tools" / "partest" / "scalajs" / scalaVersion.value - ) - testListDir.exists - }, - - scalacOptions ++= Seq( - "-deprecation", - "-unchecked", - "-feature", - "-encoding", "utf8" - ) - ) - - private val snapshotsOrReleases = - if (scalaJSIsSnapshotVersion) "snapshots" else "releases" - - private def publishToScalaJSRepoSettings = Seq( - publishTo := { - Seq("PUBLISH_USER", "PUBLISH_PASS").map(Properties.envOrNone) match { - case Seq(Some(user), Some(pass)) => - Some(Resolver.sftp( - s"scala-js-$snapshotsOrReleases", - "repo.scala-js.org", - s"/home/scalajsrepo/www/repo/$snapshotsOrReleases")( - Resolver.ivyStylePatterns) as (user, pass)) - case _ => - None - } - } - ) - - private def publishToBintraySettings = ( - bintrayPublishSettings - ) ++ Seq( - repository in bintray := "scala-js-releases", - bintrayOrganization in bintray := Some("scala-js") - ) - - val publishSettings = ( - if (Properties.envOrNone("PUBLISH_TO_BINTRAY") == Some("true")) - publishToBintraySettings - else - publishToScalaJSRepoSettings - ) ++ Seq( - publishMavenStyle := false - ) - - val defaultSettings = commonSettings ++ Seq( - scalaVersion := "2.11.2" - ) - - val myScalaJSSettings = ScalaJSPluginInternal.scalaJSAbstractSettings ++ Seq( - autoCompilerPlugins := true, - scalaJSOptimizerOptions ~= (_.withCheckScalaJSIR(true)) - ) - - val scalaJSSourceMapSettings = scalacOptions ++= { - if (scalaJSIsSnapshotVersion) Seq() - else Seq( - // Link source maps to github sources - "-P:scalajs:mapSourceURI:" + root.base.toURI + - "->https://raw.githubusercontent.com/scala-js/scala-js/v" + - scalaJSVersion + "/" - ) - } - - /** Depend library as if (exportJars in library) was set to false */ - val compileWithLibrarySetting = { - internalDependencyClasspath in Compile ++= { - val prods = (products in (library, Compile)).value - val analysis = (compile in (library, Compile)).value - - prods.map(p => Classpaths.analyzed(p, analysis)) - } - } - - // Used when compiling the compiler, adding it to scalacOptions does not help - scala.util.Properties.setProp("scalac.patmat.analysisBudget", "1024") - - override lazy val settings = super.settings ++ Seq( - // Most of the projects cross-compile - crossScalaVersions := Seq( - "2.10.2", - "2.10.3", - "2.10.4", - "2.11.0", - "2.11.1", - "2.11.2", - "2.11.4" - ), - // Default stage - scalaJSStage in Global := PreLinkStage - ) - - lazy val root: Project = Project( - id = "scalajs", - base = file("."), - settings = defaultSettings ++ Seq( - name := "Scala.js", - publishArtifact in Compile := false, - - clean := clean.dependsOn( - // compiler, library and jasmineTestFramework are aggregated - clean in tools, clean in toolsJS, clean in plugin, - clean in javalanglib, clean in javalib, clean in scalalib, - clean in libraryAux, clean in javalibEx, - clean in examples, clean in helloworld, - clean in reversi, clean in testingExample, - clean in testSuite, clean in noIrCheckTest, - clean in javalibExTestSuite, - clean in partest, clean in partestSuite).value, - - publish := {}, - publishLocal := {} - ) - ).aggregate( - compiler, library, testBridge, jasmineTestFramework - ) - - /* This project is not really used in the build. Its sources are actually - * added as sources of the `compiler` project (and meant to be added to the - * `tools` project as well). - * It exists mostly to be used in IDEs, because they don't like very much to - * have code in a project that lives outside the project's directory, and - * like even less that code be shared by different projects. - */ - lazy val irProject: Project = Project( - id = "ir", - base = file("ir"), - settings = defaultSettings ++ Seq( - name := "Scala.js IR", - exportJars := true - ) - ) - - lazy val compiler: Project = Project( - id = "compiler", - base = file("compiler"), - settings = defaultSettings ++ publishSettings ++ Seq( - name := "Scala.js compiler", - crossVersion := CrossVersion.full, // because compiler api is not binary compatible - unmanagedSourceDirectories in Compile += - (scalaSource in (irProject, Compile)).value, - libraryDependencies ++= Seq( - "org.scala-lang" % "scala-compiler" % scalaVersion.value, - "org.scala-lang" % "scala-reflect" % scalaVersion.value, - "com.novocode" % "junit-interface" % "0.9" % "test" - ), - testOptions += Tests.Setup { () => - val testOutDir = (streams.value.cacheDirectory / "scalajs-compiler-test") - IO.createDirectory(testOutDir) - sys.props("scala.scalajs.compiler.test.output") = - testOutDir.getAbsolutePath - sys.props("scala.scalajs.compiler.test.scalajslib") = - (artifactPath in (library, Compile, packageBin)).value.getAbsolutePath - sys.props("scala.scalajs.compiler.test.scalalib") = { - - def isScalaLib(att: Attributed[File]) = { - att.metadata.get(moduleID.key).exists { mId => - mId.organization == "org.scala-lang" && - mId.name == "scala-library" && - mId.revision == scalaVersion.value - } - } - - val lib = (managedClasspath in Test).value.find(isScalaLib) - lib.map(_.data.getAbsolutePath).getOrElse { - streams.value.log.error("Couldn't find Scala library on the classpath. CP: " + (managedClasspath in Test).value); "" - } - } - }, - exportJars := true - ) - ) - - val commonToolsSettings = Seq( - name := "Scala.js tools", - - unmanagedSourceDirectories in Compile ++= Seq( - baseDirectory.value.getParentFile / "shared/src/main/scala", - (scalaSource in (irProject, Compile)).value), - - sourceGenerators in Compile <+= Def.task { - ScalaJSEnvGenerator.generateEnvHolder( - baseDirectory.value.getParentFile, - (sourceManaged in Compile).value) - } - ) - - lazy val tools: Project = Project( - id = "tools", - base = file("tools/jvm"), - settings = defaultSettings ++ publishSettings ++ ( - commonToolsSettings - ) ++ Seq( - scalaVersion := "2.10.4", - - libraryDependencies ++= Seq( - "com.google.javascript" % "closure-compiler" % "v20130603", - "com.googlecode.json-simple" % "json-simple" % "1.1.1", - "com.novocode" % "junit-interface" % "0.9" % "test" - ) - ) - ) - - lazy val toolsJS: Project = Project( - id = "toolsJS", - base = file("tools/js"), - settings = defaultSettings ++ myScalaJSSettings ++ publishSettings ++ ( - commonToolsSettings - ) ++ Seq( - crossVersion := ScalaJSCrossVersion.binary - ) ++ inConfig(Test) { - // Redefine test to run Node.js and link HelloWorld - test := { - if (scalaJSStage.value == Stage.PreLink) - error("Can't run toolsJS/test in preLink stage") - - val cp = { - for (e <- (fullClasspath in Test).value) - yield JSUtils.toJSstr(e.data.getAbsolutePath) - } - - val runCode = """ - var framework = org.scalajs.jasminetest.JasmineTestFramework(); - framework.setTags("typedarray") - - // Load tests - scalajs.TestDetector().loadDetectedTests(); - - var reporter = new scalajs.JasmineConsoleReporter(true); - - // Setup and run Jasmine - var jasmineEnv = jasmine.getEnv(); - jasmineEnv.addReporter(reporter); - jasmineEnv.execute(); - """ - - val code = { - s""" - var lib = scalajs.QuickLinker().linkNode(${cp.mkString(", ")}); - var run = ${JSUtils.toJSstr(runCode)}; - - eval("(function() { 'use strict'; "+ - "var __ScalaJSEnv = null; " + - lib + "; " + run + "}).call(this);"); - """ - } - - val launcher = new MemVirtualJSFile("Generated launcher file") - .withContent(code) - - val runner = jsEnv.value.jsRunner(scalaJSExecClasspath.value, - launcher, streams.value.log, scalaJSConsole.value) - - runner.run() - } - } - ).dependsOn(compiler % "plugin", javalibEx, testSuite % "test->test") - - lazy val plugin: Project = Project( - id = "sbtPlugin", - base = file("sbt-plugin"), - settings = commonSettings ++ publishSettings ++ Seq( - name := "Scala.js sbt plugin", - sbtPlugin := true, - scalaBinaryVersion := - CrossVersion.binaryScalaVersion(scalaVersion.value), - libraryDependencies ++= Seq( - "org.mozilla" % "rhino" % "1.7R4", - "org.webjars" % "envjs" % "1.2", - "com.novocode" % "junit-interface" % "0.9" % "test" - ) ++ ScalaJSPluginInternal.phantomJSJettyModules.map(_ % "provided") - ) - ).dependsOn(tools) - - lazy val delambdafySetting = { - scalacOptions ++= ( - if (scalaBinaryVersion.value == "2.10") Seq() - else Seq("-Ydelambdafy:method")) - } - - private def serializeHardcodedIR(base: File, - infoAndTree: (ir.Infos.ClassInfo, ir.Trees.ClassDef)): File = { - // We assume that there are no weird characters in the full name - val fullName = infoAndTree._1.name - val output = base / (fullName.replace('.', '/') + ".sjsir") - - if (!output.exists()) { - IO.createDirectory(output.getParentFile) - val stream = new BufferedOutputStream(new FileOutputStream(output)) - try { - ir.InfoSerializers.serialize(stream, infoAndTree._1) - ir.Serializers.serialize(stream, infoAndTree._2) - } finally { - stream.close() - } - } - output - } - - lazy val javalanglib: Project = Project( - id = "javalanglib", - base = file("javalanglib"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "java.lang library for Scala.js", - publishArtifact in Compile := false, - delambdafySetting, - scalacOptions += "-Yskip:cleanup,icode,jvm", - scalaJSSourceMapSettings, - compileWithLibrarySetting, - - resourceGenerators in Compile <+= Def.task { - val base = (resourceManaged in Compile).value - Seq( - serializeHardcodedIR(base, JavaLangObject.InfoAndTree), - serializeHardcodedIR(base, JavaLangString.InfoAndTree) - ) - } - ) ++ ( - scalaJSExternalCompileSettings - ) - ).dependsOn(compiler % "plugin") - - lazy val javalib: Project = Project( - id = "javalib", - base = file("javalib"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "Java library for Scala.js", - publishArtifact in Compile := false, - delambdafySetting, - scalacOptions += "-Yskip:cleanup,icode,jvm", - scalaJSSourceMapSettings, - compileWithLibrarySetting - ) ++ ( - scalaJSExternalCompileSettings - ) - ).dependsOn(compiler % "plugin") - - lazy val scalalib: Project = Project( - id = "scalalib", - base = file("scalalib"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "Scala library for Scala.js", - publishArtifact in Compile := false, - delambdafySetting, - compileWithLibrarySetting, - - // The Scala lib is full of warnings we don't want to see - scalacOptions ~= (_.filterNot( - Set("-deprecation", "-unchecked", "-feature") contains _)), - - - scalacOptions ++= List( - // Do not generate .class files - "-Yskip:cleanup,icode,jvm", - // Tell plugin to hack fix bad classOf trees - "-P:scalajs:fixClassOf", - // Link source maps to github sources of original Scalalib - "-P:scalajs:mapSourceURI:" + - fetchedScalaSourceDir.value.toURI + - "->https://raw.githubusercontent.com/scala/scala/v" + - scalaVersion.value + "/" - ), - - // Link sources in override directories to our GitHub repo - scalaJSSourceMapSettings, - - fetchedScalaSourceDir := ( - baseDirectory.value / "fetchedSources" / - scalaVersion.value - ), - - fetchScalaSource := { - val s = streams.value - val cacheDir = s.cacheDirectory - val ver = scalaVersion.value - val trgDir = fetchedScalaSourceDir.value - - val report = updateClassifiers.value - val scalaLibSourcesJar = report.select( - configuration = Set("compile"), - module = moduleFilter(name = "scala-library"), - artifact = artifactFilter(`type` = "src")).headOption.getOrElse { - sys.error(s"Could not fetch scala-library sources for version $ver") - } - - FileFunction.cached(cacheDir / s"fetchScalaSource-$ver", - FilesInfo.lastModified, FilesInfo.exists) { dependencies => - s.log.info(s"Fetching Scala library sources to $trgDir...") - - if (trgDir.exists) - IO.delete(trgDir) - IO.createDirectory(trgDir) - IO.unzip(scalaLibSourcesJar, trgDir) - } (Set(scalaLibSourcesJar)) - - trgDir - }, - - unmanagedSourceDirectories in Compile := { - // Calculates all prefixes of the current Scala version - // (including the empty prefix) to construct override - // directories like the following: - // - override-2.10.2-RC1 - // - override-2.10.2 - // - override-2.10 - // - override-2 - // - override - val ver = scalaVersion.value - val base = baseDirectory.value - val parts = ver.split(Array('.','-')) - val verList = parts.inits.map { ps => - val len = ps.mkString(".").length - // re-read version, since we lost '.' and '-' - ver.substring(0, len) - } - def dirStr(v: String) = - if (v.isEmpty) "overrides" else s"overrides-$v" - val dirs = verList.map(base / dirStr(_)).filter(_.exists) - dirs.toSeq // most specific shadow less specific - }, - - // Compute sources - // Files in earlier src dirs shadow files in later dirs - sources in Compile := { - // Sources coming from the sources of Scala - val scalaSrcDir = fetchScalaSource.value - - // All source directories (overrides shadow scalaSrcDir) - val sourceDirectories = - (unmanagedSourceDirectories in Compile).value :+ scalaSrcDir - - // Filter sources with overrides - def normPath(f: File): String = - f.getPath.replace(java.io.File.separator, "/") - - val sources = mutable.ListBuffer.empty[File] - val paths = mutable.Set.empty[String] - - for { - srcDir <- sourceDirectories - normSrcDir = normPath(srcDir) - src <- (srcDir ** "*.scala").get - } { - val normSrc = normPath(src) - val path = normSrc.substring(normSrcDir.length) - val useless = - path.contains("/scala/collection/parallel/") || - path.contains("/scala/util/parsing/") - if (!useless) { - if (paths.add(path)) - sources += src - else - streams.value.log.debug(s"not including $src") - } - } - - sources.result() - }, - - // Continuation plugin (when using 2.10.x) - autoCompilerPlugins := true, - libraryDependencies ++= { - val ver = scalaVersion.value - if (ver.startsWith("2.10.")) - Seq(compilerPlugin("org.scala-lang.plugins" % "continuations" % ver)) - else - Nil - }, - scalacOptions ++= { - if (scalaVersion.value.startsWith("2.10.")) - Seq("-P:continuations:enable") - else - Nil - } - ) ++ ( - scalaJSExternalCompileSettings - ) - ).dependsOn(compiler % "plugin") - - lazy val libraryAux: Project = Project( - id = "libraryAux", - base = file("library-aux"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js aux library", - publishArtifact in Compile := false, - delambdafySetting, - scalacOptions += "-Yskip:cleanup,icode,jvm", - scalaJSSourceMapSettings, - compileWithLibrarySetting - ) ++ ( - scalaJSExternalCompileSettings - ) - ).dependsOn(compiler % "plugin") - - lazy val library: Project = Project( - id = "library", - base = file("library"), - settings = defaultSettings ++ publishSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js library", - delambdafySetting, - scalaJSSourceMapSettings, - scalacOptions in (Compile, doc) += "-implicits", - exportJars := true - ) ++ ( - scalaJSExternalCompileSettings - ) ++ inConfig(Compile)(Seq( - /* Add the .sjsir files from other lib projects - * (but not .class files) - */ - mappings in packageBin ++= { - val allProducts = ( - (products in javalanglib).value ++ - (products in javalib).value ++ - (products in scalalib).value ++ - (products in libraryAux).value) - val filter = ("*.sjsir": NameFilter) - allProducts.flatMap(base => Path.selectSubpaths(base, filter)) - } - )) - ).dependsOn(compiler % "plugin") - - lazy val javalibEx: Project = Project( - id = "javalibEx", - base = file("javalib-ex"), - settings = defaultSettings ++ publishSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js JavaLib Ex", - delambdafySetting, - scalacOptions += "-Yskip:cleanup,icode,jvm", - scalaJSSourceMapSettings, - exportJars := true, - jsDependencies += - "org.webjars" % "jszip" % "2.4.0" / "jszip.min.js" commonJSName "JSZip" - ) ++ ( - scalaJSExternalCompileSettings - ) - ).dependsOn(compiler % "plugin", library) - - lazy val stubs: Project = Project( - id = "stubs", - base = file("stubs"), - settings = defaultSettings ++ publishSettings ++ Seq( - name := "Scala.js Stubs" - ) - ) - - // Scala.js command line interface - lazy val cli: Project = Project( - id = "cli", - base = file("cli"), - settings = defaultSettings ++ assemblySettings ++ Seq( - name := "Scala.js CLI", - scalaVersion := "2.10.4", // adapt version to tools - libraryDependencies ++= Seq( - "com.github.scopt" %% "scopt" % "3.2.0" - ), - - // assembly options - mainClass in assembly := None, // don't want an executable JAR - assemblyOption in assembly ~= { _.copy(includeScala = false) }, - AssemblyKeys.jarName in assembly := - s"${normalizedName.value}-assembly_${scalaBinaryVersion.value}-${version.value}.jar" - ) - ).dependsOn(tools) - - // Test framework - lazy val testBridge = Project( - id = "testBridge", - base = file("test-bridge"), - settings = defaultSettings ++ publishSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js test bridge", - delambdafySetting, - scalaJSSourceMapSettings - ) - ).dependsOn(compiler % "plugin", library) - - lazy val jasmineTestFramework = Project( - id = "jasmineTestFramework", - base = file("jasmine-test-framework"), - settings = defaultSettings ++ publishSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js jasmine test framework", - - jsDependencies ++= Seq( - ProvidedJS / "jasmine-polyfills.js", - "org.webjars" % "jasmine" % "1.3.1" / - "jasmine.js" dependsOn "jasmine-polyfills.js" - ), - scalaJSSourceMapSettings - ) - ).dependsOn(compiler % "plugin", library, testBridge) - - // Examples - - lazy val examples: Project = Project( - id = "examples", - base = file("examples"), - settings = defaultSettings ++ Seq( - name := "Scala.js examples" - ) - ).aggregate(helloworld, reversi, testingExample) - - lazy val exampleSettings = defaultSettings ++ myScalaJSSettings - - lazy val helloworld: Project = Project( - id = "helloworld", - base = file("examples") / "helloworld", - settings = exampleSettings ++ Seq( - name := "Hello World - Scala.js example", - moduleName := "helloworld", - persistLauncher := true - ) - ).dependsOn(compiler % "plugin", library) - - lazy val reversi = Project( - id = "reversi", - base = file("examples") / "reversi", - settings = exampleSettings ++ Seq( - name := "Reversi - Scala.js example", - moduleName := "reversi" - ) - ).dependsOn(compiler % "plugin", library) - - lazy val testingExample = Project( - id = "testingExample", - base = file("examples") / "testing", - settings = exampleSettings ++ Seq( - name := "Testing - Scala.js example", - moduleName := "testing", - - jsDependencies ++= Seq( - RuntimeDOM % "test", - "org.webjars" % "jquery" % "1.10.2" / "jquery.js" % "test" - ) - ) - ).dependsOn(compiler % "plugin", library, jasmineTestFramework % "test") - - // Testing - - lazy val testSuite: Project = Project( - id = "testSuite", - base = file("test-suite"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js test suite", - publishArtifact in Compile := false, - - scalacOptions ~= (_.filter(_ != "-deprecation")), - - sources in Test ++= { - if (!scalaVersion.value.startsWith("2.10") && - scalacOptions.value.contains("-Xexperimental")) { - (((sourceDirectory in Test).value / "require-sam") ** "*.scala").get - } else { - Nil - } - }, - - /* Generate a scala source file that throws exceptions in - various places (while attaching the source line to the - exception). When we catch the exception, we can then - compare the attached source line and the source line - calculated via the source maps. - - see test-suite/src/test/resources/SourceMapTestTemplate.scala - */ - sourceGenerators in Test <+= Def.task { - val dir = (sourceManaged in Test).value - IO.createDirectory(dir) - - val template = IO.read((resourceDirectory in Test).value / - "SourceMapTestTemplate.scala") - - def lineNo(cs: CharSequence) = - (0 until cs.length).count(i => cs.charAt(i) == '\n') + 1 - - var i = 0 - val pat = "/\\*{2,3}/".r - val replaced = pat.replaceAllIn(template, { mat => - val lNo = lineNo(mat.before) - val res = - if (mat.end - mat.start == 5) - // matching a /***/ - s"if (TC.is($i)) { throw new TestException($lNo) } else " - else - // matching a /**/ - s"; if (TC.is($i)) { throw new TestException($lNo) } ;" - - i += 1 - - res - }) - - val outFile = dir / "SourceMapTest.scala" - IO.write(outFile, replaced.replace("0/*<testCount>*/", i.toString)) - Seq(outFile) - } - ) - ).dependsOn(compiler % "plugin", library, jasmineTestFramework % "test") - - lazy val noIrCheckTest: Project = Project( - id = "noIrCheckTest", - base = file("no-ir-check-test"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "Scala.js not IR checked tests", - scalaJSOptimizerOptions ~= (_.withCheckScalaJSIR(false)), - publishArtifact in Compile := false - ) - ).dependsOn(compiler % "plugin", library, jasmineTestFramework % "test") - - lazy val javalibExTestSuite: Project = Project( - id = "javalibExTestSuite", - base = file("javalib-ex-test-suite"), - settings = defaultSettings ++ myScalaJSSettings ++ Seq( - name := "JavaLib Ex Test Suite", - publishArtifact in Compile := false, - - scalacOptions in Test ~= (_.filter(_ != "-deprecation")) - ) - ).dependsOn(compiler % "plugin", javalibEx, jasmineTestFramework % "test") - - lazy val partest: Project = Project( - id = "partest", - base = file("partest"), - settings = defaultSettings ++ Seq( - name := "Partest for Scala.js", - moduleName := "scalajs-partest", - - resolvers += Resolver.typesafeIvyRepo("releases"), - - fetchedScalaSourceDir := ( - baseDirectory.value / "fetchedSources" / - scalaVersion.value - ), - - fetchScalaSource := { - import org.eclipse.jgit.api._ - - val s = streams.value - val ver = scalaVersion.value - val trgDir = fetchedScalaSourceDir.value - - if (!trgDir.exists) { - s.log.info(s"Fetching Scala source version $ver") - - // Make parent dirs and stuff - IO.createDirectory(trgDir) - - // Clone scala source code - new CloneCommand() - .setDirectory(trgDir) - .setURI("https://github.com/scala/scala.git") - .call() - } - - // Checkout proper ref. We do this anyway so we fail if - // something is wrong - val git = Git.open(trgDir) - s.log.info(s"Checking out Scala source version $ver") - git.checkout().setName(s"v$ver").call() - - trgDir - }, - - libraryDependencies ++= { - if (shouldPartest.value) - Seq( - "org.scala-sbt" % "sbt" % sbtVersion.value, - "org.scala-lang.modules" %% "scala-partest" % "1.0.1", - "com.google.javascript" % "closure-compiler" % "v20130603", - "org.mozilla" % "rhino" % "1.7R4", - "com.googlecode.json-simple" % "json-simple" % "1.1.1" - ) - else Seq() - }, - - sources in Compile := { - if (shouldPartest.value) { - // Partest sources and some sources of sbtplugin (see above) - val baseSrcs = (sources in Compile).value - // Sources for tools (and hence IR) - val toolSrcs = (sources in (tools, Compile)).value - // Individual sources from the sbtplugin - val pluginSrcs = { - val pluginBase = ((scalaSource in (plugin, Compile)).value / - "scala/scalajs/sbtplugin") - - val scalaFilter: FileFilter = "*.scala" - val files = ( - (pluginBase * "JSUtils.scala") +++ - (pluginBase / "env" * scalaFilter) +++ - (pluginBase / "env" / "nodejs" ** scalaFilter) +++ - (pluginBase / "env" / "rhino" ** scalaFilter)) - - files.get - } - toolSrcs ++ baseSrcs ++ pluginSrcs - } else Seq() - } - - ) - ).dependsOn(compiler) - - lazy val partestSuite: Project = Project( - id = "partestSuite", - base = file("partest-suite"), - settings = defaultSettings ++ Seq( - name := "Scala.js partest suite", - - fork in Test := true, - javaOptions in Test += "-Xmx1G", - - testFrameworks ++= { - if (shouldPartest.value) - Seq(new TestFramework("scala.tools.partest.scalajs.Framework")) - else Seq() - }, - - definedTests in Test <++= Def.taskDyn[Seq[sbt.TestDefinition]] { - if (shouldPartest.value) Def.task { - val _ = (fetchScalaSource in partest).value - Seq(new sbt.TestDefinition( - s"partest-${scalaVersion.value}", - // marker fingerprint since there are no test classes - // to be discovered by sbt: - new sbt.testing.AnnotatedFingerprint { - def isModule = true - def annotationName = "partest" - }, - true, - Array() - )) - } else { - Def.task(Seq()) - } - } - ) - ).dependsOn(partest % "test", library) -} |