Ruby 中真正便宜的命令行选项解析

Question

编辑：请，请，请在回复之前阅读本文底部列出的两个要求。人们不断发布他们的新 gems 和库之类的东西，显然不符合要求。

有时我想非常便宜地将一些命令行选项破解成一个简单的脚本。一种有趣的方法是：

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

这不是普通的 Unix 选项语法，因为它会接受选项非选项命令行参数，如“myprog -i foo bar -q”，但我可以接受。 （有些人，例如 Subversion 开发人员，更喜欢这个。有时我也喜欢。）

仅存在或不存在的选项无法比上述更简单地实现。 （一个赋值，一个函数调用，一个副作用。）是否有同样简单的方法来处理带参数的选项，例如“-f filename”？

编辑：

有一点我之前没有说明，因为直到 Trollop 的作者提到该库适合“在一个 [800 行] 文件中”，我才明白我不认为仅适用于简洁的语法，但适用于具有以下特征的技术：

1. 整个代码可以包含在脚本文件中（不会压倒实际的脚本本身，可能只有几十行），因此可以将单个文件放入bin dir 在任何具有标准 Ruby 1.8.[5-7] 安装的系统上并使用它。如果你不能编写一个没有 require 语句的 Ruby 脚本，并且解析几个选项的代码不到十几行左右，那么你就达不到这个要求。

2. 代码小而简单，以至于人们可以记住足够多的代码来直接输入代码，而不是从其他地方剪切和粘贴。想一想您在无法访问 Internet 的防火墙服务器的控制台上的情况，并且您想将一个快速脚本组合在一起供客户端使用。我不了解你，但是（除了不符合上述要求之外）即使是 45 行简化的 micro-optparse 也不是我想做的事。

Answer 1

作为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 的散列。你可以用它做任何你想做的事。你会得到一个漂亮的帮助页面，格式适合你的屏幕宽度，自动短参数名称，类型检查......你需要的一切。

这是一个文件，因此如果您不想要正式的依赖关系，可以将其放在您的 lib/ 目录中。它具有易于上手的最小 DSL。

LOC 每个选项的人。这很重要。

Answer 2

我和你一样厌恶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}

Answer 3

这是我通常使用的标准技术：

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

Answer 4

既然似乎没有人提到它，而且标题 确实 指的是 cheap 命令行解析，为什么不让 Ruby 解释器为您完成这项工作呢？如果您通过-s 开关（例如，在您的shebang 中），您将免费获得简单的开关，分配给单字母全局变量。这是您使用该开关的示例：

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

这是我将其保存为 ./test 并 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"]

详情请见ruby -h。

必须尽可能便宜。如果您尝试像-: 这样的开关，它将引发 NameError，因此那里有一些验证。当然，在非开关参数之后不能有任何开关，但如果你需要一些花哨的东西，你真的应该至少使用 OptionParser。事实上，这种技术唯一让我恼火的是，当你访问一个未设置的全局变量时，你会得到一个警告（如果你启用了它们），但它仍然是错误的，所以它适用于一次性工具并且快速脚本。

FelipeC 在 "How to do really cheap command-line option parsing in Ruby" 的 cmets 中指出的一个警告是，您的 shell 可能不支持 3-token shebang；您可能需要将 /usr/bin/env ruby -w 替换为您的 ruby​​ 的实际路径（如 /usr/local/bin/ruby -w），或者从包装脚本或其他方式运行它。

Answer 5

我构建了micro-optparse 来满足对简短但易于使用的选项解析器的明显需求。它的语法类似于 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

它检查输入是否与默认值的类型相同，生成短访问器和长访问器，如果给出了无效参数，则打印描述性错误消息等等。

我 compared several option-parser 使用每个选项解析器来解决我遇到的问题。 您可以使用这些示例和我的摘要来做出信息丰富的决定。 随意将更多实现添加到列表中。 :)

Answer 6

我完全理解您为什么要避免使用 optparse - 它可能会变得太多。但是有一些更“轻量级”的解决方案（与 OptParse 相比）作为库提供，但足够简单，可以让单个 gem 安装变得有价值。

例如，查看this OptiFlag example。只需几行即可进行处理。为您的案例量身定制的略微截断的示例：

require 'optiflag'

module Whatever extend OptiFlagSet
  flag "f"
  and_process!
end 

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

有tons of customized examples too。我记得使用了另一个更简单的方法，但它现在已经逃脱了我，但如果我找到它，我会回来并在此处添加评论。

Answer 7

这是我用的非常非常便宜的参数：

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

main

所以如果你运行programname foo bar，它会调用foo，然后调用bar。它对于一次性脚本很方便。

Answer 8

你可以试试这样的：

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

Answer 9

你考虑过 wycats 的Thor 吗？我认为它比 optparse 干净得多。如果您已经编写了脚本，则可能需要更多的工作来格式化它或为 thor 重构它，但它确实使处理选项变得非常简单。

这是自述文件中的示例 sn-p：

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. 在下面描述该方法。第一个参数是使用信息，第二个参数是描述。
4. 提供任何其他选项。这些将从 - 和 - 参数编组。在这种情况下，添加了 --force 和 -f 选项。

Answer 10

这是我最喜欢的快速而肮脏的选项解析器：

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

选项是正则表达式，所以“-h”也会匹配“--help”。

可读、易记、无需外部库、代码最少。

Answer 11

Trollop 相当便宜。

Answer 12

如果您想要一个简单的命令行解析器来处理键/值命令而不使用 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

Answer 13

这是我在大多数脚本顶部使用的代码 sn-p：

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

我也讨厌在我的快速而肮脏的脚本中要求额外的文件。我的解决方案非常接近您的要求。我在我的任何脚本的顶部粘贴了一个 10 行的 sn-p 代码，这些脚本解析命令行并粘贴位置参数并切换到 Hash 对象（通常分配给我命名为 arghash 的对象strong> 在下面的示例中）。

这是您可能想要解析的示例命令行...

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

这会变成这样的哈希。

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

除此之外，Hash 中还添加了两个方便的方法：

• argc() 将返回非开关参数的计数。
• switches() 将返回一个数组，其中包含当前开关的键

这是为了允许一些快速而肮脏的东西，比如......

• 验证无论传入的开关如何（arghash.argc == 2），我都有正确数量的位置参数
• 通过位置参数的相对位置访问位置参数，无论开关是否出现在位置参数之前或散布在位置参数中（例如，arghash[1] 总是获得第二个非开关参数）。
• 支持命令行中的赋值开关，例如“--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= 填充一个值，如果未传递，则添加第四个位置参数。

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

Answer 14

这与接受的答案非常相似，但使用的是ARGV.delete_if，这是我在simple parser 中使用的。唯一真正的区别是带参数的选项必须在一起（例如-lfile）。

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

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

Answer 15

显然@WilliamMorgan 和我的想法相似。我昨晚刚刚在 Github 上发布了一个类似于 Trollop 的库（命名如何？），在 Github 上搜索了 OptionParser 后，请参阅 Switches

有一些差异，但理念是相同的。一个明显的区别是 Switches 依赖于 OptionParser。

Answer 16

我正在开发my own option parser gem called Acclaim。

我写它是因为我想创建 git 风格的命令行界面，并且能够将每个命令的功能清晰地分离到单独的类中，但它也可以在没有整个命令框架的情况下使用：

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

目前还没有稳定版本，但我已经实现了一些功能，例如：

• 自定义选项解析器
• 灵活解析选项的参数，允许最小和可选
• 支持多种选项样式
• 在同一选项的多个实例上替换、追加或提升
• 自定义选项处理程序
• 自定义类型处理程序
• 通用标准库类的预定义处理程序

非常强调命令，因此对于简单的命令行解析可能有点繁重，但它运行良好，我一直在我的所有项目中使用它。如果您对命令接口方面感兴趣，请查看the project's GitHub page 了解更多信息和示例。

Answer 17

假设一个命令最多有一个操作和任意数量的选项，如下所示：

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

Answer 18

https://github.com/soveran/clap

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

46LOC（在 1.0.0），不依赖于外部选项解析器。完成工作。可能没有其他功能那么全，但它是 46LOC。

如果你检查代码，你可以很容易地复制底层技术——如果你真的不想要外部库，分配 lambda 并使用 arity 来确保正确数量的 args 跟随标志。

简单。便宜。

---

编辑：基本概念归结为我想您可以将其复制/粘贴到脚本中以制作合理的命令行解析器。这绝对是不是我会记住的东西，但是使用 lambda arity 作为廉价的解析器是一个新颖的想法：

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

Answer 19

我创建了一个非常简单但有用的解析器：parseopt。它使用 Git 的内部选项解析器作为灵感，也使用 Ruby 的 OptionParser。

看起来像这样：

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

opts.on('b', 'bool', 'Boolean') do |v|
 $bool = v
end

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

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

opts.parse