optiongrouper 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.yardopts

@@ -0,0 +1,11 @@
+--title
+OptionGrouper
+-m
+markdown
+-M
+maruku
+--readme
+README.md
+--no-private
+
+lib/**/*.rb

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kővágó, Zoltán
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+OptionGrouper
+=========
+
+Command line option parsing, inspired by trollop, in an unusual way.
+
+## Quick intro
+
+Options are grouped into groups, you can define the same option in more than one
+group. In this case, you can use a `--group:option` syntax on the command line.
+
+The default group (`:default`, also used when you do not specify a name) is a
+bit special, as you do not need to prefix commands in this group.
+
+    require 'optiongrouper'
+
+    opts = OptionGrouper.new do
+      version "My Program 1.0"
+      header "\nUsage:\n  my_program [options]\n\n"
+
+      group do
+        opt :debug, "Enable debugging"
+      end
+
+      group :debug do
+        header "Debugging options"
+        opt :level, "Set debug level", :value => :integer, :default => 0
+        opt :kill, "Kill the process <PID> with signal <SIGNAL>", :value =>
+          [[:integer, "PID"], [:integer, "SIGNAL"]]
+      end
+    end.parse
+
+    # opts[:default][:debug] is true if --debug was passed on command line
+    # opts[:debug][:kill] contains an array with [PID, SIGNAL]
+    # etc
+
+Hope you get the idea now.
+
+## Contributing to optiongrouper
+
+* Check out the latest master to make sure the feature hasn't been implemented
+  or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it
+  and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to
+  have your own version, or is otherwise necessary, that is fine, but please
+  isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright © 2010 Kővágó, Zoltán. See [LICENSE.txt](LICENSE.txt) for further
+details.
+

data/Rakefile

@@ -0,0 +1,42 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+require 'rubygems'
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "optiongrouper"
+  gem.homepage = "http://github.com/DirtYiCE/optiongrouper"
+  gem.license = "MIT"
+  gem.summary = "Command line option parsing library"
+  gem.description = "Command line option parsing library with some fancy features"
+  gem.email = "DirtY.iCE.hu@gmail.com"
+  gem.authors = ["Kővágó, Zoltán"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_runtime_dependency "blockenspiel", "~> 0.4.0"
+  gem.add_development_dependency "rspec", "~> 2.1.0"
+  gem.add_development_dependency "yard", "~> 0.6.0"
+  gem.add_development_dependency "jeweler", "~> 1.5.1"
+  gem.add_development_dependency "rcov", ">= 0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/optiongrouper.rb

@@ -0,0 +1,449 @@
+require 'blockenspiel'
+
+# A basic command line option parser with group support.
+class OptionGrouper
+  include Blockenspiel::DSL
+
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).strip
+
+  # A Group contains some parameters
+  class Group
+    include Blockenspiel::DSL
+
+    # Initialize a new group
+    # @param name [Symbol] name of the group
+    def initialize name
+      @name = name
+      @long = name.to_s.gsub(/_/, '-')
+      @opts = {}
+    end
+
+    # Invoke Group in a block to configure
+    def invoke &blk
+      Blockenspiel.invoke blk, self
+    end
+
+    # Define a new option
+    # @param name [Symbol] name of the parameter. Underscores will be converted
+    #  to hypens in long argument, and a short one will be generated unless you
+    #  define one or you declare not to generate one.
+    # @param desc [#to_s] description of the argument.
+    # @param opts [Hash] additional options.
+    # @option opts [String] :long use this as a long option.
+    # @option opts [String] :short use this as a short option (must be 1
+    #  character long to work)
+    # @option opts [Boolean] :no_short do not automatically generate a short
+    #  option if set to true
+    # @option opts [Proc] :on invoke block after parsing argument
+    # @option opts [Symbol, Array<Symbol>, Array<Array<Symbol, String>>]
+    #  :value describe additional values to the argument. Symbols declare the
+    #  type of the value, and also the string displayed on help page using
+    #  `[[Symbol, String], ...]` syntax.
+    # @option opts :default (nil) default value of the option if not specified
+    #  on command line.
+    # @option opts :set (true) set valueless commands to this if specified.
+    # @return [void]
+    def opt name, desc, opts = {}
+      opts[:desc] = desc
+      opts[:long] ||= name.to_s.gsub(/_/, '-')
+      opts[:set] ||= true
+      @opts[name] = opts
+    end
+
+    # Defines the name used in command line. By default it's the normal name
+    # with underscores replaced with hyphens. It's not advised to change it.
+    # @overload long()
+    #  Gets current command line name.
+    #  @return [String] current name
+    # @overload long str
+    #  Sets current command line name.
+    #  @return [String] the newly set name
+    def long *args
+      if args.size == 0
+        @long
+      else
+        @long = args[0]
+      end
+    end
+
+    # @overload header
+    #  Gets current header message.
+    #  @return [String] header message
+    # @overload header str
+    #  Sets a new header message
+    #  @param str [String] new header message
+    #  @return [String] header message
+    def header *args
+      if args.size == 0
+        if @header
+          "#{@header} (#{@long}):"
+        else
+          "#{@long}:"
+        end
+      else
+        @header = args[0]
+      end
+    end
+
+    # @private
+    attr_reader :opts
+  end
+
+  # Initialize an OptionGrouper. You can configure it using the yielded block.
+  def initialize &blk
+    @groups = {}
+    @on_version = :exit
+    @on_help = :exit
+    @on_invalid_parameter = :exit
+    @on_ambigous_parameter = :exit
+    @on_not_argument = :exit
+
+    run = Proc.new { show_help }
+    group do
+      header 'General options'
+      opt :help, 'Show this message', :short => 'h', :on => run
+    end
+
+    invoke &blk if blk
+  end
+
+  # Yield the configurator block again.
+  def invoke &blk
+    Blockenspiel.invoke blk, self
+  end
+
+  # What to do after printing version.
+  # * `:exit`: call exit to quit the program.
+  # * `:continue`: continue processing
+  # * `:stop`: stop processing
+  # * a Proc: call it
+  # @param res [Symbol, Proc] do this.
+  # @return [void]
+  def on_version res
+    @on_version = res
+  end
+
+  # What to do after printing help. Takes same options as \{#on_version}.
+  def on_help res
+    @on_help = res
+  end
+
+  # What to do after an invalid parameter. Takes the same options as
+  # \{#on_version}, except you can also use `:raise` to raise an exception.
+  def on_invalid_parameter to
+    @on_invalid_parameter = to
+  end
+
+  # What to do after an ambigous parameter. Takes same options as
+  # \{#on_invalid_parameter}.
+  def on_ambigous_parameter to
+    @on_ambigous_parameter = to
+  end
+
+  # What to do with a non-option string. Takes same options as
+  # \{#on_invalid_parameter}.
+  def on_not_argument to
+    @on_not_argument = to
+  end
+
+  # Sets the version of the program
+  # @param version [#to_s] program name and version.
+  # @return [void]
+  def version version
+    @version = version
+    run = Proc.new { show_version }
+    group :default do
+      opt :version, 'Show version', :on => run
+    end
+  end
+
+  # Sets header printed when help is requested.
+  # @param str [#to_s] header message
+  # @return [void]
+  def header str
+    @header = str
+  end
+
+  # Define a new group, if needed, then invoke it.
+  # @param name [Symbol] name of the group
+  # @yield a configuration block
+  # @return [Group] the defined group
+  def group name = :default, &blk
+    @groups[name] ||= Group.new(name)
+    @groups[name].invoke &blk
+    @groups[name]
+  end
+
+  # Parse command line arguments
+  # @param args [Array<String>] list of command line arguments.
+  # @return [Hash] \{#result}
+  def parse args = ARGV
+    init_parse
+
+    catch(:stop) do
+      while a = args.shift
+        if a == '--'
+          break
+        elsif a =~ /^--[^-]/
+          handle_long args, a
+        elsif a =~ /^-[^-]/
+          handle_short args, a
+        else
+          @ignored << a
+          on_error @on_not_argument, "`#{a}' is not an argument."
+        end
+      end
+    end
+    @result
+  ensure
+    args.unshift *@ignored
+  end
+
+  # Hash of parsed results.
+  # Hash keys are the group names, values are another hashes, where key is the
+  # option name and value is the parsed value.
+  # @return [Hash{Symbol => Hash{Symbol => Object}}]
+  attr_reader :result
+
+  # Stop argument processing (call it in callbacks)
+  def stop
+    throw :stop
+  end
+
+  private
+  # @private
+  # Marker for ambigous arguments without group
+  AMBIGOUS = -1
+
+  # Initialize parsing structures
+  def init_parse
+    # list of long arguments without group
+    @long_nogrp = {}
+    # long arguments in group:name format
+    @long_grp = {}
+    # short arguments
+    @shorts = {}
+    @result = {}
+    @group_names = {}
+    # list of ignored parameters
+    @ignored = []
+
+    @groups.each do |gname, grp|
+      @group_names[grp.long] = gname
+
+      @result[gname] = {}
+      grp.opts.each do |oname, opt|
+        long = opt[:long].to_s
+        if @long_nogrp[long] # if this group is already defined
+          unless @long_nogrp[long][0] == :default
+            # only mark as ambigous if the other item is not in the default group
+            ot = @long_nogrp[long][@long_nogrp[0] == AMBIGOUS ? 1..-1 : 0]
+            @long_nogrp[long] = [AMBIGOUS, ot, gname].flatten
+          end
+        else
+          @long_nogrp[long] = [gname, oname]
+        end
+        @long_grp["#{grp.long}:#{long}"] = [gname, oname]
+        short_coll gname, oname if @shorts[opt[:short]]
+        @shorts[opt[:short]] = [gname, oname] if opt[:short]
+
+        @result[gname][oname] = opt[:default]
+      end
+    end
+    # after gone through the list once, fill in unset short parameters
+    # automatically
+    @groups.each do |gname, grp|
+      grp.opts.each do |oname, opt|
+        next if opt[:short] || opt[:no_short]
+        opt[:long].each_char do |c|
+          next if c == "-"
+          if !@shorts[c]
+            @shorts[c] = [gname, oname]
+            break
+          elsif !@shorts[c.capitalize]
+            @shorts[c.capitalize] = [gname, oname]
+            break
+          end
+        end
+      end
+    end
+  end
+
+  # Called when two options try to set the same short argument.
+  def short_coll g, o
+    s = @groups[g].opts[o][:short]
+    a = @shorts[s]
+    raise RuntimeError, "`--#{a.join ':'}` and `--#{g}:#{o}' both tried to set short option `-#{s}'."
+  end
+
+  # Handle long parameters (`--xx`)
+  def handle_long args, a
+    arg = a[2..-1].split '=', 2
+
+    # Check first if we have group defined
+    grparg = arg[0].split ':', 2
+    if grparg.size == 2
+      unless @group_names[grparg[0]]
+        c = @group_names.select {|k,v| k.start_with? grparg[0] }
+        return invalid_parameter a if c.size == 0
+        return ambigous_parameter a, c.map {|k,v| "#{k}:..." } if c.size > 1
+        grparg[0] = c.keys.first
+      end
+      find = "#{grparg[0]}:#{grparg[1]}"
+      long = @long_grp
+    else
+      find = arg[0]
+      long = @long_nogrp
+    end
+
+    x = long[find]
+    unless x # handle abbreviated options
+      c = long.select {|k,v| k.start_with? find }
+      return invalid_parameter a if c.size == 0
+      return ambigous_parameter a, c.keys if c.size > 1
+      x = c.values.first
+    end
+    return ambigous_parameter a, x[1..-1].map {|m| "#{m}:#{arg[0]}"} if x[0] == AMBIGOUS
+    opt = @groups[x[0]].opts[x[1]]
+
+    handle_general args, x, opt, arg[1]
+  end
+
+  # Handle short options
+  def handle_short args, arg, a = arg[1..-1]
+    x = @shorts[a[0]]
+    return invalid_parameter "-#{a}" unless x
+    opt = @groups[x[0]].opts[x[1]]
+
+    # If it has a value, we take anything left in the argument as value
+    if opt[:value] && a.size > 1
+      handle_general args, x, opt, a[1..-1]
+    else
+      handle_general args, x, opt
+      handle_short args, arg, a[1..-1] if a.size > 1
+    end
+  end
+
+  def handle_general args, x, opt, value = nil
+    if opt[:value]
+      if opt[:value].is_a? Array
+        @result[x[0]][x[1]] = opt[:value].map do |v|
+          z = parse_param(value || args.shift, v)
+          value = nil
+          z
+        end
+      else
+        @result[x[0]][x[1]] = parse_param(value || args.shift, opt[:value])
+      end
+    else
+      @result[x[0]][x[1]] = opt[:set]
+    end
+    opt[:on].call @result[x[0]][x[1]] if opt[:on]
+  end
+
+  def invalid_parameter par
+    @ignored << par
+    on_error @on_invalid_parameter, "Unknown argument `#{par}'."
+  end
+
+  def ambigous_parameter par, cand
+    @ignored << par
+    msg = "Ambigous parameter `#{par}'.\nCandidates:\n"
+    msg << cand.map {|m| "  --#{m}" }.join("\n")
+    on_error @on_ambigous_parameter, msg
+  end
+
+  def show_version
+    puts @version
+    on_general @on_version
+  end
+
+  def show_help
+    puts @version if @version
+    puts @header if @header
+
+    prompts = {}
+    max = 1
+    @groups.each do |gname, grp|
+      prompts[gname] = {}
+      grp.opts.each do |oname, opt|
+        short = @shorts.key [gname, oname]
+        msg = short ? " -#{short}, " : "     "
+        if @long_nogrp[opt[:long]][0] != gname
+          msg << "--#{grp.long}:#{opt[:long]}"
+        else
+          msg << "--#{opt[:long]}"
+        end
+        if opt[:value].is_a? Array
+          opt[:value].each {|v| msg << param_display(v) }
+        elsif opt[:value]
+          msg << param_display(opt[:value])
+        end
+        prompts[gname][oname] = msg
+        max = msg.size if msg.size > max
+      end
+    end
+
+    @groups.each do |gname, grp|
+      puts grp.header
+      grp.opts.each do |oname, opt|
+        printf "%#{max}s: %s\n", prompts[gname][oname], opt[:desc]
+      end
+      puts
+    end
+
+    on_general @on_help
+  end
+
+  def on_general on
+    case on
+    when :exit
+      exit
+    when :continue
+      # nop
+    when :stop
+      stop
+    else
+      on.call
+    end
+  end
+
+  def on_error on, msg
+    case on
+    when :exit
+      $stderr.puts msg
+      $stderr.puts "\nRun with `--help' to get help."
+      exit
+    when :raise
+      raise RuntimeError, msg
+    when :continue
+      # nop
+    when :stop
+      stop
+    else
+      on.call msg
+    end
+  end
+
+  def parse_param param, type
+    type = type[0] if type.is_a? Array
+    if type.is_a? Proc
+      type.call param
+    elsif Kernel.respond_to? type.to_s.capitalize
+      Kernel.send type.to_s.capitalize, param
+    else
+      raise RuntimeError, "Unknown type #{type.inspect} specified"
+    end
+  end
+
+  def param_display type
+    str = if type.is_a? Array
+            type[1]
+          elsif type.is_a? Proc
+            "PARAM"
+          else
+            type.to_s.upcase
+          end
+    " <#{str}>"
+  end
+end

data/spec/optiongrouper_spec.rb

@@ -0,0 +1,497 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe OptionGrouper do
+  before(:each) { $stdout = StringIO.new; $stderr = StringIO.new }
+  after(:each) { $stdout = STDOUT; $stderr = STDERR }
+  let(:out) { $stdout.string }
+  let(:err) { $stderr.string }
+
+  describe 'built-in commands' do
+    it 'should print a version number' do
+      OptionGrouper.new do
+        on_version :continue
+        version '0.0.0'
+      end.parse ['--version']
+      out.should == "0.0.0\n"
+    end
+
+    it 'should print a version number and exit' do
+      o = OptionGrouper.new do
+        version 'x.x.x'
+      end
+      o.parse []
+      lambda { o.parse ['--version'] }.should raise_error SystemExit
+      out.should == "x.x.x\n"
+
+      o.on_version :exit
+      lambda { o.parse ['--version'] }.should raise_error SystemExit
+    end
+
+    it 'should stop processing if told so' do
+      o = OptionGrouper.new do
+        on_version :stop
+        version '0.0.0'
+        group do
+          opt :foo, "Foo bar"
+        end
+      end
+      o.parse([])[:default][:foo].should be_nil
+      o.parse(['--foo'])[:default][:foo].should be_true
+      out.should be_empty
+      o.parse(%w(--version --foo))[:default][:foo].should be_nil
+      out.should == "0.0.0\n"
+    end
+
+    it 'should print a help message' do
+      o = OptionGrouper.new do
+        header "FooBar\n\n"
+        group do
+          opt :foo, "Do foo foo"
+        end
+        group :bar do
+          header "Bing"
+          opt :foo, "Foo collission"
+          opt :asd, "Asd asd", :value => :integer
+          opt :zee, "Zee", :value => [:string, :integer]
+          opt :fee, "Fee", :value => [[:integer, 'INT'], [:string, 'STR']]
+        end
+        group :asd do
+          long :foobar
+          opt :foo, "Foo n+1", :no_short => true
+        end
+      end
+      lambda { o.parse ['--help'] }.should raise_error SystemExit
+      out.should == <<EOS
+FooBar
+
+General options (default):
+                   -h, --help: Show this message
+                    -f, --foo: Do foo foo
+
+Bing (bar):
+                -F, --bar:foo: Foo collission
+          -a, --asd <INTEGER>: Asd asd
+ -z, --zee <STRING> <INTEGER>: Zee
+        -e, --fee <INT> <STR>: Fee
+
+foobar:
+                 --foobar:foo: Foo n+1
+
+EOS
+    end
+  end
+
+  describe 'single-group long parameters' do
+    it 'should parse more valueless parameters' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "Foo"
+          opt :bar, "Bar", :default => 3, :set => 5
+          opt :asd, "Asd"
+          opt :def, "Def", :set => :def
+        end
+      end.parse(%w(--asd --def))[:default]
+      res[:foo].should be_nil
+      res[:bar].should == 3
+      res[:asd].should be_true
+      res[:def].should == :def
+    end
+
+    it 'should parse string arguments' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "Foo", :value => :string
+          opt :bar, "Bar", :value => :string, :default => "bar"
+          opt :asd, "Asd", :value => :string, :default => "asd"
+        end
+      end.parse(%w(--foo foo --asd gher))[:default]
+      res[:foo].should == "foo"
+      res[:bar].should == "bar"
+      res[:asd].should == "gher"
+    end
+
+    it 'should parse string arguments using =' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "Foo", :value => :string
+          opt :bar, "Bar", :value => :string, :default => "bar"
+          opt :asd, "Asd", :value => :string, :default => "asd"
+        end
+      end.parse(%w(--foo=foo --asd=gher))[:default]
+      res[:foo].should == "foo"
+      res[:bar].should == "bar"
+      res[:asd].should == "gher"
+    end
+
+    it 'should parse integer, float arguments' do
+      res = OptionGrouper.new do
+        group do
+          opt :int1, "int", :value => :integer
+          opt :int2, "int", :value => :integer, :default => 3
+          opt :flt1, "float", :value => :float, :default => 4.3
+          opt :flt2, "float", :value => :float, :default => 2.2
+        end
+      end.parse(%w(--int2=99 --flt1 9.8))[:default]
+      res[:int1].should be_nil
+      res[:int2].should == 99
+      res[:flt1].should be_within(0.0001).of(9.8)
+      res[:flt2].should be_within(0.0001).of(2.2)
+    end
+
+    it 'should parse using lambdas' do
+      res = OptionGrouper.new do
+        group do
+          opt :a, "a", :value => lambda {|s| Integer(s) + 5 }
+          opt :b, "b", :value => lambda {|s| Float(s) / 2 }
+        end
+      end.parse(%w(--a 1 --b=5))[:default]
+      res[:a].should == 6
+      res[:b].should be_within(0.0001).of(2.5)
+    end
+
+    it 'should parse multi value arguments' do
+      res = OptionGrouper.new do
+        group do
+          opt :a, "a", :value => [:string, :integer], :default => ["a", 3]
+          opt :b, "b", :value => [[:integer, "INT"], :string], :default => [7, "b"]
+          opt :c, "c", :value => [:integer, :integer, :string]
+        end
+      end.parse(%w(--b=2 foo --c 2 5 foo))[:default]
+      res[:a].should == ["a", 3]
+      res[:b].should == [2, "foo"]
+      res[:c].should == [2, 5, 'foo']
+    end
+  end
+
+  describe 'single-group short options' do
+    it 'should use supplied single arguments' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "foo", :short => 'f'
+          opt :bar, "bar", :short => 'b'
+          opt :asd, "asd", :short => 'a'
+        end
+      end.parse(%w(-f -ba))[:default]
+      res[:foo].should be_true
+      res[:bar].should be_true
+      res[:asd].should be_true
+    end
+
+    it 'should automatically generate single arguments' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+      end.parse(%w(-b))[:default]
+      res[:foo].should be_nil
+      res[:bar].should be_true
+    end
+
+    it 'should work with multiple options starting the same' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo1, "foo1"
+          opt :foo2, "foo2"
+          opt :foo3, "foo3"
+          opt :foo4, "foo4"
+          opt :foo5, "foo5"
+        end
+      end.parse(['-Fo5'])[:default]
+      res[:foo1].should be_nil
+      res[:foo2].should be_true
+      res[:foo3].should be_true
+      res[:foo4].should be_nil
+      res[:foo5].should be_true
+    end
+
+    it 'should parse values' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo, "foo", :value => :integer
+          opt :bar, "bar", :value => :string
+          opt :multi, "multi", :value => [:integer, :string]
+        end
+      end.parse(%w(-f 6 -bzizi -m3 bar))[:default]
+      res[:foo].should == 6
+      res[:bar].should == "zizi"
+      res[:multi].should == [3, "bar"]
+    end
+  end
+
+  describe 'single-group error handling' do
+    it 'should handle invalid commands' do
+      lambda { OptionGrouper.new.parse(['--foo']) }.should raise_error SystemExit
+      err.should == "Unknown argument `--foo'.\n\nRun with `--help' to get help.\n"
+    end
+
+    it 'should handle invalid short commands' do
+      lambda { OptionGrouper.new.parse(['-f']) }.should raise_error SystemExit
+      err.should == "Unknown argument `-f'.\n\nRun with `--help' to get help.\n"
+    end
+
+    it 'should ignore invalid commands' do
+      args = %w(--xd -x -f7 --bar)
+      res = OptionGrouper.new do
+        on_invalid_parameter :continue
+        group do
+          opt :foo, "foo", :value => :integer
+        end
+      end.parse(args)[:default]
+      res[:foo].should == 7
+      args.should == %w(--xd -x --bar)
+    end
+
+    it 'should stop processing at an invalid command' do
+      args = %w(--foo --xd --bar)
+      res = OptionGrouper.new do
+        on_invalid_parameter :stop
+        group do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+      end.parse(args)[:default]
+      res[:foo].should be_true
+      res[:bar].should be_nil
+      args.should == %w(--xd --bar)
+    end
+
+    it 'should raise an error on invalid commands' do
+      o = OptionGrouper.new { on_invalid_parameter :raise }
+      lambda { o.parse(['--foo']) }.should raise_error RuntimeError, "Unknown argument `--foo'."
+    end
+
+    it 'should call lambda on invalid command' do
+      check = 0
+      OptionGrouper.new do
+        on_invalid_parameter lambda {|msg| check += 1 }
+      end.parse ['--foo']
+      check.should == 1
+    end
+  end
+
+  describe 'single-group abbreviation' do
+    it 'should acceppt non-ambigous abbrevations' do
+      res = OptionGrouper.new do
+        group do
+          opt :foo_bar, "FooBar"
+          opt :asd, "Asd"
+        end
+      end.parse(['--foo'])[:default]
+      res[:foo_bar].should be_true
+      res[:asd].should be_nil
+    end
+
+    it 'should bail out on ambigous parameters' do
+      o = OptionGrouper.new do
+        group do
+          opt :foo_bar, "FooBar"
+          opt :foo_baz, "FooBaz"
+        end
+      end
+      l = lambda { o.parse ['--foo'] }
+      l.should raise_error SystemExit
+      msg = <<EOS
+Ambigous parameter `--foo'.
+Candidates:
+  --foo-bar
+  --foo-baz
+EOS
+      err.should == msg + "\nRun with `--help' to get help.\n"
+
+      o.on_ambigous_parameter :raise
+      l.should raise_error RuntimeError, msg.strip
+    end
+
+    it 'should ignore ambigous parameters (why?)' do
+      res = OptionGrouper.new do
+        on_ambigous_parameter :continue
+        group do
+          opt :foo_bar, "FooBar"
+          opt :foo_baz, "FooBaz"
+          opt :bar, "bar"
+        end
+      end.parse(%w(--foo --bar))[:default]
+      res[:foo_bar].should be_nil
+      res[:foo_baz].should be_nil
+      res[:bar].should be_true
+    end
+
+    it 'should stop on ambigous parameters' do
+      res = OptionGrouper.new do
+        on_ambigous_parameter :stop
+        group do
+          opt :foo_bar, "FooBar"
+          opt :foo_baz, "FooBaz"
+          opt :bar, "bar"
+        end
+      end.parse(%w(--foo --bar))[:default]
+      res[:foo_bar].should be_nil
+      res[:foo_baz].should be_nil
+      res[:bar].should be_nil
+    end
+  end
+
+  describe 'multi group' do
+    it 'should work with no collisions' do
+      res = OptionGrouper.new do
+        group :a do
+          opt :a, "a"
+          opt :a_b, "a b"
+        end
+        group :b do
+          opt :x, "x"
+          opt :yize, "y"
+        end
+      end.parse %w(--a-b -x --yize)
+      res[:a][:a].should be_nil
+      res[:a][:a_b].should be_true
+      res[:b][:x].should be_true
+      res[:b][:yize].should be_true
+    end
+
+    it 'should work with no collision full name qualifying' do
+      res = OptionGrouper.new do
+        group :aaa do
+          opt :a, "a"
+          opt :a_b, "a b"
+        end
+        group :bbb do
+          long "ccc"
+          opt :x, "x"
+          opt :yize, "y"
+        end
+      end.parse %w(--aaa:a-b --ccc:yize)
+      res[:aaa][:a].should be_nil
+      res[:aaa][:a_b].should be_true
+      res[:bbb][:x].should be_nil
+      res[:bbb][:yize].should be_true
+    end
+
+    it 'should work with collissions also' do
+      res = OptionGrouper.new do
+        group :abc do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+        group :def do
+          opt :foo, "foo"
+          opt :baz, "baz"
+        end
+      end.parse %w(--abc:foo --bar --baz)
+      res[:abc][:foo].should be_true
+      res[:abc][:bar].should be_true
+      res[:def][:foo].should be_nil
+      res[:def][:baz].should be_true
+    end
+
+    it 'should handle ambigous parameters' do
+      o = OptionGrouper.new do
+        group :abc do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+        group :def do
+          opt :foo, "foo"
+          opt :baz, "baz"
+        end
+      end
+      lambda { o.parse ['--foo'] }.should raise_error SystemExit
+      msg = <<EOS
+Ambigous parameter `--foo'.
+Candidates:
+  --abc:foo
+  --def:foo
+EOS
+      err.should == msg + "\nRun with `--help' to get help.\n"
+
+      o.on_ambigous_parameter :raise
+      lambda { o.parse ['--foo']}.should raise_error RuntimeError, msg.strip
+
+      o.on_ambigous_parameter :continue
+      res = o.parse %w(--foo --bar)
+      res[:abc][:foo].should be_nil
+      res[:abc][:bar].should be_true
+      res[:def][:foo].should be_nil
+      res[:def][:baz].should be_nil
+
+      o.on_ambigous_parameter :stop
+      res = o.parse %w(--foo --bar)
+      res[:abc][:foo].should be_nil
+      res[:abc][:bar].should be_nil
+      res[:def][:foo].should be_nil
+      res[:def][:baz].should be_nil
+    end
+
+    it 'should allow abbreviated groups' do
+      o = OptionGrouper.new do
+        group :abcd do
+          long "abgh"
+          opt :opt1, "opt1"
+        end
+        group :abef do
+          opt :opt2, "opt2"
+        end
+      end
+      res = o.parse %w(--abg:opt1)
+      res[:abcd][:opt1].should be_true
+      res[:abef][:opt2].should be_nil
+
+      lambda { o.parse %w(--ab:opt1) }.should raise_error SystemExit
+      err.should == <<EOS
+Ambigous parameter `--ab:opt1'.
+Candidates:
+  --abgh:...
+  --abef:...
+
+Run with `--help' to get help.
+EOS
+    end
+  end
+
+  describe 'not an option' do
+    it 'should bail out on not an option' do
+      lambda { OptionGrouper.new.parse %w(foo --bar) }.should raise_error SystemExit
+      err.should == "`foo' is not an argument.\n\nRun with `--help' to get help.\n"
+    end
+
+    it 'should throw an exception and stop' do
+      o = OptionGrouper.new do
+        on_not_argument :raise
+        group do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+      end
+      args = %w(--foo foo --bar)
+
+      lambda { o.parse args }.should raise_error RuntimeError, "`foo' is not an argument."
+      res = o.result[:default]
+      res[:foo].should be_true
+      res[:bar].should be_nil
+      args.should == %w(foo --bar)
+    end
+
+    it 'should ignore or stop' do
+      o = OptionGrouper.new do
+        on_not_argument :continue
+        group do
+          opt :foo, "foo"
+          opt :bar, "bar"
+        end
+      end
+      args = %w(--bar foo --foo)
+      res = o.parse(args)[:default]
+      res[:foo].should be_true
+      res[:bar].should be_true
+      args.should == ['foo']
+
+      o.on_not_argument :stop
+      args = %w(--bar foo --foo)
+      res = o.parse(args)[:default]
+      res[:foo].should be_nil
+      res[:bar].should be_true
+      args.should == %w(foo --foo)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'optiongrouper'
+require 'stringio'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: optiongrouper
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- "K\xC5\x91v\xC3\xA1g\xC3\xB3, Zolt\xC3\xA1n"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: blockenspiel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Command line option parsing library with some fancy features
+email: DirtY.iCE.hu@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+files: 
+- .document
+- .rspec
+- .yardopts
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/optiongrouper.rb
+- spec/optiongrouper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/DirtYiCE/optiongrouper
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Command line option parsing library
+test_files: 
+- spec/optiongrouper_spec.rb
+- spec/spec_helper.rb