Add Ammonite's MIT license

Author: felixmulder

src/dotty/tools/dotc/repl/SyntaxHighlighter.scala renamed to src/dotty/tools/dotc/printing/SyntaxHighlighting.scala

@@ -1,13 +1,8 @@
 package dotty.tools
 package dotc
-package repl
+package printing
 
 import parsing.Tokens._
-import ammonite.terminal.FilterTools._
-import ammonite.terminal.LazyList._
-import ammonite.terminal.SpecialKeys._
-import ammonite.terminal.Filter
-import ammonite.terminal._
 import scala.annotation.switch
 import scala.collection.mutable.StringBuilder
 

src/dotty/tools/dotc/repl/AmmoniteReader.scala

@@ -10,6 +10,7 @@ import filters._
 import BasicFilters._
 import GUILikeFilters._
 import util.SourceFile
+import printing.SyntaxHighlighting
 
 class AmmoniteReader(val interpreter: Interpreter)(implicit ctx: Context) extends InteractiveReader {
   val interactive = true

src/dotty/tools/dotc/repl/ammonite/Ansi.scala

@@ -18,6 +18,7 @@ object Ansi {
     def matches(state: Short) = (state & resetMask) == applyMask
     def apply(s: Ansi.Str) = s.overlay(this, 0, s.length)
   }
+
   object Attr {
     val Reset = new Attr(Some(Console.RESET), Short.MaxValue, 0)
 
@@ -38,7 +39,7 @@ object Ansi {
     * Represents a set of [[Ansi.Attr]]s all occupying the same bit-space
     * in the state `Short`
     */
-  sealed abstract class Category(){
+  sealed abstract class Category() {
     val mask: Int
     val all: Seq[Attr]
     lazy val bitsMap = all.map{ m => m.applyMask -> m}.toMap
@@ -47,7 +48,7 @@ object Ansi {
     }
   }
 
-  object Color extends Category{
+  object Color extends Category {
 
     val mask = 15 << 7
     val Reset     = makeAttr(Some("\u001b[39m"),     0 << 7)
@@ -66,7 +67,7 @@ object Ansi {
     )
   }
 
-  object Back extends Category{
+  object Back extends Category {
     val mask = 15 << 3
 
     val Reset    = makeAttr(Some("\u001b[49m"),       0 << 3)
@@ -84,43 +85,37 @@ object Ansi {
       Blue, Magenta, Cyan, White
     )
   }
-  object Bold extends Category{
+
+  object Bold extends Category {
     val mask = 1 << 0
     val On  = makeAttr(Some(Console.BOLD), 1 << 0)
     val Off = makeAttr(None              , 0 << 0)
     val all = Seq(On, Off)
   }
 
-  object Underlined extends Category{
+  object Underlined extends Category {
     val mask = 1 << 1
     val On  = makeAttr(Some(Console.UNDERLINED), 1 << 1)
     val Off = makeAttr(None,                     0 << 1)
     val all = Seq(On, Off)
   }
-  object Reversed extends Category{
+
+  object Reversed extends Category {
     val mask = 1 << 2
     val On  = makeAttr(Some(Console.REVERSED),   1 << 2)
     val Off = makeAttr(None,                     0 << 2)
     val all = Seq(On, Off)
   }
 
   val hardOffMask = Bold.mask | Underlined.mask | Reversed.mask
-  val categories = Vector(
-    Color,
-    Back,
-    Bold,
-    Underlined,
-    Reversed
-  )
+  val categories = List(Color, Back, Bold, Underlined, Reversed)
 
   object Str {
-
-    lazy val ansiRegex = "\u001B\\[[;\\d]*m".r
+    @sharable lazy val ansiRegex = "\u001B\\[[;\\d]*m".r
 
     implicit def parse(raw: CharSequence): Str = {
-      // This will
-      val chars = new Array[Char](raw.length)
-      val colors = new Array[Short](raw.length)
+      val chars        = new Array[Char](raw.length)
+      val colors       = new Array[Short](raw.length)
       var currentIndex = 0
       var currentColor = 0.toShort
 
@@ -147,7 +142,6 @@ object Ansi {
 
       Str(chars.take(currentIndex), colors.take(currentIndex))
     }
-
   }
 
   /**
@@ -187,6 +181,7 @@ object Ansi {
       val (leftColors, rightColors) = colors.splitAt(index)
       (new Str(leftChars, leftColors), new Str(rightChars, rightColors))
     }
+
     def length = chars.length
     override def toString = render
 
@@ -238,12 +233,9 @@ object Ansi {
       // Cap off the left-hand-side of the rendered string with any ansi escape
       // codes necessary to rest the state to 0
       emitDiff(0)
-
       output.toString
     }
 
-
-
     /**
       * Overlays the desired color over the specified range of the [[Ansi.Str]].
       */
@@ -260,8 +252,5 @@ object Ansi {
       }
       new Str(chars, colorsOut)
     }
-
   }
-
-
 }

src/dotty/tools/dotc/repl/ammonite/Filter.scala

@@ -4,28 +4,24 @@ package repl
 package ammonite.terminal
 
 object Filter {
-
   def apply(id: String)(f: PartialFunction[TermInfo, TermAction]): Filter =
-    new Filter{
+    new Filter {
       val op = f.lift
       def identifier = id
     }
 
   def wrap(id: String)(f: TermInfo => Option[TermAction]): Filter =
-    new Filter{
+    new Filter {
       val op = f
       def identifier = id
     }
 
-  /**
-    * Merges multiple [[Filter]]s into one.
-    */
+  /** Merges multiple [[Filter]]s into one. */
   def merge(pfs: Filter*) = new Filter {
-
     val op = (v1: TermInfo) => pfs.iterator.map(_.op(v1)).find(_.isDefined).flatten
-
     def identifier = pfs.iterator.map(_.identifier).mkString(":")
   }
+
   val empty = Filter.merge()
 }
 

src/dotty/tools/dotc/repl/ammonite/FilterTools.scala

@@ -2,6 +2,7 @@ package dotty.tools
 package dotc
 package repl
 package ammonite.terminal
+
 /**
  * A collection of helpers that to simpify the common case of building filters
  */
@@ -12,8 +13,8 @@ object FilterTools {
     var splitIndex = 0
     var length = 0
 
-    while(length < in){
-      ansiRegex.r.findPrefixOf(buffer.drop(splitIndex)) match{
+    while(length < in) {
+      ansiRegex.r.findPrefixOf(buffer.drop(splitIndex)) match {
         case None =>
           splitIndex += 1
           length += 1
@@ -24,9 +25,6 @@ object FilterTools {
     splitIndex
   }
 
-
-
-
   /**
    * Shorthand to construct a filter in the common case where you're
    * switching on the prefix of the input stream and want to run some
@@ -58,12 +56,9 @@ object FilterTools {
     def identifier = "Case"
   }
 
-  /**
-   * Shorthand for pattern matching on [[TermState]]
-   */
+  /** Shorthand for pattern matching on [[TermState]] */
   val TS = TermState
 
-
   def findChunks(b: Vector[Char], c: Int) = {
     val chunks = Terminal.splitBuffer(b)
     // The index of the first character in each chunk
@@ -76,11 +71,10 @@ object FilterTools {
     (chunks, chunkStarts, chunkIndex)
   }
 
-  def firstRow(cursor: Int, buffer: Vector[Char], width: Int) = {
+  def firstRow(cursor: Int, buffer: Vector[Char], width: Int) =
     cursor < width && (buffer.indexOf('\n') >= cursor || buffer.indexOf('\n') == -1)
-  }
-  def lastRow(cursor: Int, buffer: Vector[Char], width: Int) = {
+
+  def lastRow(cursor: Int, buffer: Vector[Char], width: Int) =
     (buffer.length - cursor) < width &&
       (buffer.lastIndexOf('\n') < cursor || buffer.lastIndexOf('\n') == -1)
-  }
 }

src/dotty/tools/dotc/repl/ammonite/LICENSE

@@ -0,0 +1,25 @@
+License
+=======
+
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Li Haoyi ([email protected])
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

src/dotty/tools/dotc/repl/ammonite/Protocol.scala

@@ -7,21 +7,24 @@ case class TermInfo(ts: TermState, width: Int)
 
 sealed trait TermAction
 case class Printing(ts: TermState, stdout: String) extends TermAction
-case class TermState(inputs: LazyList[Int],
-                     buffer: Vector[Char],
-                     cursor: Int,
-                     msg: Ansi.Str = "") extends TermAction
-object TermState{
-  def unapply(ti: TermInfo): Option[(LazyList[Int], Vector[Char], Int, Ansi.Str)] = {
+case class TermState(
+  inputs: LazyList[Int],
+  buffer: Vector[Char],
+  cursor: Int,
+  msg: Ansi.Str = ""
+) extends TermAction
+
+object TermState {
+  def unapply(ti: TermInfo): Option[(LazyList[Int], Vector[Char], Int, Ansi.Str)] =
     TermState.unapply(ti.ts)
-  }
-  def unapply(ti: TermAction): Option[(LazyList[Int], Vector[Char], Int, Ansi.Str)] = ti match{
-    case ts: TermState => TermState.unapply(ts)
-    case _ => None
-  }
 
+  def unapply(ti: TermAction): Option[(LazyList[Int], Vector[Char], Int, Ansi.Str)] =
+    ti match {
+      case ts: TermState => TermState.unapply(ts)
+      case _ => None
+    }
 }
+
 case class ClearScreen(ts: TermState) extends TermAction
 case object Exit extends TermAction
 case class Result(s: String) extends TermAction
-