Wirklich günstiges Parsen von Befehlszeilenoptionen in Ruby

BEARBEITEN: Bitte, bitte , bitte lesen Sie die beiden Anforderungen, die am Ende dieses Beitrags aufgeführt sind, bevor Sie antworten. Die Leute veröffentlichen immer wieder ihre neuen Juwelen und Bibliotheken und so weiter, die eindeutig nicht den Anforderungen entsprechen.

Manchmal möchte ich einige Befehlszeilenoptionen sehr billig in ein einfaches Skript hacken. Eine unterhaltsame Möglichkeit, dies zu tun, ohne sich mit Getopts, Parsing oder Ähnlichem zu befassen, ist:

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

Es ist nicht ganz die normale Unix-Optionssyntax, da sie Optionen akzeptiert, die keine Optionsbefehlszeilenparameter sind, wie in " myprog -i foo bar -q", aber damit kann ich leben. (Einige Leute, wie die Subversion-Entwickler, bevorzugen dies. Manchmal auch.)

Eine Option, die nur vorhanden ist oder fehlt, kann nicht viel einfacher als die oben genannte implementiert werden. (Eine Zuweisung, ein Funktionsaufruf, ein Nebeneffekt.) Gibt es eine ebenso einfache Möglichkeit, mit Optionen umzugehen, die einen Parameter annehmen, z. B. " -f Dateiname "?

BEARBEITEN:

Ein Punkt, den ich vorher nicht angesprochen habe, weil mir erst klar geworden war, als der Autor von Trollop erwähnte, dass die Bibliothek "in eine [800-Zeilen] -Datei" passt, ist, dass ich nicht nur nach sauber suche Syntax, jedoch für eine Technik mit folgenden Eigenschaften:

1. Der gesamte Code kann in die Skriptdatei aufgenommen werden (ohne das eigentliche Skript selbst zu überfordern, das nur ein paar Dutzend Zeilen umfassen kann), sodass eine einzelne Datei in einem binVerzeichnis auf jedem System mit einem Standard-Ruby 1.8 abgelegt werden kann [5-7] installieren und verwenden. Wenn Sie kein Ruby-Skript schreiben können, für das keine erforderlichen Anweisungen erforderlich sind und der Code zum Parsen einiger Optionen weniger als ein Dutzend Zeilen enthält, besteht diese Anforderung nicht.

2. Der Code ist klein und einfach genug, dass man sich genug daran erinnern kann, um direkt Code einzugeben, der den Trick macht, anstatt ihn von einem anderen Ort aus auszuschneiden und einzufügen. Stellen Sie sich die Situation vor, in der Sie sich auf der Konsole eines Firewall-Servers ohne Internetzugang befinden und ein schnelles Skript für einen Client zusammenstellen möchten. Ich weiß nichts über dich, aber (abgesehen davon, dass ich die oben genannten Anforderungen nicht erfüllt habe) ist es mir nicht wichtig, mir selbst die 45 Zeilen vereinfachter Mikrooptik zu merken.

Als Autor von Trollop kann ich nicht glauben , was die Leute in einem Optionsparser für vernünftig halten. Ernsthaft. Es verwirrt den Geist.

Warum sollte ich ein Modul erstellen müssen, das ein anderes Modul erweitert, um Optionen zu analysieren? Warum sollte ich etwas unterordnen müssen? Warum sollte ich ein "Framework" abonnieren müssen, um die Befehlszeile zu analysieren?

Hier ist die Trollop-Version von oben:

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

Und das ist es. optsist nun ein Hash mit Tasten :quiet, :interactive, und :filename. Sie können damit machen, was Sie wollen. Und Sie erhalten eine schöne Hilfeseite, die an Ihre Bildschirmbreite angepasst ist, automatische Kurzargumentnamen, Typprüfung ... alles, was Sie brauchen.

Es ist eine Datei, sodass Sie sie in Ihrem lib / -Verzeichnis ablegen können, wenn Sie keine formale Abhängigkeit wünschen. Es hat ein minimales DSL, das leicht zu erlernen ist.

LOC pro Option Personen. Es ist wichtig.

Ich teile Ihre Abneigung gegen require 'getopts', vor allem wegen der Großartigkeit, die ist OptionParser:

% cat temp.rb                                                            
require 'optparse'
OptionParser.new do |o|
  o.on('-d') { |b| $quiet = b }
  o.on('-i') { |b| $interactive = b }
  o.on('-f FILENAME') { |filename| $filename = filename }
  o.on('-h') { puts o; exit }
  o.parse!
end
p :quiet => $quiet, :interactive => $interactive, :filename => $filename
% ruby temp.rb                                                           
{:interactive=>nil, :filename=>nil, :quiet=>nil}
% ruby temp.rb -h                                                        
Usage: temp [options]
    -d
    -i
    -f FILENAME
    -h
% ruby temp.rb -d                                                        
{:interactive=>nil, :filename=>nil, :quiet=>true}
% ruby temp.rb -i                                                        
{:interactive=>true, :filename=>nil, :quiet=>nil}
% ruby temp.rb -di                                                       
{:interactive=>true, :filename=>nil, :quiet=>true}
% ruby temp.rb -dif apelad                                               
{:interactive=>true, :filename=>"apelad", :quiet=>true}
% ruby temp.rb -f apelad -i                                              
{:interactive=>true, :filename=>"apelad", :quiet=>nil}

Hier ist die Standardtechnik, die ich normalerweise verwende:

#!/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}")

Da schien es niemand zu erwähnen, und der Titel bezieht sich billig Befehlszeilen Parsing, warum nicht nur die Ruby - Interpreter lassen die Arbeit für Sie tun? Wenn Sie den -sSchalter übergeben (zum Beispiel in Ihrem Shebang), erhalten Sie kostenlos schmutzige Schalter, die globalen Variablen mit einem Buchstaben zugewiesen sind. Hier ist Ihr Beispiel mit diesem Schalter:

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

Und hier ist die Ausgabe, wenn ich das speichere als ./test und 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"]

Siehe ruby -hfür Details.

Das muss so billig sein wie es nur geht. Es wird ein NameError ausgelöst, wenn Sie einen Schalter wie versuchen -:, also gibt es dort eine Validierung. Natürlich können Sie nach einem Nicht-Schalter-Argument keine Schalter haben, aber wenn Sie etwas Besonderes benötigen, sollten Sie wirklich mindestens den OptionParser verwenden. Das einzige, was mich an dieser Technik ärgert, ist, dass Sie beim Zugriff auf eine nicht gesetzte globale Variable eine Warnung erhalten (wenn Sie sie aktiviert haben), aber sie ist immer noch falsch, sodass sie für Wegwerfwerkzeuge gut und schnell funktioniert Skripte.

Eine Einschränkung, auf die FelipeC in den Kommentaren in " Wie man wirklich billige Befehlszeilenoptionen in Ruby analysiert " hinweist , ist, dass Ihre Shell den 3-Token-Shebang möglicherweise nicht unterstützt. Möglicherweise müssen Sie /usr/bin/env ruby -wden tatsächlichen Pfad zu Ihrem Ruby (wie /usr/local/bin/ruby -w) ersetzen oder ihn über ein Wrapper-Skript oder etwas anderes ausführen.

Ich habe Micro-Optparse entwickelt , um diesen offensichtlichen Bedarf an einem kurzen, aber einfach zu verwendenden Options-Parser zu decken . Es hat eine ähnliche Syntax wie Trollop und ist 70 Zeilen kurz. Wenn Sie keine Validierungen benötigen und auf leere Zeilen verzichten können, können Sie diese auf 45 Zeilen reduzieren. Ich denke, genau das haben Sie gesucht.

Kurzes Beispiel:

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!

Aufruf des Skripts mit -hoder --helpwird gedruckt

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

Es prüft, ob die Eingabe vom gleichen Typ wie der Standardwert ist, generiert kurze und lange Accessoren, druckt beschreibende Fehlermeldungen, wenn ungültige Argumente angegeben werden, und vieles mehr.

Ich habe mehrere Optionsparser verglichen, indem ich jeden Optionsparser für das Problem verwendet habe, das ich hatte. Sie können diese Beispiele und meine Zusammenfassung verwenden, um eine informative Entscheidung zu treffen. Fühlen Sie sich frei, der Implementierung weitere Implementierungen hinzuzufügen. :) :)

Ich verstehe vollkommen, warum Sie Optparse vermeiden wollen - es kann zu viel werden. Es gibt jedoch einige weitaus "leichtere" Lösungen (im Vergleich zu OptParse), die als Bibliotheken geliefert werden, aber einfach genug sind, um eine einzelne Edelsteininstallation lohnenswert zu machen.

Zum Beispiel Besuche dieses OptiFlag Beispiel . Nur ein paar Zeilen für die Bearbeitung. Ein leicht verkürztes Beispiel, das auf Ihren Fall zugeschnitten ist:

require 'optiflag'

module Whatever extend OptiFlagSet
  flag "f"
  and_process!
end 

ARGV.flags.f # => .. whatever ..

Es gibt auch Tonnen von kundenspezifischen Beispielen . Ich erinnere mich, dass ich ein anderes verwendet habe, das noch einfacher war, aber es ist mir vorerst entgangen, aber ich werde zurückkommen und hier einen Kommentar hinzufügen, wenn ich ihn finde.

Dies ist, was ich für wirklich, wirklich billige Argumente benutze:

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

main

Wenn Sie also ausführen programname foo bar, wird foo und dann bar aufgerufen. Es ist praktisch für Wegwerfskripte.

Sie können etwas versuchen wie:

if( ARGV.include( '-f' ) )
  file = ARGV[ARGV.indexof( '-f' ) + 1 )]
  ARGV.delete('-f')
  ARGV.delete(file)
end

Haben Sie Thor von Wycats in Betracht gezogen? Ich denke, es ist viel sauberer als optparse. Wenn Sie bereits ein Skript geschrieben haben, ist es möglicherweise etwas aufwendiger, es zu formatieren oder für thor umzugestalten, aber es macht die Handhabungsoptionen sehr einfach.

Hier ist das Beispiel-Snippet aus der 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 ordnet Befehle automatisch als solche zu:

app install myname --force

Das wird konvertiert zu:

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

1. Von Thor erben, um eine Klasse in einen Optionsmapper zu verwandeln
2. Ordnen Sie bestimmten Methoden zusätzliche ungültige Bezeichner zu. In diesem Fall konvertieren Sie -L in: list
3. Beschreiben Sie die Methode direkt unten. Der erste Parameter ist die Verwendungsinformation und der zweite Parameter ist die Beschreibung.
4. Geben Sie zusätzliche Optionen an. Diese werden von - und - Parametern gemarshallt. In diesem Fall werden die Optionen --force und -f hinzugefügt.

Hier ist mein Lieblings-Parser für schnelle und schmutzige Optionen:

case ARGV.join
when /-h/
  puts "help message"
  exit
when /-opt1/
  puts "running opt1"
end

Die Optionen sind reguläre Ausdrücke, daher würde "-h" auch mit "--help" übereinstimmen.

Lesbar, leicht zu merken, keine externe Bibliothek und minimaler Code.

Trollop ist ziemlich billig.

Wenn Sie einen einfachen Befehlszeilenparser für Schlüssel- / Wertbefehle ohne Verwendung von Edelsteinen benötigen:

Aber dieses funktioniert jedoch nur, wenn Sie immer Schlüssel / Wert-Paare haben.

# example
# script.rb -u username -p mypass

# check if there are even set of params given
if ARGV.count.odd? 
    puts 'invalid number of arguments'
    exit 1
end

# holds key/value pair of cl params {key1 => value1, key2 => valye2, ...}
opts = {} 

(ARGV.count/2).times do |i|
    k,v = ARGV.shift(2)
    opts[k] = v # create k/v pair
end

# set defaults if no params are given
opts['-u'] ||= 'root'

# example use of opts
puts "username:#{opts['-u']} password:#{opts['-p']}"

Wenn Sie keine Überprüfung benötigen, können Sie einfach Folgendes verwenden:

opts = {} 

(ARGV.count/2).times do |i|
    k,v = ARGV.shift(2)
    opts[k] = v # create k/v pair
end

Hier ist das Code-Snippet, das ich oben in den meisten meiner Skripte verwende:

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) }
}

Ich hasse es auch, zusätzliche Dateien in meinen schnellen und schmutzigen Skripten zu benötigen. Meine Lösung ist fast das, wonach Sie fragen. Ich füge einen 10-zeiligen Codeausschnitt oben in eines meiner Skripte ein, der die Befehlszeile analysiert, Positionsargumente speichert und in ein Hash-Objekt wechselt (normalerweise einem Objekt zugewiesen, das ich arghash genannt habe in den folgenden Beispielen ).

Hier ist ein Beispiel für eine Befehlszeile, die Sie möglicherweise analysieren möchten ...

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

Welches würde ein Hash wie dieser werden.

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

Darüber hinaus werden dem Hash zwei praktische Methoden hinzugefügt:

• argc() gibt die Anzahl der Nicht-Switch-Argumente zurück.
• switches() gibt ein Array zurück, das die Schlüssel für vorhandene Schalter enthält

Dies soll ein paar schnelle und schmutzige Sachen wie ...

• Überprüfen Sie, ob ich die richtige Anzahl von Positionsargumenten habe, unabhängig von den übergebenen Schaltern ( arghash.argc == 2 ) übergebenen
• Greifen Sie auf Positionsargumente über ihre relative Position zu, unabhängig davon, ob Schalter vor oder mit Positionsargumenten durchsetzt sind (z. B. wird arghash[1]immer das zweite Nicht-Schalter-Argument abgerufen).
• Unterstützt wertzugewiesene Schalter in der Befehlszeile wie "--max = 15", auf die zugegriffen werden kann, arghash['--max=']wodurch in der Beispielbefehlszeile der Wert '15' erhalten wird.
• Testen Sie das Vorhandensein oder Fehlen eines Schalters in der Befehlszeile mit einer sehr einfachen Notation, die beispielsweise als arghash['-s']wahr ausgewertet wird, wenn sie vorhanden ist, und als Null, wenn sie nicht vorhanden ist.

• Testen Sie das Vorhandensein eines Schalters oder von Alternativen von Schaltern mit festgelegten Operationen wie

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

• Identifizieren Sie die Verwendung ungültiger Schalter mithilfe von Set-Operationen wie z

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

• Geben Sie Standardwerte für fehlende Argumente an, indem Sie ein einfaches Beispiel Hash.merge()wie das folgende verwenden, das einen Wert für -max = ausfüllt, wenn eines nicht festgelegt wurde, und ein viertes Positionsargument hinzufügt, wenn eines nicht übergeben wurde.

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

Dies ist der akzeptierten Antwort sehr ähnlich, aber mit ARGV.delete_if welcher ich sie in meinem einfachen Parser . Der einzige wirkliche Unterschied besteht darin, dass Optionen mit Argumenten zusammen sein müssen (z -l=file. B. ).

def usage
  "usage: #{File.basename($0)}: [-l=<logfile>] [-q] file ..."
end

$quiet = false
$logfile = nil

ARGV.delete_if do |cur|
  next false if cur[0] != '-'
  case cur
  when '-q'
    $quiet = true
  when /^-l=(.+)$/
    $logfile = $1
  else
    $stderr.puts "Unknown option: #{cur}"
    $stderr.puts usage
    exit 1
  end
end

puts "quiet: #{$quiet} logfile: #{$logfile.inspect} args: #{ARGV.inspect}"

Anscheinend denken @WilliamMorgan und ich gleich. Ich habe gestern Abend für Github veröffentlicht. Was ich jetzt sehe, ist eine ähnliche Bibliothek wie Trollop (benannt wie?), Nachdem ich auf Github nach OptionParser gesucht habe, siehe Switches

Es gibt einige Unterschiede, aber die Philosophie ist dieselbe. Ein offensichtlicher Unterschied besteht darin, dass Switches von OptionParser abhängig sind.

Ich entwickle mein eigenes Optionsparser-Juwel namens Acclaim .

Ich habe es geschrieben, weil ich Befehlszeilenschnittstellen im Git-Stil erstellen und die Funktionalität jedes Befehls sauber in separate Klassen unterteilen wollte, aber es kann auch ohne das gesamte Befehlsframework verwendet werden:

(options = []) << Acclaim::Option.new(:verbose, '-v', '--verbose')
values = Acclaim::Option::Parser.new(ARGV, options).parse!
puts 'Verbose.' if values.verbose?

Noch keine stabile Version, aber ich habe bereits einige Funktionen implementiert wie:

• Parser für benutzerdefinierte Optionen
• Flexibles Parsen der Optionsargumente, das sowohl minimale als auch optionale Argumente zulässt
• Unterstützung für viele Optionsstile
• Ersetzen, Anhängen oder Erhöhen mehrerer Instanzen derselben Option
• benutzerdefinierte Optionshandler
• Benutzerdefinierte Typhandler
• vordefinierte Handler für die allgemeinen Standardbibliotheksklassen

Es wird viel Wert auf Befehle gelegt, daher ist es für das einfache Parsen von Befehlszeilen möglicherweise etwas schwer, aber es funktioniert gut und ich habe es in all meinen Projekten verwendet. Wenn Sie sich für den Aspekt der Befehlsoberfläche interessieren, finden Sie auf der GitHub-Seite des Projekts weitere Informationen und Beispiele.

Angenommen, ein Befehl hat höchstens eine Aktion und eine beliebige Anzahl solcher Optionen:

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

Das Parsen ohne Validierung kann folgendermaßen aussehen:

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

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

https://github.com/soveran/clap

other_args = Clap.run ARGV,
  "-s" => lambda { |s| switch = s },
  "-o" => lambda { other = true }

46LOC (bei 1.0.0), keine Abhängigkeit vom externen Optionsparser. Erledigt die Arbeit. Wahrscheinlich nicht so voll ausgestattet wie andere, aber es ist 46LOC.

Wenn Sie den Code überprüfen, können Sie die zugrunde liegende Technik ziemlich einfach duplizieren - weisen Sie Lambdas zu und verwenden Sie die Arität, um sicherzustellen, dass die richtige Anzahl von Argumenten dem Flag folgt, wenn Sie wirklich keine externe Bibliothek möchten.

Einfach. Billig.

BEARBEITEN : Das zugrunde liegende Konzept ist auf den Punkt gebracht, da Sie es möglicherweise kopieren / in ein Skript einfügen, um einen vernünftigen Befehlszeilenparser zu erstellen. Es ist definitiv nichts, was ich in Erinnerung behalten würde, aber die Lambda-Arität als billigen Parser zu verwenden, ist eine neuartige Idee:

flag = false
option = nil
opts = {
  "--flag" => ->() { flag = true },
  "--option" => ->(v) { option = v }
}

argv = ARGV
args = []

while argv.any?
  item = argv.shift
  flag = opts[item]

  if flag
    raise ArgumentError if argv.size < arity
    flag.call(*argv.shift(arity))
  else
    args << item
  end
end

# ...do stuff...

Ich werde meinen eigenen einfachen Optionsparser teilen, an dem ich seit einiger Zeit arbeite. Es sind lediglich 74 Codezeilen und es werden die Grundlagen des internen Optionsparsers des Git erläutert. Ich habe OptionParser als Inspiration genommen und auch Git's.

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

Es sieht aus wie das:

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

EasyOptions erfordert überhaupt keinen Optionsparsing-Code. Schreiben Sie einfach den Hilfetext, benötigen Sie, fertig.

## Options:
##   -i, --interactive  Interactive mode
##   -q, --quiet        Silent mode

require 'easyoptions'
unless EasyOptions.options[:quiet]
    puts 'Interactive mode enabled' if EasyOptions.options[:interactive]
    EasyOptions.arguments.each { |item| puts "Argument: #{item}" }
end