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
|
package forge
import java.nio.{file => jnio}
import play.api.libs.json.{Format, Json}
abstract class Target[T](implicit formatter: Format[T]) extends Target.Ops[T]{
/**
* Where in the Scala codebase was this target defined?
*/
val defCtx: DefCtx
/**
* What other Targets does this Target depend on?
*/
val inputs: Seq[Target[_]]
/**
* Evaluate this target
*/
def evaluate(args: Args): T
/**
* Even if this target's inputs did not change, does it need to re-evaluate
* anyway?
*
* - None means it never needs to re-evaluate unless its inputs do
* - Some(f) contains a function that returns whether or not it should re-evaluate,
* e.g. if the files this target represents on disk changed
*/
val dirty: Option[() => Boolean] = Some(() => false)
}
object Target{
abstract class Ops[T](implicit val formatter: Format[T]){ this: Target[T] =>
def evaluateAndWrite(args: Args): (T, String) = {
val res = evaluate(args)
val str = formatter.writes(res)
(res, Json.stringify(str))
}
val defCtx: DefCtx
def map[V: Format](f: T => V)(implicit defCtx: DefCtx) = {
new Target.Mapped(this, f, defCtx)
}
def zip[V: Format](other: Target[V])(implicit defCtx: DefCtx) = {
new Target.Zipped(this, other, defCtx)
}
def ~[V: Format, R: Format](other: Target[V])
(implicit s: Implicits.Sequencer[T, V, R], defCtx: DefCtx): Target[R] = {
this.zip(other).map(s.apply _ tupled)
}
override def toString = defCtx.label.split('.').last
}
def test(inputs: Target[Int]*)(implicit defCtx: DefCtx) = {
new Test(inputs, defCtx, pure = inputs.nonEmpty)
}
/**
* A dummy target that takes any number of inputs, and whose output can be
* controlled externally, so you can construct arbitrary dataflow graphs and
* test how changes propagate.
*/
class Test(val inputs: Seq[Target[Int]],
val defCtx: DefCtx,
val pure: Boolean) extends Target[Int]{
var counter = 0
var lastCounter = counter
def evaluate(args: Args) = {
lastCounter = counter
counter + args.args.map(_.asInstanceOf[Int]).sum
}
override val dirty = if (pure) None else Some(() => lastCounter != counter)
}
def traverse[T: Format](source: Seq[Target[T]])(implicit defCtx: DefCtx) = {
new Traverse[T](source, defCtx)
}
class Traverse[T: Format](val inputs: Seq[Target[T]], val defCtx: DefCtx) extends Target[Seq[T]]{
def evaluate(args: Args) = {
for (i <- 0 until args.length)
yield args(i).asInstanceOf[T]
}
}
class Mapped[T, V: Format](source: Target[T], f: T => V,
val defCtx: DefCtx) extends Target[V]{
def evaluate(args: Args) = f(args(0))
val inputs = List(source)
}
class Zipped[T: Format, V: Format](source1: Target[T],
source2: Target[V],
val defCtx: DefCtx) extends Target[(T, V)]{
def evaluate(args: Args) = (args(0), args(0))
val inputs = List(source1, source1)
}
def path(path: jnio.Path)(implicit defCtx: DefCtx) = new Path(path, defCtx)
class Path(path: jnio.Path, val defCtx: DefCtx) extends Target[jnio.Path]{
def evaluate(args: Args) = path
val inputs = Nil
}
class Subprocess(val inputs: Seq[Target[_]],
command: Args => Seq[String],
val defCtx: DefCtx) extends Target[Subprocess.Result] {
def evaluate(args: Args) = {
jnio.Files.createDirectories(args.dest)
import ammonite.ops._
implicit val path = ammonite.ops.Path(args.dest, pwd)
val output = %%(command(args))
assert(output.exitCode == 0)
Subprocess.Result(output, args.dest)
}
}
object Subprocess{
case class Result(result: ammonite.ops.CommandResult, dest: jnio.Path)
}
}
|
