Utilisation d'OptionParser pour analyser les commandes dans Ruby

Dans l'article sur les fonctionnalités d'OptionParser, nous avons discuté de certaines des raisons qui rendent l'utilisation d'OptionParser dans Ruby préférable à la recherche manuelle dans ARGV pour analyser les commandes à la main. Il est maintenant temps d'apprendre à utiliser OptionParser et ses fonctionnalités.

Le code passe-partout suivant sera utilisé pour tous les exemples de ce didacticiel. Pour essayer l'un des exemples, il suffit de mettre l'exemple opts.on bloc à côté du commentaire TODO. L'exécution du programme affichera l'état des options a et ARGV, vous permettant d'examiner les effets de vos commutateurs.

#! / usr / bin / env rubis
exiger 'optparse'
nécessite 'pp'
# Ce hachage contiendra toutes les options
# analysé depuis la ligne de commande par
# OptionParser.
options =
optparse = OptionParser.new do | opts |
# TODO: Mettez les options de ligne de commande ici
# Ceci affiche l'écran d'aide, tous les programmes sont
# supposé avoir cette option.
opts.on ('-h', '--help', 'Afficher cet écran') do
met opts
sortie
fin
fin
# Analyser la ligne de commande. N'oubliez pas qu'il existe deux formes
# de la méthode d'analyse. La méthode 'parse' analyse simplement
# ARGV, tandis que le 'parse!' la méthode analyse ARGV et supprime
# toutes les options qui s'y trouvent, ainsi que tous les paramètres pour
# les options. Ce qui reste est la liste des fichiers à redimensionner.
optparse.parse!
pp "Options:", options
pp "ARGV:", ARGV

Interrupteur simple

Un simple commutateur est un argument sans formulaire facultatif ni paramètre. L'effet sera de simplement définir un drapeau dans le hachage des options. Aucun autre paramètre ne sera transmis au sur méthode.

options [: simple] = false
opts.on ('-s', '--simple', "Argument simple") do
options [: simple] = true
fin

Commutateur avec paramètre obligatoire

Les commutateurs qui prennent un paramètre doivent uniquement indiquer le nom du paramètre sous la forme longue du commutateur. Par exemple, "-f", "--file FILE" signifie que le commutateur -f ou --file prend un seul paramètre appelé FILE, et ce paramètre est obligatoire. Vous ne pouvez pas utiliser -f ou --file sans lui passer également un paramètre.

options [: mand] = ""
opts.on ('-m', '--mandatory FILE', "Mandatory argument") do | f |
options [: mand] = f
fin

Commutateur avec paramètre facultatif

Les paramètres de commutation n'ont pas à être obligatoires, ils peuvent être facultatifs. Pour déclarer un paramètre de commutateur facultatif, placez son nom entre crochets dans la description du commutateur. Par exemple, "--logfile [FILE]" signifie que le paramètre FILE est facultatif. S'il n'est pas fourni, le programme assumera une valeur par défaut saine, comme un fichier appelé log.txt.

Dans l'exemple, l'idiome a = b || c est utilisé. C'est juste un raccourci pour "a = b, mais si b est faux ou nul, a = c".

options [: opt] = false
opts.on ('-o', '--optional [OPT]', "Argument optionnel") do | f |
options [: opt] = f || "rien"
fin

Convertir automatiquement en flottant

OptionParser peut convertir automatiquement l'argument en certains types. Un de ces types est Float. Pour convertir automatiquement vos arguments en un commutateur sur Float, passez Float au sur méthode après vos chaînes de description de commutateur.

Les conversions automatiques sont pratiques. Non seulement ils vous épargnent l'étape de conversion de la chaîne au type souhaité, mais vérifient également le format pour vous et lèveront une exception si elle est formatée incorrectement.

options [: float] = 0.0
opts.on ('-f', '--float NUM', Float, "Convert to float") do | f |
options [: float] = f
fin

Certains autres types que OptionParser peut convertir pour inclure automatiquement Time et Integer.

Listes d'arguments

Les arguments peuvent être interprétés comme des listes. Cela peut être considéré comme une conversion en tableau, comme vous l'avez converti en Float. Alors que votre chaîne d'options peut définir le paramètre à appeler "a, b, c", OptionParser autorisera aveuglément n'importe quel nombre d'éléments de la liste. Donc, si vous avez besoin d'un nombre spécifique d'éléments, assurez-vous de vérifier vous-même la longueur du tableau.

options [: list] = []
opts.on ('-l', '--list a, b, c', Array, "Liste des paramètres") do | l |
options [: liste] = l
fin

Ensemble d'arguments

Parfois, il est logique de limiter les arguments à un passage à quelques choix. Par exemple, le commutateur suivant ne prendra qu'un seul paramètre obligatoire et le paramètre doit être l'un des Oui, non ou peut être. Si le paramètre est autre chose, une exception sera levée.

Pour ce faire, passez une liste de paramètres acceptables sous forme de symboles après les chaînes de description du commutateur.

options [: set] =: oui
opts.on ('-s', '--set OPT', [: oui,: non,: peut-être], "Paramètres d'un ensemble") do | s |
options [: set] = s
fin

Formes négatives

Les commutateurs peuvent avoir une forme négative. L'interrupteur --nié peut en avoir un qui fait l'effet inverse, appelé --non-nié. Pour décrire cela dans la chaîne de description du commutateur, placez la partie alternative entre crochets: --[no-] nié. Si le premier formulaire est rencontré, true sera transmis au bloc et false sera bloqué si le second formulaire est rencontré.

options [: neg] = false
opts.on ('-n', '- [no-] negated', "Formes négatives") do | n |
options [: neg] = n
fin