Analyser les arguments de ligne de commande dans un script Ruby

En fonction de la réponse par @MartinCortez voici un court one-off qui fait un hachage de paires clé/valeur, où les valeurs doivent être jointes avec un = signe. Il prend également en charge le drapeau des arguments sans valeurs:

args = Hash[ ARGV.join(' ').scan(/--?([^=\s]+)(?:=(\S+))?/) ]

...ou sinon...

args = Hash[ ARGV.flat_map{|s| s.scan(/--?([^=\s]+)(?:=(\S+))?/) } ]

Appelé avec -x=foo -h --jim=jam il retourne {"x"=>"foo", "h"=>nil, "jim"=>"jam"} de sorte que vous pouvez faire des choses comme:

puts args['jim'] if args.key?('h')
#=> jam

Bien qu'il existe plusieurs bibliothèques pour gérer ce—y compris GetoptLong fourni avec Ruby—personnellement, je préfère rouler mes propres. Voici le modèle que j'utilise, ce qui la rend raisonnablement générique, non lié à une utilisation spécifique de format, et suffisamment souple pour permettre mélangés les drapeaux, les options et les arguments requis dans différents ordres:

USAGE = <<ENDUSAGE
Usage:
docubot [-h] [-v] [create [-s shell] [-f]] directory [-w writer] [-o output_file] [-n] [-l log_file]
ENDUSAGE
HELP = <<ENDHELP
-h, --help       Show this help.
-v, --version    Show the version number (#{DocuBot::VERSION}).
create           Create a starter directory filled with example files;
also copies the template for easy modification, if desired.
-s, --shell      The shell to copy from.
Available shells: #{DocuBot::SHELLS.join(', ')}
-f, --force      Force create over an existing directory,
deleting any existing files.
-w, --writer     The output type to create [Defaults to 'chm']
Available writers: #{DocuBot::Writer::INSTALLED_WRITERS.join(', ')}
-o, --output     The file or folder (depending on the writer) to create.
[Default value depends on the writer chosen.]
-n, --nopreview  Disable automatic preview of .chm.
-l, --logfile    Specify the filename to log to.
ENDHELP
ARGS = { :shell=>'default', :writer=>'chm' } # Setting default values
UNFLAGGED_ARGS = [ :directory ]              # Bare arguments (no flag)
next_arg = UNFLAGGED_ARGS.first
ARGV.each do |arg|
case arg
when '-h','--help'      then ARGS[:help]      = true
when 'create'           then ARGS[:create]    = true
when '-f','--force'     then ARGS[:force]     = true
when '-n','--nopreview' then ARGS[:nopreview] = true
when '-v','--version'   then ARGS[:version]   = true
when '-s','--shell'     then next_arg = :shell
when '-w','--writer'    then next_arg = :writer
when '-o','--output'    then next_arg = :output
when '-l','--logfile'   then next_arg = :logfile
else
if next_arg
ARGS[next_arg] = arg
UNFLAGGED_ARGS.delete( next_arg )
end
next_arg = UNFLAGGED_ARGS.first
end
end
puts "DocuBot v#{DocuBot::VERSION}" if ARGS[:version]
if ARGS[:help] or !ARGS[:directory]
puts USAGE unless ARGS[:version]
puts HELP if ARGS[:help]
exit
end
if ARGS[:logfile]
$stdout.reopen( ARGS[:logfile], "w" )
$stdout.sync = true
$stderr.reopen( $stdout )
end
# etc.

Personnellement, je utiliser Docopt. C'est beaucoup plus clair, plus facile à gérer et plus facile à faire de la lecture.

Ont un look à en ligne Ruby mise en œuvre doc pour des exemples. L'utilisation est vraiment simple.

gem install docopt

Code Ruby:

doc = <<DOCOPT
My program who says hello
Usage:
#{__FILE__} --first_name=<first_name> --last_name=<last_name>
DOCOPT
begin
args = Docopt::docopt(doc)
rescue Docopt::Exit => e
puts e.message
exit
end
print "Hello #{args['--first_name']} #{args['--last_name']}"

Puis de l'appel:

$ ./says_hello.rb --first_name=Homer --last_name=Simpsons
Hello Homer Simpsons

Et sans arguments :

$ ./says_hello.rb
Usage:
says_hello.rb --first_name=<first_name> --last_name=<last_name>

Une version améliorée qui gère les arguments qui ne sont pas les options, les arguments avec un paramètre, et -a ainsi que --a.

def parse(args)
parsed = {}
args.each do |arg|
match = /^-?-(?<key>.*?)(=(?<value>.*)|)$/.match(arg)
if match
parsed[match[:key].to_sym] = match[:value]
else
parsed[:text] = "#{parsed[:text]} #{arg}".strip
end
end
parsed
end