¿Construir una aplicación Clojure con una interfaz de línea de comandos?
clojure-contrib (5)
La antigua clojure.contrib.command-line ha sido reemplazada por tools.cli.
tools.cli solía llamarse clargon. A continuación hay dos entradas de blog que dan ejemplos del uso de tools.cli (simplemente reemplace cualquier referencia a clargon con tools.cli. Las publicaciones están desactualizadas).
Esto muestra algunas formas de métodos, incluido el antiguo clojure.contrib.command-line
Empecé con Clojure (procedente de Ruby) y me gustaría crear una pequeña aplicación con una interfaz de línea de comandos. ¿Cómo manejo la entrada / salida a una CL?
Noté que hay una línea de pedido y clojure.contrib.com, pero la documentación es delgada.
Me gustaría agregar que puedes hacer
(apply -main *command-line-args*)
debajo de (defn -main ...) para que funcione en modo interpretado.
Mucho tiempo después de plantear la pregunta, puedo sugerir el uso de docopt bibliotecas docopt a la hora de compilar la interfaz CLI. Hay uno para Clojure - docopt.clj
docopt se basa en convenciones que se utilizan durante décadas en mensajes de ayuda y páginas man para la descripción de la interfaz del programa. La descripción de la interfaz en docopt es un mensaje de ayuda, pero formalizado
Así que puedes declarar tu interfaz y documentarla al mismo tiempo; eso es increíble y fácil de hacer.
Para más detalles, recomiendo comprobar http://docopt.org/
También hay una aplicación en línea para verificar su interfaz http://try.docopt.org/
Y finalmente aquí está mi ejemplo de cómo se puede usar la biblioteca de Clojure.
Tal vez intente Jark. Jark es una herramienta para ejecutar programas de clojure en una JVM persistente. Tiene algunas útiles utilidades de línea de comandos.
jark ns load file.clj
jark <namespace>.<function> <args>
jark if cli-json <namespace><function> args
Aquí hay un ejemplo de cómo usar su macro con with-command-line . El siguiente código especifica una clase trivial con un método principal que no hace más que imprimir los valores de sus argumentos de línea de comando.
(ns cmd-line-demo
(:gen-class)
(:use clojure.contrib.command-line))
(defn -main [& args]
(with-command-line args
"Command line demo"
[[foo "This is the description for foo" 1]
[bar "This is the description for bar" 2]
[boolean? b? "This is a boolean flag."]
remaining]
(println "foo: " foo)
(println "bar: " bar)
(println "boolean?: " boolean?)
(println "remaining: " remaining)))
Compila la clase en REPL:
user> (compile ''cmd-line-demo)
cmd-line-demo
Ejemplo de uso
1) Ejecutar sin argumentos de línea de comando hará que se muestre la información de ayuda. La información de ayuda también puede mostrarse con --help or -h flags. Tenga en cuenta que la información de ayuda se genera automáticamente desde su cmdspec.
$ java -classpath . cmd_line_demo
Command line demo
Options
--foo <arg> This is the description for foo [default 1]
--bar <arg> This is the description for bar [default 2]
--boolean, -b This is a boolean flag.
2) Los argumentos no especificados reciben el valor predeterminado como se especifica en el enlace cmdspec. Por ejemplo, bar tiene un valor predeterminado de 2 .
$ java -classpath . cmd_line_demo --foo "changed value"
foo: changed value
bar: 2
boolean?: nil
remaining: []
3) Los indicadores booleanos se indican con el sufijo "?" en el cmdspec. Tenga en cuenta que la bandera en sí no incluye el "?" como parte de su nombre.
$ java -classpath . cmd_line_demo -boolean
foo: 1
bar: 2
boolean?: true
remaining: []
4) También tenga en cuenta que puede especificar alias de indicador especificando múltiples símbolos en la especificación cmdspec. He hecho esto con boolean? y b? banderas.
5) Finalmente, he especificado que remaining todos los argumentos restantes sin banderas asociadas.
$ java -classpath . cmd_line_demo -foo test file1 file2 file3
foo: test
bar: 2
boolean?: nil
remaining: [file1 file2 file3]