Rubyでの非常に安価なコマンドラインオプションの解析

編集：お願い、お願い、お願い応答する前に、この記事の一番下にリストされている2つの要件をお読みください。人々は新しい宝石やライブラリなどを投稿し続けますが、それらは明らかに要件を満たしていません。

コマンドラインオプションをシンプルなスクリプトに非常に安価にハックしたい場合があります。getoptsや解析などを行わずにそれを行う楽しい方法は次のとおりです。

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

" myprog -i foo bar -q"のようにオプション以外のコマンドラインパラメーターを受け入れるため、これは通常のUnixオプション構文ではありませんが、それでも問題ありません。（Subversion開発者などの一部の人はこれを好みます。時には私もそうします。）

存在するオプションまたは存在しないオプションは、上記よりも簡単に実装することはできません。（1つの割り当て、1つの関数呼び出し、1つの副作用。） " -f filename」？

編集：

ライブラリが「1つの[800行]ファイルに収まる」とTrollopの作者が言うまで私には明確にならなかったので、私が以前に触れなかった1つの点は、私がクリーンなだけでなく探しているということです。構文ですが、次の特性を持つ手法の場合：

1. コード全体をスクリプトファイルに含めることができ（実際のスクリプト自体を圧倒することなく、これは数十行になる場合があります）、bin標準のRuby 1.8を搭載した任意のシステムのディレクトリに単一のファイルをドロップできます。。[5-7]インストールして使用します。requireステートメントのないRubyスクリプトを記述できず、いくつかのオプションを解析するコードが数十行以下の場合、この要件は満たされません。

2. コードは小さくてシンプルなので、他の場所からカットアンドペーストするのではなく、トリックを実行するコードを直接入力するのに十分なほど覚えています。ファイアウォールで保護されたサーバーのコンソール上でインターネットにアクセスできない状況で、クライアントが使用する簡単なスクリプトを一緒に投げたいと考えているとします。私はあなたのことは知りませんが、（上記の要件を満たしていないことを除いて）45行の簡略化されたmicro-optparseを記憶することは、私がやりたいことではありません。

Trollopの作者として、私は人々がオプションパーサーで合理的であると考えるものをことはできません。真剣に。それは心を揺さぶる。

オプションを解析するために他のモジュールを拡張するモジュールを作成する必要があるのはなぜですか？なぜ何かをサブクラス化する必要があるのですか？コマンドラインを解析するためだけに「フレームワーク」をサブスクライブする必要があるのはなぜですか？

上記のTrollopバージョンは次のとおりです。

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

以上です。opts今キーを持つハッシュである:quiet、:interactiveと:filename。あなたはそれで好きなことをすることができます。画面の幅に合わせてフォーマットされた美しいヘルプページ、自動の短い引数名、タイプチェックなど、必要なものがすべて表示されます。

これは1つのファイルなので、正式な依存関係が必要ない場合は、lib /ディレクトリにドロップできます。それは簡単に拾うことができる最小限のDSLを持っています。

オプションの人あたりのLOC。それは重要です。

私はあなたのために嫌悪感を共有するrequire 'getopts'主な原因である素晴らしさに、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}

これが私が通常使う標準的なテクニックです：

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

誰も言及していないようで、タイトルは安価なコマンドライン解析を指しているので、Rubyインタープリターに作業を任せてみませんか？-s（たとえば、シバンで）スイッチを渡すと、1文字のグローバル変数に割り当てられた、ごく単純なスイッチが無料で手に入ります。このスイッチを使用した例を次に示します。

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

そして、これを保存して./testchmodしたときの出力は+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"]

詳細ruby -hについては、を参照してください。

それはできるだけ安くなければなりません。次のようなスイッチを試すと、NameErrorが発生します。-:そこにいくつかの検証があります。もちろん、スイッチ以外の引数の後にスイッチを配置することはできませんが、特別なことが必要な場合は、最小限のOptionParserを使用する必要があります。実際、この手法について私を悩ます唯一のことは、未設定のグローバル変数にアクセスすると警告が表示されることです（有効にした場合）が、それでもまだ誤っているため、使い捨てツールとクイックスクリプト。

「Rubyで非常に安価なコマンドラインオプションを解析する方法」のコメントでFelipeCが指摘した警告の1つは、シェルが3トークンシバンをサポートしていない可能性があることです。/usr/bin/env ruby -wRubyへの実際のパス（など/usr/local/bin/ruby -w）に置き換えるか、ラッパースクリプトなどから実行する必要がある場合があります。

私はmicro-optparseを作成して、短くて使いやすいoption-parserのこの明白なニーズを満たすようにしました。Trollopに似た構文を持ち、70行短いです。検証が不要で、空の行なしで実行できる場合は、45行に減らすことができます。それがまさにあなたが探していたものだと思います。

短い例：

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!

-hまたはで--help印刷するスクリプトを呼び出す

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

入力がデフォルト値と同じタイプかどうかをチェックし、短いアクセサと長いアクセサを生成し、無効な引数が指定された場合は説明的なエラーメッセージを出力します。

私はいくつかのオプションパーサーを比較し、それぞれのオプションパーサーを使用して問題を解決しました。これらの例と私の要約を使用して、有益な決定を行うことができます。リストに実装を追加してください。:)

なぜあなたがoptparseを避けたいのか私は完全に理解しています-それはあまりにも多くなるかもしれません。しかし、ライブラリとして提供される（OptParseと比べて）はるかに「軽い」ソリューションがいくつかありますが、単一のgemインストールを価値あるものにするのに十分なほど単純です。

たとえば、このOptiFlagの例を確認してください。処理のためのほんの数行。ケースに合わせて少し切り詰めた例：

require 'optiflag'

module Whatever extend OptiFlagSet
  flag "f"
  and_process!
end 

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

ありすぎて、カスタマイズの例のトンが。もっと簡単な別の方法を使用したことを思い出しましたが、今のところそれは脱出していますが、見つかったらここに戻ってコメントを追加します。

これは私が本当に、本当に安い引数に使用するものです：

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

main

したがって、実行programname foo barするとfooが呼び出され、次にbarが呼び出されます。使い捨てスクリプトに便利です。

あなたは次のようなことを試すことができます：

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

トールをwycatsで検討しましたか？optparseよりもずっときれいだと思います。すでにスクリプトを作成している場合は、それをフォーマットしたり、リファクタリングしたりするのに少し手間がかかるかもしれませんが、オプションの処理が非常に簡単になります。

以下は、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はコマンドを次のように自動的にマッピングします。

app install myname --force

これは次のように変換されます：

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

1. Thorから継承してクラスをオプションマッパーに変換する
2. 追加の無効な識別子を特定のメソッドにマップします。この場合、-Lを：listに変換します
3. すぐ下に方法を記述します。最初のパラメーターは使用法情報で、2番目のパラメーターは説明です。
4. 追加のオプションを提供します。これらは-および-paramsからマーシャリングされます。この場合、-forceおよび-fオプションが追加されます。

これが私のお気に入りの汚いオプションパーサーです。

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

オプションは正規表現であるため、「-h」は「--help」にも一致します。

読みやすく、覚えやすく、外部ライブラリはなく、最小限のコード。

Trollopはかなり安いです。

gemを使用せずにキー/値コマンドの単純なコマンドラインパーサーが必要な場合：

ただし、これは常にキーと値のペアがある場合にのみ機能します。

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

チェックが必要ない場合は、次のように使用できます。

opts = {} 

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

これが、ほとんどのスクリプトの上部で使用するコードスニペットです。

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

また、汚いスクリプトで追加のファイルを要求することも嫌いです。私の解決策は、あなたが求めているものに非常に近いものです。コマンドラインを解析して位置引数を固定し、ハッシュオブジェクト（通常は、arghashという名前のオブジェクトに割り当てられている）に切り替える、スクリプトの先頭に10行のコードスニペットを貼り付けます、以下の例でます。

解析するコマンドラインの例を次に示します...

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

このようなハッシュになります。

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

さらに、2つの便利なメソッドがハッシュに追加されています。

• argc() 非スイッチ引数の数を返します。
• switches() 存在するスイッチのキーを含む配列を返します

これは、次のような迅速で汚いものを許可することを意味します...

• 渡されたスイッチに関係なく、位置引数の数が正しいことを確認します（ arghash.argc == 2）で
• 位置引数の前または間にあるスイッチに関係なく、相対位置で位置引数にアクセスします（たとえば、arghash[1]常に2番目の非スイッチ引数を取得します）。
• 「--max = 15」などのコマンドラインで値が割り当てられたスイッチをサポートします。arghash['--max=']これにより、コマンドラインの例で「15」の値が得られます。
• スイッチが存在する場合はarghash['-s']true、存在しない場合はnilと評価するなどの非常に単純な表記法を使用して、コマンドラインでスイッチの有無をテストします。

• 次のような集合演算を使用して、スイッチまたはスイッチの代替の存在をテストします。

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

• 次のような集合演算を使用して無効なスイッチの使用を識別します

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

• Hash.merge()設定されていない場合は-max =の値を入力し、渡されなかった場合は4番目の位置引数を追加する次の例のような簡単な方法を使用して、欠落している引数のデフォルト値を指定します。

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

これは受け入れられた回答と非常に似ていますが、ARGV.delete_if私が使用しているのは、単純なパーサーで使用する方法です。唯一の真の違いは、引数付きのオプションは一緒になければならないということです（例：）-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}"

どうやら@WilliamMorganと私は似ていると思います。昨夜Githubにリリースしたばかりです。GithubでOptionParserを検索した後、Trollopと同様のライブラリ（名前は？）が表示されるようになりました。スイッチを参照してください。

いくつかの違いがありますが、哲学は同じです。明らかな違いの1つは、SwitchesがOptionParserに依存していることです。

Acclaimという独自のオプションパーサーgemを開発しています。

gitスタイルのコマンドラインインターフェイスを作成し、各コマンドの機能を個別のクラスに明確に分離できるようにしたかったので、それを記述しましたが、コマンドフレームワーク全体がなくても使用できます。

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

現時点では安定版リリースはありませんが、次のような機能をすでに実装しています。

• カスタムオプションパーサー
• 最小とオプションの両方を可能にするオプションの引数の柔軟な解析
• 多くのオプションスタイルのサポート
• 同じオプションの複数のインスタンスを置換、追加、または発生させる
• カスタムオプションハンドラー
• カスタム型ハンドラー
• 共通標準ライブラリクラスの定義済みハンドラ

コマンドには多くの重点が置かれているため、単純なコマンドライン解析では少し重いかもしれませんが、うまく機能し、すべてのプロジェクトで使用しています。コマンドインターフェースの側面に興味がある場合は、プロジェクトのGitHubページで詳細と例を確認してください。

コマンドに次のような最大1つのアクションと任意の数のオプションがあるとします。

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

検証なしの解析は次のようになります。

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）、外部オプションパーサーに依存しません。仕事を終わらせます。おそらく他のものほどフル機能ではありませんが、46LOCです。

コードをチェックすると、基礎となる手法をかなり簡単に複製できます。ラムダを割り当て、アリティを使用して、本当に外部ライブラリが必要ない場合は、適切な数の引数がフラグに続くようにします。

シンプル。安いです。

編集：合理的なコマンドラインパーサーを作成するためにスクリプトにコピー/貼り付けする可能性があると思うので、根底にあるコンセプトを煮詰めました。それは間違いなく私がメモリにコミットするものではありませんが、ラムダアリティを安価なパーサーとして使用することは斬新なアイデアです。

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

しばらく取り組んできた独自のシンプルなオプションパーサーを共有します。わずか74行のコードで、Gitの内部オプションパーサーが行うことの基本を実行します。OptionParserとGitをインスピレーションとして使用しました。

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

次のようになります。

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は、コードを解析するオプションをまったく必要としません。ヘルプテキストを書いて、要求し、完了します。

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