O Ruby vem equipado com uma ferramenta poderosa e flexível para analisar as opções de linha de comando, OptionParser. Depois de aprender a usar isso, você nunca mais voltará a examinar o ARGV manualmente. O OptionParser possui vários recursos que o tornam bastante atraente para os programadores de Ruby. Se você já analisou as opções manualmente em Ruby ou C, ou com o getoptlong C, você verá como algumas dessas alterações são bem-vindas.
- OptionParser é SECO. Você só precisa escrever a opção de linha de comando, seus argumentos, o código a ser executado quando for encontrado e a descrição da opção de linha de comando uma vez em seu script. O OptionParser irá gerar automaticamente telas de ajuda para você a partir dessa descrição, além de inferir tudo sobre o argumento a partir de sua descrição. Por exemplo, ele saberá o --arquivo [ARQUIVO] A opção é opcional e utiliza um único argumento. Além disso, saberá que - [- no] -verbose é realmente duas opções e aceitará ambas as formas.
- OptionParser converterá automaticamente opções para uma classe específica. Se a opção usar um número inteiro, poderá converter qualquer seqüência passada na linha de comando em um número inteiro. Isso reduz parte do tédio envolvido na análise das opções da linha de comando.
- Tudo está muito contido. Todas as opções estão no mesmo lugar, e o efeito da opção fica ao lado da definição da opção. Se for necessário adicionar, alterar opções ou alguém simplesmente quiser ver o que faz, existe apenas um lugar para procurar. Depois que a linha de comando é analisada, um único Hash ou OpenStruct manterá os resultados.
Já basta, mostre-me algum código
Então, aqui está um exemplo simples de como usar OptionParser. Ele não usa nenhum dos recursos avançados, apenas o básico. Existem três opções, e uma delas aceita um parâmetro. Todas as opções são obrigatórias. Existem os -v / - detalhado e -q / - rápido opções, bem como as -l / - arquivo de log opção. Além disso, o script leva uma lista de arquivos independentemente das opções.
#! / usr / bin / env ruby
# Um script que fingirá redimensionar várias imagens
requer 'optparse'
# Este hash conterá todas as opções
# analisado na linha de comando por
# OptionParser.
options = {}
optparse = OptionParser.new do | opts |
# Defina um banner, exibido na parte superior
# da tela de ajuda.
opts.banner = "Uso: optparse1.rb [opções] arquivo1 arquivo2 ..."
# Defina as opções e o que elas fazem
opções [: detalhado] = false
opts.on ('-v', '--verbose', 'Output more information')
opções [: detalhado] = true
fim
opções [: rápido] = falso
opts.on ('-q', '--quick', 'Execute a tarefa rapidamente') faça
opções [: rápido] = verdadeiro
fim
opções [: arquivo de log] = nulo
opts.on ('-l', '--logfile FILE', 'Write log to FILE') do | arquivo |
options [: logfile] = arquivo
fim
# Isso exibe a tela de ajuda, todos os programas são
# assumiu ter essa opção.
opts.on ('-h', '--help', 'Exibir esta tela')
coloca opta
Saída
fim
fim
# Analise a linha de comando. Lembre-se de que existem duas formas
# do método de análise. O método 'analisar' simplesmente analisa
# ARGV, enquanto o 'parse!' O método analisa o ARGV e remove
# quaisquer opções encontradas lá, bem como parâmetros para
# as opções. O que resta é a lista de arquivos para redimensionar.
optparse.parse!
coloca "Sendo detalhado" se opções [: detalhado]
coloca "Ser rápido" se as opções [: rápido]
coloca "Registrando no arquivo # {options [: logfile]}" se options [: logfile]
ARGV.each do | f |
coloca "Redimensionando a imagem # {f} ..."
sono 0.5
fim
Examinando o código
Para começar, o optparse biblioteca é necessária. Lembre-se, este não é um gema. Ele vem com Ruby, então não há necessidade de instalar uma gema ou exigir rubygems antes optparse.
Existem dois objetos interessantes nesse script. O primeiro é opções, declarado no escopo superior. É um simples vazio cerquilha. Quando as opções são definidas, eles escrevem seus valores padrão nesse hash. Por exemplo, o comportamento padrão é esse script não ser detalhado, então opções [: detalhado] está definido como falso. Quando opções são encontradas na linha de comando, elas alteram os valores em opções para refletir seus efeitos. Por exemplo, quando -v / - detalhado for encontrado, ele atribuirá true a opções [: detalhado].
O segundo objeto interessante é optparse. Isto é o OptionParser próprio objeto. Quando você constrói esse objeto, passa um bloco para ele. Esse bloco é executado durante a construção e cria uma lista de opções nas estruturas de dados internas e se prepara para analisar tudo. É neste bloco que toda a mágica acontece. Você define todas as opções aqui.
Definindo Opções
Cada opção segue o mesmo padrão. Primeiro, você escreve o valor padrão no hash. Isso acontecerá assim que o OptionParser É construído. Em seguida, você chama o emmétodo, que define a opção em si. Existem várias formas desse método, mas apenas uma é usada aqui. Os outros formulários permitem definir conversões de tipo automáticas e conjuntos de valores aos quais uma opção está restrita. Os três argumentos usados aqui são a forma abreviada, a forma longa e a descrição da opção.
o em O método inferirá várias coisas da forma longa. Uma coisa é inferir é a presença de quaisquer parâmetros. Se houver algum parâmetro presente na opção, ele passará como parâmetro para o bloco.
Se a opção for encontrada na linha de comandos, o bloco passado para o em método é executado. Aqui, os blocos não fazem muito, apenas definem valores no hash das opções. Mais poderia ser feito, como verificar se existe um arquivo referido, etc. Se houver algum erro, exceções podem ser lançadas nesses blocos.
Finalmente, a linha de comando é analisada. Isso acontece chamando o analisar! método em um OptionParser objeto. Na verdade, existem duas formas desse método, analisar e analisar!. Como a versão com o ponto de exclamação implica, é destrutiva. Ele não apenas analisa a linha de comando, mas também remove todas as opções encontradas em ARGV. Isso é importante, deixará apenas a lista de arquivos fornecidos após as opções em ARGV.