Vraiment pas Cher Option de Ligne de Commande l'Analyse en Ruby

Comme l'auteur de Gourgandine, je ne peux pas CROIRE les choses que les gens pensent que ce qui est raisonnable dans une option analyseur. Sérieusement. Cela dépasse l'entendement.

Pourquoi devrais-je faire un module qui s'étend sur quelque autre module pour analyser les options? Pourquoi devrais-je avoir à la sous-classe quoi que ce soit? Pourquoi devrais-je souscrire à certaines "cadre" pour analyser la ligne de commande?

Voici la Gourgandine version de la ci-dessus:

opts = Trollop::options do
  opt :quiet, "Use minimal output", :short => 'q'
  opt :interactive, "Be interactive"
  opt :filename, "File to process", :type => String
end

Et c'est tout. opts est maintenant une valeur de hachage avec des touches de :quiet, :interactive, et :filename. Vous pouvez faire ce que vous voulez avec elle. Et vous obtenez une belle page d'aide, mis en forme pour s'adapter à votre largeur de l'écran, réglage automatique de court les noms d'argument, la vérification du type... tout ce dont vous avez besoin.

C'est un fichier, de sorte que vous pouvez déposer dans votre répertoire lib/si vous ne voulez pas un formelle de dépendance. Il a un minimum de LIS qui est facile à ramasser.

LOC par option de gens. C'questions.

Voici la technique que j'utilise habituellement:

#!/usr/bin/env ruby

def usage(s)
    $stderr.puts(s)
    $stderr.puts("Usage: #{File.basename($0)}: [-l <logfile] [-q] file ...")
    exit(2)
end

$quiet   = false
$logfile = nil

loop { case ARGV[0]
    when '-q' then  ARGV.shift; $quiet = true
    when '-l' then  ARGV.shift; $logfile = ARGV.shift
    when /^-/ then  usage("Unknown option: #{ARGV[0].inspect}")
    else break
end; }

# Program carries on here.
puts("quiet: #{$quiet} logfile: #{$logfile.inspect} args: #{ARGV.inspect}")

J'ai construit 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.

Court 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!

De l'appel du script avec -h ou --help imprime

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.

Je comparé plusieurs option-analyseur par l'utilisation 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. 🙂

C'est ce que j'utilise vraiment, vraiment pas cher args:

def main
  ARGV.each { |a| eval a }
end

main

donc, si vous exécutez programname foo bar il appelle foo et puis bar. C'est pratique pour les jetables scripts.

Avez-vous envisagé de Thor par wycats? Je pense que c'est beaucoup plus propre que optparse. Si vous avez déjà un script écrit, il pourrait être un peu plus de travail pour le formater ou de refactoriser le code de thor, mais il ne font d'options de traitement de très simple.

Voici l'exemple extrait du README:

class MyApp < Thor                                                # [1]
  map "-L" => :list                                               # [2]

  desc "install APP_NAME", "install one of the available apps"    # [3]
  method_options :force => :boolean, :alias => :optional          # [4]
  def install(name)
    user_alias = options[:alias]
    if options.force?
      # do something
    end
    # ... other code ...
  end

  desc "list [SEARCH]", "list all of the available apps, limited by SEARCH"
  def list(search = "")
    # list everything
  end
end

Thor mappe automatiquement les commandes en tant que tel:

app install myname --force

Qui est converti en:

MyApp.new.install("myname")
# with {'force' => true} as options hash

1. Hériter de Thor à son tour d'une classe dans une option mappeur
2. Carte supplémentaire non-valide identifiants à des méthodes spécifiques. Dans ce cas, convertissez -L :liste
3. Décrire la méthode immédiatement ci-dessous. Le premier paramètre est l'utilisation de l'information, et le second paramètre est la description.
4. Fournir des options supplémentaires. Ces sera assemblée à partir de -- et - params. Dans ce cas, une force et une option-f est ajouté.

Gourgandine est assez bon marché.

Voici l'extrait de code que j'utilise au début de la plupart de mes scripts:

arghash = Hash.new.tap { |h| # Parse ARGV into a hash
    i = -1                      
    ARGV.map{  |s| /(-[a-zA-Z_-])?([^=]+)?(=)?(.+)?/m.match(s).to_a }
     .each{ |(_,a,b,c,d)| h[ a ? "#{a}#{b}#{c}" : (i+=1) ] =
                             (a ? (c ? "#{d}" : true) : "#{b}#{c}#{d}") 
          }
    [[:argc,Proc.new  {|| h.count{|(k,_)| !k.is_a?(String)}}],
     [:switches, Proc.new {|| h.keys.select{|k| k[0] == '-' }}]
    ].each{|(n,p)| h.define_singleton_method(n,&p) }
}

Je déteste aussi d'exiger d'autres fichiers dans mon quick-and-dirty scripts. Ma solution est très près de ce que vous me demandez. Je colle un 10 ligne extrait de code en haut de l'un de mes scripts qui analyse la ligne de commande et des bâtons de position args et bascule dans un objet de Hachage (habituellement attribué à un objet que j'ai nommé arghash dans les exemples ci-dessous).

Voici un exemple de ligne de commande, vous pourriez vouloir analyser...

./myexampleprog.rb -s -x=15 --longswitch arg1 --longswitch2=val1 arg2

Qui allait devenir un Hachage de ce genre.

 { 
   '-s' => true, 
   '-x=' => '15', 
   '--longswitch' => true, 
   '--longswitch2=' => 'val1', 
   0 => 'arg1', 
   1 => 'arg2'
 }

En plus de cela, deux méthodes pratiques sont ajoutés à la valeur de Hachage:

• argc() sera de retour le nombre de non-commutateur arguments.
• switches() retourne un tableau contenant les clés de commutateurs qui sont présents

C'est un moyen de permettre à certains "rapide et sale" des trucs comme...

• Valider j'ai le bon nombre d'arguments de position quelle que soit la commutateurs adopté en ( arghash.argc == 2 )
• L'accès des arguments de position par leur position relative, quel que soit commutateurs apparaissant avant ou intercalés avec des arguments de position ( par exemple, arghash[1] obtient toujours la seconde non-switch argument).
• L'appui de la valeur attribuée commutateurs dans la ligne de commande comme "--max=15" qui peut être consulté par arghash['--max='] qui donne une valeur de '15' donné l'exemple de la ligne de commande.
• Tester la présence ou l'absence d'un interrupteur dans la ligne de commande à l'aide d'une très simple notation comme arghash['-s'] qui évalue à true si il est présent et nul si son absence.

• Tester la présence d'un commutateur ou des solutions de rechange de commutateurs à l'aide des opérations définies comme

  puts USAGETEXT if !(%w(-h --help) & arghash.switches()).empty?

• La détection de l'utilisation de l'invalidité de commutateurs à l'aide des opérations définies comme

  puts "Invalid switch found!" if !(arghash.switches - %w(-valid1 -valid2)).empty?

• Spécifier des valeurs par défaut pour les arguments manquants à l'aide d'un simple Hash.merge() comme l'exemple ci-dessous qui se remplit à une valeur de -max= si l'on n'était pas ensemble et ajoute un 4e position argument si l'on n'a pas été adopté.

  with_defaults = {'-max=' => 20, 3 => 'default.txt'}.merge(arghash)

Apparemment @WilliamMorgan et je pense de même. Je viens juste de sortir de la nuit dernière pour Github ce que je vois maintenant est une bibliothèque semblable à Gourgandine (Appelé comment?) après avoir fait une recherche pour OptionParser sur Github, voir Les commutateurs

Il y a quelques différences, mais la philosophie est la même. Une différence évidente est que les Interrupteurs dépend de OptionParser.

Supposons qu'une commande a au plus une action et nombre arbitraire d'options comme ceci:

cmd.rb
cmd.rb action
cmd.rb action -a -b ...
cmd.rb action -ab ...

L'analyse sans validation peut être comme ceci:

ACTION = ARGV.shift
OPTIONS = ARGV.join.tr('-', '')

if ACTION == '***'
  ...
  if OPTIONS.include? '*'
    ...
  end
  ...
end

Je vais partager mon propre simple option analyseur qui j'ai travaillé pendant un certain temps. C'est simplement 74 lignes de code, et il ne les bases de ce que l'Git interne de l'option analyseur ne. J'ai pris OptionParser comme source d'inspiration, et aussi Git est.

https://gist.github.com/felipec/6772110

Il ressemble à ceci:

opts = ParseOpt.new
opts.usage = "git foo"

opts.on("b", "bool", help: "Boolean") do |v|
 $bool = v
end

opts.on("s", "string", help: "String") do |v|
 $str = v
end

opts.on("n", "number", help: "Number") do |v|
 $num = v.to_i
end

opts.parse