1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
package mill
package scalalib
import java.io.File
import ammonite.ops._
import coursier.{Cache, Fetch, MavenRepository, Repository, Resolution, Module => CoursierModule}
import mill.eval.{PathRef, Result}
import mill.util.Loose.Agg
object CompilationResult {
implicit val jsonFormatter: upickle.default.ReadWriter[CompilationResult] = upickle.default.macroRW
}
// analysisFile is represented by Path, so we won't break caches after file changes
case class CompilationResult(analysisFile: Path, classes: PathRef)
object Lib{
def grepJar(classPath: Agg[Path], s: String) = {
classPath
.find(_.toString.endsWith(s))
.getOrElse(throw new Exception("Cannot find " + s))
.toIO
}
/**
* Resolve dependencies using Coursier.
*
* We do not bother breaking this out into the separate ScalaWorker classpath,
* because Coursier is already bundled with mill/Ammonite to support the
* `import $ivy` syntax.
*/
def resolveDependencies(repositories: Seq[Repository],
scalaVersion: String,
scalaBinaryVersion: String,
deps: TraversableOnce[Dep],
sources: Boolean = false): Result[Agg[PathRef]] = {
val flattened = deps.map{
case Dep.Java(dep) => dep
case Dep.Scala(dep) =>
dep.copy(module = dep.module.copy(name = dep.module.name + "_" + scalaBinaryVersion))
case Dep.Point(dep) =>
dep.copy(module = dep.module.copy(name = dep.module.name + "_" + scalaVersion))
}.toSet
val start = Resolution(flattened)
val fetch = Fetch.from(repositories, Cache.fetch())
val resolution = start.process.run(fetch).unsafePerformSync
val errs = resolution.metadataErrors
if(errs.nonEmpty) {
val header =
s"""|
|Resolution failed for ${errs.length} modules:
|--------------------------------------------
|""".stripMargin
val errLines = errs.map {
case ((module, vsn), errMsgs) => s" ${module.trim}:$vsn \n\t" + errMsgs.mkString("\n\t")
}.mkString("\n")
val msg = header + errLines + "\n"
Result.Failure(msg)
} else {
val sourceOrJar =
if (sources) resolution.classifiersArtifacts(Seq("sources"))
else resolution.artifacts
val localArtifacts: Seq[File] = scalaz.concurrent.Task
.gatherUnordered(sourceOrJar.map(Cache.file(_).run))
.unsafePerformSync
.flatMap(_.toOption)
Agg.from(
localArtifacts.map(p => PathRef(Path(p), quick = true)).filter(_.path.ext == "jar")
)
}
}
def scalaCompilerIvyDeps(scalaVersion: String) = Agg[Dep](
Dep.Java("org.scala-lang", "scala-compiler", scalaVersion),
Dep.Java("org.scala-lang", "scala-reflect", scalaVersion)
)
def scalaRuntimeIvyDeps(scalaVersion: String) = Agg[Dep](
Dep.Java("org.scala-lang", "scala-library", scalaVersion)
)
def compilerBridgeIvyDep(scalaVersion: String) =
Dep.Point(coursier.Dependency(coursier.Module("com.lihaoyi", "mill-bridge"), "0.1", transitive = false))
val DefaultShellScript: Seq[String] = Seq(
"#!/usr/bin/env sh",
"exec java -jar \"$0\" \"$@\""
)
}
|
