-
-
Notifications
You must be signed in to change notification settings - Fork 6
/
build.sc
226 lines (198 loc) · 8.37 KB
/
build.sc
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
// mill plugins
import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version::0.4.0`
import $ivy.`de.tototec::de.tobiasroeser.mill.integrationtest::0.7.1`
import $ivy.`com.lihaoyi::mill-contrib-scoverage:`
import $ivy.`com.github.lolgab::mill-mima::0.1.1`
// imports
import mill._
import mill.contrib.scoverage.ScoverageModule
import mill.define.{Command, Sources, Target, Task, TaskModule}
import mill.scalalib._
import mill.scalalib.api.ZincWorkerUtil
import mill.scalalib.publish._
import de.tobiasroeser.mill.integrationtest._
import de.tobiasroeser.mill.vcs.version._
import com.github.lolgab.mill.mima.Mima
import scala.util.{Properties, Try}
// `lazy` to work around issue https://github.com/com-lihaoyi/mill/issues/2582
lazy val baseDir = build.millSourcePath
trait Deps {
def millPlatform: String
def millVersion: String
def scalaVersion: String = "2.13.14"
def testWithMill: Seq[String]
def mimaPreviousVersions: Seq[String] = Seq()
val millMain = ivy"com.lihaoyi::mill-main:${millVersion}"
val scalaTest = ivy"org.scalatest::scalatest:3.2.19"
val scoverageVersion = "2.2.0"
val scoverageRuntime = ivy"org.scoverage::scalac-scoverage-runtime:${scoverageVersion}"
}
class Deps_latest(override val millVersion: String) extends Deps {
override def millPlatform = millVersion
override def testWithMill = Seq(millVersion)
override def mimaPreviousVersions = Seq()
}
object Deps_0_11 extends Deps {
override def millPlatform = "0.11"
override def millVersion = "0.11.0" // scala-steward:off
override def testWithMill = Seq("0.11.8", millVersion)
override def mimaPreviousVersions = Seq()
}
object Deps_0_10 extends Deps {
override def millPlatform = "0.10"
override def millVersion = "0.10.0" // scala-steward:off
// 0.10.4 and 0.10.3 don't run in CI on Windows
override def testWithMill = Seq("0.10.15", "0.10.5", millVersion)
}
object Deps_0_9 extends Deps {
override def millPlatform = "0.9"
override def millVersion = "0.9.3" // scala-steward:off
override def testWithMill =
Seq("0.9.12", "0.9.11", "0.9.10", "0.9.9", "0.9.8", "0.9.7", "0.9.6", "0.9.5", "0.9.4", millVersion)
}
object Deps_0_7 extends Deps {
override def millPlatform = "0.7"
override def millVersion = "0.7.0" // scala-steward:off
override def testWithMill = Seq("0.8.0", "0.7.4", "0.7.3", "0.7.2", "0.7.1", millVersion)
}
object Deps_0_6 extends Deps {
override def millPlatform = "0.6"
override def millVersion = "0.6.0" // scala-steward:off
override def scalaVersion = "2.12.20"
override def testWithMill = Seq("0.6.3", "0.6.2", "0.6.1", millVersion)
}
lazy val latestDeps: Seq[Deps] = {
val path = baseDir / "MILL_DEV_VERSION"
interp.watch(path)
println(s"Checking for file ${path}")
if (os.exists(path)) {
Try {
Seq(new Deps_latest(os.read(path).trim()))
}
.recover { _ => Seq() }
}.get
else Seq()
}
lazy val crossDeps: Seq[Deps] = (Seq(Deps_0_11, Deps_0_10, Deps_0_9, Deps_0_7, Deps_0_6) ++ latestDeps).distinct
lazy val millApiVersions = crossDeps.map(x => x.millPlatform -> x)
lazy val millItestVersions = crossDeps.flatMap(x => x.testWithMill.map(_ -> x))
/** Shared configuration. */
trait BaseModule extends ScalaModule with PublishModule with ScoverageModule with Mima {
def millApiVersion: String
def deps: Deps = millApiVersions.toMap.apply(millApiVersion)
def scalaVersion = deps.scalaVersion
override def artifactSuffix: T[String] = s"_mill${deps.millPlatform}_${artifactScalaVersion()}"
override def ivyDeps = T {
Agg(ivy"${scalaOrganization()}:scala-library:${scalaVersion()}")
}
def publishVersion = VcsVersion.vcsState().format()
override def versionScheme: T[Option[VersionScheme]] = T(Option(VersionScheme.EarlySemVer))
override def mimaPreviousVersions = deps.mimaPreviousVersions
override def mimaPreviousArtifacts: Target[Agg[Dep]] = T {
val md = artifactMetadata()
Agg.from(
mimaPreviousVersions().map(v => ivy"${md.group}:${md.id}:${v}")
)
}
override def sources = T.sources {
Seq(PathRef(millSourcePath / "src")) ++
(ZincWorkerUtil.matchingVersions(millApiVersion) ++
ZincWorkerUtil.versionRanges(millApiVersion, crossDeps.map(_.millPlatform)))
.map(p => PathRef(millSourcePath / s"src-${p}"))
}
override def javacOptions = {
(if (Properties.isJavaAtLeast(9)) Seq("--release", "8") else Seq("-source", "1.8", "-target", "1.8")) ++
Seq("-encoding", "UTF-8", "-deprecation")
}
override def scalacOptions = Seq("-target:jvm-1.8", "-encoding", "UTF-8", "-deprecation")
def pomSettings = T {
PomSettings(
description = "Mill plugin to derive a version from (last) git tag and edit state",
organization = "de.tototec",
url = "https://github.com/lefou/mill-vcs-version",
licenses = Seq(License.`Apache-2.0`),
versionControl = VersionControl.github("lefou", "mill-vcs-version"),
developers = Seq(Developer("lefou", "Tobias Roeser", "https.//github.com/lefou"))
)
}
override def scoverageVersion = deps.scoverageVersion
trait Tests extends ScoverageTests
}
/* The actual mill plugin compilied against different mill APIs. */
object core extends Cross[CoreCross](millApiVersions.map(_._1))
trait CoreCross extends BaseModule with Cross.Module[String] {
override def millApiVersion: String = crossValue
override def artifactName = "de.tobiasroeser.mill.vcs.version"
override def skipIdea: Boolean = deps != crossDeps.head
override def compileIvyDeps = Agg(deps.millMain)
object test extends Tests with TestModule.ScalaTest {
override def ivyDeps = Agg(deps.scalaTest, deps.millMain)
}
}
/** Integration tests. */
object itest extends Cross[ItestCross](millItestVersions.map(_._1)) with TaskModule {
override def defaultCommandName(): String = "test"
def testCached: T[Seq[TestCase]] = itest(millItestVersions.map(_._1).head).testCached
def test(args: String*): Command[Seq[TestCase]] = itest(millItestVersions.map(_._1).head).test(args: _*)
}
trait ItestCross extends MillIntegrationTestModule with Cross.Module[String] {
def millItestVersion = crossValue
val millApiVersion = millItestVersions.toMap.apply(millItestVersion).millPlatform
def deps: Deps = millApiVersions.toMap.apply(millApiVersion)
override def millTestVersion = millItestVersion
override def pluginsUnderTest = Seq(core(millApiVersion))
/** Replaces the plugin jar with a scoverage-enhanced version of it. */
override def pluginUnderTestDetails: Task[Seq[(PathRef, (PathRef, (PathRef, (PathRef, (PathRef, Artifact)))))]] =
Target.traverse(pluginsUnderTest) { p =>
val jar = p match {
case p: ScoverageModule => p.scoverage.jar
case p => p.jar
}
jar zip (p.sourceJar zip (p.docJar zip (p.pom zip (p.ivy zip p.artifactMetadata))))
}
override def testInvocations: Target[Seq[(PathRef, Seq[TestInvocation.Targets])]] = T {
testCases().map { pathref =>
pathref.path.last match {
case "01-simple" =>
pathref -> Seq(
TestInvocation.Targets(Seq("-d", "verify1")),
TestInvocation.Targets(Seq("de.tobiasroeser.mill.vcs.version.VcsVersion/vcsState")),
TestInvocation.Targets(Seq("changeSomething")),
TestInvocation.Targets(Seq("verify2"))
)
case "no-git" =>
pathref -> Seq(
// setting GIT_DIR explicitly disables repository discovery
TestInvocation.Targets(targets = Seq("-d", "verify"), env = Map("GIT_DIR" -> "."))
)
case _ =>
pathref -> Seq(TestInvocation.Targets(Seq("-d", "verify")))
}
}
}
override def perTestResources = T.sources {
Seq(generatedSharedSrc())
}
def generatedSharedSrc = T {
os.write(
T.dest / "shared.sc",
s"""import $$ivy.`${deps.scoverageRuntime.dep.module.organization.value}::${deps.scoverageRuntime.dep.module.name.value}:${deps.scoverageRuntime.dep.version}`
|""".stripMargin
)
PathRef(T.dest)
}
}
def findLatestMill(toFile: String = "") = T.command {
import coursier._
val versions =
Versions(cache.FileCache().withTtl(concurrent.duration.Duration(1, java.util.concurrent.TimeUnit.MINUTES)))
.withModule(mod"com.lihaoyi:mill-main_2.13")
.run()
println(s"Latest Mill versions: ${versions.latest}")
if (toFile.nonEmpty) {
val path = os.Path.expandUser(toFile, os.pwd)
println(s"Writing file: ${path}")
os.write.over(path, versions.latest, createFolders = true)
}
versions.latest
}