clive 0.1.0

data/.document

@@ -0,0 +1,2 @@
+lib/**/*.rb
+bin/*

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.yardoc
+doc
+ideas.rb
+research

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Joshua Hawxwell
+
+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,150 @@
+# clive
+
+Clive is a DSL for creating a command line interface. It is for people who, like me, love [OptionParser's](http://ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html) syntax and love [GLI's](http://github.com/davetron5000/gli) commands.
+
+## Install
+
+Install with:
+    
+    (sudo) gem install clive
+    
+
+## How To
+
+A simple example to start:
+
+    require 'clive'
+    
+    opts = {}
+    c = Clive.new do
+      switch(:v, :verbose, "Run verbosely") {opts[:verbose] = true}
+    end
+    c.parse(ARGV)
+    p opts
+
+This creates a very simple interface which can have one switch, you can then use the long or short form to call the block.
+
+    my_file -v
+    #=> {:verbose => true}
+    my_file --verbose
+    #=> {:verbose => true}
+    
+
+### Switches
+
+As we've seen above switches are created using #switch. You can provide as little information as you want. `switch(:v) {}` creates a switch that responds only to `-v`, or `switch(:verbose) {}` creates a switch that only responds to `--verbose`.
+
+### Flags
+
+Flags are like switches but also take an argument:
+
+    c = Clive.new do
+      flag(:p, :print, "Print the argument") do |i|
+        p i
+      end
+    end
+    c.parse(ARGV)
+    
+    ####
+    
+    my_file --print=hello
+    #=> "hello"
+    my_file --print equalsless
+    #=> "equalsless"
+    my_file -p short
+    #=> "short"
+
+The argument is then passed into the block. As you can see you can use short, long, equals, or no equals to call flags. As with switches you can call `flag(:p) {|i| ...}` which responds to `-p ...`, `flag(:print) {|i| ...}` which responds to `--print ...` or `--print=...`.
+
+### Commands
+
+Commands work like in git, here's an example:
+    
+    opts = {}
+    c = Clive.new do
+      command(:add) do
+        opts[:add] = {}
+        flag(:r, :require, "Require a library") {|i| opts[:add][:lib] = i}
+      end
+    end
+    c.parse(ARGV)
+    p opts
+    
+    ####
+    
+    my_file add -r Clive
+    #=> {:add => {:lib => "Clive"}}
+
+Commands make it easy to group flags, switches and even other commands. The block for the command is executed on finding the command, this allows you to put other code within the block specific for the command, as shown above.
+
+
+### Arguments
+
+Anything that isn't a command, switch or flag is taken as an argument. These are returned by #parse as an array. 
+    
+    opts = {}
+    c = Clive.new do
+      flag(:size) {|i| opts[:size] = i}
+    end
+    args = c.parse(ARGV)
+    p args
+    
+    ####
+    
+    my_file --size big /usr/bin
+    #=> ["/usr/bin"]
+
+### Putting It All Together
+
+    require 'clive'
+    
+    opts = {}
+    c = Clive.new do
+      switch(:v, :verbose, "Run verbosely") {opts[:verbose] = true}
+      
+      command(:add, "Add a new project")) do
+        opts[:add] = {}
+        
+        switch(:force, "Force overwrite") {opts[:add][:force] = true}
+        flag(:framework, "Add framework") do |i| 
+          opts[:add][:framework] ||= []
+          opts[:add][:framework] << i
+        end
+        
+        command(:init, "Initialize the project after creating") do
+          switch(:m, :minimum, "Use minimum settings") {opts[:add][:min] = true}
+          flag(:width) {|i| opts[:add][:width] = i.to_i}
+        end
+      
+      end
+      
+      switch(:version, "Show version") do
+        puts "1.0.0"
+        exit
+      end
+    end
+    args = c.parse(ARGV)
+    p opts
+    p args
+    
+    ####
+    
+    my_file --version
+    #=> 1.0.0
+    my_file -v add --framework=blueprint init -m -w 200 ~/Desktop/new_thing ~/Desktop/another_thing
+    #=> {:verbose => true, :add => {:framework => ["blueprint"], :min => true, :width => 200}}
+    #=> ["~/Desktop/new_thing", "~/Desktop/another_thing"]
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2010 Joshua Hawxwell. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "clive"
+    gem.summary = %Q{Imagine if optparse and gli had a son called clive.}
+    gem.description = %Q{Clive is a DSL for creating a command line interface. It is for people who, like me, love OptionParser's syntax and love GLI's commands.}
+    gem.email = "m@hawx.me"
+    gem.homepage = "http://github.com/hawx/clive"
+    gem.authors = ["Joshua Hawxwell"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/clive.rb

@@ -0,0 +1,45 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'clive/tokens'
+require 'clive/ext'
+require 'clive/switches'
+require 'clive/flags'
+require 'clive/commands'
+
+# Clive is a simple dsl for creating command line interfaces
+#
+# @example Simple Example
+#
+#   opts = {}
+#   c = Clive.new do
+#     switch(:v, :verbose, "Run verbosely") {
+#       opts[:verbose] = true
+#     }
+#   end
+#   c.parse(ARGV)
+#
+class Clive
+
+  attr_accessor :base
+  
+  def initialize(&block)
+    @base = Command.new(true, &block)
+  end
+  
+  def parse(argv)
+    @base.run(argv)
+  end
+  
+  def switches
+    @base.switches
+  end
+  
+  def commands
+    @base.commands
+  end
+  
+  def flags
+    @base.flags
+  end
+  
+end

data/lib/clive/commands.rb

@@ -0,0 +1,224 @@
+class Clive
+  
+  # A string which describes the command to execute
+  #   eg. git add
+  #       git pull
+  #
+  class Command
+    
+    attr_accessor :switches, :flags, :commands
+    attr_accessor :name, :desc, :block, :argv
+    attr_accessor :base
+    
+    # Create a new Command instance
+    #
+    # @overload initialize(base, &block)
+    #   Creates a new base Command to house everything else
+    #   @param [Boolean] base whether the command is the base
+    #
+    # @overload initialize(name, desc, &block)
+    #   Creates a new Command as part of the base Command
+    #   @param [Symbol] name the name of the command
+    #   @param [String] desc the description of the command
+    #
+    # @yield A block to run, containing switches, flags and commands
+    #
+    def initialize(*args, &block)
+      @argv     = []
+      @switches = Clive::Array.new
+      @flags    = Clive::Array.new
+      @commands = Clive::Array.new
+    
+      if args.length == 1 && args[0] == true
+        @base = true
+        self.instance_eval(&block)
+      else
+        @base = false
+        args.each do |i|
+          case i
+          when Symbol
+            @name = i.to_s
+          when String
+            @desc = i
+          end
+        end
+        @block = block
+      end
+    end
+    
+    # Run the block that was passed to find switches, flags, etc.
+    #
+    # This should only be called if the command has been called
+    # as the block could contain other actions to perform only 
+    # when called.
+    #
+    def find
+      return nil if @base
+      self.instance_eval(&@block)
+    end
+    
+    # Parse the ARGV passed from the command line, and run
+    #
+    # @param [Array] argv the command line input, usually just ARGV
+    # @return [Array] any arguments that were present in the input but not used
+    #
+    def run(argv)
+      tokens = argv
+      tokens = tokenize(argv) if @base
+      
+      r = []
+      tokens.each do |i|
+        k, v = i[0], i[1]
+        case k
+        when :command
+          v.run(i[2])
+        when :switch
+          v.run
+        when :flag
+          v.run(i[2])
+        when :argument
+          r << v
+        end
+      end
+      r
+    end
+    
+    # Turns the command line input into a series of tokens.
+    # It will only raise errors if this is the base command instance.
+    #
+    # @param [Array] argv the command line input
+    # @return [Array] a series of tokens
+    #
+    # @example
+    #
+    #   c.tokenize(["add", "-al", "--verbose"])
+    #   #=> [[:command, #<Clive::Command>, ...args...], [:switch, "a", 
+    #        #<Clive::Switch>], [:switch, "l", #<Clive::Switch>], [:switch, 
+    #        "verbose", #<Clive::Switch>]]
+    #
+    def tokenize(argv)
+      tokens = []
+      pre = Tokens.to_tokens(argv)
+      command = nil
+      @argv = argv unless @base
+      
+      pre.each do |i|
+        k, v = i[0], i[1]
+        case k
+        when :word
+          if @commands[v]
+            command = @commands[v]
+            pre -= [[:word, v]]
+          end
+        end
+      end
+      
+      if command
+        command.find
+        # tokenify the command
+        tokens << [:command, command, command.tokenize(Tokens.to_array(pre))]
+        pre = Tokens.to_tokens(command.argv)
+      end 
+      
+      pre.each do |i|
+        k, v = i[0], i[1]
+        case k
+        when :short, :long
+          if switch = @switches[v]
+            tokens << [:switch, switch]
+            pre -= [[k, v]] unless @base
+          elsif flag = @flags[v]
+            tokens << [:flag, flag]
+            pre -= [[k, v]] unless @base
+          else
+            raise "error, flag/switch '#{v}' does not exist" if @base
+          end
+        when :word
+          if tokens.last
+            case tokens.last[0]
+            when :flag
+              tokens.last[2] = v
+            else
+              tokens << [:argument, v] if @base
+            end
+          end
+        end
+      end
+      @argv = Tokens.to_array(pre)
+      
+      tokens
+    end
+    
+    #### CREATION HELPERS #### 
+    
+    # Add a new switch to +@switches+
+    #
+    # @overload switch(short, long, desc, &block)
+    #   Creates a new switch
+    #   @param [Symbol] short single character for short switch, eg. +:v+ => +-v+
+    #   @param [Symbol] long longer switch to be used, eg. +:verbose+ => +--verbose+
+    #   @param [String] desc the description for the switch
+    #
+    # @yield A block to run if the switch is triggered
+    #
+    def switch(*args, &block)
+      short, long, desc = nil, nil, nil
+      args.each do |i|
+        if i.is_a? String
+          desc = i
+        elsif i.length == 1
+          short = i.to_s
+        else
+          long = i.to_s
+        end
+      end
+      @switches << Switch.new(short, long, desc, &block)
+    end
+    
+    # Add a new command to +@commands+
+    #
+    # @overload command(name, desc, &block)
+    #   Creates a new command
+    #   @param [Symbol] name the name of the command, eg. +:add+ for +git add+
+    #   @param [String] desc description of the command
+    # 
+    # @yield A block to run when the command is called, can contain switches
+    #   and flags
+    #
+    def command(*args, &block)
+      name, desc = nil, nil
+      args.each do |i|
+        if i.is_a? String
+          desc = i
+        else
+          name = i
+        end
+      end
+      @commands << Command.new(name, desc, &block)
+    end
+    
+    # Add a new flag to +@flags+
+    #
+    # @overload flag(short, long, desc, &block)
+    #   Creates a new flag
+    #   @param [Symbol] short single character for short flag, eg. +:t+ => +-t 10+
+    #   @param [Symbol] long longer switch to be used, eg. +:tries+ => +--tries=10+
+    #   @param [String] desc the description for the flag
+    #
+    # @yield [String] A block to be run if switch is triggered
+    def flag(*args, &block)
+      short, long, desc = nil, nil, nil
+      args.each do |i|
+        if i.is_a? String
+          desc = i
+        elsif i.length == 1
+          short = i.to_s
+        else
+          long = i.to_s
+        end
+      end
+      @flags << Flag.new(short, long, desc, &block)
+    end
+    
+  end
+end

data/lib/clive/ext.rb

@@ -0,0 +1,29 @@
+class Clive
+
+  class Array < ::Array
+    
+    # If passed a Symbol or String will get the item with that name,
+    # checks #long and #short if available or #name. Otherwise does 
+    # what you expect of an Array (see Array#[])
+    #
+    # @param [Symbol, String, Integer, Range] val name or index of item to return
+    # @return the item that has been found
+    def [](val)
+      val = val.to_s if val.is_a? Symbol
+      if val.is_a? String
+        if self[0].respond_to?(:name)
+          self.find_all {|i| i.name == val}[0]
+        elsif self[0].respond_to?(:long) 
+          if val.length == 1
+            self.find_all {|i| i.short == val}[0]
+          else
+            self.find_all {|i| i.long == val}[0]
+          end
+        end
+      else
+        super
+      end
+    end
+    
+  end
+end

data/lib/clive/flags.rb

@@ -0,0 +1,17 @@
+class Clive
+  
+  # A switch that takes an argument, with or without an equals
+  #   eg. wget --tries=10
+  #       wget -t 10
+  #
+  class Flag < Switch
+  
+    # Runs the block that was given with an argument
+    #
+    # @param [String] arg argument to pass to the block
+    def run(arg)
+      @block.call(arg)
+    end
+    
+  end
+end

data/lib/clive/switches.rb

@@ -0,0 +1,24 @@
+class Clive
+  
+  # A string that takes no argument, beginning with one or two dashes
+  #   eg. ruby --version
+  #       ruby -v
+  #
+  class Switch
+    attr_accessor :short, :long, :desc, :block
+    
+    def initialize(short, long, desc, &block)
+      @short = short
+      @long = long
+      @desc = desc
+      @block = block
+    end
+    
+    # Runs the block that was given
+    def run
+      @block.call
+    end
+    
+  end
+  
+end

data/lib/clive/tokens.rb

@@ -0,0 +1,80 @@
+class Clive
+
+  # A subclass of Array to allow the creation of arrays that look
+  # like:
+  #
+  #    [[:word, 'Value'], [:long, 'verbose'], [:short, 'r']]
+  #
+  # And converting between these and ordinary arrays.
+  #
+  class Tokens < Array
+    attr_accessor :tokens, :array
+    
+    def self.to_tokens(tokens)
+      Tokens.new.to_tokens(tokens)
+    end
+    
+    def self.to_array(arr)
+      Tokens.new.to_array(arr)
+    end
+    
+    # Turn into simple tokens that have been split up into logical parts
+    #
+    # @example
+    #   
+    #   a = Tokens.new
+    #   a.to_tokens(["add", "-al", "--verbose"])
+    #   #=> [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
+    #
+    def to_tokens(arr=@array)
+      @tokens = []
+      arr.each do |i|
+        if i[0..1] == "--"
+          if i.include?('=')
+            a, b = i[2..i.length].split('=')
+            @tokens << [:long, a] << [:word, b]
+          else
+            @tokens << [:long, i[2..i.length]]
+          end
+        
+        elsif i[0] == "-"
+          i[1..i.length].split('').each do |j|
+            tokens << [:short, j]
+          end
+        
+        else
+          @tokens << [:word, i]
+        end
+      end
+      
+      @tokens
+    end
+    
+    # Turn tokens back to a normal array
+    #
+    # @example
+    #   
+    #   a = Tokens.new
+    #   a.to_array([[:word, "add"], [:short, "a"], [:short, "l"],
+    #              [:long, "verbose"]])
+    #   #=> ["add", "-al", "--verbose"]
+    #
+    def to_array(tokens=@tokens)
+      @array = []
+      tokens.each do |i|
+        k, v = i[0], i[1]
+        case k
+        when :long
+          @array << "--#{v}"
+        when :short
+          @array << "-#{v}"
+        when :word
+          @array << v
+        end
+      end
+      
+      @array
+    end
+    
+  end
+end

data/test/bin_test

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'clive'
+
+options = {}
+c = Clive.new do
+
+  switch(:v, :verbose, "Run verbosely") {
+    options[:verbose] = true
+  }
+  
+  flag(:t, :type, "Type to choose") {
+    p "hi"
+  }
+  
+  flag(:long_only, "A flag with only a long") {}
+  
+  command(:add, "Add something") {
+    
+    p "adding stuff"
+    
+    switch(:f, :full, "Use full") {
+      options[:full] = true
+    }  
+    
+    # Use with app-name add -e
+    switch(:e, :empty, "Use empty") {
+      options[:full] = false
+    }
+  
+  }
+
+end
+
+c.parse(ARGV)
+p options
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'clive'
+
+class Test::Unit::TestCase
+end

data/test/test_clive.rb

@@ -0,0 +1,214 @@
+require 'helper'
+
+class TestClive < Test::Unit::TestCase
+  
+  should "create flag" do
+    c = Clive.new do
+      flag(:v) {}
+    end
+    assert_equal 1, c.flags.length
+    assert_instance_of Clive::Flag, c.flags[0]
+  end
+  
+  should "create switch" do
+    c = Clive.new do
+      switch(:v) {}
+    end
+    assert_equal 1, c.switches.length
+    assert_instance_of Clive::Switch, c.switches[0]
+  end
+  
+  should "create command" do
+    c = Clive.new do
+      command(:add) {}
+    end
+    assert_equal 1, c.commands.length
+    assert_instance_of Clive::Command, c.commands[0]
+  end
+  
+  context "When parsing input" do
+  
+    should "recognise flags with equals" do
+      opts = {}
+      c = Clive.new do
+        flag(:type) {|i| opts[:type] = i}
+      end
+      c.parse(["--type=big"])
+      r = {:type => 'big'}
+      assert_equal r, opts
+    end
+    
+    should "recognise flags without equals" do
+      opts = {}
+      c = Clive.new do
+        flag(:type) {|i| opts[:type] = i}
+      end
+      c.parse(["--type", "big"])
+      r = {:type => 'big'}
+      assert_equal r, opts
+    end
+    
+    should "recongise short flags" do
+      opts = {}
+      c = Clive.new do
+        flag(:t) {|i| opts[:type] = i}
+      end
+      c.parse(["-t", "big"])
+      r = {:type => 'big'}
+      assert_equal r, opts
+    end
+    
+    should "recognise multiple flags" do
+      opts = {}
+      c = Clive.new do
+        flag(:type) {|i| opts[:type] = i}
+        flag(:lang) {|i| opts[:lang] = i}
+        flag(:e) {|i| opts[:e] = i}
+      end
+      c.parse(["--type=big", "--lang", "eng", "-e", "true"])
+      r = {:type => 'big', :lang => 'eng', :e => 'true'}
+      assert_equal r, opts
+    end
+    
+    
+    should "recognise switches" do
+      opts = {}
+      c = Clive.new do
+        switch(:v, :verbose) {opts[:verbose] = true}
+      end
+      c.parse(["--verbose"])
+      r = {:verbose => true}
+      assert_equal r, opts
+    end
+    
+    should "recognise short switches" do
+      opts = {}
+      c = Clive.new do
+        switch(:v, :verbose) {opts[:verbose] = true}
+      end
+      c.parse(["-v"])
+      r = {:verbose => true}
+      assert_equal r, opts
+    end
+    
+    should "recognise multiple switches" do
+      opts = {}
+      c = Clive.new do
+        switch(:v, :verbose) {opts[:verbose] = true}
+        switch(:r, :recursive) {opts[:recursive] = true}
+      end
+      c.parse(["--verbose", "-r"])
+      r = {:verbose => true, :recursive => true}
+      assert_equal r, opts
+    end
+    
+    should "recognise multiple combined short switches" do
+      opts = {}
+      c = Clive.new do
+        switch(:v, :verbose) {opts[:verbose] = true}
+        switch(:r, :recursive) {opts[:recursive] = true}
+      end
+      c.parse(["-vr"])
+      r = {:verbose => true, :recursive => true}
+      assert_equal r, opts
+    end
+    
+    
+    should "recognise commands" do
+      opts = {}
+      c = Clive.new do
+        command(:add) {opts[:add] = true}
+      end
+      c.parse(["add"])
+      r = {:add => true}
+      assert_equal r, opts
+    end
+    
+    should "recognise flags and switches within commands" do
+      opts = {}
+      c = Clive.new do
+        command(:add) {
+          opts[:add] = true
+          
+          switch(:v, :verbose) {opts[:verbose] = true}
+          flag(:type) {|i| opts[:type] = i}
+        }
+      end
+      c.parse(["add", "--verbose", "--type=big"])
+      r = {:add => true, :verbose => true, :type => "big"}
+      assert_equal r, opts
+    end
+    
+    
+    should "parse a mixture properly" do
+      opts = {}
+      c = Clive.new do
+        switch(:v) {opts[:v] = true}
+        flag(:h) {opts[:h] = true}
+        command(:add) {
+          switch(:full) {opts[:full] = true}
+        }
+      end
+      c.parse(["-v", "add", "--full"])
+      r = {:v => true, :full => true}
+      assert_equal r, opts
+    end
+    
+    
+    should "return unused arguments" do
+      opts = {}
+      c = Clive.new do
+        switch(:v) {opts[:v] = true}
+        flag(:h) {opts[:h] = true}
+        command(:add) {
+          switch(:full) {opts[:full] = true}
+        }
+      end
+      result = c.parse(["-v", "add", "--full", "truearg"])
+      assert_equal ["truearg"], result
+    end
+    
+    should "return multiple unused arguments" do
+      opts = {}
+      c = Clive.new do
+        switch(:v) {opts[:v] = true}
+        flag(:h) {opts[:h] = true}
+        command(:add) {
+          switch(:full) {opts[:full] = true}
+        }
+      end
+      result = c.parse(["-v", "onearg", "twoarg", "/usr/bin/env"])
+      assert_equal ["onearg", "twoarg", "/usr/bin/env"], result
+    end
+    
+  end
+  
+  
+  context "When parsing ridiculous edge tests" do
+  
+    should "parse this crazy guy" do
+      opts = {}
+      c = Clive.new do
+        switch(:v) {opts[:v] = true}
+        flag(:h) {opts[:h] = true}
+        
+        command(:add) {
+          opts[:add] = {}
+          switch(:full) {opts[:add][:full] = true}
+          flag(:breed) {|i| opts[:add][:breed] = i}
+          
+          command(:init) {
+            opts[:add][:init] = {}
+            switch(:base) {opts[:add][:init][:base] = true}
+            flag(:name) {|i| opts[:add][:init][:name] = i}
+          }
+        }
+      end
+      c.parse(["-v", "add", "--full", "init", "--base", "--name=Works"])
+      r = {:v => true, :add => {:full => true, :init => {:base => true, :name => 'Works'}} }
+      assert_equal r, opts
+    end
+  
+  end
+  
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: clive
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Joshua Hawxwell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Clive is a DSL for creating a command line interface. It is for people who, like me, love OptionParser's syntax and love GLI's commands.
+email: m@hawx.me
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/clive.rb
+- lib/clive/commands.rb
+- lib/clive/ext.rb
+- lib/clive/flags.rb
+- lib/clive/switches.rb
+- lib/clive/tokens.rb
+- test/bin_test
+- test/helper.rb
+- test/test_clive.rb
+has_rdoc: true
+homepage: http://github.com/hawx/clive
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Imagine if optparse and gli had a son called clive.
+test_files: 
+- test/helper.rb
+- test/test_clive.rb