luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Adapting to Zinc changes

This commit is contained in:
Eugene Yokota 2016-06-26 03:49:11 +02:00
parent 824b59a3ef
commit 246ec58e35
9 changed files with 58 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
main-actions/src/main/scala/sbt/Compiler.scala
View File

@ -3,10 +3,10 @@
*/ */
package sbt package sbt
import sbt.internal.inc.javac.{ IncrementalCompilerJavaTools, JavaTools } import sbt.internal.inc.javac.JavaTools
import sbt.internal.inc.{ Analysis, AnalyzingCompiler, ClasspathOptions, CompileOutput, ComponentCompiler, IncrementalCompilerImpl, JavaTool, Locate, LoggerReporter, ScalaInstance } import sbt.internal.inc.{ Analysis, AnalyzingCompiler, CompileOutput, ComponentCompiler, IncrementalCompilerImpl, Locate, LoggerReporter, ScalaInstance }
import xsbti.{ Logger => _, _ } import xsbti.{ Logger => _, _ }
import xsbti.compile.{ CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, MiniSetup } import xsbti.compile.{ ClasspathOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, MiniSetup }
import CompileOrder.{ JavaThenScala, Mixed, ScalaThenJava } import CompileOrder.{ JavaThenScala, Mixed, ScalaThenJava }
import java.io.File import java.io.File
@ -120,7 +120,7 @@ object Compiler {
ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): Compilers = { ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): Compilers = {
val scalac = scalaCompiler(instance, cpOptions, javaHome, ivyConfiguration, sourcesModule) val scalac = scalaCompiler(instance, cpOptions, javaHome, ivyConfiguration, sourcesModule)
val javac = JavaTools.directOrFork(instance, cpOptions, javaHome) val javac = JavaTools.directOrFork(instance, cpOptions, javaHome)
IncrementalCompilerImpl.Compilers(scalac, javac) new Compilers(scalac, javac)
} }
def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler = def scalaCompiler(instance: ScalaInstance, cpOptions: ClasspathOptions, javaHome: Option[File], ivyConfiguration: IvyConfiguration, sourcesModule: ModuleID)(implicit app: AppConfiguration, log: Logger): AnalyzingCompiler =
{ {

6
main-actions/src/main/scala/sbt/Console.scala
View File

@ -4,11 +4,11 @@
package sbt package sbt
import java.io.File import java.io.File
import sbt.internal.inc.{ AnalyzingCompiler, IncrementalCompilerImpl } import sbt.internal.inc.AnalyzingCompiler
import sbt.internal.util.JLine import sbt.internal.util.JLine
import sbt.util.Logger import sbt.util.Logger
import xsbti.compile.Inputs import xsbti.compile.{ Inputs, Compilers }
final class Console(compiler: AnalyzingCompiler) { final class Console(compiler: AnalyzingCompiler) {
/** Starts an interactive scala interpreter session with the given classpath.*/ /** Starts an interactive scala interpreter session with the given classpath.*/
@ -32,6 +32,6 @@ final class Console(compiler: AnalyzingCompiler) {
object Console { object Console {
def apply(conf: Inputs): Console = def apply(conf: Inputs): Console =
conf.compilers match { conf.compilers match {
case IncrementalCompilerImpl.Compilers(scalac, _) => new Console(scalac) case cs: Compilers => new Console(cs.scalac match { case x: AnalyzingCompiler => x })
} }
} }

21
main-actions/src/main/scala/sbt/Doc.scala
View File

@ -4,7 +4,7 @@
package sbt package sbt
import java.io.{ File, PrintWriter } import java.io.{ File, PrintWriter }
import sbt.internal.inc.{ AnalyzingCompiler, JavaCompiler } import sbt.internal.inc.AnalyzingCompiler
import Predef.{ conforms => _, _ } import Predef.{ conforms => _, _ }
import sbt.internal.util.Types.:+: import sbt.internal.util.Types.:+:
@ -17,6 +17,7 @@ import sbt.internal.util.Tracked.{ inputChanged, outputChanged }
import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo } import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo }
import sbt.internal.util.FilesInfo.{ exists, hash, lastModified } import sbt.internal.util.FilesInfo.{ exists, hash, lastModified }
import xsbti.Reporter import xsbti.Reporter
import xsbti.compile.JavaTools
import sbt.util.Logger import sbt.util.Logger
@ -26,9 +27,9 @@ object Doc {
scaladoc(label, cache, compiler, Seq()) scaladoc(label, cache, compiler, Seq())
def scaladoc(label: String, cache: File, compiler: AnalyzingCompiler, fileInputOptions: Seq[String]): Gen = def scaladoc(label: String, cache: File, compiler: AnalyzingCompiler, fileInputOptions: Seq[String]): Gen =
cached(cache, fileInputOptions, prepare(label + " Scala API documentation", compiler.doc)) cached(cache, fileInputOptions, prepare(label + " Scala API documentation", compiler.doc))
def javadoc(label: String, cache: File, doc: sbt.internal.inc.javac.JavaTools, log: Logger, reporter: Reporter): Gen = def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter): Gen =
javadoc(label, cache, doc, log, reporter, Seq()) javadoc(label, cache, doc, log, reporter, Seq())
def javadoc(label: String, cache: File, doc: sbt.internal.inc.javac.JavaTools, log: Logger, reporter: Reporter, fileInputOptions: Seq[String]): Gen = def javadoc(label: String, cache: File, doc: JavaTools, log: Logger, reporter: Reporter, fileInputOptions: Seq[String]): Gen =
cached(cache, fileInputOptions, prepare(label + " Java API documentation", filterSources(javaSourcesOnly, cached(cache, fileInputOptions, prepare(label + " Java API documentation", filterSources(javaSourcesOnly,
(sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maxErrors: Int, log: Logger) => { (sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], maxErrors: Int, log: Logger) => {
// doc.doc // doc.doc
@ -48,13 +49,13 @@ object Doc {
generate("Scala", label, compiler.doc, sources, classpath, outputDirectory, options, maximumErrors, log) generate("Scala", label, compiler.doc, sources, classpath, outputDirectory, options, maximumErrors, log)
} }
} }
// TODO: trait Javadoc in package inc is deprecated: Please use the new set of compilers in sbt.compilers.javac
private[sbt] final class Javadoc(maximumErrors: Int, doc: sbt.internal.inc.Javadoc) extends Doc { // private[sbt] final class Javadoc(maximumErrors: Int, doc: sbt.internal.inc.Javadoc) extends Doc {
def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger): Unit = { // def apply(label: String, sources: Seq[File], classpath: Seq[File], outputDirectory: File, options: Seq[String], log: Logger) {
// javadoc doesn't handle *.scala properly, so we evict them from javadoc sources list. // // javadoc doesn't handle *.scala properly, so we evict them from javadoc sources list.
generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log) // generate("Java", label, doc.doc, sources.filterNot(_.name.endsWith(".scala")), classpath, outputDirectory, options, maximumErrors, log)
} // }
} // }
} }
// @deprecated("No longer used. See `Doc.javadoc` or `Doc.scaladoc`", "0.13.0") // @deprecated("No longer used. See `Doc.javadoc` or `Doc.scaladoc`", "0.13.0")
sealed trait Doc { sealed trait Doc {

3
main-actions/src/main/scala/sbt/RawCompileLike.scala
View File

@ -4,7 +4,7 @@
package sbt package sbt
import java.io.File import java.io.File
import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions, JavaCompiler, RawCompiler, ScalaInstance } import sbt.internal.inc.{ AnalyzingCompiler, RawCompiler, ScalaInstance }
import Predef.{ conforms => _, _ } import Predef.{ conforms => _, _ }
import sbt.io.syntax._ import sbt.io.syntax._
@ -16,6 +16,7 @@ import sbt.internal.util.Cache.{ defaultEquiv, hConsCache, hNilCache, IntFormat,
import sbt.internal.util.Tracked.{ inputChanged, outputChanged } import sbt.internal.util.Tracked.{ inputChanged, outputChanged }
import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo } import sbt.internal.util.{ FilesInfo, HashFileInfo, HNil, ModifiedFileInfo, PlainFileInfo }
import sbt.internal.util.FilesInfo.{ exists, hash, lastModified } import sbt.internal.util.FilesInfo.{ exists, hash, lastModified }
import xsbti.compile.ClasspathOptions
import sbt.util.Logger import sbt.util.Logger

45
main/src/main/scala/sbt/Defaults.scala
View File

@ -9,9 +9,6 @@ import sbt.internal.util.Attributed
import sbt.internal.util.Attributed.data import sbt.internal.util.Attributed.data
import Scope.{ fillTaskAxis, GlobalScope, ThisScope } import Scope.{ fillTaskAxis, GlobalScope, ThisScope }
import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties } import sbt.internal.librarymanagement.mavenint.{ PomExtraDependencyAttributes, SbtPomExtraProperties }
import xsbt.api.Discovery
import xsbti.compile.{ CompileAnalysis, CompileOptions, CompileOrder, CompileResult, DefinesClass, IncOptions, IncOptionsUtil, Inputs, MiniSetup, PreviousResult, Setup, TransactionalManagerType }
import xsbti.compile.PerClasspathEntryLookup
import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar } import Project.{ inConfig, inScope, inTask, richInitialize, richInitializeTask, richTaskSessionVar }
import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition } import Def.{ Initialize, ScopedKey, Setting, SettingsDefinition }
import sbt.internal.librarymanagement.{ CustomPomParser, DependencyFilter } import sbt.internal.librarymanagement.{ CustomPomParser, DependencyFilter }
@ -21,7 +18,6 @@ import sbt.librarymanagement.Configurations.{ Compile, CompilerPlugin, Integrati
import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion } import sbt.librarymanagement.CrossVersion.{ binarySbtVersion, binaryScalaVersion, partialVersion }
import sbt.internal.util.complete._ import sbt.internal.util.complete._
import std.TaskExtra._ import std.TaskExtra._
import sbt.internal.inc.{ Analysis, ClassfileManager, ClasspathOptions, CompilerCache, FileValueCache, IncrementalCompilerImpl, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance }
import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint } import testing.{ Framework, Runner, AnnotatedFingerprint, SubclassFingerprint }
import sbt.librarymanagement.{ `package` => _, _ } import sbt.librarymanagement.{ `package` => _, _ }
@ -54,6 +50,12 @@ import Path._
import sbt.io.syntax._ import sbt.io.syntax._
import Keys._ import Keys._
// incremental compiler
import xsbt.api.Discovery
import xsbti.compile.{ Compilers, ClasspathOptions, CompileAnalysis, CompileOptions, CompileOrder, CompileResult, DefinesClass, IncOptions, IncOptionsUtil, Inputs, MiniSetup, PreviousResult, Setup, TransactionalManagerType }
import xsbti.compile.PerClasspathEntryLookup
import sbt.internal.inc.{ AnalyzingCompiler, Analysis, ClassfileManager, CompilerCache, FileValueCache, IncrementalCompilerImpl, Locate, LoggerReporter, MixedAnalyzingCompiler, ScalaInstance, ClasspathOptionsUtil }
object Defaults extends BuildCommon { object Defaults extends BuildCommon {
final val CacheDirectoryName = "cache" final val CacheDirectoryName = "cache"
@ -255,8 +257,8 @@ object Defaults extends BuildCommon {
// must be a val: duplication detected by object identity // must be a val: duplication detected by object identity
private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(Seq( private[this] lazy val compileBaseGlobal: Seq[Setting[_]] = globalDefaults(Seq(
incOptions := IncOptionsUtil.defaultIncOptions, incOptions := IncOptionsUtil.defaultIncOptions,
classpathOptions :== ClasspathOptions.boot, classpathOptions :== ClasspathOptionsUtil.boot,
classpathOptions in console :== ClasspathOptions.repl, classpathOptions in console :== ClasspathOptionsUtil.repl,
compileOrder :== CompileOrder.Mixed, compileOrder :== CompileOrder.Mixed,
javacOptions :== Nil, javacOptions :== Nil,
scalacOptions :== Nil, scalacOptions :== Nil,
@ -803,7 +805,7 @@ object Defaults extends BuildCommon {
fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"), fileInputOptions := Seq("-doc-root-content", "-diagrams-dot-path"),
key in TaskGlobal := { key in TaskGlobal := {
val s = streams.value val s = streams.value
val cs: IncrementalCompilerImpl.Compilers = compilers.value match { case c: IncrementalCompilerImpl.Compilers => c } val cs: Compilers = compilers.value
val srcs = sources.value val srcs = sources.value
val out = target.value val out = target.value
val sOpts = scalacOptions.value val sOpts = scalacOptions.value
@ -820,10 +822,14 @@ object Defaults extends BuildCommon {
(hasScala, hasJava) match { (hasScala, hasJava) match {
case (true, _) => case (true, _) =>
val options = sOpts ++ Opts.doc.externalAPI(xapis) val options = sOpts ++ Opts.doc.externalAPI(xapis)
val runDoc = Doc.scaladoc(label, s.cacheDirectory / "scala", cs.scalac.onArgs(exported(s, "scaladoc")), fiOpts) val runDoc = Doc.scaladoc(label, s.cacheDirectory / "scala",
cs.scalac match {
case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scaladoc"))
},
fiOpts)
runDoc(srcs, cp, out, options, maxErrors.value, s.log) runDoc(srcs, cp, out, options, maxErrors.value, s.log)
case (_, true) => case (_, true) =>
val javadoc = sbt.inc.Doc.cachedJavadoc(label, s.cacheDirectory / "java", cs.javac) val javadoc = sbt.inc.Doc.cachedJavadoc(label, s.cacheDirectory / "java", cs.javaTools)
javadoc.run(srcs.toList, cp, out, javacOptions.value.toList, s.log, reporter) javadoc.run(srcs.toList, cp, out, javacOptions.value.toList, s.log, reporter)
case _ => () // do nothing case _ => () // do nothing
} }
@ -842,12 +848,14 @@ object Defaults extends BuildCommon {
def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick) def consoleQuickTask = consoleTask(externalDependencyClasspath, consoleQuick)
def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] = def consoleTask(classpath: TaskKey[Classpath], task: TaskKey[_]): Initialize[Task[Unit]] =
(compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map { (compilers in task, classpath in task, scalacOptions in task, initialCommands in task, cleanupCommands in task, taskTemporaryDirectory in task, scalaInstance in task, streams) map {
// TODO: Make exhaustive after zinc is updated to include https://github.com/sbt/zinc/pull/128 case (cs: Compilers, cp, options, initCommands, cleanup, temp, si, s) =>
case (cs: IncrementalCompilerImpl.Compilers, cp, options, initCommands, cleanup, temp, si, s) =>
val cpFiles = data(cp) val cpFiles = data(cp)
val fullcp = (cpFiles ++ si.allJars).distinct val fullcp = (cpFiles ++ si.allJars).distinct
val loader = sbt.internal.inc.classpath.ClasspathUtilities.makeLoader(fullcp, si, IO.createUniqueDirectory(temp)) val loader = sbt.internal.inc.classpath.ClasspathUtilities.makeLoader(fullcp, si, IO.createUniqueDirectory(temp))
val compiler = cs.scalac.onArgs(exported(s, "scala")) val compiler =
cs.scalac match {
case ac: AnalyzingCompiler => ac.onArgs(exported(s, "scala"))
}
(new Console(compiler))(cpFiles, options, loader, initCommands, cleanup)()(s.log).foreach(msg => sys.error(msg)) (new Console(compiler))(cpFiles, options, loader, initCommands, cleanup)()(s.log).foreach(msg => sys.error(msg))
println() println()
} }
@ -880,8 +888,17 @@ object Defaults extends BuildCommon {
private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Inputs): CompileResult = private[this] def compileIncrementalTaskImpl(s: TaskStreams, ci: Inputs): CompileResult =
{ {
lazy val x = s.text(ExportStream) lazy val x = s.text(ExportStream)
def onArgs(cs: IncrementalCompilerImpl.Compilers) = cs.copy(scalac = cs.scalac.onArgs(exported(x, "scalac")), javac = cs.javac /*.onArgs(exported(x, "javac"))*/ ) def onArgs(cs: Compilers) =
val compilers: IncrementalCompilerImpl.Compilers = ci.compilers match { case compilers: IncrementalCompilerImpl.Compilers => compilers } cs.withScalac(
cs.scalac match {
case ac: AnalyzingCompiler => ac.onArgs(exported(x, "scalac"))
case x => x
}
)
// .withJavac(
// cs.javac.onArgs(exported(x, "javac"))
//)
val compilers: Compilers = ci.compilers
val i = ci.withCompilers(onArgs(compilers)) val i = ci.withCompilers(onArgs(compilers))
try Compiler.compile(i, s.log) try Compiler.compile(i, s.log)
finally x.close() // workaround for #937 finally x.close() // workaround for #937

4
main/src/main/scala/sbt/Keys.scala
View File

@ -9,9 +9,9 @@ import scala.concurrent.duration.{ FiniteDuration, Duration }
import Def.ScopedKey import Def.ScopedKey
import sbt.internal.util.complete._ import sbt.internal.util.complete._
import xsbti.compile.DefinesClass import xsbti.compile.DefinesClass
import sbt.internal.inc.{ ClasspathOptions, MixedAnalyzingCompiler, ScalaInstance } import sbt.internal.inc.{ MixedAnalyzingCompiler, ScalaInstance }
import std.TaskExtra._ import std.TaskExtra._
import xsbti.compile.{ CompileAnalysis, CompileOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, PreviousResult, Setup } import xsbti.compile.{ ClasspathOptions, CompileAnalysis, CompileOptions, CompileOrder, Compilers, CompileResult, GlobalsCache, IncOptions, Inputs, PreviousResult, Setup }
import scala.xml.{ Node => XNode, NodeSeq } import scala.xml.{ Node => XNode, NodeSeq }
import org.apache.ivy.core.module.{ descriptor, id } import org.apache.ivy.core.module.{ descriptor, id }
import descriptor.ModuleDescriptor, id.ModuleRevisionId import descriptor.ModuleDescriptor, id.ModuleRevisionId

4
main/src/main/scala/sbt/internal/ConsoleProject.scala
View File

@ -8,7 +8,7 @@ import sbt.util.Logger
import java.io.File import java.io.File
import sbt.librarymanagement.Resolver import sbt.librarymanagement.Resolver
import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths } import sbt.internal.librarymanagement.{ InlineIvyConfiguration, IvyPaths }
import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptions, IncrementalCompilerImpl, ScalaInstance } import sbt.internal.inc.{ AnalyzingCompiler, ClasspathOptionsUtil, IncrementalCompilerImpl, ScalaInstance }
object ConsoleProject { object ConsoleProject {
def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(implicit log: Logger): Unit = { def apply(state: State, extra: String, cleanupCommands: String = "", options: Seq[String] = Nil)(implicit log: Logger): Unit = {
@ -22,7 +22,7 @@ object ConsoleProject {
ScalaInstance(scalaProvider.version, scalaProvider.launcher) ScalaInstance(scalaProvider.version, scalaProvider.launcher)
} }
val sourcesModule = extracted.get(Keys.scalaCompilerBridgeSource) val sourcesModule = extracted.get(Keys.scalaCompilerBridgeSource)
val compiler = Compiler.scalaCompiler(scalaInstance, ClasspathOptions.repl, None, ivyConf, sourcesModule)(state.configuration, log) val compiler = Compiler.scalaCompiler(scalaInstance, ClasspathOptionsUtil.repl, None, ivyConf, sourcesModule)(state.configuration, log)
val imports = BuildUtil.getImports(unit.unit) ++ BuildUtil.importAll(bindings.map(_._1)) val imports = BuildUtil.getImports(unit.unit) ++ BuildUtil.importAll(bindings.map(_._1))
val importString = imports.mkString("", ";\n", ";\n\n") val importString = imports.mkString("", ";\n", ";\n\n")
val initCommands = importString + extra val initCommands = importString + extra

4
main/src/main/scala/sbt/internal/Load.scala
View File

@ -13,7 +13,7 @@ import java.net.{ URI, URL }
import compiler.{ Eval, EvalImports } import compiler.{ Eval, EvalImports }
import scala.annotation.tailrec import scala.annotation.tailrec
import collection.mutable import collection.mutable
import sbt.internal.inc.{ Analysis, ClasspathOptions, FileValueCache, Locate, ModuleUtilities } import sbt.internal.inc.{ Analysis, ClasspathOptionsUtil, FileValueCache, Locate, ModuleUtilities }
import sbt.internal.inc.classpath.ClasspathUtilities import sbt.internal.inc.classpath.ClasspathUtilities
import Project.inScope import Project.inScope
import Def.{ isDummy, ScopedKey, ScopeLocal, Setting } import Def.{ isDummy, ScopedKey, ScopeLocal, Setting }
@ -56,7 +56,7 @@ private[sbt] object Load {
val ivyPaths = new IvyPaths(baseDirectory, bootIvyHome(state.configuration)) val ivyPaths = new IvyPaths(baseDirectory, bootIvyHome(state.configuration))
val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil), val ivyConfiguration = new InlineIvyConfiguration(ivyPaths, Resolver.withDefaultResolvers(Nil),
Nil, Nil, localOnly, lock, checksums, None, UpdateOptions(), log) Nil, Nil, localOnly, lock, checksums, None, UpdateOptions(), log)
val compilers = Compiler.compilers(ClasspathOptions.boot, ivyConfiguration)(state.configuration, log) val compilers = Compiler.compilers(ClasspathOptionsUtil.boot, ivyConfiguration)(state.configuration, log)
val evalPluginDef = EvaluateTask.evalPluginDef(log) _ val evalPluginDef = EvaluateTask.evalPluginDef(log) _
val delegates = defaultDelegates val delegates = defaultDelegates
val initialID = baseDirectory.getName val initialID = baseDirectory.getName

2
project/Dependencies.scala
View File

@ -12,7 +12,7 @@ object Dependencies {
val ioVersion = "1.0.0-M6" val ioVersion = "1.0.0-M6"
val utilVersion = "0.1.0-M13" val utilVersion = "0.1.0-M13"
val librarymanagementVersion = "0.1.0-M12" val librarymanagementVersion = "0.1.0-M12"
val zincVersion = "1.0.0-M3" val zincVersion = "1.0.0-M3-2541fa40f245c612f5ad8d363b0ffea6dbffa991"
lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion lazy val sbtIO = "org.scala-sbt" %% "io" % ioVersion
lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion lazy val utilCollection = "org.scala-sbt" %% "util-collection" % utilVersion
lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion lazy val utilLogging = "org.scala-sbt" %% "util-logging" % utilVersion