Existe-t-il une bonne bibliothèque pour intégrer une invite de commande dans une application scala (ou java)?

Question

J'ai une application dans laquelle j'aimerais recevoir une invite. Si cela aide, il s'agit d'une implémentation de base de données graphique et j'ai besoin d'un invite comme tout autre client de base de données (MySQL, Postgresql, etc.).

Jusqu'à présent, j'ai mon propre REPL comme ceci:

object App extends Application { 
    REPL ! Read 
} 

object REPL extends Actor { 
    def act() { 
     loop { 
      react { 
       case Read => { 
        print("prompt> ") 
        var message = Console.readLine 
        this ! Eval(message) 
       } 
       case More(sofar) => { 
        //Eval didn't see a semicolon 
        print(" --> ") 
        var message = Console.readLine 
        this ! Eval(sofar + " " + message) 
       } 
       case Eval(message) => { 
        Evaluator ! Eval(message) 
       } 
       case Print(message) => { 
        println(message) 
        //And here's the loop 
        this ! Read 
       } 
       case Exit => { 
        exit() 
       } 
       case _ => { 
        println("App: How did we get here") 
       } 
      } 
     } 
    } 
    this.start 
} 

Il fonctionne, mais je voudrais vraiment quelque chose avec l'histoire. L'achèvement de l'onglet n'est pas nécessaire.

Des suggestions sur une bonne bibliothèque? Scala ou Java fonctionne. Pour être clair, je n'ai pas besoin d'un REPL pour évaluer mon code (je reçois ça avec scala!), Ni d'appeler ou d'utiliser quelque chose depuis la ligne de commande. Je suis à la recherche d'une invite correspondant à mon expérience utilisateur lorsque mon application cliente démarre.

Answer 1

Scala lui-même, et beaucoup de programmes là-bas, utilise pour sa REPL une bibliothèque readline -comme. Plus précisément, JLine.

J'ai trouvé another question à ce sujet, pour lequel les réponses ne semblent pas prometteuses.

Answer 2

BeanShell fait partie de ce que vous voulez: http://www.beanshell.org/

Answer 3

Je l'ai eu. ces deux blogs ont vraiment aidé.

http://danielwestheide.com/blog/2013/01/09/the-neophytes-guide-to-scala-part-8-welcome-to-the-future.html

http://danielwestheide.com/blog/2013/01/16/the-neophytes-guide-to-scala-part-9-promises-and-futures-in-practice.html

def interprete(code: String) : Future[String] = { 
val p = Promise[String]() 

Future { 
    var result = reader.readLine() 
    p.success(result) 
} 

writer.write(code + "\n") 
writer.flush() 

p.future 

}

for (ln <- io.Source.stdin.getLines){ 
    val f = interprete(ln) 
    f.onComplete { 
    case Success(s) => 
     println("future returned: " + s) 
    case Failure(ex) => 
     println(s"interpreter failed due to ${ex.getMessage}") 
    } 

}