¿Cómo se especifica un cambio obligatorio(no argumento) con Ruby OptionParser?

arguments

Question

Estoy escribiendo un script y quiero requerir un --host switch con valor, pero si el parámetro --host no está especificado, quiero que el análisis de la opción falle.

Parece que no puedo entender cómo hacerlo. Los documentos parecen solo especificar cómo hacer obligatorio el valor del argumento, no el interruptor en sí.

Answer 1

Convertí esto en una joya que puedes descargar e instalar desde rubygems.org:

gem install pickled_optparse

Y puede consultar el código fuente del proyecto actualizado en github:
http://github.com/PicklePumpers/pickled_optparse

- Información anterior de la publicación -

Esto realmente me estaba molestando, así que lo arreglé y mantuve el uso súper seco.

Para hacer un cambio requerido simplemente agregue un símbolo: requerido en cualquier lugar de la matriz de opciones, como sigue:

opts.on("-f", "--foo [Bar]", String, :required, "Some required option") do |option|
@options[:foo] = option
end

Luego, al final de su bloque OptionParser, agregue uno de estos para imprimir los interruptores faltantes y las instrucciones de uso:

if opts.missing_switches?
puts opts.missing_switches
puts opts
exit
end

Y finalmente, para que todo funcione, debes agregar el siguiente archivo "optparse_required_switches.rb" a tu proyecto en algún lugar y requerirlo cuando hagas tu análisis de línea de comando.

Escribí un pequeño artículo con un ejemplo en mi blog: picklepumpers.com/wordpress/?p=949

Y aquí está el archivo OptionParser modificado con un ejemplo de su uso:

required_switches_example.rb

#!/usr/bin/env ruby
require ''optparse''
require_relative ''optparse_required_switches''
# Configure options based on command line options
@options = {}
OptionParser.new do |opts|
opts.banner = "Usage: test [options] in_file[.srt] out_file[.srt]"
# Note that :required can be anywhere in the parameters
# Also note that OptionParser is bugged and will only check
# for required parameters on the last option, not my bug.
# required switch, required parameter
opts.on("-s Short", String, :required, "a required switch with just a short") do |operation|
@options[:operation] = operation
end
# required switch, optional parameter
opts.on(:required, "--long [Long]", String, "a required switch with just a long") do |operation|
@options[:operation] = operation
end
# required switch, required parameter
opts.on("-b", "--both ShortAndLong", String, "a required switch with short and long", :required) do |operation|
@options[:operation] = operation
end
# optional switch, optional parameter
opts.on("-o", "--optional [Whatever]", String, "an optional switch with short and long") do |operation|
@options[:operation] = operation
end
# Now we can see if there are any missing required
# switches so we can alert the user to what they
# missed and how to use the program properly.
if opts.missing_switches?
puts opts.missing_switches
puts opts
exit
end
end.parse!

optparse_required_switches.rb

# Add required switches to OptionParser
class OptionParser
# An array of messages describing the missing required switches
attr_reader :missing_switches
# Convenience method to test if we''re missing any required switches
def missing_switches?
!@missing_switches.nil?
end
def make_switch(opts, block = nil)
short, long, nolong, style, pattern, conv, not_pattern, not_conv, not_style = [], [], []
ldesc, sdesc, desc, arg = [], [], []
default_style = Switch::NoArgument
default_pattern = nil
klass = nil
n, q, a = nil
# Check for required switches
required = opts.delete(:required)
opts.each do |o|
# argument class
next if search(:atype, o) do |pat, c|
klass = notwice(o, klass, ''type'')
if not_style and not_style != Switch::NoArgument
not_pattern, not_conv = pat, c
else
default_pattern, conv = pat, c
end
end
# directly specified pattern(any object possible to match)
if (!(String === o || Symbol === o)) and o.respond_to?(:match)
pattern = notwice(o, pattern, ''pattern'')
if pattern.respond_to?(:convert)
conv = pattern.method(:convert).to_proc
else
conv = SPLAT_PROC
end
next
end
# anything others
case o
when Proc, Method
block = notwice(o, block, ''block'')
when Array, Hash
case pattern
when CompletingHash
when nil
pattern = CompletingHash.new
conv = pattern.method(:convert).to_proc if pattern.respond_to?(:convert)
else
raise ArgumentError, "argument pattern given twice"
end
o.each {|pat, *v| pattern[pat] = v.fetch(0) {pat}}
when Module
raise ArgumentError, "unsupported argument type: #{o}", ParseError.filter_backtrace(caller(4))
when *ArgumentStyle.keys
style = notwice(ArgumentStyle[o], style, ''style'')
when /^--no-([^/[/]=/s]*)(.+)?/
q, a = $1, $2
o = notwice(a ? Object : TrueClass, klass, ''type'')
not_pattern, not_conv = search(:atype, o) unless not_style
not_style = (not_style || default_style).guess(arg = a) if a
default_style = Switch::NoArgument
default_pattern, conv = search(:atype, FalseClass) unless default_pattern
ldesc << "--no-#{q}"
long << ''no-'' + (q = q.downcase)
nolong << q
when /^--/[no-/]([^/[/]=/s]*)(.+)?/
q, a = $1, $2
o = notwice(a ? Object : TrueClass, klass, ''type'')
if a
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
ldesc << "--[no-]#{q}"
long << (o = q.downcase)
not_pattern, not_conv = search(:atype, FalseClass) unless not_style
not_style = Switch::NoArgument
nolong << ''no-'' + o
when /^--([^/[/]=/s]*)(.+)?/
q, a = $1, $2
if a
o = notwice(NilClass, klass, ''type'')
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
ldesc << "--#{q}"
long << (o = q.downcase)
when /^-(/[/^?/]?(?:[^///]]|//.)*/])(.+)?/
q, a = $1, $2
o = notwice(Object, klass, ''type'')
if a
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
sdesc << "-#{q}"
short << Regexp.new(q)
when /^-(.)(.+)?/
q, a = $1, $2
if a
o = notwice(NilClass, klass, ''type'')
default_style = default_style.guess(arg = a)
default_pattern, conv = search(:atype, o) unless default_pattern
end
sdesc << "-#{q}"
short << q
when /^=/
style = notwice(default_style.guess(arg = o), style, ''style'')
default_pattern, conv = search(:atype, Object) unless default_pattern
else
desc.push(o)
end
end
default_pattern, conv = search(:atype, default_style.pattern) unless default_pattern
if !(short.empty? and long.empty?)
s = (style || default_style).new(pattern || default_pattern, conv, sdesc, ldesc, arg, desc, block)
elsif !block
if style or pattern
raise ArgumentError, "no switch given", ParseError.filter_backtrace(caller)
end
s = desc
else
short << pattern
s = (style || default_style).new(pattern, conv, nil, nil, arg, desc, block)
end
# Make sure required switches are given
if required && !(default_argv.include?("-#{short[0]}") || default_argv.include?("--#{long[0]}"))
@missing_switches ||= [] # Should be placed in initialize if incorporated into Ruby proper
# This is more clear but ugly and long.
#missing = "-#{short[0]}" if !short.empty?
#missing = "#{missing} or " if !short.empty? && !long.empty?
#missing = "#{missing}--#{long[0]}" if !long.empty?
# This is less clear and uglier but shorter.
missing = "#{"-#{short[0]}" if !short.empty?}#{" or " if !short.empty? && !long.empty?}#{"--#{long[0]}" if !long.empty?}"
@missing_switches << "Missing switch: #{missing}"
end
return s, short, long,
(not_style.new(not_pattern, not_conv, sdesc, ldesc, nil, desc, block) if not_style),
nolong
end
end

Answer 2

La idea es definir un OptionParser , ¡luego parse! y lo puts si faltan algunos campos. Establecer filename de filename para cadena vacía de forma predeterminada probablemente no sea la mejor manera de hacerlo, pero usted tuvo la idea.

require ''optparse''
filename = ''''
options = OptionParser.new do |opts|
opts.banner = "Usage: swift-code-style.rb [options]"
opts.on("-iNAME", "--input-filename=NAME", "Input filename") do |name|
filename = name
end
opts.on("-h", "--help", "Prints this help") do
puts opts
exit
end
end
options.parse!
if filename == ''''
puts "Missing filename./n---/n"
puts options
exit
end
puts "Processing ''#{filename}''..."

Si falta el -i filename , se muestra:

~/prj/gem/swift-code-kit ./swift-code-style.rb
Missing filename.
---
Usage: swift-code-style.rb [options]
-i, --input-filename=NAME Input filename
-h, --help Prints this help

Answer 3

La respuesta de unknown (google) es buena, pero contiene un error menor.

rescue OptionParser::InvalidArgument, OptionParser::MissingArgument

debiera ser

OptionParser::InvalidOption, OptionParser::MissingArgument

De lo contrario, optparse.parse! activará la salida de error estándar para OptionParser::InvalidOption , no el mensaje personalizado.

Answer 4

Se me ocurrió una solución clara y concisa que resume sus contribuciones. OptionParser::MissingArgument excepción OptionParser::MissingArgument con los argumentos faltantes como un mensaje. Esta excepción queda atrapada en el bloque de rescue junto con el resto de excepciones provenientes de OptionParser .

#!/usr/bin/env ruby
require ''optparse''
options = {}
optparse = OptionParser.new do |opts|
opts.on(''-h'', ''--host hostname'', "Host name") do |host|
options[:host] = host
end
end
begin
optparse.parse!
mandatory = [:host]
missing = mandatory.select{ |param| options[param].nil? }
raise OptionParser::MissingArgument, missing.join('', '') unless missing.empty?
rescue OptionParser::ParseError => e
puts e
puts optparse
exit
end

Ejecutando este ejemplo:

 ./program
missing argument: host
Usage: program [options]
-h, --host hostname Host name

Answer 5

Si haces algo como esto:

opts.on(''-h'', ''--host'',
''required host name [STRING]'') do |h|
someoptions[:host] = h || nil
end

Entonces el someoptions[:host] será el valor de la línea de comandos o nil (si no proporciona --host y / o no value después de --host) y puede probarlo fácilmente (y condicionalmente fallar) después el análisis:

fail "Hostname not provided" unless someoptions[:host]

Answer 6

Si se requiere un host , seguramente no es una opción , es un argumento .

Con eso en mente, aquí hay una manera de resolver su problema. Puede interrogar a la matriz ARGV para ver si se ha especificado un host y, si no lo ha sido, entonces call abort("You must specify a host!") , o similar, para que su programa se cierre con un estado de error .

Answer 7

Supongo que está utilizando optparse aquí, aunque la misma técnica funcionará para otras bibliotecas de análisis de opciones.

El método más simple es probablemente analizar los parámetros usando la biblioteca de análisis de opciones elegida y luego generar una excepción OptionParser :: MissingArgument si el valor de host es nulo.

El siguiente código ilustra

#!/usr/bin/env ruby
require ''optparse''
options = {}
optparse = OptionParser.new do |opts|
opts.on(''-h'', ''--host HOSTNAME'', "Mandatory Host Name") do |f|
options[:host] = f
end
end
optparse.parse!
#Now raise an exception if we have not found a host option
raise OptionParser::MissingArgument if options[:host].nil?
puts "Host = #{options[:host]}"

Ejecutando este ejemplo con una línea de comando de

./program -h somehost

pantallas simples "Host = somehost"

Mientras se ejecuta con una falta -h y sin nombre de archivo produce la siguiente salida

./program:15: missing argument: (OptionParser::MissingArgument)

Y ejecutar con una línea de comando de ./program -h produce

/usr/lib/ruby/1.8/optparse.rb:451:in `parse'': missing argument: -h (OptionParser::MissingArgument)
from /usr/lib/ruby/1.8/optparse.rb:1288:in `parse_in_order''
from /usr/lib/ruby/1.8/optparse.rb:1247:in `catch''
from /usr/lib/ruby/1.8/optparse.rb:1247:in `parse_in_order''
from /usr/lib/ruby/1.8/optparse.rb:1241:in `order!''
from /usr/lib/ruby/1.8/optparse.rb:1332:in `permute!''
from /usr/lib/ruby/1.8/optparse.rb:1353:in `parse!''
from ./program:13

Answer 8

Un enfoque que usa optparse que proporciona resultados amigables en interruptores faltantes:

#!/usr/bin/env ruby
require ''optparse''
options = {}
optparse = OptionParser.new do |opts|
opts.on(''-f'', ''--from SENDER'', ''username of sender'') do |sender|
options[:from] = sender
end
opts.on(''-t'', ''--to RECIPIENTS'', ''comma separated list of recipients'') do |recipients|
options[:to] = recipients
end
options[:number_of_files] = 1
opts.on(''-n'', ''--num_files NUMBER'', Integer, "number of files to send (default #{options[:number_of_files]})") do |number_of_files|
options[:number_of_files] = number_of_files
end
opts.on(''-h'', ''--help'', ''Display this screen'') do
puts opts
exit
end
end
begin
optparse.parse!
mandatory = [:from, :to] # Enforce the presence of
missing = mandatory.select{ |param| options[param].nil? } # the -t and -f switches
unless missing.empty? #
raise OptionParser::MissingArgument.new(missing.join('', '')) #
end #
rescue OptionParser::InvalidOption, OptionParser::MissingArgument #
puts $!.to_s # Friendly output when parsing fails
puts optparse #
exit #
end #
puts "Performing task with options: #{options.inspect}"

La ejecución sin los conmutadores -t o -f muestra el siguiente resultado:

Missing options: from, to
Usage: test_script [options]
-f, --from SENDER username of sender
-t, --to RECIPIENTS comma separated list of recipients
-n, --num_files NUMBER number of files to send (default 1)
-h, --help

Ejecutar el método de análisis en una cláusula de inicio / rescate permite un formato amigable ante otras fallas, como argumentos faltantes o valores de cambio no válidos, por ejemplo, intente pasar una cadena para el -n .