", "", UpdatableDisplay.generateId()) + + // https://stackoverflow.com/a/25228492/3714539 + private def escapeHTML(s: String): String = { + val out = new StringBuilder(java.lang.Math.max(16, s.length)) + for (i <- 0 until s.length) { + val c = s.charAt(i) + if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&') { + out.append("&#") + out.append(c.toInt) + out.append(';') + } else + out.append(c) + } + out.toString + } +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/Html.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/Html.scala new file mode 100644 index 000000000..2a49ad93b --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/Html.scala @@ -0,0 +1,32 @@ +package almond.display + +import java.net.URL + +final class Html private( + val contentOrUrl: Either[URL, String], + val displayId: String +) extends TextDisplay { + + private def copy( + contentOrUrl: Either[URL, String] = contentOrUrl + ): Html = + new Html(contentOrUrl, displayId) + + def withContent(code: String): Html = + copy(contentOrUrl = Right(code)) + def withUrl(url: String): Html = + copy(contentOrUrl = Left(new URL(url))) + def withUrl(url: URL): Html = + copy(contentOrUrl = Left(url)) + + def data(): Map[String, String] = + Map(Html.mimeType -> finalContent) + +} + +object Html extends TextDisplay.Builder[Html] { + protected def build(contentOrUrl: Either[URL, String]): Html = + new Html(contentOrUrl, UpdatableDisplay.generateId()) + + def mimeType: String = "text/html" +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/IFrame.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/IFrame.scala new file mode 100644 index 000000000..5ffebf34b --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/IFrame.scala @@ -0,0 +1,68 @@ +package almond.display + +import java.net.URLEncoder + +final class IFrame private( + val src: String, + val width: Option[String], + val height: Option[String], + val params: Seq[(String, String)], + val displayId: String +) extends UpdatableDisplay { + + private def copy( + src: String = src, + width: Option[String] = width, + height: Option[String] = height, + params: Seq[(String, String)] = params + ): IFrame = + new IFrame(src, width, height, params, displayId) + + def withSrc(src: String): IFrame = + copy(src = src) + def withWidth(width: Int): IFrame = + copy(width = Some(width.toString)) + def withWidth(width: String): IFrame = + copy(width = Some(width)) + def withWidth(widthOpt: Option[String]): IFrame = + copy(width = widthOpt) + def withHeight(height: Int): IFrame = + copy(height = Some(height.toString)) + def withHeight(height: String): IFrame = + copy(height = Some(height)) + def withHeight(heightOpt: Option[String]): IFrame = + copy(height = heightOpt) + + private def html: String = { + val widthPart = width.fold("")(w => s"""width="$w"""") + val heightPart = height.fold("")(h => s"""height="$h"""") + val url = src + { + if (params.isEmpty) "" + else { + def encode(s: String): String = + URLEncoder.encode(s, "UTF-8") + .replaceAll("\\+", "%20") + params + .map { case (k, v) => s"${encode(k)}=${encode(v)}" } + .mkString("?", "&", "") + } + } + // FIXME Escaping of width / height + s""" + """.stripMargin + } + + def data(): Map[String, String] = + Map(Html.mimeType -> html) + +} + +object IFrame extends { + def apply(src: String): IFrame = + new IFrame(src, None, None, Nil, UpdatableDisplay.generateId()) +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/Image.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/Image.scala new file mode 100644 index 000000000..40763f7b1 --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/Image.scala @@ -0,0 +1,157 @@ +package almond.display + +import java.io.{ByteArrayInputStream, IOException} +import java.net.{HttpURLConnection, URL, URLConnection} +import java.util.Base64 + +import scala.util.Try + +final class Image private ( + val width: Option[String], + val height: Option[String], + val format: Option[Image.Format], + byteArrayOrUrl: Either[URL, Array[Byte]], + val embed: Boolean, + val displayId: String +) extends UpdatableDisplay { + + def byteArrayOpt: Option[Array[Byte]] = + byteArrayOrUrl.right.toOption + def urlOpt: Option[URL] = + byteArrayOrUrl.left.toOption + + private def copy( + width: Option[String] = width, + height: Option[String] = height, + format: Option[Image.Format] = format, + byteArrayOrUrl: Either[URL, Array[Byte]] = byteArrayOrUrl, + embed: Boolean = embed + ): Image = + new Image( + width, + height, + format, + byteArrayOrUrl, + embed, + displayId + ) + + def withByteArray(data: Array[Byte]): Image = + copy(byteArrayOrUrl = Right(data)) + def withUrl(url: URL): Image = + copy(byteArrayOrUrl = Left(url)) + def withUrl(url: String): Image = + copy(byteArrayOrUrl = Left(new URL(url))) + def withHeight(height: Int): Image = + copy(height = Some(height.toString)) + def withHeight(heightOpt: Option[String]): Image = + copy(height = heightOpt) + def withWidth(width: Int): Image = + copy(width = Some(width.toString)) + def withWidth(widthOpt: Option[String]): Image = + copy(width = widthOpt) + def withFormat(format: Image.Format): Image = + copy(format = Some(format)) + def withFormat(formatOpt: Option[Image.Format]): Image = + copy(format = formatOpt) + def withEmbed(): Image = + copy(embed = true) + def withEmbed(embed: Boolean): Image = + copy(embed = embed) + + override def metadata(): Map[String, String] = + Map() ++ + width.map("width" -> _) ++ + height.map("height" -> _) + + def data(): Map[String, String] = + byteArrayOrUrl match { + case Left(url) => + + if (embed) { + val (contentTypeOpt, b) = Image.urlContent(url) + val contentType = format + .map(_.contentType) + .orElse(contentTypeOpt) + .orElse(Option(URLConnection.guessContentTypeFromStream(new ByteArrayInputStream(b)))) + .getOrElse { + throw new Exception(s"Cannot detect format or unrecognizable format for image at $url") + } + + if (!Image.imageTypes.contains(contentType)) + throw new IOException("Unknown or unsupported content type: " + contentType) + + val b0 = Base64.getEncoder.encodeToString(b) + Map(contentType -> b0) + } else { + val attrs = metadata().map { case (k, v) => s"$k=$v" }.mkString(" ") + Map(Html.mimeType -> s"
") + val bar = s"""""" + + labelPart + bar + } + + private def text: String = { + + val bar = progress match { + case None => + val ellipsis = (total - 2).min(3).max(0) + val remaining = (total - 2 - ellipsis).max(0) + val remainingLeft = remaining / 2 + val remainingRight = remaining - remainingLeft + "[" + (" " * remainingLeft) + ("." * ellipsis) + (" " * remainingRight) + "]" + case Some(p) => + val remaining = (total - 2).max(0) + val filled = ((p * remaining) / total).max(0) + val empty = (remaining - filled).max(0) + "[" + ("#" * filled) + (" " * empty) + "]" + } + + finalLabelOpt.fold("")(_ + System.lineSeparator()) + + bar + } + + def data(): Map[String, String] = + Map( + Text.mimeType -> text, + Html.mimeType -> html + ) + +} + +object ProgressBar extends { + def apply(total: Int): ProgressBar = + new ProgressBar(None, total, None, "60ex", 60, UpdatableDisplay.generateId()) + def apply(progress: Int, total: Int): ProgressBar = + new ProgressBar(None, total, Some(progress), "60ex", 60, UpdatableDisplay.generateId()) +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/Svg.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/Svg.scala new file mode 100644 index 000000000..32519749b --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/Svg.scala @@ -0,0 +1,32 @@ +package almond.display + +import java.net.URL + +final class Svg private( + val contentOrUrl: Either[URL, String], + val displayId: String +) extends TextDisplay { + + private def copy( + contentOrUrl: Either[URL, String] = contentOrUrl + ): Svg = + new Svg(contentOrUrl, displayId) + + def withContent(code: String): Svg = + copy(contentOrUrl = Right(code)) + def withUrl(url: String): Svg = + copy(contentOrUrl = Left(new URL(url))) + def withUrl(url: URL): Svg = + copy(contentOrUrl = Left(url)) + + def data(): Map[String, String] = + Map(Svg.mimeType -> finalContent) + +} + +object Svg extends TextDisplay.Builder[Svg] { + protected def build(contentOrUrl: Either[URL, String]): Svg = + new Svg(contentOrUrl, UpdatableDisplay.generateId()) + + def mimeType = "image/svg+xml" +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/Text.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/Text.scala new file mode 100644 index 000000000..cb94131ce --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/Text.scala @@ -0,0 +1,32 @@ +package almond.display + +import java.net.URL + +final class Text private( + val contentOrUrl: Either[URL, String], + val displayId: String +) extends TextDisplay { + + private def copy( + contentOrUrl: Either[URL, String] = contentOrUrl + ): Text = + new Text(contentOrUrl, displayId) + + def withContent(code: String): Text = + copy(contentOrUrl = Right(code)) + def withUrl(url: String): Text = + copy(contentOrUrl = Left(new URL(url))) + def withUrl(url: URL): Text = + copy(contentOrUrl = Left(url)) + + def data(): Map[String, String] = + Map(Text.mimeType -> finalContent) + +} + +object Text extends TextDisplay.Builder[Text] { + protected def build(contentOrUrl: Either[URL, String]): Text = + new Text(contentOrUrl, UpdatableDisplay.generateId()) + + def mimeType = "text/plain" +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/TextDisplay.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/TextDisplay.scala new file mode 100644 index 000000000..d0f4daa36 --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/TextDisplay.scala @@ -0,0 +1,83 @@ +package almond.display + +import java.io.{ByteArrayOutputStream, InputStream} +import java.net.{HttpURLConnection, URL, URLConnection} +import java.nio.charset.{Charset, StandardCharsets} + +import scala.util.Try + +abstract class TextDisplay extends UpdatableDisplay { + + def contentOrUrl: Either[URL, String] + + def content: Option[String] = contentOrUrl.right.toOption + def url: Option[URL] = contentOrUrl.left.toOption + + def finalContent: String = + contentOrUrl match { + case Left(url) => + TextDisplay.urlContent(url) + case Right(c) => c + } + + def withContent(code: String): UpdatableDisplay + def withUrl(url: String): UpdatableDisplay + +} + +object TextDisplay { + + type Builder[T] = Display.Builder[String, T] + + private[almond] def readFully(is: InputStream): Array[Byte] = { + + val buffer = new ByteArrayOutputStream + val data = Array.ofDim[Byte](16384) + + var nRead = 0 + while ( { + nRead = is.read(data, 0, data.length) + nRead != -1 + }) + buffer.write(data, 0, nRead) + + buffer.flush() + buffer.toByteArray + } + + def urlContent(url: URL): String = { + + var conn: URLConnection = null + val (rawContent, charsetOpt) = try { + conn = url.openConnection() + conn.setConnectTimeout(5000) // allow users to tweak that? + val b = readFully(conn.getInputStream) + val charsetOpt0 = conn match { + case conn0: HttpURLConnection => + conn0 + .getContentType + .split(';') + .map(_.trim) + .find(_.startsWith("charset=")) + .map(_.stripPrefix("charset=")) + .filter(Charset.isSupported) + .map(Charset.forName) + case _ => + None + } + (b, charsetOpt0) + } finally { + if (conn != null) { + Try(conn.getInputStream.close()) + conn match { + case conn0: HttpURLConnection => + Try(conn0.getErrorStream.close()) + Try(conn0.disconnect()) + case _ => + } + } + } + + new String(rawContent, charsetOpt.getOrElse(StandardCharsets.UTF_8)) + } +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/display/UpdatableDisplay.scala b/modules/scala/jupyter-api/src/main/scala/almond/display/UpdatableDisplay.scala new file mode 100644 index 000000000..d558416a2 --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/display/UpdatableDisplay.scala @@ -0,0 +1,48 @@ +package almond.display + +import java.util.{Locale, UUID} +import java.util.concurrent.atomic.AtomicInteger + +import almond.interpreter.api.{DisplayData, OutputHandler} + +trait UpdatableDisplay extends Display { + def displayId: String + override def displayData(): DisplayData = + DisplayData(data(), metadata = metadata(), idOpt = Some(displayId)) + protected def emptyDisplayData(): DisplayData = { + val data = displayData() + data.copy(data = data.data.mapValues(_ => "").toMap) + } + + def update()(implicit output: OutputHandler): Unit = + output.updateDisplay(displayData()) + + def clear()(implicit output: OutputHandler): Unit = + output.updateDisplay(emptyDisplayData()) +} + +object UpdatableDisplay { + + def useRandomIds(): Boolean = + sys.props + .get("almond.ids.random") + .forall(s => s == "1" || s.toLowerCase(Locale.ROOT) == "true") + + private val idCounter = new AtomicInteger + private val divCounter = new AtomicInteger + + def generateId(): String = + if (useRandomIds()) + UUID.randomUUID().toString + else + idCounter.incrementAndGet().toString + + def generateDiv(prefix: String = "data-"): String = + prefix + { + if (useRandomIds()) + UUID.randomUUID().toString + else + divCounter.incrementAndGet().toString + } + +} diff --git a/modules/scala/jupyter-api/src/main/scala/almond/input/Input.scala b/modules/scala/jupyter-api/src/main/scala/almond/input/Input.scala new file mode 100644 index 000000000..eb5e80456 --- /dev/null +++ b/modules/scala/jupyter-api/src/main/scala/almond/input/Input.scala @@ -0,0 +1,38 @@ +package almond.input + +import almond.api.JupyterApi + +final class Input private ( + val prompt: String, + val password: Boolean +) { + + private def copy( + prompt: String = prompt, + password: Boolean = password + ): Input = + new Input(prompt, password) + + def withPrompt(prompt: String): Input = + copy(prompt = prompt) + def withPassword(password: Boolean): Input = + copy(password = password) + def withPassword(): Input = + copy(password = true) + + // TODO Also allow to return result via a future? + def request()(implicit api: JupyterApi): String = + api.stdin(prompt, password) + +} + +object Input { + def apply(): Input = + new Input("", password = false) + def apply(prompt: String): Input = + new Input(prompt, password = false) + def password(): Input = + new Input("", password = true) + def password(prompt: String): Input = + new Input(prompt, password = true) +} diff --git a/modules/scala/scala-interpreter/src/main/java/almond/internals/HtmlAnsiOutputStream.java b/modules/scala/scala-interpreter/src/main/java/almond/internals/HtmlAnsiOutputStream.java new file mode 100644 index 000000000..eff25abd0 --- /dev/null +++ b/modules/scala/scala-interpreter/src/main/java/almond/internals/HtmlAnsiOutputStream.java @@ -0,0 +1,128 @@ + +// adapted from https://github.com/fusesource/jansi/blob/70ff98d5cbd5fb005d8a44ed31050388b256f9c6/jansi/src/main/java/org/fusesource/jansi/HtmlAnsiOutputStream.java + +package almond.internals; + +import org.fusesource.jansi.AnsiOutputStream; + +import java.io.IOException; +import java.io.OutputStream; +import java.util.ArrayList; +import java.util.List; + +public class HtmlAnsiOutputStream extends AnsiOutputStream { + + private boolean concealOn = false; + + @Override + public void close() throws IOException { + closeAttributes(); + super.close(); + } + + private static final String[] ANSI_COLOR_MAP = {"black", "red", + "green", "yellow", "blue", "magenta", "cyan", "white",}; + + private static final byte[] BYTES_QUOT = """.getBytes(); + private static final byte[] BYTES_AMP = "&".getBytes(); + private static final byte[] BYTES_LT = "<".getBytes(); + private static final byte[] BYTES_GT = ">".getBytes(); + + public HtmlAnsiOutputStream(OutputStream os) { + super(os); + } + + private final List
+ |
""".stripMargin
+ log.debug(s"HTML: $html")
+ val d = r.add(
+ almond.display.Data(
+ almond.display.Text.mimeType -> res0,
+ almond.display.Html.mimeType -> html
+ ).displayData(),
+ variables
+ )
+ outputHandler match {
+ case None =>
+ d
+ case Some(h) =>
+ h.display(d)
+ DisplayData.empty
+ }
+ }
+ r.map((_, data))
+ }
+ }
+ }
+ }
+ } yield ev
+ }
+
+ def apply(
+ ammInterp: ammonite.interp.Interpreter,
+ code: String,
+ inputManager: Option[InputManager],
+ outputHandler: Option[OutputHandler],
+ colors0: Ref[Colors]
+ ): ExecuteResult = {
+
+ storage.fullHistory() = storage.fullHistory() :+ code
+ history0 = history0 :+ code
+
+ val hackedLine =
+ if (code.contains("$ivy.`"))
+ automaticDependencies.foldLeft(code) {
+ case (line0, (triggerDep, autoDeps)) =>
+ if (line0.contains(triggerDep)) {
+ log.info(s"Adding auto dependencies $autoDeps")
+ autoDeps.map(dep => s"import $$ivy.`$dep`; ").mkString + line0
+ } else
+ line0
+ }
+ else
+ code
+
+ ammResult(ammInterp, hackedLine, inputManager, outputHandler) match {
+ case Res.Success((_, data)) =>
+ ExecuteResult.Success(data)
+ case Res.Failure(msg) =>
+ interruptedStackTraceOpt0 match {
+ case None =>
+ val err = Execute.error(colors0(), None, msg)
+ outputHandler.foreach(_.stderr(err.message)) // necessary?
+ err
+ case Some(st) =>
+
+ val cutoff = Set("$main", "evaluatorRunPrinter")
+
+ ExecuteResult.Error(
+ (
+ "Interrupted!" +: st
+ .takeWhile(x => !cutoff(x.getMethodName))
+ .map(Execute.highlightFrame(_, fansi.Attr.Reset, colors0().literal()))
+ ).mkString(System.lineSeparator())
+ )
+ }
+
+ case Res.Exception(ex, msg) =>
+ log.error(s"exception in user code (${ex.getMessage})", ex)
+ Execute.error(colors0(), Some(ex), msg)
+
+ case Res.Skip =>
+ ExecuteResult.Success()
+
+ case Res.Exit(_) =>
+ ExecuteResult.Exit
+ }
+ }
+}
+
+object Execute {
+
+ // these come from Ammonite
+ // exception display was tweaked a bit (too much red for notebooks else)
+
+ private def highlightFrame(f: StackTraceElement,
+ highlightError: fansi.Attrs,
+ source: fansi.Attrs) = {
+ val src =
+ if (f.isNativeMethod) source("Native Method")
+ else if (f.getFileName == null) source("Unknown Source")
+ else source(f.getFileName) ++ ":" ++ source(f.getLineNumber.toString)
+
+ val prefix :+ clsName = f.getClassName.split('.').toSeq
+ val prefixString = prefix.map(_+'.').mkString("")
+ val clsNameString = clsName //.replace("$", error("$"))
+ val method =
+ fansi.Str(prefixString) ++ highlightError(clsNameString) ++ "." ++
+ highlightError(f.getMethodName)
+
+ fansi.Str(s" ") ++ method ++ "(" ++ src ++ ")"
+ }
+
+ def showException(ex: Throwable,
+ error: fansi.Attrs,
+ highlightError: fansi.Attrs,
+ source: fansi.Attrs) = {
+
+ val cutoff = Set("$main", "evaluatorRunPrinter")
+ val traces = Ex.unapplySeq(ex).get.map(exception =>
+ error(exception.toString).render + System.lineSeparator() +
+ exception
+ .getStackTrace
+ .takeWhile(x => !cutoff(x.getMethodName))
+ .map(highlightFrame(_, highlightError, source))
+ .mkString(System.lineSeparator())
+ )
+ traces.mkString(System.lineSeparator())
+ }
+
+ private def error(colors: Colors, exOpt: Option[Throwable], msg: String) =
+ ExecuteResult.Error(
+ msg + exOpt.fold("")(ex => (if (msg.isEmpty) "" else "\n") + showException(
+ ex, colors.error(), fansi.Attr.Reset, colors.literal()
+ ))
+ )
+
+}
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/JupyterApiImpl.scala b/modules/scala/scala-interpreter/src/main/scala/almond/JupyterApiImpl.scala
new file mode 100644
index 000000000..2b323dc70
--- /dev/null
+++ b/modules/scala/scala-interpreter/src/main/scala/almond/JupyterApiImpl.scala
@@ -0,0 +1,57 @@
+package almond
+
+import java.io.ByteArrayOutputStream
+import java.nio.charset.StandardCharsets
+
+import almond.api.{FullJupyterApi, JupyterApi}
+import almond.internals.HtmlAnsiOutputStream
+import almond.interpreter.api.CommHandler
+import pprint.{TPrint, TPrintColors}
+
+import scala.concurrent.Await
+import scala.concurrent.duration.Duration
+import scala.reflect.ClassTag
+
+/** Actual [[almond.api.JupyterApi]] instance */
+final class JupyterApiImpl(
+ execute: Execute,
+ commHandlerOpt: => Option[CommHandler],
+ replApi: ReplApiImpl
+) extends FullJupyterApi {
+
+ protected def printOnChange[T](
+ value: => T,
+ ident: String,
+ custom: Option[String],
+ onChange: Option[(T => Unit) => Unit],
+ onChangeOrError: Option[(Either[Throwable, T] => Unit) => Unit]
+ )(implicit
+ tprint: TPrint[T],
+ tcolors: TPrintColors,
+ classTagT: ClassTag[T]
+ ): Iterator[String] =
+ replApi.printSpecial(value, ident, custom, onChange, onChangeOrError, replApi.pprinter, Some(updatableResults))(tprint, tcolors, classTagT).getOrElse {
+ replApi.Internal.print(value, ident, custom)(tprint, tcolors, classTagT)
+ }
+
+ protected def ansiTextToHtml(text: String): String = {
+ val baos = new ByteArrayOutputStream
+ val haos = new HtmlAnsiOutputStream(baos)
+ haos.write(text.getBytes(StandardCharsets.UTF_8))
+ haos.close()
+ baos.toString("UTF-8")
+ }
+
+ def stdinOpt(prompt: String, password: Boolean): Option[String] =
+ for (m <- execute.currentInputManagerOpt)
+ yield Await.result(m.readInput(prompt, password), Duration.Inf)
+
+ override def changingPublish =
+ execute.currentPublishOpt.getOrElse(super.changingPublish)
+ override def commHandler =
+ commHandlerOpt.getOrElse(super.commHandler)
+
+ protected def updatableResults0: JupyterApi.UpdatableResults =
+ execute.updatableResults
+}
+
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/ReplApiImpl.scala b/modules/scala/scala-interpreter/src/main/scala/almond/ReplApiImpl.scala
new file mode 100644
index 000000000..75e43a816
--- /dev/null
+++ b/modules/scala/scala-interpreter/src/main/scala/almond/ReplApiImpl.scala
@@ -0,0 +1,206 @@
+package almond
+
+import almond.api.JupyterApi
+import almond.interpreter.api.DisplayData
+import ammonite.ops.read
+import ammonite.repl.{FrontEnd, FullReplAPI, ReplLoad, SessionApiImpl}
+import ammonite.runtime.Storage
+import ammonite.util.{Bind, Colors, CompilationError, Ref, Res}
+import ammonite.util.Util.normalizeNewlines
+import fansi.Attr
+import jupyter.{Displayer, Displayers}
+import pprint.{TPrint, TPrintColors}
+
+import scala.collection.mutable
+import scala.reflect.ClassTag
+
+/** Actual [[ammonite.repl.ReplAPI]] instance */
+final class ReplApiImpl(
+ execute0: Execute,
+ storage: Storage,
+ colors0: Ref[Colors],
+ ammInterp: => ammonite.interp.Interpreter,
+ sess0: SessionApiImpl
+) extends ammonite.repl.ReplApiImpl { self =>
+
+
+ private val defaultDisplayer = Displayers.registration().find(classOf[almond.ReplApiImpl.Foo])
+
+ def printSpecial[T](
+ value: => T,
+ ident: String,
+ custom: Option[String],
+ onChange: Option[(T => Unit) => Unit],
+ onChangeOrError: Option[(Either[Throwable, T] => Unit) => Unit],
+ pprinter: Ref[pprint.PPrinter],
+ updatableResultsOpt: Option[JupyterApi.UpdatableResults]
+ )(implicit tprint: TPrint[T], tcolors: TPrintColors, classTagT: ClassTag[T]): Option[Iterator[String]] =
+ execute0.currentPublishOpt match {
+ case None =>
+ None
+ case Some(p) =>
+
+ val isUpdatableDisplay =
+ classTagT != null &&
+ classOf[almond.display.Display]
+ .isAssignableFrom(classTagT.runtimeClass)
+
+ val jvmReprDisplayer: Displayer[_] =
+ Displayers.registration().find(classTagT.runtimeClass)
+ val useJvmReprDisplay =
+ jvmReprDisplayer ne defaultDisplayer
+
+ if (isUpdatableDisplay) {
+ val d = value.asInstanceOf[almond.display.Display]
+ d.display()(p)
+ Some(Iterator())
+ } else if (useJvmReprDisplay) {
+ import scala.collection.JavaConverters._
+ val m = jvmReprDisplayer
+ .asInstanceOf[Displayer[T]]
+ .display(value)
+ .asScala
+ .toMap
+ p.display(DisplayData(m))
+ Some(Iterator())
+ } else
+ for (updatableResults <- updatableResultsOpt if (onChange.nonEmpty && custom.isEmpty) || (onChangeOrError.nonEmpty && custom.nonEmpty)) yield {
+
+ // Pre-compute how many lines and how many columns the prefix of the
+ // printed output takes, so we can feed that information into the
+ // pretty-printing of the main body
+ val prefix = new pprint.Truncated(
+ Iterator(
+ colors0().ident()(ident).render, ": ",
+ implicitly[pprint.TPrint[T]].render(tcolors), " = "
+ ),
+ pprinter().defaultWidth,
+ pprinter().defaultHeight
+ )
+ val output = mutable.Buffer.empty[fansi.Str]
+
+ prefix.foreach(output.+=)
+
+ val rhs = custom match {
+ case None =>
+
+ var currentValue = value // FIXME May be better to only hold weak references here
+ // (in case we allow to wipe previous values at some point)
+
+ val id = updatableResults.updatable {
+ pprinter().tokenize(
+ currentValue,
+ height = pprinter().defaultHeight - prefix.completedLineCount,
+ initialOffset = prefix.lastLineLength
+ ).map(_.render).mkString
+ }
+
+ onChange.foreach(_ { value0 =>
+ if (value0 != currentValue) {
+ val s = pprinter().tokenize(
+ value0,
+ height = pprinter().defaultHeight - prefix.completedLineCount,
+ initialOffset = prefix.lastLineLength
+ )
+ updatableResults.update(id, s.map(_.render).mkString, last = false)
+ currentValue = value0
+ }
+ })
+
+ id
+
+ case Some(s) =>
+
+ val messageColor = Some(pprinter().colorLiteral)
+ .filter(_ == fansi.Attrs.Empty)
+ .getOrElse(fansi.Color.LightGray)
+
+ val id = updatableResults.updatable {
+ messageColor(s).render
+ }
+
+ onChangeOrError.foreach(_ {
+ case Left(ex) =>
+
+ val messageColor = Some(pprinter().colorLiteral)
+ .filter(_ == fansi.Attrs.Empty)
+ .getOrElse(fansi.Color.LightGray)
+
+ val err = Execute.showException(ex, colors0().error(), Attr.Reset, colors0().literal())
+ val s = messageColor("[last attempt failed]").render + "\n" + err
+ updatableResults.update(id, s, last = false)
+ case Right(value0) =>
+ val s = pprinter().tokenize(
+ value0,
+ height = pprinter().defaultHeight - prefix.completedLineCount,
+ initialOffset = prefix.lastLineLength
+ )
+ updatableResults.update(id, s.map(_.render).mkString, last = true)
+ })
+
+ id
+ }
+
+ output.iterator.map(_.render) ++ Iterator(rhs)
+ }
+ }
+
+
+
+ def replArgs0 = Vector.empty[Bind[_]]
+ def printer = execute0.printer
+
+ def sess = sess0
+ val prompt = Ref("nope")
+ val frontEnd = Ref[FrontEnd](null)
+ def lastException: Throwable = execute0.lastExceptionOpt.orNull
+ def fullHistory = storage.fullHistory()
+ def history = execute0.history
+ val colors = colors0
+ def newCompiler() = ammInterp.compilerManager.init(force = true)
+ def compiler = ammInterp.compilerManager.compiler.compiler
+ def interactiveCompiler = ammInterp.compilerManager.pressy.compiler
+ def fullImports = ammInterp.predefImports ++ imports
+ def imports = ammInterp.frameImports
+ def usedEarlierDefinitions = ammInterp.frameUsedEarlierDefinitions
+ def width = 80
+ def height = 80
+
+ val load: ReplLoad =
+ new ReplLoad {
+ def apply(line: String) =
+ ammInterp.processExec(line, execute0.currentLine, () => execute0.incrementLineCount()) match {
+ case Res.Failure(s) => throw new CompilationError(s)
+ case Res.Exception(t, _) => throw t
+ case _ =>
+ }
+
+ def exec(file: ammonite.ops.Path): Unit = {
+ ammInterp.watch(file)
+ apply(normalizeNewlines(read(file)))
+ }
+ }
+
+ override protected[this] def internal0: FullReplAPI.Internal =
+ new FullReplAPI.Internal {
+ def pprinter = self.pprinter
+ def colors = self.colors
+ def replArgs: IndexedSeq[Bind[_]] = replArgs0
+
+ val defaultDisplayer = Displayers.registration().find(classOf[ReplApiImpl.Foo])
+
+ override def print[T](
+ value: => T,
+ ident: String,
+ custom: Option[String]
+ )(implicit tprint: TPrint[T], tcolors: TPrintColors, classTagT: ClassTag[T]): Iterator[String] =
+ printSpecial(value, ident, custom, None, None, pprinter, None)(tprint, tcolors, classTagT).getOrElse {
+ super.print(value, ident, custom)(tprint, tcolors, classTagT)
+ }
+ }
+}
+
+object ReplApiImpl {
+ private class Foo
+}
+
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreter.scala b/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreter.scala
index 299eb5a22..bf384760b 100644
--- a/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreter.scala
+++ b/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreter.scala
@@ -1,422 +1,105 @@
package almond
-import java.nio.charset.StandardCharsets.UTF_8
-import java.nio.file.{Files, Path}
-
-import almond.api.JupyterApi
-import almond.api.helpers.Display
import almond.internals._
import almond.interpreter._
-import almond.interpreter.api.{CommHandler, DisplayData, OutputHandler}
+import almond.interpreter.api.{CommHandler, OutputHandler}
import almond.interpreter.input.InputManager
-import almond.interpreter.util.CancellableFuture
+import almond.interpreter.util.AsyncInterpreterOps
import almond.logger.LoggerContext
import almond.protocol.KernelInfo
-import ammonite.interp.{CodeClassWrapper, CodeWrapper, Parsers, Preprocessor}
-import ammonite.ops.read
-import ammonite.repl._
+import ammonite.interp.Parsers
+import ammonite.repl.{ReplApiImpl => _, _}
import ammonite.runtime._
import ammonite.util._
-import ammonite.util.Util.{newLine, normalizeNewlines}
-import coursier.almond.tmp.Tmp
import fastparse.Parsed
import io.github.soc.directories.ProjectDirectories
-import jupyter.{Displayer, Displayers}
-import pprint.{TPrint, TPrintColors}
-import scala.collection.mutable
-import scala.concurrent.{Await, ExecutionContext}
-import scala.concurrent.duration.Duration
-import scala.reflect.ClassTag
-import scala.util.{Failure, Success}
+import scala.util.control.NonFatal
+/** Holds bits of state for the interpreter, and implements [[almond.interpreter.Interpreter]]. */
final class ScalaInterpreter(
- updateBackgroundVariablesEcOpt: Option[ExecutionContext] = None,
- extraRepos: Seq[String] = Nil,
- extraBannerOpt: Option[String] = None,
- extraLinks: Seq[KernelInfo.Link] = Nil,
- predefCode: String = "",
- predefFiles: Seq[Path] = Nil,
- automaticDependencies: Map[String, Seq[String]] = Map(),
- forceMavenProperties: Map[String, String] = Map(),
- mavenProfiles: Map[String, Boolean] = Map(),
- codeWrapper: CodeWrapper = CodeClassWrapper,
- initialColors: Colors = Colors.Default,
- initialClassLoader: ClassLoader = Thread.currentThread().getContextClassLoader,
- val logCtx: LoggerContext = LoggerContext.nop,
- val metabrowse: Boolean = false,
- val metabrowseHost: String = "localhost",
- val metabrowsePort: Int = -1,
- lazyInit: Boolean = false,
- trapOutput: Boolean = false,
- disableCache: Boolean = false
-) extends Interpreter with ScalaInterpreterInspections { scalaInterp =>
+ params: ScalaInterpreterParams = ScalaInterpreterParams(),
+ val logCtx: LoggerContext = LoggerContext.nop
+) extends Interpreter with AsyncInterpreterOps {
private val log = logCtx(getClass)
- def pressy = ammInterp.compilerManager.pressy.compiler
-
- private val colors0 = Ref[Colors](initialColors)
- private val history0 = new History(Vector())
-
- private var currentInputManagerOpt = Option.empty[InputManager]
-
- private var currentPublishOpt = Option.empty[OutputHandler]
-
- private val input = new FunctionInputStream(
- UTF_8,
- currentInputManagerOpt.flatMap { m =>
-
- val res = {
- implicit val ec = ExecutionContext.global // just using that one to map over an existing future…
- log.info("Awaiting input")
- Await.result(
- m.readInput()
- .map(s => Success(s + newLine))
- .recover { case t => Failure(t) },
- Duration.Inf
- )
- }
- log.info("Received input")
+ private val frames0: Ref[List[Frame]] = Ref(List(Frame.createInitial(params.initialClassLoader)))
- res match {
- case Success(s) => Some(s)
- case Failure(_: InputManager.NoMoreInputException) => None
- case Failure(e) => throw new Exception("Error getting more input", e)
- }
- }
+ private val inspections = new ScalaInterpreterInspections(
+ logCtx,
+ params.metabrowse,
+ params.metabrowseHost,
+ params.metabrowsePort,
+ ammInterp.compilerManager.pressy.compiler,
+ frames0
)
- private val capture =
- if (trapOutput)
- Capture.nop()
- else
- Capture.create()
+ private val colors0: Ref[Colors] = Ref(params.initialColors)
private var commHandlerOpt = Option.empty[CommHandler]
- private val updatableResultsOpt =
- updateBackgroundVariablesEcOpt.map { ec =>
- new UpdatableResults(
- ec,
- logCtx,
- data => commHandlerOpt.foreach(_.updateDisplay(data)) // throw if commHandlerOpt is empty?
- )
- }
-
- private val resultVariables = new mutable.HashMap[String, String]
- private val resultOutput = new StringBuilder
- private val resultStream = new FunctionOutputStream(20, 20, UTF_8, resultOutput.append(_)).printStream()
-
private val storage =
- if (disableCache)
+ if (params.disableCache)
Storage.InMemory()
else
new Storage.Folder(os.Path(ProjectDirectories.from(null, null, "Almond").cacheDir) / "ammonite")
- private val frames0 = Ref(List(Frame.createInitial(initialClassLoader)))
- private val sess0 = new SessionApiImpl(frames0)
- private var currentLine0 = 0
-
- def frames(): List[Frame] = frames0()
-
- private val printer0 = Printer(
- capture.out,
- capture.err,
- resultStream,
- s => currentPublishOpt.fold(Console.err.println(s))(_.stderr(s)),
- s => currentPublishOpt.fold(Console.err.println(s))(_.stderr(s)),
- s => currentPublishOpt.fold(println(s))(_.stdout(s))
+ private val execute0 = new Execute(
+ params.trapOutput,
+ params.automaticDependencies,
+ storage,
+ logCtx,
+ params.updateBackgroundVariablesEcOpt,
+ commHandlerOpt
)
- private def withInputManager[T](m: Option[InputManager])(f: => T): T = {
- val previous = currentInputManagerOpt
- try {
- currentInputManagerOpt = m
- f
- } finally {
- currentInputManagerOpt = previous
- m.foreach(_.done())
- }
- }
-
- private def withOutputHandler[T](handlerOpt: Option[OutputHandler])(f: => T): T = {
- val previous = currentPublishOpt
- try {
- currentPublishOpt = handlerOpt
- f
- } finally {
- currentPublishOpt = previous
- }
- }
-
- private def withClientStdin[T](t: => T): T =
- Console.withIn(input) {
- val previous = System.in
- try {
- System.setIn(input)
- t
- } finally {
- System.setIn(previous)
- input.clear()
- }
- }
+ lazy val ammInterp: ammonite.interp.Interpreter = {
- private def capturingOutput[T](t: => T): T =
- currentPublishOpt match {
- case None => t
- case Some(p) => capture(p.stdout, p.stderr)(t)
- }
+ val sessApi = new SessionApiImpl(frames0)
+ val replApi =
+ new ReplApiImpl(
+ execute0,
+ storage,
+ colors0,
+ ammInterp,
+ sessApi
+ )
- lazy val ammInterp: ammonite.interp.Interpreter = {
+ val jupyterApi =
+ new JupyterApiImpl(execute0, commHandlerOpt, replApi)
- val replApi: ReplApiImpl =
- new ReplApiImpl { self =>
- def replArgs0 = Vector.empty[Bind[_]]
- def printer = printer0
-
- def sess = sess0
- val prompt = Ref("nope")
- val frontEnd = Ref[FrontEnd](null)
- def lastException: Throwable = null
- def fullHistory = storage.fullHistory()
- def history = history0
- val colors = colors0
- def newCompiler() = ammInterp.compilerManager.init(force = true)
- def compiler = ammInterp.compilerManager.compiler.compiler
- def interactiveCompiler = ammInterp.compilerManager.pressy.compiler
- def fullImports = ammInterp.predefImports ++ imports
- def imports = ammInterp.frameImports
- def usedEarlierDefinitions = ammInterp.frameUsedEarlierDefinitions
- def width = 80
- def height = 80
-
- val load: ReplLoad =
- new ReplLoad {
- def apply(line: String) =
- ammInterp.processExec(line, currentLine0, () => currentLine0 += 1) match {
- case Res.Failure(s) => throw new CompilationError(s)
- case Res.Exception(t, _) => throw t
- case _ =>
- }
-
- def exec(file: ammonite.ops.Path): Unit = {
- ammInterp.watch(file)
- apply(normalizeNewlines(read(file)))
- }
- }
-
- override protected[this] def internal0: FullReplAPI.Internal =
- new FullReplAPI.Internal {
- def pprinter = self.pprinter
- def colors = self.colors
- def replArgs: IndexedSeq[Bind[_]] = replArgs0
-
- val defaultDisplayer = Displayers.registration().find(classOf[ScalaInterpreter.Foo])
-
- override def print[T](
- value: => T,
- ident: String,
- custom: Option[String]
- )(implicit tprint: TPrint[T], tcolors: TPrintColors, classTagT: ClassTag[T]): Iterator[String] = {
-
- val displayerPublishOpt =
- if (classTagT == null)
- None
- else
- currentPublishOpt.flatMap { p =>
- Some(Displayers.registration().find(classTagT.runtimeClass))
- .filter(_ ne defaultDisplayer)
- .map(d => (d.asInstanceOf[Displayer[T]], p))
- }
-
- displayerPublishOpt match {
- case None =>
- super.print(value, ident, custom)(tprint, tcolors, classTagT)
- case Some((displayer, publish)) =>
- import scala.collection.JavaConverters._
- val m = displayer.display(value)
- val data = DisplayData(m.asScala.toMap)
- publish.display(data)
- Iterator()
- }
- }
- }
- }
-
- val jupyterApi: JupyterApi =
- new JupyterApi {
-
- def stdinOpt(prompt: String, password: Boolean): Option[String] =
- for (m <- currentInputManagerOpt)
- yield Await.result(m.readInput(prompt, password), Duration.Inf)
-
- override def changingPublish =
- currentPublishOpt.getOrElse(super.changingPublish)
- override def commHandler =
- commHandlerOpt.getOrElse(super.commHandler)
-
- protected def updatableResults0: JupyterApi.UpdatableResults =
- new JupyterApi.UpdatableResults {
- override def addVariable(k: String, v: String) =
- resultVariables += k -> v
- override def updateVariable(k: String, v: String, last: Boolean) =
- updatableResultsOpt match {
- case None => throw new Exception("Results updating not available")
- case Some(r) => r.update(k, v, last)
- }
- }
- }
-
- for (ec <- updateBackgroundVariablesEcOpt)
+ for (ec <- params.updateBackgroundVariablesEcOpt)
UpdatableFuture.setup(replApi, jupyterApi, ec)
- val predefFileInfos =
- predefFiles.zipWithIndex.map {
- case (path, idx) =>
- val suffix = if (idx <= 0) "" else s"-$idx"
- PredefInfo(
- Name("FilePredef" + suffix),
- // read with the local charset…
- new String(Files.readAllBytes(path)),
- false,
- Some(os.Path(path))
- )
- }
-
- try {
-
- log.info("Creating Ammonite interpreter")
-
- val ammInterp0: ammonite.interp.Interpreter =
- new ammonite.interp.Interpreter(
- printer0,
- storage = storage,
- wd = ammonite.ops.pwd,
- basePredefs = Seq(
- PredefInfo(
- Name("defaultPredef"),
- ScalaInterpreter.predef + ammonite.main.Defaults.replPredef + ammonite.main.Defaults.predefString,
- true,
- None
- )
- ),
- customPredefs = predefFileInfos ++ Seq(
- PredefInfo(Name("CodePredef"), predefCode, false, None)
- ),
- extraBridges = Seq(
- (ammonite.repl.ReplBridge.getClass.getName.stripSuffix("$"), "repl", replApi),
- (almond.api.JupyterAPIHolder.getClass.getName.stripSuffix("$"), "kernel", jupyterApi)
- ),
- colors = Ref(Colors.Default),
- getFrame = () => frames0().head,
- createFrame = () => {
- val f = sess0.childFrame(frames0().head); frames0() = f :: frames0(); f
- },
- replCodeWrapper = codeWrapper,
- scriptCodeWrapper = codeWrapper,
- alreadyLoadedDependencies = ammonite.main.Defaults.alreadyLoadedDependencies("almond/almond-user-dependencies.txt")
- )
-
- log.info("Initializing interpreter predef")
-
- for ((e, _) <- ammInterp0.initializePredef())
- e match {
- case Res.Failure(msg) =>
- throw new ScalaInterpreter.PredefException(msg, None)
- case Res.Exception(t, msg) =>
- throw new ScalaInterpreter.PredefException(msg, Some(t))
- case Res.Skip =>
- case Res.Exit(v) =>
- log.warn(s"Ignoring exit request from predef (exit value: $v)")
- }
-
- log.info("Loading base dependencies")
-
- ammInterp0.repositories() = ammInterp0.repositories() ++ extraRepos.map { repo =>
- coursier.MavenRepository(repo)
- }
-
- log.info("Initializing Ammonite interpreter")
-
- ammInterp0.compilerManager.init()
-
- log.info("Processing scalac args")
-
- ammInterp0.compilerManager.preConfigureCompiler(_.processArguments(Nil, processAll = true))
-
- log.info("Ammonite interpreter ok")
-
- if (forceMavenProperties.nonEmpty)
- ammInterp0.resolutionHooks += { fetch =>
- val params0 = Tmp.resolutionParams(fetch)
- val params = params0
- .withForcedProperties(params0.forcedProperties ++ forceMavenProperties)
- fetch.withResolutionParams(params)
- }
-
- if (mavenProfiles.nonEmpty)
- ammInterp0.resolutionHooks += { fetch =>
- val mavenProfiles0 = mavenProfiles.toVector.map {
- case (p, true) => p
- case (p, false) => "!" + p
- }
- val params0 = Tmp.resolutionParams(fetch)
- val params = params0
- .withProfiles(params0.profiles ++ mavenProfiles0)
- fetch.withResolutionParams(params)
- }
-
- ammInterp0
- } catch {
- case t: Throwable =>
- log.error(s"Caught exception while initializing interpreter", t)
- throw t
- }
+ AmmInterpreter(
+ execute0,
+ storage,
+ replApi,
+ jupyterApi,
+ params.predefCode,
+ params.predefFiles,
+ frames0,
+ params.codeWrapper,
+ params.extraRepos,
+ params.forceMavenProperties,
+ params.mavenProfiles,
+ params.autoUpdateLazyVals,
+ params.autoUpdateVars,
+ logCtx
+ )
}
- if (!lazyInit)
+ if (!params.lazyInit)
// eagerly initialize ammInterp
ammInterp
- private var interruptedStackTraceOpt = Option.empty[Array[StackTraceElement]]
- private var currentThreadOpt = Option.empty[Thread]
-
override def interruptSupported: Boolean =
true
- override def interrupt(): Unit = {
- currentThreadOpt match {
- case None =>
- log.warn("Interrupt asked, but no execution is running")
- case Some(t) =>
- log.debug(s"Interrupt asked, stopping thread $t\n${t.getStackTrace.map(" " + _).mkString("\n")}")
- t.stop()
- }
- }
-
- private def interruptible[T](t: => T): T = {
- interruptedStackTraceOpt = None
- currentThreadOpt = Some(Thread.currentThread())
- try {
- Signaller("INT") {
- currentThreadOpt match {
- case None =>
- log.warn("Received SIGINT, but no execution is running")
- case Some(t) =>
- interruptedStackTraceOpt = Some(t.getStackTrace)
- log.debug(s"Received SIGINT, stopping thread $t\n${interruptedStackTraceOpt.map(" " + _).mkString("\n")}")
- t.stop()
- }
- }.apply {
- t
- }
- } finally {
- currentThreadOpt = None
- }
- }
-
+ override def interrupt(): Unit =
+ execute0.interrupt()
override def supportComm: Boolean = true
override def setCommHandler(commHandler0: CommHandler): Unit =
@@ -427,116 +110,11 @@ final class ScalaInterpreter(
storeHistory: Boolean, // FIXME Take that one into account
inputManager: Option[InputManager],
outputHandler: Option[OutputHandler]
- ): ExecuteResult = {
-
- val hackedLine =
- if (code.contains("$ivy.`"))
- automaticDependencies.foldLeft(code) {
- case (line0, (triggerDep, autoDeps)) =>
- if (line0.contains(triggerDep)) {
- log.info(s"Adding auto dependencies $autoDeps")
- autoDeps.map(dep => s"import $$ivy.`$dep`; ").mkString + line0
- } else
- line0
- }
- else
- code
-
- val ammInterp0 = ammInterp // ensures we don't capture output / catch signals during interp initialization
-
- val ammResult =
- withOutputHandler(outputHandler) {
- for {
- (code, stmts) <- fastparse.parse(hackedLine, Parsers.Splitter(_)) match {
- case Parsed.Success(value, _) =>
- Res.Success((hackedLine, value))
- case f: Parsed.Failure => Res.Failure(
- Preprocessor.formatFastparseError("(console)", code, f)
- )
- }
- _ = log.info(s"splitted $hackedLine")
- ev <- interruptible {
- withInputManager(inputManager) {
- withClientStdin {
- capturingOutput {
- resultOutput.clear()
- resultVariables.clear()
- log.info(s"Compiling / evaluating $code ($stmts)")
- val r = ammInterp0.processLine(code, stmts, currentLine0, silent = false, incrementLine = () => currentLine0 += 1)
- log.info(s"Handling output of $hackedLine")
- Repl.handleOutput(ammInterp0, r)
- val variables = resultVariables.toMap
- val res0 = resultOutput.result()
- log.info(s"Result of $hackedLine: $res0")
- resultOutput.clear()
- resultVariables.clear()
- val data =
- if (variables.isEmpty) {
- if (res0.isEmpty)
- DisplayData.empty
- else
- DisplayData.text(res0)
- } else
- updatableResultsOpt match {
- case None =>
- DisplayData.text(res0)
- case Some(r) =>
- val d = r.add(
- DisplayData.text(res0).withId(Display.newId()),
- variables
- )
- outputHandler match {
- case None =>
- d
- case Some(h) =>
- h.display(d)
- DisplayData.empty
- }
- }
- r.map((_, data))
- }
- }
- }
- }
- } yield ev
- }
-
- ammResult match {
- case Res.Success((_, data)) =>
- ExecuteResult.Success(data)
- case Res.Failure(msg) =>
- interruptedStackTraceOpt match {
- case None =>
- val err = ScalaInterpreter.error(colors0(), None, msg)
- outputHandler.foreach(_.stderr(err.message)) // necessary?
- err
- case Some(st) =>
-
- val cutoff = Set("$main", "evaluatorRunPrinter")
-
- ExecuteResult.Error(
- (
- "Interrupted!" +: st
- .takeWhile(x => !cutoff(x.getMethodName))
- .map(ScalaInterpreter.highlightFrame(_, fansi.Attr.Reset, colors0().literal()))
- ).mkString(newLine)
- )
- }
-
- case Res.Exception(ex, msg) =>
- log.error(s"exception in user code (${ex.getMessage})", ex)
- ScalaInterpreter.error(colors0(), Some(ex), msg)
-
- case Res.Skip =>
- ExecuteResult.Success()
-
- case Res.Exit(_) =>
- ExecuteResult.Exit
- }
- }
+ ): ExecuteResult =
+ execute0(ammInterp, code, inputManager, outputHandler, colors0)
def currentLine(): Int =
- currentLine0
+ execute0.currentLine
override def isComplete(code: String): Option[IsCompleteResult] = {
@@ -552,24 +130,14 @@ final class ScalaInterpreter(
Some(res)
}
- // As most "cancelled" calculations (completions, inspections, …) are run in other threads by the presentation
- // compiler, they aren't actually cancelled, they'll keep running in the background. This just interrupts
- // the thread that waits for the background calculation.
- // Having a thread that blocks for results, in turn, is almost required by scala.tools.nsc.interactive.Response…
- private val cancellableFuturePool = new CancellableFuturePool(logCtx)
-
- override def asyncIsComplete(code: String): Some[CancellableFuture[Option[IsCompleteResult]]] =
- Some(cancellableFuturePool.cancellableFuture(isComplete(code)))
- override def asyncComplete(code: String, pos: Int): Some[CancellableFuture[Completion]] =
- Some(cancellableFuturePool.cancellableFuture(complete(code, pos)))
- override def asyncInspect(code: String, pos: Int, detailLevel: Int): Some[CancellableFuture[Option[Inspection]]] =
- Some(cancellableFuturePool.cancellableFuture(inspect(code, pos)))
+ override def inspect(code: String, pos: Int, detailLevel: Int): Option[Inspection] =
+ inspections.inspect(code, pos, detailLevel)
override def complete(code: String, pos: Int): Completion = {
val (newPos, completions0, _) = ammInterp.compilerManager.complete(
pos,
- frames0().head.imports.toString(),
+ (ammInterp.predefImports ++ frames0().head.imports).toString(),
code
)
@@ -600,82 +168,17 @@ final class ScalaInterpreter(
|Ammonite ${ammonite.Constants.version}
|${scala.util.Properties.versionMsg}
|Java ${sys.props.getOrElse("java.version", "[unknown]")}""".stripMargin +
- extraBannerOpt.fold("")("\n\n" + _),
- help_links = Some(extraLinks.toList).filter(_.nonEmpty)
+ params.extraBannerOpt.fold("")("\n\n" + _),
+ help_links = Some(params.extraLinks.toList).filter(_.nonEmpty)
)
- override def shutdown(): Unit =
- inspectionsShutdown()
-
-}
-
-object ScalaInterpreter {
-
- final class PredefException(
- msg: String,
- causeOpt: Option[Throwable]
- ) extends Exception(msg, causeOpt.orNull) {
- def describe: String =
- if (causeOpt.isEmpty)
- s"Error while running predef: $msg"
- else
- s"Caught exception while running predef: $msg"
- }
-
- // these come from Ammonite
- // exception display was tweaked a bit (too much red for notebooks else)
-
- private def highlightFrame(f: StackTraceElement,
- highlightError: fansi.Attrs,
- source: fansi.Attrs) = {
- val src =
- if (f.isNativeMethod) source("Native Method")
- else if (f.getFileName == null) source("Unknown Source")
- else source(f.getFileName) ++ ":" ++ source(f.getLineNumber.toString)
-
- val prefix :+ clsName = f.getClassName.split('.').toSeq
- val prefixString = prefix.map(_+'.').mkString("")
- val clsNameString = clsName //.replace("$", error("$"))
- val method =
- fansi.Str(prefixString) ++ highlightError(clsNameString) ++ "." ++
- highlightError(f.getMethodName)
-
- fansi.Str(s" ") ++ method ++ "(" ++ src ++ ")"
- }
-
- private def showException(ex: Throwable,
- error: fansi.Attrs,
- highlightError: fansi.Attrs,
- source: fansi.Attrs) = {
-
- val cutoff = Set("$main", "evaluatorRunPrinter")
- val traces = Ex.unapplySeq(ex).get.map(exception =>
- error(exception.toString) + newLine +
- exception
- .getStackTrace
- .takeWhile(x => !cutoff(x.getMethodName))
- .map(highlightFrame(_, highlightError, source))
- .mkString(newLine)
- )
- traces.mkString(newLine)
+ override def shutdown(): Unit = {
+ try Function.chain(ammInterp.beforeExitHooks).apply(())
+ catch {
+ case NonFatal(e) =>
+ log.warn("Caught exception while trying to run exit hooks", e)
+ }
+ inspections.shutdown()
}
- private def predef =
- """import almond.api.JupyterAPIHolder.value.{
- | publish,
- | commHandler
- |}
- |import almond.api.JupyterAPIHolder.value.publish.display
- |import almond.interpreter.api.DisplayData.DisplayDataSyntax
- |import almond.api.helpers.Display.{html, js, latex, markdown, text, svg, Image}
- """.stripMargin
-
- private def error(colors: Colors, exOpt: Option[Throwable], msg: String) =
- ExecuteResult.Error(
- msg + exOpt.fold("")(ex => (if (msg.isEmpty) "" else "\n") + showException(
- ex, colors.error(), fansi.Attr.Reset, colors.literal()
- ))
- )
-
- private class Foo
}
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreterParams.scala b/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreterParams.scala
new file mode 100644
index 000000000..af648219c
--- /dev/null
+++ b/modules/scala/scala-interpreter/src/main/scala/almond/ScalaInterpreterParams.scala
@@ -0,0 +1,32 @@
+package almond
+
+import java.nio.file.Path
+
+import almond.protocol.KernelInfo
+import ammonite.interp.{CodeClassWrapper, CodeWrapper}
+import ammonite.util.Colors
+
+import scala.concurrent.ExecutionContext
+
+final case class ScalaInterpreterParams(
+ updateBackgroundVariablesEcOpt: Option[ExecutionContext] = None,
+ extraRepos: Seq[String] = Nil,
+ extraBannerOpt: Option[String] = None,
+ extraLinks: Seq[KernelInfo.Link] = Nil,
+ predefCode: String = "",
+ predefFiles: Seq[Path] = Nil,
+ automaticDependencies: Map[String, Seq[String]] = Map(),
+ forceMavenProperties: Map[String, String] = Map(),
+ mavenProfiles: Map[String, Boolean] = Map(),
+ codeWrapper: CodeWrapper = CodeClassWrapper,
+ initialColors: Colors = Colors.Default,
+ initialClassLoader: ClassLoader = Thread.currentThread().getContextClassLoader,
+ metabrowse: Boolean = false,
+ metabrowseHost: String = "localhost",
+ metabrowsePort: Int = -1,
+ lazyInit: Boolean = false,
+ trapOutput: Boolean = false,
+ disableCache: Boolean = false,
+ autoUpdateLazyVals: Boolean = true,
+ autoUpdateVars: Boolean = true
+)
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/internals/UpdatableFuture.scala b/modules/scala/scala-interpreter/src/main/scala/almond/internals/UpdatableFuture.scala
index 30aef433f..03fe9dec8 100644
--- a/modules/scala/scala-interpreter/src/main/scala/almond/internals/UpdatableFuture.scala
+++ b/modules/scala/scala-interpreter/src/main/scala/almond/internals/UpdatableFuture.scala
@@ -1,7 +1,5 @@
package almond.internals
-import java.util.UUID
-
import almond.api.JupyterApi
import ammonite.repl.ReplAPI
@@ -15,21 +13,26 @@ object UpdatableFuture {
ec: ExecutionContext
): Unit =
replApi.pprinter() = {
+ import jupyterApi.updatableResults._
val p = replApi.pprinter()
p.copy(
additionalHandlers = p.additionalHandlers.orElse {
case f: Future[_] =>
implicit val ec0 = ec
- val id = "${baos.toString("UTF-8")}
+ |"""
+ else
+ ""
+ extra + """"
+ else ""
+ "
" + extra
+ }
+
+ private def html: String =
+ prefix + ansiToHtml(text) + suffix
+
+ def data(): Map[String, String] =
+ Map(
+ Text.mimeType -> text,
+ Html.mimeType -> html
+ )
+
+}
+
+object PrettyPrint extends {
+ def apply(value: Any)(implicit jupyterApi: FullJupyterApi, replApi: ReplAPI): PrettyPrint =
+ new PrettyPrint(value, replApi.pprinter, None, jupyterApi.Internal.ansiTextToHtml _, UpdatableDisplay.generateId())
+
+ def apply(value: Any, pprinter: Ref[PPrinter], ansiTextToHtml: String => String): PrettyPrint =
+ new PrettyPrint(value, pprinter, None, ansiTextToHtml, UpdatableDisplay.generateId())
+}
diff --git a/modules/scala/scala-kernel/src/main/scala/almond/Options.scala b/modules/scala/scala-kernel/src/main/scala/almond/Options.scala
index 034a72c4a..1f3a58cac 100644
--- a/modules/scala/scala-kernel/src/main/scala/almond/Options.scala
+++ b/modules/scala/scala-kernel/src/main/scala/almond/Options.scala
@@ -39,7 +39,11 @@ final case class Options(
@HelpMessage("Trap what user code sends to stdout and stderr")
trapOutput: Boolean = false,
@HelpMessage("Disable ammonite compilation cache")
- disableCache: Boolean = false
+ disableCache: Boolean = false,
+ @HelpMessage("Whether to automatically update lazy val-s upon computation")
+ autoUpdateLazyVals: Boolean = true,
+ @HelpMessage("Whether to automatically update var-s upon change")
+ autoUpdateVars: Boolean = true
) {
def autoDependencyMap(): Map[String, Seq[String]] =
diff --git a/modules/scala/scala-kernel/src/main/scala/almond/ScalaKernel.scala b/modules/scala/scala-kernel/src/main/scala/almond/ScalaKernel.scala
index 67c0333a9..0b16ae526 100644
--- a/modules/scala/scala-kernel/src/main/scala/almond/ScalaKernel.scala
+++ b/modules/scala/scala-kernel/src/main/scala/almond/ScalaKernel.scala
@@ -75,14 +75,15 @@ object ScalaKernel extends CaseApp[Options] {
val predefFiles = options.predefFiles()
- log.info(
- autoDependencies
- .flatMap {
- case (trigger, auto) =>
- Seq("Auto dependency:", s" Trigger: $trigger") ++ auto.map(dep => s" Adds: $dep")
- }
- .mkString("\n")
- )
+ if (autoDependencies.nonEmpty)
+ log.debug(
+ autoDependencies
+ .flatMap {
+ case (trigger, auto) =>
+ Seq("Auto dependency:", s" Trigger: $trigger") ++ auto.map(dep => s" Adds: $dep")
+ }
+ .mkString("\n")
+ )
val interpreterEc = singleThreadedExecutionContext("scala-interpreter")
@@ -97,26 +98,30 @@ object ScalaKernel extends CaseApp[Options] {
else
Thread.currentThread().getContextClassLoader
- log.info("Creating interpreter")
+ log.debug("Creating interpreter")
val interpreter = new ScalaInterpreter(
- updateBackgroundVariablesEcOpt = Some(updateBackgroundVariablesEc),
- extraRepos = options.extraRepository,
- extraBannerOpt = options.banner,
- extraLinks = extraLinks,
- predefCode = options.predefCode,
- predefFiles = predefFiles,
- automaticDependencies = autoDependencies,
- forceMavenProperties = forceProperties,
- mavenProfiles = mavenProfiles,
- initialClassLoader = initialClassLoader,
- logCtx = logCtx,
- metabrowse = options.metabrowse,
- lazyInit = true,
- trapOutput = options.trapOutput,
- disableCache = options.disableCache
+ params = ScalaInterpreterParams(
+ updateBackgroundVariablesEcOpt = Some(updateBackgroundVariablesEc),
+ extraRepos = options.extraRepository,
+ extraBannerOpt = options.banner,
+ extraLinks = extraLinks,
+ predefCode = options.predefCode,
+ predefFiles = predefFiles,
+ automaticDependencies = autoDependencies,
+ forceMavenProperties = forceProperties,
+ mavenProfiles = mavenProfiles,
+ initialClassLoader = initialClassLoader,
+ metabrowse = options.metabrowse,
+ lazyInit = true,
+ trapOutput = options.trapOutput,
+ disableCache = options.disableCache,
+ autoUpdateLazyVals = options.autoUpdateLazyVals,
+ autoUpdateVars = options.autoUpdateVars
+ ),
+ logCtx = logCtx
)
- log.info("Created interpreter")
+ log.debug("Created interpreter")
// Actually init Ammonite interpreter in background
@@ -125,9 +130,9 @@ object ScalaKernel extends CaseApp[Options] {
setDaemon(true)
override def run() =
try {
- log.info("Initializing interpreter (background)")
+ log.debug("Initializing interpreter (background)")
interpreter.ammInterp
- log.info("Initialized interpreter (background)")
+ log.debug("Initialized interpreter (background)")
} catch {
case t: Throwable =>
log.error(s"Caught exception while initializing interpreter, exiting", t)
@@ -138,10 +143,14 @@ object ScalaKernel extends CaseApp[Options] {
initThread.start()
- log.info("Running kernel")
- Kernel.create(interpreter, interpreterEc, kernelThreads, logCtx)
- .flatMap(_.runOnConnectionFile(connectionFile, "scala", zeromqThreads))
- .unsafeRunSync()
+ log.debug("Running kernel")
+ try {
+ Kernel.create(interpreter, interpreterEc, kernelThreads, logCtx)
+ .flatMap(_.runOnConnectionFile(connectionFile, "scala", zeromqThreads))
+ .unsafeRunSync()
+ } finally {
+ interpreter.shutdown()
+ }
}
}
diff --git a/modules/shared/interpreter/src/main/scala/almond/interpreter/InterpreterToIOInterpreter.scala b/modules/shared/interpreter/src/main/scala/almond/interpreter/InterpreterToIOInterpreter.scala
index 61c8e8f98..9e3a49ec2 100644
--- a/modules/shared/interpreter/src/main/scala/almond/interpreter/InterpreterToIOInterpreter.scala
+++ b/modules/shared/interpreter/src/main/scala/almond/interpreter/InterpreterToIOInterpreter.scala
@@ -64,7 +64,7 @@ final class InterpreterToIOInterpreter(
IO.pure(ExecuteResult.Abort)
case false =>
IO {
- log.info(s"Executing $line")
+ log.debug(s"Executing $line")
val res =
try interpreter.execute(line, storeHistory, inputManager, outputHandler)
catch {
@@ -72,7 +72,7 @@ final class InterpreterToIOInterpreter(
log.error(s"Error when executing $line", t)
throw t
}
- log.info(s"Result: $res")
+ log.debug(s"Result: $res")
res
}
}
diff --git a/modules/shared/interpreter/src/main/scala/almond/interpreter/util/AsyncInterpreterOps.scala b/modules/shared/interpreter/src/main/scala/almond/interpreter/util/AsyncInterpreterOps.scala
new file mode 100644
index 000000000..79de68ab5
--- /dev/null
+++ b/modules/shared/interpreter/src/main/scala/almond/interpreter/util/AsyncInterpreterOps.scala
@@ -0,0 +1,23 @@
+package almond.interpreter.util
+
+import almond.interpreter.{Completion, Inspection, Interpreter, IsCompleteResult}
+import almond.logger.LoggerContext
+
+trait AsyncInterpreterOps extends Interpreter {
+
+ def logCtx: LoggerContext
+
+ // As most "cancelled" calculations (completions, inspections, …) are run in other threads by the presentation
+ // compiler, they aren't actually cancelled, they'll keep running in the background. This just interrupts
+ // the thread that waits for the background calculation.
+ // Having a thread that blocks for results, in turn, is almost required by scala.tools.nsc.interactive.Response…
+ private val cancellableFuturePool = new CancellableFuturePool(logCtx)
+
+ override def asyncIsComplete(code: String): Some[CancellableFuture[Option[IsCompleteResult]]] =
+ Some(cancellableFuturePool.cancellableFuture(isComplete(code)))
+ override def asyncComplete(code: String, pos: Int): Some[CancellableFuture[Completion]] =
+ Some(cancellableFuturePool.cancellableFuture(complete(code, pos)))
+ override def asyncInspect(code: String, pos: Int, detailLevel: Int): Some[CancellableFuture[Option[Inspection]]] =
+ Some(cancellableFuturePool.cancellableFuture(inspect(code, pos)))
+
+}
diff --git a/modules/scala/scala-interpreter/src/main/scala/almond/internals/CancellableFuturePool.scala b/modules/shared/interpreter/src/main/scala/almond/interpreter/util/CancellableFuturePool.scala
similarity index 95%
rename from modules/scala/scala-interpreter/src/main/scala/almond/internals/CancellableFuturePool.scala
rename to modules/shared/interpreter/src/main/scala/almond/interpreter/util/CancellableFuturePool.scala
index c312b9b55..9bfe66041 100644
--- a/modules/scala/scala-interpreter/src/main/scala/almond/internals/CancellableFuturePool.scala
+++ b/modules/shared/interpreter/src/main/scala/almond/interpreter/util/CancellableFuturePool.scala
@@ -1,9 +1,8 @@
-package almond.internals
+package almond.interpreter.util
import java.lang.Thread.UncaughtExceptionHandler
import java.util.concurrent.{Executors, ThreadFactory}
-import almond.interpreter.util.CancellableFuture
import almond.logger.LoggerContext
import scala.concurrent.{Future, Promise}
"""
+ }
+ private def suffix = {
+ val extra =
+ if (fadeIn0) "