SI-9339 Support classpaths with no single compatible jline

As usual, the repl will use whatever jline 2 jar on the classpath,
if there is one. Failing that, there's a fallback and an override.

If instantiating the standard `jline.InteractiveReader` fails,
we fall back to an embedded, shaded, version of jline,
provided by `jline_embedded.InteractiveReader`.

(Assume `import scala.tools.nsc.interpreter._` for this message.)

The instantiation of `InteractiveReader` eagerly exercises jline,
so that a linkage error will result if jline is missing or if the
provided one is not binary compatible.

The property `scala.repl.reader` overrides this behavior, if set to
the FQN of a class that looks like `YourInteractiveReader` below.

```
class YourInteractiveReader(completer: () => Completion) extends InteractiveReader
```

The repl logs which classes it tried to instantiate under `-Ydebug`.

 # Changes to source & build

The core of the repl (`src/repl`) no longer depends on jline.
The jline interface is now in `src/repl-jline`.

The embedded jline + our interface to it are generated by the `quick.repl` target.
The build now also enforces that only `src/repl-jline` depends on jline.
The sources in `src/repl` are now sure to be independent of it,
though they do use reflection to instantiate a suitable subclass
of `InteractiveReader`, as explained above.

The `quick.repl` target builds the sources in `src/repl` and `src/repl-jline`,
producing a jar for the `repl-jline` classes, which is then transformed using
jarjar to obtain a shaded copy of the `scala.tools.nsc.interpreter.jline` package.

Jarjar is used to combine the `jline` jar and the `repl-jline` into a new jar,
rewriting package names as follows:
  - `org.fusesource` -> `scala.tools.fusesource_embedded`
  - `jline` -> `scala.tools.jline_embedded`
  - `scala.tools.nsc.interpreter.jline` -> `scala.tools.nsc.interpreter.jline_embedded`

Classes not reachable from `scala.tools.**` are pruned, as well as empty dirs.

The classes in the `repl-jline` jar as well as those in the rewritten one
are copied to the repl's output directory.

PS: The sbt build is not updated, sorry.
PPS: A more recent fork of jarjar: https://github.com/shevek/jarjar.

1 files changed, 93 insertions, 0 deletions

diff --git a/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala b/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala
new file mode 100644
index 0000000000..b6c9792ec0
--- /dev/null
+++ b/src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala
@@ -0,0 +1,93 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2015 LAMP/EPFL
+ * @author Paul Phillips
+ */
+
+package scala.tools.nsc.interpreter.jline
+
+import _root_.jline.console.history.PersistentHistory
+
+
+import scala.tools.nsc.interpreter
+import scala.tools.nsc.io.{File, Path}
+
+/** TODO: file locking.
+  */
+trait FileBackedHistory extends JLineHistory with PersistentHistory {
+  def maxSize: Int
+
+  protected lazy val historyFile: File = FileBackedHistory.defaultFile
+  private var isPersistent = true
+
+  locally {
+    load()
+  }
+
+  def withoutSaving[T](op: => T): T = {
+    val saved = isPersistent
+    isPersistent = false
+    try op
+    finally isPersistent = saved
+  }
+
+  def addLineToFile(item: CharSequence): Unit = {
+    if (isPersistent)
+      append(item + "\n")
+  }
+
+  /** Overwrites the history file with the current memory. */
+  protected def sync(): Unit = {
+    val lines = asStrings map (_ + "\n")
+    historyFile.writeAll(lines: _*)
+  }
+
+  /** Append one or more lines to the history file. */
+  protected def append(lines: String*): Unit = {
+    historyFile.appendAll(lines: _*)
+  }
+
+  def load(): Unit = {
+    if (!historyFile.canRead)
+      historyFile.createFile()
+
+    val lines: IndexedSeq[String] = {
+      try historyFile.lines().toIndexedSeq
+      catch {
+        // It seems that control characters in the history file combined
+        // with the default codec can lead to nio spewing exceptions.  Rather
+        // than abandon hope we'll try to read it as ISO-8859-1
+        case _: Exception =>
+          try historyFile.lines("ISO-8859-1").toIndexedSeq
+          catch {
+            case _: Exception => Vector()
+          }
+      }
+    }
+
+    interpreter.repldbg("Loading " + lines.size + " into history.")
+
+    // avoid writing to the history file
+    withoutSaving(lines takeRight maxSize foreach add)
+    // truncate the history file if it's too big.
+    if (lines.size > maxSize) {
+      interpreter.repldbg("File exceeds maximum size: truncating to " + maxSize + " entries.")
+      sync()
+    }
+    moveToEnd()
+  }
+
+  def flush(): Unit = ()
+
+  def purge(): Unit = historyFile.truncate()
+}
+
+object FileBackedHistory {
+  //   val ContinuationChar = '\003'
+  //   val ContinuationNL: String = Array('\003', '\n').mkString
+
+  import scala.tools.nsc.Properties.userHome
+
+  def defaultFileName = ".scala_history"
+
+  def defaultFile: File = File(Path(userHome) / defaultFileName)
+}