alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Scala example source code file (CompletionAware.scala)

This example Scala source code file (CompletionAware.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Scala tags/keywords

boolean, completionaware, completionaware, int, list, nametransformer, nil, none, none, option, option, parsed, string, string

The Scala CompletionAware.scala source code

/* NSC -- new Scala compiler
 * Copyright 2005-2011 LAMP/EPFL
 * @author Paul Phillips
 */
 
package scala.tools.nsc
package interpreter

import scala.reflect.NameTransformer

/** An interface for objects which are aware of tab completion and
 *  will supply their own candidates and resolve their own paths.
 */
trait CompletionAware {
  /** The delimiters which are meaningful when this CompletionAware
   *  object is in control.
   */
  // TODO
  // def delimiters(): List[Char] = List('.')

  /** The complete list of unqualified Strings to which this
   *  object will complete.
   */
  def completions(verbosity: Int): List[String]
  
  /** Default filter to apply to completions.
   */
  def filterNotFunction(s: String): Boolean = false
  
  /** Default sort.
   */
  def sortFunction(s1: String, s2: String): Boolean = s1 < s2
  
  /** Default map.
   */
  def mapFunction(s: String) = NameTransformer decode s
  
  /** The next completor in the chain.
   */
  def follow(id: String): Option[CompletionAware] = None
  
  /** What to return if this completion is given as a command.  It
   *  returns None by default, which means to allow the repl to interpret
   *  the line normally.  Returning Some(_) means the line will never
   *  reach the scala interpreter.
   */
  def execute(id: String): Option[Any] = None

  /** A list of useful information regarding a specific uniquely
   *  identified completion.  This is specifically written for the
   *  following situation, but should be useful elsewhere too:
   *
   *    x.y.z.methodName<tab>
   *
   *  If "methodName" is among z's completions, and verbosity > 0
   *  indicating tab has been pressed twice consecutively, then we
   *  call alternativesFor and show a list of overloaded method
   *  signatures.
   */
  def alternativesFor(id: String): List[String] = Nil
  
  /** Given string 'buf', return a list of all the strings
   *  to which it can complete.  This may involve delegating
   *  to other CompletionAware objects.
   */
  def completionsFor(parsed: Parsed): List[String] = {    
    import parsed.{ buffer, verbosity }
    val comps = completions(verbosity) filter (_ startsWith buffer)
    val exact = comps contains buffer

    val results =
      if (parsed.isEmpty) comps
      else if (parsed.isUnqualified && !parsed.isLastDelimiter)
        if (verbosity > 0 && exact) alternativesFor(buffer)
        else comps
      else follow(parsed.bufferHead) map (_ completionsFor parsed.bufferTail) getOrElse Nil
  
    results filterNot filterNotFunction map mapFunction sortWith (sortFunction _)
  }
  
  /** TODO - unify this and completionsFor under a common traverser.
   */
  def executionFor(parsed: Parsed): Option[Any] = {
    import parsed._
    
    if (isUnqualified && !isLastDelimiter && (completions(verbosity) contains buffer)) execute(buffer)
    else if (!isQualified) None
    else follow(bufferHead) flatMap (_ executionFor bufferTail)
  }
}

object CompletionAware {
  val Empty = new CompletionAware { def completions(verbosity: Int) = Nil }

  /** Artificial object demonstrating completion */
  // lazy val replVars = CompletionAware(
  //   Map[String, CompletionAware](
  //     "ids" -> CompletionAware(() => unqualifiedIds, completionAware _),
  //     "synthVars" -> CompletionAware(() => allBoundNames filter isSynthVarName map (_.toString)),
  //     "types" -> CompletionAware(() => allSeenTypes map (_.toString)),
  //     "implicits" -> CompletionAware(() => allImplicits map (_.toString))
  //   )
  // )
  
  // class Forwarder(underlying: CompletionAware) extends CompletionAware {
  //   override def completions() = underlying.completions()
  //   override def filterNotFunction(s: String) = underlying.filterNotFunction(s)
  //   override def sortFunction(s1: String, s2: String) = underlying.sortFunction(s1, s2)
  //   override def mapFunction(s: String) = underlying.mapFunction(s)
  //   override def follow(id: String) = underlying.follow(id)
  //   override def execute(id: String) = underlying.execute(id)
  //   override def completionsFor(parsed: Parsed) = underlying.completionsFor(parsed)
  //   override def executionFor(parsed: Parsed) = underlying.executionFor(parsed)
  // } 
  //
  
  def unapply(that: Any): Option[CompletionAware] = that match {
    case x: CompletionAware => Some((x))
    case _                  => None
  }
  
  /** Create a CompletionAware object from the given functions.
   *  The first should generate the list of completions whenever queried,
   *  and the second should return Some(CompletionAware) object if
   *  subcompletions are possible.
   */
  def apply(terms: () => List[String], followFunction: String => Option[CompletionAware]): CompletionAware =
    new CompletionAware {
      def completions = terms()
      def completions(verbosity: Int) = completions
      override def follow(id: String) = followFunction(id)
    }

  /** Convenience factories.
   */
  def apply(terms: () => List[String]): CompletionAware = apply(terms, _ => None)
  def apply(map: collection.Map[String, CompletionAware]): CompletionAware =
    apply(() => map.keys.toList, map.get _)
}

Other Scala examples (source code examples)

Here is a short list of links related to this Scala CompletionAware.scala source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.