Merge pull request scala#4563 from adriaanm/jline-shade

Corral, shade & embed jline.

Author: adriaanm

build.sbt

@@ -191,6 +191,7 @@ lazy val interactive = configureAsSubproject(project)
   .settings(disableDocsAndPublishingTasks: _*)
   .dependsOn(compiler)
 
+// TODO: SI-9339 embed shaded copy of jline & its interface (see #4563)
 lazy val repl = configureAsSubproject(project)
   .settings(
     libraryDependencies += jlineDep,

build.xml

@@ -275,6 +275,10 @@ TODO:
         <dependency groupId="biz.aQute" artifactId="bnd" version="1.50.0"/>
       </artifact:dependencies>
 
+      <artifact:dependencies pathId="jarjar.classpath">
+        <dependency groupId="com.googlecode.jarjar" artifactId="jarjar" version="1.3"/>
+      </artifact:dependencies>
+
       <!-- JUnit -->
       <property name="junit.version" value="4.11"/>
       <artifact:dependencies pathId="junit.classpath" filesetId="junit.fileset">
@@ -696,7 +700,7 @@ TODO:
     <property name="partest-javaagent.description" value="Scala Compiler Testing Tool (compiler-specific java agent)"/>
 
     <!-- projects without project-specific options: forkjoin, manual, bin, repl -->
-    <for list="actors,compiler,interactive,scaladoc,library,parser-combinators,partest,partest-extras,partest-javaagent,reflect,scalap,swing,xml,continuations-plugin,continuations-library" param="project">
+    <for list="actors,compiler,interactive,scaladoc,library,parser-combinators,partest,partest-extras,partest-javaagent,reflect,scalap,swing,xml,continuations-plugin,continuations-library,repl-jline" param="project">
       <sequential>
         <!-- description is mandatory -->
         <init-project-prop project="@{project}" name="package"     default=""/> <!-- used by mvn-package, copy-bundle, make-bundle -->
@@ -799,6 +803,11 @@ TODO:
     <path id="quick.repl.build.path">
       <path refid="quick.compiler.build.path"/>
       <pathelement location="${build-quick.dir}/classes/repl"/>
+    </path>
+
+    <path id="quick.repl-jline.build.path">
+      <path refid="quick.repl.build.path"/>
+      <pathelement location="${build-quick.dir}/classes/repl-jline"/>
       <path refid="repl.deps.classpath"/>
     </path>
 
@@ -873,6 +882,8 @@ TODO:
       <fileset dir="${build-quick.dir}/classes/actors"/>
     </path>
 
+    <path id="pack.repl-jline.files">    <fileset dir="${build-quick.dir}/classes/repl-jline"/> </path>
+
     <path id="pack.compiler.files">
       <fileset dir="${build-quick.dir}/classes/compiler"/>
 
@@ -1076,6 +1087,7 @@ TODO:
     </patternset>
 
     <taskdef resource="scala/tools/ant/sabbus/antlib.xml" classpathref="starr.compiler.path"/>
+    <taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpathref="jarjar.classpath" />
   </target>
 
 <!-- ===========================================================================
@@ -1157,7 +1169,31 @@ TODO:
     <staged-build with="locker"   stage="quick" project="compiler"/> </target>
 
   <target name="quick.repl"       depends="quick.comp">
-    <staged-build with="locker"   stage="quick" project="repl"/> </target>
+    <staged-build with="locker"   stage="quick" project="repl"/>
+    <staged-build with="locker"   stage="quick" project="repl-jline"/>
+
+    <staged-pack project="repl-jline"/>
+
+    <!-- make jline_embedded jar with classes of repl-jline and jline, then shade-->
+    <jarjar jarfile="${build-pack.dir}/${repl-jline.targetdir}/scala-repl-jline-embedded.jar" whenmanifestonly="fail">
+      <zipfileset src="${jline:jline:jar}"/>
+      <zipfileset src="${build-pack.dir}/${repl-jline.targetdir}/${repl-jline.targetjar}"/>
+
+      <rule pattern="org.fusesource.**" result="scala.tools.fusesource_embedded.@1"/>
+      <rule pattern="jline.**" result="scala.tools.jline_embedded.@1"/>
+      <rule pattern="scala.tools.nsc.interpreter.jline.**" result="scala.tools.nsc.interpreter.jline_embedded.@1"/>
+      <keep pattern="scala.tools.**"/>
+    </jarjar>
+
+    <!-- unzip jar to repl's class dir to obtain
+           - standard repl-jline
+           - a shaded repl-jline (scala/tools/nsc/interpreter/jline_embedded) & jline (scala.tools.jline_embedded)
+    -->
+    <copy todir="${build-quick.dir}/classes/repl">
+      <zipfileset src="${build-pack.dir}/${repl-jline.targetdir}/${repl-jline.targetjar}"/>
+      <zipfileset src="${build-pack.dir}/${repl-jline.targetdir}/scala-repl-jline-embedded.jar"/>
+    </copy>
+  </target>
 
   <target name="quick.scaladoc"   depends="quick.comp">
     <staged-build with="locker"   stage="quick" project="scaladoc" version="scaladoc"/> </target>

src/repl/scala/tools/nsc/interpreter/session/FileBackedHistory.scala renamed to src/repl-jline/scala/tools/nsc/interpreter/jline/FileBackedHistory.scala

@@ -1,20 +1,22 @@
 /* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
+ * Copyright 2005-2015 LAMP/EPFL
  * @author Paul Phillips
  */
 
-package scala.tools.nsc
-package interpreter
-package session
+package scala.tools.nsc.interpreter.jline
 
-import scala.tools.nsc.io._
-import FileBackedHistory._
+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 JPersistentHistory {
+  */
+trait FileBackedHistory extends JLineHistory with PersistentHistory {
   def maxSize: Int
-  protected lazy val historyFile: File = defaultFile
+
+  protected lazy val historyFile: File = FileBackedHistory.defaultFile
   private var isPersistent = true
 
   locally {
@@ -27,6 +29,7 @@ trait FileBackedHistory extends JLineHistory with JPersistentHistory {
     try op
     finally isPersistent = saved
   }
+
   def addLineToFile(item: CharSequence): Unit = {
     if (isPersistent)
       append(item + "\n")
@@ -37,6 +40,7 @@ trait FileBackedHistory extends JLineHistory with JPersistentHistory {
     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: _*)
@@ -54,31 +58,36 @@ trait FileBackedHistory extends JLineHistory with JPersistentHistory {
         // 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() }
+          catch {
+            case _: Exception => Vector()
+          }
       }
     }
 
-    repldbg("Loading " + lines.size + " into history.")
+    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) {
-      repldbg("File exceeds maximum size: truncating to " + maxSize + " entries.")
+      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 Properties.userHome
+
+  import scala.tools.nsc.Properties.userHome
 
   def defaultFileName = ".scala_history"
+
   def defaultFile: File = File(Path(userHome) / defaultFileName)
 }

src/repl-jline/scala/tools/nsc/interpreter/jline/JLineDelimiter.scala

@@ -0,0 +1,25 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author Paul Phillips
+ */
+
+package scala.tools.nsc.interpreter.jline
+
+import scala.tools.nsc.interpreter
+
+import _root_.jline.console.completer.ArgumentCompleter.{ ArgumentDelimiter, ArgumentList }
+
+// implements a jline interface
+class JLineDelimiter extends ArgumentDelimiter {
+  def toJLine(args: List[String], cursor: Int) = args match {
+    case Nil => new ArgumentList(new Array[String](0), 0, 0, cursor)
+    case xs => new ArgumentList(xs.toArray, xs.size - 1, xs.last.length, cursor)
+  }
+
+  def delimit(buffer: CharSequence, cursor: Int) = {
+    val p = interpreter.Parsed(buffer.toString, cursor)
+    toJLine(p.args, cursor)
+  }
+
+  def isDelimiter(buffer: CharSequence, cursor: Int) = interpreter.Parsed(buffer.toString, cursor).isDelimiter
+}

src/repl-jline/scala/tools/nsc/interpreter/jline/JLineHistory.scala

@@ -0,0 +1,77 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2013 LAMP/EPFL
+ * @author Paul Phillips
+ */
+
+package scala.tools.nsc.interpreter.jline
+
+import java.util.{Iterator => JIterator, ListIterator => JListIterator}
+
+import _root_.jline.{console => jconsole}
+import jconsole.history.History.{Entry => JEntry}
+import jconsole.history.{History => JHistory}
+
+import scala.tools.nsc.interpreter
+import scala.tools.nsc.interpreter.session.{History, SimpleHistory}
+
+
+/** A straight scalification of the jline interface which mixes
+ *  in the sparse jline-independent one too.
+ */
+trait JLineHistory extends JHistory with History {
+  def size: Int
+  def isEmpty: Boolean
+  def index: Int
+  def clear(): Unit
+  def get(index: Int): CharSequence
+  def add(line: CharSequence): Unit
+  def replace(item: CharSequence): Unit
+
+  def entries(index: Int): JListIterator[JEntry]
+  def entries(): JListIterator[JEntry]
+  def iterator: JIterator[JEntry]
+
+  def current(): CharSequence
+  def previous(): Boolean
+  def next(): Boolean
+  def moveToFirst(): Boolean
+  def moveToLast(): Boolean
+  def moveTo(index: Int): Boolean
+  def moveToEnd(): Unit
+
+  override def historicize(text: String): Boolean = {
+    text.lines foreach add
+    moveToEnd()
+    true
+  }
+}
+
+object JLineHistory {
+  class JLineFileHistory extends SimpleHistory with FileBackedHistory {
+    override def add(item: CharSequence): Unit = {
+      if (!isEmpty && last == item)
+        interpreter.repldbg("Ignoring duplicate entry '" + item + "'")
+      else {
+        super.add(item)
+        addLineToFile(item)
+      }
+    }
+    override def toString = "History(size = " + size + ", index = " + index + ")"
+
+    import scala.collection.JavaConverters._
+
+    override def asStrings(from: Int, to: Int): List[String] =
+      entries(from).asScala.take(to - from).map(_.value.toString).toList
+
+    case class Entry(index: Int, value: CharSequence) extends JEntry {
+      override def toString = value.toString
+    }
+
+    private def toEntries(): Seq[JEntry] = buf.zipWithIndex map { case (x, i) => Entry(i, x)}
+    def entries(idx: Int): JListIterator[JEntry] = toEntries().asJava.listIterator(idx)
+    def entries(): JListIterator[JEntry] = toEntries().asJava.listIterator()
+    def iterator: JIterator[JEntry] = toEntries().iterator.asJava
+  }
+
+  def apply(): History = try new JLineFileHistory catch { case x: Exception => new SimpleHistory() }
+}