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
|
package dotty.tools
package dotc
package repl
package ammonite.terminal
import java.io.{FileOutputStream, Writer, File => JFile}
import scala.annotation.tailrec
/**
* Prints stuff to an ad-hoc logging file when running the repl or terminal in
* development mode
*
* Very handy for the common case where you're debugging terminal interactions
* and cannot use `println` because it will stomp all over your already messed
* up terminal state and block debugging. With [[Debug]], you can have a
* separate terminal open tailing the log file and log as verbosely as you
* want without affecting the primary terminal you're using to interact with
* Ammonite.
*/
object Debug {
lazy val debugOutput =
new FileOutputStream(new JFile("terminal/target/log"))
def apply(s: Any) =
if (System.getProperty("ammonite-sbt-build") == "true")
debugOutput.write((System.currentTimeMillis() + "\t\t" + s + "\n").getBytes)
}
class AnsiNav(output: Writer) {
def control(n: Int, c: Char) = output.write(s"\033[" + n + c)
/**
* Move up `n` squares
*/
def up(n: Int) = if (n == 0) "" else control(n, 'A')
/**
* Move down `n` squares
*/
def down(n: Int) = if (n == 0) "" else control(n, 'B')
/**
* Move right `n` squares
*/
def right(n: Int) = if (n == 0) "" else control(n, 'C')
/**
* Move left `n` squares
*/
def left(n: Int) = if (n == 0) "" else control(n, 'D')
/**
* Clear the screen
*
* n=0: clear from cursor to end of screen
* n=1: clear from cursor to start of screen
* n=2: clear entire screen
*/
def clearScreen(n: Int) = control(n, 'J')
/**
* Clear the current line
*
* n=0: clear from cursor to end of line
* n=1: clear from cursor to start of line
* n=2: clear entire line
*/
def clearLine(n: Int) = control(n, 'K')
}
object AnsiNav {
val resetUnderline = "\u001b[24m"
val resetForegroundColor = "\u001b[39m"
val resetBackgroundColor = "\u001b[49m"
}
object TTY {
// Prefer standard tools. Not sure why we need to do this, but for some
// reason the version installed by gnu-coreutils blows up sometimes giving
// "unable to perform all requested operations"
val pathedTput = if (new java.io.File("/usr/bin/tput").exists()) "/usr/bin/tput" else "tput"
val pathedStty = if (new java.io.File("/bin/stty").exists()) "/bin/stty" else "stty"
def consoleDim(s: String) = {
import sys.process._
Seq("bash", "-c", s"$pathedTput $s 2> /dev/tty").!!.trim.toInt
}
def init() = {
stty("-a")
val width = consoleDim("cols")
val height = consoleDim("lines")
// Debug("Initializing, Width " + width)
// Debug("Initializing, Height " + height)
val initialConfig = stty("-g").trim
stty("-icanon min 1 -icrnl -inlcr -ixon")
sttyFailTolerant("dsusp undef")
stty("-echo")
stty("intr undef")
// Debug("")
(width, height, initialConfig)
}
private def sttyCmd(s: String) = {
import sys.process._
Seq("bash", "-c", s"$pathedStty $s < /dev/tty"): ProcessBuilder
}
def stty(s: String) =
sttyCmd(s).!!
/*
* Executes a stty command for which failure is expected, hence the return
* status can be non-null and errors are ignored.
* This is appropriate for `stty dsusp undef`, since it's unsupported on Linux
* (http://man7.org/linux/man-pages/man3/termios.3.html).
*/
def sttyFailTolerant(s: String) =
sttyCmd(s ++ " 2> /dev/null").!
def restore(initialConfig: String) = {
stty(initialConfig)
}
}
/**
* A truly-lazy implementation of scala.Stream
*/
case class LazyList[T](headThunk: () => T, tailThunk: () => LazyList[T]) {
var rendered = false
lazy val head = {
rendered = true
headThunk()
}
lazy val tail = tailThunk()
def dropPrefix(prefix: Seq[T]) = {
@tailrec def rec(n: Int, l: LazyList[T]): Option[LazyList[T]] = {
if (n >= prefix.length) Some(l)
else if (prefix(n) == l.head) rec(n + 1, l.tail)
else None
}
rec(0, this)
}
override def toString = {
@tailrec def rec(l: LazyList[T], res: List[T]): List[T] = {
if (l.rendered) rec(l.tailThunk(), l.head :: res)
else res
}
s"LazyList(${(rec(this, Nil).reverse ++ Seq("...")).mkString(",")})"
}
def ~:(other: => T) = LazyList(() => other, () => this)
}
object LazyList {
object ~: {
def unapply[T](x: LazyList[T]) = Some((x.head, x.tail))
}
def continually[T](t: => T): LazyList[T] = LazyList(() => t, () =>continually(t))
implicit class CS(ctx: StringContext) {
val base = ctx.parts.mkString
object p {
def unapply(s: LazyList[Int]): Option[LazyList[Int]] = {
s.dropPrefix(base.map(_.toInt))
}
}
}
}
|
