Ruby'de Gerçekten Ucuz Komut Satırı Seçeneği Ayrıştırma

DÜZENLEME: Lütfen lütfen , lütfen cevap vermeden önce bu yazının altındaki listelenen iki gereksinimleri okumak. İnsanlar yeni mücevherlerini, kitaplıklarını falan yayınlamaya devam ediyor, bu da açıkça gereksinimleri karşılamıyor.

Bazen bazı komut satırı seçeneklerini çok ucuza basit bir betiğe dönüştürmek istiyorum. Getopts, ayrıştırma veya benzeri bir şeyle uğraşmadan bunu yapmanın eğlenceli bir yolu şudur:

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

Bu tam olarak normal Unix seçenekleri sözdizimi değil, çünkü " myprog -i foo bar -q" seçeneğindeki gibi seçenek olmayan komut satırı parametrelerini kabul edecek , ancak bununla yaşayabilirim. (Subversion geliştiricileri gibi bazı insanlar bunu tercih ediyor. Bazen ben de tercih ediyorum.)

Sadece mevcut olan veya olmayan bir seçenek yukarıdakilerden çok daha basit bir şekilde uygulanamaz. (Tek atama, tek işlev çağrısı, tek yan etki.) " -f Dosya adı " gibi bir parametre alan seçenekleri ele almanın eşit derecede basit bir yolu var mı ?

DÜZENLE:

Daha önce belirtmediğim bir nokta, çünkü Trollop'un yazarı kitaplığın "tek bir [800 satırlık] dosyaya" sığdığından söz edene kadar benim için netleşmemişti, sadece temiz sözdizimi, ancak aşağıdaki özelliklere sahip bir teknik için:

1. Kodun tamamı komut dosyasına dahil edilebilir (gerçek betiğin kendisini ezmeden, ki bu sadece birkaç düzine satır olabilir), böylece binstandart Ruby 1.8 ile herhangi bir sistemdeki bir dizine tek bir dosya bırakılabilir. . [5-7] kurulum ve kullanma. Require ifadesi içermeyen ve birkaç seçeneği ayrıştıracak kodun bir düzine satırın altında olduğu bir Ruby betiği yazamazsanız, bu gereksinimi karşılayamazsınız.

2. Kod, başka bir yerden kesip yapıştırmak yerine, hile yapacak kodu doğrudan yazmak için yeterince küçük ve basittir. İnternet erişimi olmayan, güvenlik duvarlı bir sunucunun konsolunda olduğunuz ve bir istemcinin kullanması için hızlı bir komut dosyasını bir araya getirmek istediğiniz durumu düşünün. Sizi bilmiyorum, ancak (yukarıdaki gerekliliği yerine getirmemenin yanı sıra) 45 satırlık basitleştirilmiş mikro-optiği ezberlemek bile yapmayı umursadığım bir şey değil.

Trollop'un yazarı olarak , insanların bir seçenek çözümleyicide makul olduğunu düşündükleri şeylere İNANAMAM . Ciddi anlamda. Zihni şaşırtıyor.

Neden başka bir modülü seçenekleri ayrıştırmak için genişleten bir modül yapmalıyım? Neden herhangi bir şeyi alt sınıflara ayırmalıyım? Komut satırını ayrıştırmak için neden bazı "çerçevelere" abone olmalıyım?

İşte yukarıdakilerin Trollop versiyonu:

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

Ve bu kadar. optsartık anahtarları :quietolan bir karma :interactiveve :filename. Onunla ne istersen yapabilirsin. Ve ekran genişliğinize uyacak şekilde biçimlendirilmiş güzel bir yardım sayfası, otomatik kısa argüman adları, yazım denetimi ... ihtiyacınız olan her şey.

Bu tek bir dosyadır, eğer resmi bir bağımlılık istemiyorsanız onu lib / dizininize bırakabilirsiniz. Alınması kolay minimal bir DSL'ye sahiptir.

Seçenek kişi başına LOC. Fark eder, önemi var.

Hoşnutsuzluğunuzu paylaşıyorum require 'getopts', esas olarak şu muhteşemlik nedeniyle 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}

İşte genellikle kullandığım standart teknik:

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

Kimse söz göründü ve başlık yana gelmez bakın ucuz komut satırı ayrıştırma, neden sadece sizin için işi yapmak tercüman Ruby izin? -sAnahtarı geçerseniz (örneğin, sizin yazınızda), tek harfli global değişkenlere atanmış, kir-basit anahtarları ücretsiz olarak alırsınız. İşte bu anahtarı kullanan örneğiniz:

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

Ve bunu farklı kaydettiğimde ./testve değiştirdiğimde çıkan çıktı +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"]

Ayrıntılar ruby -hiçin bakın.

Bu zorunluluk olabildiğince ucuz . Gibi bir anahtarı denerseniz bir NameError yükseltecektir.-: , bu yüzden orada bazı doğrulama var. Elbette, geçişsiz bir argümandan sonra herhangi bir anahtarınız olamaz, ancak süslü bir şeye ihtiyacınız varsa, gerçekten minimum OptionParser kullanmalısınız. Aslında, bu teknikle ilgili beni rahatsız eden tek şey, ayarlanmayan bir global değişkene erişirken (etkinleştirdiyseniz) bir uyarı alacağınızdır, ancak yine de yanlıştır, bu nedenle atılabilir araçlar ve hızlı Kodlar.

FelipeC'nin " Ruby'de gerçekten ucuz komut satırı seçeneği nasıl ayrıştırılır " yazısındaki yorumlarda dikkat çektiği bir uyarı, kabuğunuzun 3 simgeli shebang'ı desteklemeyebileceğidir; /usr/bin/env ruby -wRuby'nize giden gerçek yolu (gibi /usr/local/bin/ruby -w) değiştirmeniz veya bir sarmalayıcı komut dosyasından veya başka bir şeyle çalıştırmanız gerekebilir .

Ben inşa mikro optparse kısa bu bariz ihtiyaç doldurmak için, ama kolay bir seçenek-ayrıştırıcı kullanmak. Trollop'a benzer bir sözdizimi vardır ve 70 satır kısadır. Doğrulamalara ihtiyacınız yoksa ve boş satırlar olmadan yapabiliyorsanız, 45 satıra kadar kesebilirsiniz. Sanırım tam da aradığın buydu.

Kısa örnek:

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!

Komut dosyasını çağırmak -hveya --helpyazdırmak

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

Girişin varsayılan değerle aynı türde olup olmadığını kontrol eder, kısa ve uzun erişimciler üretir, geçersiz bağımsız değişkenler verilirse açıklayıcı hata mesajları yazdırır ve daha fazlasını yapar.

Ben birkaç seçenek-ayrıştırıcı karşılaştırıldığında vardı problemi için her seçenek-ayrıştırıcı kullanarak. Bilgilendirici bir karar vermek için bu örnekleri ve özetimi kullanabilirsiniz. Listeye daha fazla uygulama eklemekten çekinmeyin. :)

İyimser olmaktan neden kaçınmak istediğinizi tamamen anlıyorum - çok fazla olabilir. Ancak kitaplık olarak gelen ancak tek bir mücevher kurulumunu değerli kılacak kadar basit olan birkaç "daha hafif" çözüm (OptParse ile karşılaştırıldığında) vardır.

Örneğin, bu OptiFlag örneğine bakın . İşleme için sadece birkaç satır. Durumunuza uyarlanmış, biraz kısaltılmış bir örnek:

require 'optiflag'

module Whatever extend OptiFlagSet
  flag "f"
  and_process!
end 

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

Orada özelleştirilmiş örneklerinden ton da . Daha da kolay olan başka birini kullandığımı hatırlıyorum, ama şimdilik benden kaçtı ama geri gelip bulursam buraya bir yorum ekleyeceğim.

Gerçekten ucuz argümanlar için kullandığım şey bu:

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

main

yani çalıştırırsanız programname foo barfoo ve ardından bar'ı çağırır. Kullanılmayan komut dosyaları için kullanışlıdır.

Şunun gibi bir şey deneyebilirsiniz:

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

Eğer kabul mü Thor wycats tarafından? Optparse'den çok daha temiz olduğunu düşünüyorum. Zaten yazılmış bir betiğiniz varsa, onu formatlamak veya thor için yeniden düzenlemek biraz daha çalışma olabilir, ancak bu, işleme seçeneklerini çok basit hale getirir.

README'den örnek pasaj:

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, komutları şu şekilde otomatik olarak eşler:

app install myname --force

Bu şuna dönüştürülür:

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

1. Bir sınıfı bir seçenek eşleştiricisine dönüştürmek için Thor'dan devralın
2. Ek geçerli olmayan tanımlayıcıları belirli yöntemlerle eşleyin. Bu durumda, -L'yi listeye dönüştürün
3. Hemen aşağıdaki yöntemi açıklayın. İlk parametre kullanım bilgisidir ve ikinci parametre açıklamadır.
4. Herhangi bir ek seçenek sağlayın. Bunlar - ve - parametrelerinden sıralanacaktır. Bu durumda, bir --force ve a -f seçeneği eklenir.

İşte en sevdiğim hızlı ve kirli seçenek ayrıştırıcım:

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

Seçenekler normal ifadelerdir, dolayısıyla "-h" ayrıca "--help" ile de eşleşir.

Okunabilir, hatırlaması kolay, harici kitaplık yok ve minimum kod.

Trollop oldukça ucuz.

Değerli taşlar kullanmadan anahtar / değer komutları için basit bir komut satırı ayrıştırıcısı istiyorsanız:

Ancak bu yalnızca her zaman anahtar / değer çiftleriniz varsa işe yarar.

# 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']}"

Herhangi bir kontrole ihtiyacınız yoksa, sadece şunları kullanabilirsiniz:

opts = {} 

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

Komut dosyalarımın çoğunun üstünde kullandığım kod pasajı:

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

Hızlı ve kirli komut dosyalarımda ek dosyalara ihtiyaç duymaktan da nefret ediyorum. Benim çözümüm, neredeyse istediğiniz şey. Komut dosyalarımın üst kısmına, komut satırını ayrıştıran ve konumsal değişkenleri yapıştıran ve bir Hash nesnesine (genellikle arghash adını verdiğim bir nesneye atanan) 10 satırlık bir kod parçası yapıştırıyorum. aşağıdaki örneklerde .

İşte ayrıştırmak isteyebileceğiniz örnek bir komut satırı ...

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

Hangisi böyle bir Hash olur.

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

Buna ek olarak, Hash'e iki kolaylık yöntemi eklenmiştir:

• argc() anahtar olmayan bağımsız değişkenlerin sayısını döndürür.
• switches() mevcut anahtarların anahtarlarını içeren bir dizi döndürür

Bu, bazı hızlı ve kirli şeylere izin vermek anlamına gelir ...

• Geçilen anahtarlardan bağımsız olarak doğru sayıda konumsal bağımsız değişkene sahip olduğumu doğrulayın ( arghash.argc == 2 )
• Konumsal argümanlardan önce görünen veya konumsal argümanlarla serpiştirilmiş anahtarlardan bağımsız olarak konumsal argümanlara göreceli konumlarına göre erişin (örneğin arghash[1]her zaman ikinci anahtar olmayan argümanı alır).
• arghash['--max=']Örnek komut satırı verildiğinde '15' değerini veren "--max = 15" gibi komut satırında değer atanmış anahtarları destekleyin .
• Komut satırında bir anahtarın varlığını veya yokluğunu test etmek için çok basit bir gösterim arghash['-s']kullanın; bu, mevcutsa doğru, yoksa sıfır olarak değerlendirilir.

• Bir anahtarın veya anahtar alternatiflerinin varlığını test edin.

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

• Aşağıdaki gibi ayarlı işlemleri kullanarak geçersiz anahtarların kullanımını tanımlayın

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

• Eksik bağımsız değişkenler için varsayılan değerleri Hash.merge(), aşağıdaki örnekte olduğu gibi, biri ayarlanmadıysa -max = için bir değer dolduran ve geçirilmemişse 4. bir konumsal bağımsız değişken ekleyen bir basit kullanarak belirtin .

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

Bu, kabul edilen cevaba çok benziyor, ancak basit ayrıştırıcımdaARGV.delete_if hangisini kullanıyorum . Tek gerçek fark, bağımsız değişkenli seçeneklerin birlikte olması gerektiğidir (örneğin ).-l=file

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

Görünüşe göre @WilliamMorgan ve ben benzer düşünüyorum. Dün gece Github'a yayınladım, şimdi gördüğüm şey, Github'da OptionParser için bir arama yaptıktan sonra Trollop'a benzer bir kitaplık (Nasıl adlandırıldı?), Bkz. Anahtarları

Birkaç farklılık var ama felsefe aynı. Belirgin bir fark, Switch'lerin OptionParser'a bağlı olmasıdır.

Gelişiyorum Beğeni denilen kendi opsiyon ayrıştırıcı mücevher .

Bunu, git tarzı komut satırı arayüzleri oluşturmak ve her komutun işlevselliğini ayrı sınıflara temiz bir şekilde ayırabilmek istediğim için yazdım, ancak tüm komut çerçevesi olmadan da kullanılabilir:

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

Henüz kararlı bir sürüm yok, ancak aşağıdaki gibi bazı özellikleri zaten uyguladım:

• özel seçenek ayrıştırıcı
• Hem minimum hem de isteğe bağlı olarak izin veren seçenek argümanlarının esnek ayrıştırılması
• birçok seçenek stili için destek
• aynı seçeneğin birden çok örneğini değiştirme, ekleme veya yükseltme
• özel seçenek işleyicileri
• özel tür işleyiciler
• ortak standart kitaplık sınıfları için önceden tanımlanmış işleyiciler

Komutlara çok fazla vurgu yapıldığından, basit komut satırı ayrıştırması için biraz ağır olabilir, ancak iyi çalışıyor ve bunu tüm projelerimde kullanıyorum. Komut arayüzü yönüyle ilgileniyorsanız, daha fazla bilgi ve örnekler için projenin GitHub sayfasına bakın.

Bir komutun en fazla bir eylemi ve aşağıdaki gibi keyfi sayıda seçeneği olduğunu varsayalım:

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

Doğrulama olmadan ayrıştırma şu şekilde olabilir:

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 (1.0.0'da), harici seçenek ayrıştırıcısına bağımlılık yok. İşi bitirir. Muhtemelen diğerleri kadar tam özellikli değil, ancak 46LOC.

Kodu kontrol ederseniz, temeldeki tekniği oldukça kolay bir şekilde çoğaltabilirsiniz - lambdalar atayın ve gerçekten harici bir kitaplık istemiyorsanız bayrağı uygun sayıda argüman sağlamak için arity'yi kullanın.

Basit. Ucuz.

DÜZENLEME : makul bir komut satırı ayrıştırıcısı yapmak için onu bir komut dosyasına kopyalayıp / yapıştırabileceğinizi düşündüğüm için temeldeki kavram kaynatıldı. Kesinlikle hafızaya alacağım bir şey değil , ancak lambda arity'yi ucuz bir ayrıştırıcı olarak kullanmak yeni bir fikir:

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...

Bir süredir üzerinde çalıştığım kendi basit seçenek ayrıştırıcımı paylaşacağım. Yalnızca 74 satırlık bir koddur ve Git'in dahili seçenek ayrıştırıcısının yaptığı şeyin temellerini yapar. OptionParser'ı ve ayrıca Git'i ilham olarak aldım.

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

Şöyle görünüyor:

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 , herhangi bir seçenek ayrıştırma kodu gerektirmez. Sadece yardım metnini yazın, gerekli, bitti.

## 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