Análisis de opciones de línea de comandos realmente barato en Ruby

EDIT: Por favor, por favor , por favor, lea los dos requisitos que figuran en la parte inferior de este post antes de responder. La gente sigue publicando sus nuevas gemas y bibliotecas y todo eso, que claramente no cumplen con los requisitos.

A veces quiero piratear algunas opciones de la línea de comandos de forma muy económica en un script simple. Una forma divertida de hacerlo, sin tener que lidiar con getopts o parsing ni nada de eso, es:

...
$quiet       = ARGV.delete('-d')
$interactive = ARGV.delete('-i')
...
# Deal with ARGV as usual here, maybe using ARGF or whatever.

No es del todo la sintaxis de opciones normal de Unix, porque acepta opciones que no son parámetros de línea de comandos de opciones, como en " myprog -i foo bar -q", pero puedo vivir con eso. (Algunas personas, como los desarrolladores de Subversion, prefieren esto. A veces yo también.)

Una opción que está presente o ausente no se puede implementar de manera mucho más simple que la anterior. (Una asignación, una llamada a función, un efecto secundario). ¿Existe una forma igualmente sencilla de tratar las opciones que toman un parámetro, como " -f nombre de archivo "?

EDITAR:

Un punto que no mencioné antes, porque no me había quedado claro hasta que el autor de Trollop mencionó que la biblioteca cabía "en un archivo [de 800 líneas]", es que no solo estoy buscando sintaxis, pero para una técnica que tiene las siguientes características:

1. La totalidad del código se puede incluir en el archivo de secuencia de comandos (sin abrumar la secuencia de comandos en sí, que puede ser solo un par de docenas de líneas), de modo que uno puede colocar un solo archivo en un bindirectorio en cualquier sistema con un Ruby 1.8 estándar . [5-7] instalación y uso. Si no puede escribir una secuencia de comandos de Ruby que no tenga declaraciones de requerimiento y donde el código para analizar un par de opciones tenga menos de una docena de líneas, no cumple con este requisito.

2. El código es lo suficientemente pequeño y simple como para que uno pueda recordar lo suficiente como para escribir directamente el código que funcionará, en lugar de cortar y pegar desde otro lugar. Piense en la situación en la que se encuentra en la consola de un servidor con cortafuegos sin acceso a Internet y desea preparar un script rápido para que lo use un cliente. No sé ustedes, pero (además de fallar el requisito anterior) memorizar incluso las 45 líneas de micro-optparse simplificado no es algo que me interese hacer.

Como autor de Trollop , no puedo CREER las cosas que la gente piensa que es razonable en un analizador de opciones. Seriamente. Aturde la mente.

¿Por qué debería tener que hacer un módulo que amplíe algún otro módulo para analizar las opciones? ¿Por qué debería tener que subclasificar algo? ¿Por qué debería suscribirme a algún "marco" sólo para analizar la línea de comandos?

Aquí está la versión Trollop de lo anterior:

opts = Trollop::options do
  opt :quiet, "Use minimal output", :short => 'q'
  opt :interactive, "Be interactive"
  opt :filename, "File to process", :type => String
end

Y eso es. optsahora es un hash con las teclas :quiet, :interactivey :filename. Puedes hacer lo que quieras con eso. Y obtienes una hermosa página de ayuda, formateada para adaptarse al ancho de tu pantalla, nombres cortos automáticos de argumentos, verificación de tipos ... todo lo que necesitas.

Es un archivo, por lo que puede colocarlo en su directorio lib / si no desea una dependencia formal. Tiene un DSL mínimo que es fácil de captar.

LOC por opción personas. Importa.

Comparto su disgusto por require 'getopts', principalmente debido a la genialidad que es OptionParser:

% cat temp.rb                                                            
require 'optparse'
OptionParser.new do |o|
  o.on('-d') { |b| $quiet = b }
  o.on('-i') { |b| $interactive = b }
  o.on('-f FILENAME') { |filename| $filename = filename }
  o.on('-h') { puts o; exit }
  o.parse!
end
p :quiet => $quiet, :interactive => $interactive, :filename => $filename
% ruby temp.rb                                                           
{:interactive=>nil, :filename=>nil, :quiet=>nil}
% ruby temp.rb -h                                                        
Usage: temp [options]
    -d
    -i
    -f FILENAME
    -h
% ruby temp.rb -d                                                        
{:interactive=>nil, :filename=>nil, :quiet=>true}
% ruby temp.rb -i                                                        
{:interactive=>true, :filename=>nil, :quiet=>nil}
% ruby temp.rb -di                                                       
{:interactive=>true, :filename=>nil, :quiet=>true}
% ruby temp.rb -dif apelad                                               
{:interactive=>true, :filename=>"apelad", :quiet=>true}
% ruby temp.rb -f apelad -i                                              
{:interactive=>true, :filename=>"apelad", :quiet=>nil}

Esta es la técnica estándar que suelo usar:

#!/usr/bin/env ruby

def usage(s)
    $stderr.puts(s)
    $stderr.puts("Usage: #{File.basename($0)}: [-l <logfile] [-q] file ...")
    exit(2)
end

$quiet   = false
$logfile = nil

loop { case ARGV[0]
    when '-q' then  ARGV.shift; $quiet = true
    when '-l' then  ARGV.shift; $logfile = ARGV.shift
    when /^-/ then  usage("Unknown option: #{ARGV[0].inspect}")
    else break
end; }

# Program carries on here.
puts("quiet: #{$quiet} logfile: #{$logfile.inspect} args: #{ARGV.inspect}")

Dado que nadie pareció mencionarlo, y el título se refiere a un análisis de línea de comandos barato , ¿por qué no dejar que el intérprete Ruby haga el trabajo por usted? Si pasa el -sinterruptor (en su shebang, por ejemplo), obtiene interruptores muy simples de forma gratuita, asignados a variables globales de una sola letra. Aquí está su ejemplo usando ese interruptor:

#!/usr/bin/env ruby -s
puts "#$0: Quiet=#$q Interactive=#$i, ARGV=#{ARGV.inspect}"

Y aquí está la salida cuando guardo eso como ./testy lo modifico +x:

$ ./test
./test: Quiet= Interactive=, ARGV=[]
$ ./test -q foo
./test: Quiet=true Interactive=, ARGV=["foo"]
$ ./test -q -i foo bar baz
./test: Quiet=true Interactive=true, ARGV=["foo", "bar", "baz"]
$ ./test -q=very foo
./test: Quiet=very Interactive=, ARGV=["foo"]

Consulte ruby -hpara obtener más detalles.

Eso debe ser tan barato como se pone. Generará un NameError si prueba un cambio como -:, por lo que hay algo de validación allí. Por supuesto, no puede tener ningún cambio después de un argumento sin cambio, pero si necesita algo sofisticado, realmente debería usar como mínimo OptionParser. De hecho, lo único que me molesta de esta técnica es que recibirás una advertencia (si las has habilitado) cuando accedas a una variable global no configurada, pero sigue siendo falsa, por lo que funciona bien para herramientas desechables y rápidas. guiones.

Una advertencia señalada por FelipeC en los comentarios en " Cómo hacer un análisis de opciones de línea de comandos realmente barato en Ruby ", es que su shell podría no ser compatible con el shebang de 3 tokens; es posible que deba reemplazar /usr/bin/env ruby -wcon la ruta real a su ruby ​​(como /usr/local/bin/ruby -w), o ejecutarlo desde un script contenedor, o algo así.

Construí micro-optparse para esta obvia necesidad de un analizador de opciones corto pero fácil de usar. Tiene una sintaxis similar a Trollop y tiene 70 líneas cortas. Si no necesita validaciones y puede prescindir de las líneas vacías, puede reducirlo a 45 líneas. Creo que eso es exactamente lo que estabas buscando.

Ejemplo corto:

options = Parser.new do |p|
  p.version = "fancy script version 1.0"
  p.option :verbose, "turn on verbose mode"
  p.option :number_of_chairs, "defines how many chairs are in the classroom", :default => 1
  p.option :room_number, "select room number", :default => 2, :value_in_set => [1,2,3,4]
end.process!

Llamar al script con -ho --helpimprimirá

Usage: micro-optparse-example [options]
    -v, --[no-]verbose               turn on verbose mode
    -n, --number-of-chairs 1         defines how many chairs are in the classroom
    -r, --room-number 2              select room number
    -h, --help                       Show this message
    -V, --version                    Print version

Comprueba si la entrada es del mismo tipo que el valor predeterminado, genera accesos cortos y largos, imprime mensajes de error descriptivos si se dan argumentos no válidos y más.

Yo comparé varias opciones-analizador mediante el uso de cada opción-analizador para el problema que tenía. Puede utilizar estos ejemplos y mi resumen para tomar una decisión informativa. No dude en agregar más implementaciones a la lista. :)

Entiendo totalmente por qué desea evitar optparse: puede ser demasiado. Pero hay algunas soluciones mucho más "ligeras" (en comparación con OptParse) que vienen como bibliotecas pero son lo suficientemente simples como para hacer que valga la pena instalar una sola gema.

Por ejemplo, consulte este ejemplo de OptiFlag . Solo unas pocas líneas para el procesamiento. Un ejemplo ligeramente truncado adaptado a su caso:

require 'optiflag'

module Whatever extend OptiFlagSet
  flag "f"
  and_process!
end 

ARGV.flags.f # => .. whatever ..

También hay toneladas de ejemplos personalizados . Recuerdo haber usado otro que era aún más fácil, pero se me ha escapado por ahora, pero volveré y agregaré un comentario aquí si lo encuentro.

Esto es lo que uso para argumentos realmente baratos:

def main
  ARGV.each { |a| eval a }
end

main

así que si lo ejecutas programname foo barllama a foo y luego a bar. Es útil para guiones desechables.

Puedes probar algo como:

if( ARGV.include( '-f' ) )
  file = ARGV[ARGV.indexof( '-f' ) + 1 )]
  ARGV.delete('-f')
  ARGV.delete(file)
end

¿Has considerado a Thor? por wycats? Creo que es mucho más limpio que optparse. Si ya tiene un script escrito, podría ser un poco más trabajo formatearlo o refactorizarlo para Thor, pero hace que las opciones de manejo sean muy simples.

Aquí está el fragmento de ejemplo del archivo README:

class MyApp < Thor                                                # [1]
  map "-L" => :list                                               # [2]

  desc "install APP_NAME", "install one of the available apps"    # [3]
  method_options :force => :boolean, :alias => :optional          # [4]
  def install(name)
    user_alias = options[:alias]
    if options.force?
      # do something
    end
    # ... other code ...
  end

  desc "list [SEARCH]", "list all of the available apps, limited by SEARCH"
  def list(search = "")
    # list everything
  end
end

Thor mapea automáticamente los comandos como tales:

app install myname --force

Eso se convierte en:

MyApp.new.install("myname")
# with {'force' => true} as options hash

1. Hereda de Thor para convertir una clase en un mapeador de opciones
2. Asigne identificadores no válidos adicionales a métodos específicos. En este caso, convierta -L en: list
3. Describe el método inmediatamente a continuación. El primer parámetro es la información de uso y el segundo parámetro es la descripción.
4. Proporcione opciones adicionales. Estos se calcularán desde y params. En este caso, se agrega una opción --force y una -f.

Aquí está mi analizador de opciones rápido y sucio favorito:

case ARGV.join
when /-h/
  puts "help message"
  exit
when /-opt1/
  puts "running opt1"
end

Las opciones son expresiones regulares, por lo que "-h" también coincidiría con "--help".

Legible, fácil de recordar, sin biblioteca externa y código mínimo.

Trollop es bastante barato.

Si desea un analizador de línea de comando simple para comandos clave / valor sin el uso de gemas:

Pero esto solo funciona si siempre tiene pares clave / valor.

# example
# script.rb -u username -p mypass

# check if there are even set of params given
if ARGV.count.odd? 
    puts 'invalid number of arguments'
    exit 1
end

# holds key/value pair of cl params {key1 => value1, key2 => valye2, ...}
opts = {} 

(ARGV.count/2).times do |i|
    k,v = ARGV.shift(2)
    opts[k] = v # create k/v pair
end

# set defaults if no params are given
opts['-u'] ||= 'root'

# example use of opts
puts "username:#{opts['-u']} password:#{opts['-p']}"

Si no necesita ninguna verificación , puede usar:

opts = {} 

(ARGV.count/2).times do |i|
    k,v = ARGV.shift(2)
    opts[k] = v # create k/v pair
end

Aquí está el fragmento de código que utilizo en la parte superior de la mayoría de mis scripts:

arghash = Hash.new.tap { |h| # Parse ARGV into a hash
    i = -1                      
    ARGV.map{  |s| /(-[a-zA-Z_-])?([^=]+)?(=)?(.+)?/m.match(s).to_a }
     .each{ |(_,a,b,c,d)| h[ a ? "#{a}#{b}#{c}" : (i+=1) ] =
                             (a ? (c ? "#{d}" : true) : "#{b}#{c}#{d}") 
          }
    [[:argc,Proc.new  {|| h.count{|(k,_)| !k.is_a?(String)}}],
     [:switches, Proc.new {|| h.keys.select{|k| k[0] == '-' }}]
    ].each{|(n,p)| h.define_singleton_method(n,&p) }
}

También odio requerir archivos adicionales en mis scripts rápidos y sucios. Mi solución es casi lo que estás pidiendo. Pego un fragmento de código de 10 líneas en la parte superior de cualquiera de mis scripts que analiza la línea de comando y pega argumentos posicionales y cambia a un objeto Hash (generalmente asignado a un objeto que he llamado arghash en los ejemplos a continuación).

Aquí hay una línea de comando de ejemplo que quizás desee analizar ...

./myexampleprog.rb -s -x=15 --longswitch arg1 --longswitch2=val1 arg2

Que se convertiría en un hash como este.

 { 
   '-s' => true, 
   '-x=' => '15', 
   '--longswitch' => true, 
   '--longswitch2=' => 'val1', 
   0 => 'arg1', 
   1 => 'arg2'
 }

Además de eso, se agregan dos métodos de conveniencia al Hash:

• argc() devolverá el recuento de argumentos que no son de cambio.
• switches() devolverá una matriz que contiene las claves para los interruptores que están presentes

Esto es para permitir algunas cosas rápidas y sucias como ...

• Validar que tengo el número correcto de argumentos posicionales independientemente de los interruptores pasados ​​( arghash.argc == 2 )
• Acceda a los argumentos posicionales por su posición relativa, independientemente de los interruptores que aparezcan antes o intercalados con argumentos posicionales (por ejemplo, arghash[1]siempre obtiene el segundo argumento que no es el interruptor).
• Admite conmutadores de valor asignado en la línea de comando, como "--max = 15", a los que se puede acceder mediante arghash['--max='] cual se obtiene un valor de '15' dada la línea de comando de ejemplo.
• Pruebe la presencia o ausencia de un conmutador en la línea de comando utilizando una notación muy simple, como arghash['-s']que se evalúa como verdadero si está presente y nulo si está ausente.

• Pruebe la presencia de un interruptor o alternativas de interruptores usando operaciones establecidas como

  puts USAGETEXT if !(%w(-h --help) & arghash.switches()).empty?

• Identificar el uso de interruptores no válidos mediante operaciones de configuración como

  puts "Invalid switch found!" if !(arghash.switches - %w(-valid1 -valid2)).empty?

• Especifique los valores predeterminados para los argumentos que faltan usando un Hash.merge()ejemplo simple como el siguiente, que completa un valor para -max = si no se estableció uno y agrega un cuarto argumento posicional si no se pasó uno.

  with_defaults = {'-max=' => 20, 3 => 'default.txt'}.merge(arghash)

Esto es muy similar a la respuesta aceptada, pero usando ARGV.delete_ifcuál es lo que uso en mi analizador simple . La única diferencia real es que las opciones con argumentos deben estar juntas (p -l=file. Ej .).

def usage
  "usage: #{File.basename($0)}: [-l=<logfile>] [-q] file ..."
end

$quiet = false
$logfile = nil

ARGV.delete_if do |cur|
  next false if cur[0] != '-'
  case cur
  when '-q'
    $quiet = true
  when /^-l=(.+)$/
    $logfile = $1
  else
    $stderr.puts "Unknown option: #{cur}"
    $stderr.puts usage
    exit 1
  end
end

puts "quiet: #{$quiet} logfile: #{$logfile.inspect} args: #{ARGV.inspect}"

Aparentemente @WilliamMorgan y yo pensamos igual. Acabo de publicar anoche en Github lo que ahora veo es una biblioteca similar a Trollop (¿nombrada cómo?) Después de haber hecho una búsqueda de OptionParser en Github, consulte Switches

Hay algunas diferencias, pero la filosofía es la misma. Una diferencia obvia es que Switches depende de OptionParser.

Estoy desarrollando mi propia gema de analizador de opciones llamada Acclaim .

Lo escribí porque quería crear interfaces de línea de comandos de estilo git y poder separar limpiamente la funcionalidad de cada comando en clases separadas, pero también se puede usar sin el marco de comandos completo:

(options = []) << Acclaim::Option.new(:verbose, '-v', '--verbose')
values = Acclaim::Option::Parser.new(ARGV, options).parse!
puts 'Verbose.' if values.verbose?

Aún no hay una versión estable, pero ya he implementado algunas características como:

• analizador de opciones personalizadas
• análisis flexible de los argumentos de la opción que permite tanto el mínimo como el opcional
• soporte para muchos estilos de opciones
• reemplazar, agregar o aumentar en múltiples instancias de la misma opción
• controladores de opciones personalizadas
• controladores de tipo personalizado
• controladores predefinidos para las clases de biblioteca estándar comunes

Hay mucho énfasis en los comandos, por lo que puede ser un poco pesado para el análisis simple de la línea de comandos, pero funciona bien y lo he estado usando en todos mis proyectos. Si está interesado en el aspecto de la interfaz de comandos, consulte la página de GitHub del proyecto para obtener más información y ejemplos.

Suponga que un comando tiene como máximo una acción y un número arbitrario de opciones como esta:

cmd.rb
cmd.rb action
cmd.rb action -a -b ...
cmd.rb action -ab ...

El análisis sin validación puede ser así:

ACTION = ARGV.shift
OPTIONS = ARGV.join.tr('-', '')

if ACTION == '***'
  ...
  if OPTIONS.include? '*'
    ...
  end
  ...
end

https://github.com/soveran/clap

other_args = Clap.run ARGV,
  "-s" => lambda { |s| switch = s },
  "-o" => lambda { other = true }

46LOC (en 1.0.0), sin dependencia del analizador de opciones externo. Hace el trabajo. Probablemente no sea tan completo como otros, pero es 46LOC.

Si verifica el código, puede duplicar con bastante facilidad la técnica subyacente: asigne lambdas y use la aridad para asegurarse de que el número adecuado de argumentos siga la marca si realmente no desea una biblioteca externa.

Sencillo. Barato.

EDITAR : el concepto subyacente se redujo, ya que supongo que podría copiarlo / pegarlo en un script para hacer un analizador de línea de comando razonable. Definitivamente no es algo que me gustaría memorizar, pero usar el lambda arity como un analizador barato es una idea novedosa:

flag = false
option = nil
opts = {
  "--flag" => ->() { flag = true },
  "--option" => ->(v) { option = v }
}

argv = ARGV
args = []

while argv.any?
  item = argv.shift
  flag = opts[item]

  if flag
    raise ArgumentError if argv.size < arity
    flag.call(*argv.shift(arity))
  else
    args << item
  end
end

# ...do stuff...

Voy a compartir mi propio analizador de opciones simple en el que he estado trabajando durante algún tiempo. Son solo 74 líneas de código, y hace lo básico de lo que hace el analizador de opciones interno de Git. Tomé OptionParser como inspiración, y también la de Git.

https://gist.github.com/felipec/6772110

Se parece a esto:

opts = ParseOpt.new
opts.usage = "git foo"

opts.on("b", "bool", help: "Boolean") do |v|
 $bool = v
end

opts.on("s", "string", help: "String") do |v|
 $str = v
end

opts.on("n", "number", help: "Number") do |v|
 $num = v.to_i
end

opts.parse

EasyOptions no requiere ningún código de análisis de opciones. Simplemente escriba el texto de ayuda, requiera, listo.

## Options:
##   -i, --interactive  Interactive mode
##   -q, --quiet        Silent mode

require 'easyoptions'
unless EasyOptions.options[:quiet]
    puts 'Interactive mode enabled' if EasyOptions.options[:interactive]
    EasyOptions.arguments.each { |item| puts "Argument: #{item}" }
end