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
|
package mill
import ammonite.interp.Interpreter
import ammonite.main.Scripts
import ammonite.ops._
import ammonite.util.{Colors, Res}
import mill.define.Task
import mill.discover._
import mill.eval.{Evaluator, Result}
import mill.util.{Logger, OSet, PrintLogger}
import ammonite.main.Scripts.pathScoptRead
import ammonite.repl.Repl
import mill.define.Task.TaskModule
object Main {
def parseSelector(input: String) = {
import fastparse.all._
val segment = P( CharsWhileIn(('a' to 'z') ++ ('A' to 'Z') ++ ('0' to '9')).! ).map(
Mirror.Segment.Label
)
val crossSegment = P( "[" ~ CharsWhile(c => c != ',' && c != ']').!.rep(1, sep=",") ~ "]" ).map(
Mirror.Segment.Cross
)
val query = P( segment ~ ("." ~ segment | crossSegment).rep ~ End ).map{
case (h, rest) => h :: rest.toList
}
query.parse(input)
}
def parseArgs(selectorString: String): Either[String, List[Mirror.Segment]] = {
import fastparse.all.Parsed
if (selectorString.isEmpty) Left("Selector cannot be empty")
else parseSelector(selectorString) match {
case f: Parsed.Failure => Left(s"Parsing exception ${f.msg}")
case Parsed.Success(selector, _) => Right(selector)
}
}
def discoverMirror[T: Discovered](obj: T): Either[String, Discovered[T]] = {
val discovered = implicitly[Discovered[T]]
val consistencyErrors = Discovered.consistencyCheck(obj, discovered)
if (consistencyErrors.nonEmpty) {
Left(s"Failed Discovered.consistencyCheck: ${consistencyErrors.map(Mirror.renderSelector)}")
} else {
Right(discovered)
}
}
def evaluate(evaluator: Evaluator,
target: Task[Any],
watch: Path => Unit): Option[String] = {
val evaluated = evaluator.evaluate(OSet(target))
evaluated.transitive.foreach {
case t: define.Source => watch(t.handle.path)
case _ => // do nothing
}
val errorStr =
(for((k, fs) <- evaluated.failing.items()) yield {
val ks = k match{
case Left(t) => t.toString
case Right(t) => Mirror.renderSelector(t.segments.toList)
}
val fss = fs.map{
case Result.Exception(t) => t.toString
case Result.Failure(t) => t
}
s"$ks ${fss.mkString(", ")}"
}).mkString("\n")
evaluated.failing.keyCount match {
case 0 => None
case n => Some(s"$n targets failed\n$errorStr")
}
}
def apply[T: Discovered](args: Seq[String],
obj: T,
watch: Path => Unit,
coloredOutput: Boolean): Int = {
val log = new PrintLogger(coloredOutput)
val Seq(selectorString, rest @_*) = args
val res = for {
sel <- parseArgs(selectorString)
disc <- discoverMirror(obj)
crossSelectors = sel.map{
case Mirror.Segment.Cross(x) => x.toList.map(_.toString)
case _ => Nil
}
target <- mill.main.Resolve.resolve(sel, disc.mirror, obj, rest, crossSelectors, Nil)
evaluator = new Evaluator(pwd / 'out, Discovered.mapping(obj)(disc), log)
_ <- evaluate(evaluator, target, watch).toLeft(())
} yield ()
res match {
case Left(err) =>
log.error(err)
1
case Right(_) => 0
}
}
case class Config(home: ammonite.ops.Path = pwd/'out/'ammonite,
colored: Option[Boolean] = None,
help: Boolean = false,
repl: Boolean = false,
watch: Boolean = false)
def main(args: Array[String]): Unit = {
val syntheticPath = pwd / 'out / "run.sc"
write.over(
syntheticPath,
s"""import $$file.^.build
|import mill._
|
|val discovered = implicitly[mill.discover.Discovered[build.type]]
|
|@main def run(args: String*) = mill.Main(args, build, interp.watch, true)(discovered)
|
|@main def idea() = mill.scalaplugin.GenIdea(build)(discovered)
|
|implicit val replApplyHandler = new mill.main.ReplApplyHandler(build)(discovered)""".stripMargin
)
import ammonite.main.Cli
var repl = false
val replCliArg = Cli.Arg[Cli.Config, Unit](
"repl",
None,
"Open a Build REPL",
(x, _) => {
repl = true
x
}
)
Cli.groupArgs(
args.toList,
Cli.ammoniteArgSignature :+ replCliArg,
Cli.Config()
) match{
case Left(msg) =>
System.err.println(msg)
System.exit(1)
case Right((cliConfig, leftoverArgs)) =>
if (repl){
val runner = new ammonite.MainRunner(
cliConfig.copy(
predefFile = Some(pwd / 'out / "run.sc"),
predefCode = "import build._",
welcomeBanner = None
),
System.out, System.err,
System.in, System.out, System.err
)
runner.printInfo("Loading...")
runner.runRepl()
} else {
val runner = new ammonite.MainRunner(
cliConfig,
System.out, System.err,
System.in, System.out, System.err
)
runner.runScript(syntheticPath, leftoverArgs)
}
}
}
}
|
