Option de ligne de commande vraiment pas cher, l’analyse en Ruby

Question

Parfois, je veux à très bon marché, hack certaines options de ligne de commande dans un script simple. Une façon amusante de le faire, sans traiter getopts ou de l'analyse ou de quoi que ce soit, est:

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

Ce n'est pas tout à fait normal Unix syntaxe des options, car il va accepter les options non-option paramètres de ligne de commande, comme dans "myprog -i foo bar -q", mais je peux vivre avec ça. (Certaines personnes, comme par exemple la Subversion développeurs préfèrent cette. Parfois, je le fais aussi).

Une option qui est tout simplement la présence ou l'absence ne peut pas être mis en œuvre de façon beaucoup plus simple que le précédent. (Une affectation, un appel de fonction, un effet de bord.) Est-il aussi un moyen simple de traiter avec des options qui prend un paramètre, tel que "-f nom de fichier"?

EDIT:

Un point que je n'ai pas fait plus tôt, car il n'était pas devenu clair pour moi jusqu'à ce que l'auteur de Gourgandine mentionné que la bibliothèque tenir "dans un [800-ligne] fichier," c'est que je suis à la recherche non seulement pour le nettoyage de la syntaxe, mais une technique qui a les caractéristiques suivantes:

1. L'intégralité du code peuvent être inclus dans le fichier de script (sans submerger le script lui-même, qui peut être seulement un couple de douzaine de lignes), de sorte que l'on peut supprimer un seul fichier dans un bin dir sur n'importe quel système avec un standard de Ruby 1.8.[5-7] installation et d'utilisation, il

2. Le code est petit et assez simple que l'on peut se rappeler assez pour taper directement dans le code qui fera l'affaire, plutôt que de couper et coller à partir de quelque part d'autre. Pensez à la situation où vous vous trouvez sur la console d'un pare-feu rompre avec aucun accès à Internet, et que vous voulez jeter un rapide script pour un client à utiliser.

Answer 1

Je partage votre dégoût pour , principalement pour l’awesomeness qui est :

Answer 2

Voici la technique que j’utilise habituellement :

Answer 3

Puisque personne ne semble le mentionner, et le titre ne reportez-vous à bas prix en ligne de commande de l'analyse, pourquoi ne pas simplement laisser l'interpréteur ruby faire le travail pour vous? Si vous passez l' -s switch (dans votre arborescence, par exemple), vous obtenez la saleté de simples contacts gratuitement, attribué à une seule lettre de variables globales. Voici l'exemple d'utilisation de ce commutateur:

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

Et voici la sortie lorsque j'enregistre que ./test et la commande chmod +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"]

Voir ruby -h pour plus de détails. :)

Qui doit être aussi bon marché qu'il obtient. Il va soulever une NameError si vous essayez un commutateur, comme -:, donc il y a la validation de certains. Bien sûr, vous ne pouvez pas avoir tous les interrupteurs après un non-switch argument, mais si vous avez besoin de quelque chose de fantaisie, vous devez vraiment être à l'aide d'au minimum OptionParser. En fait, la seule chose qui me dérange à propos de cette technique est que vous aurez un avertissement (si vous avez activé) lors de l'accès à un unset variable globale, mais il est encore falsey, de sorte qu'il fonctionne parfaitement pour du jetable outils et rapide des scripts.

Answer 4

J'ai construit des micro-optparse pour combler ce besoin évident pour une courte, mais facile à utiliser l'option-analyseur. Il a une syntaxe similaire à la Gourgandine et est de 70 lignes courtes. Si vous n'avez pas besoin de validations et peut faire sans les lignes vides, vous pouvez le couper à 45 lignes. Je pense que c'est exactement ce que vous cherchez.

Petit exemple:

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!

L'appel du script avec -h ou --help sera imprimée

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

Il vérifie si l'entrée est du même type que la valeur par défaut, génère à court et à long accesseurs, estampes descriptif des messages d'erreur si les arguments non valides sont donnés et plus.

J'ai comparé plusieurs option-analyseur à l'aide de chaque option analyseur syntaxique pour le problème que j'ai eu. Vous pouvez utiliser ces exemples et mon résumé à faire un arrêt instructif. N'hésitez pas à ajouter plus implémentations de la liste. :)