clive 0.5.0 → 0.6.1

data/Rakefile

@@ -1,53 +1,9 @@
 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/lib/clive.rb

@@ -1,14 +1,5 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'clive/exceptions'
-require 'clive/tokens'
-require 'clive/ext'
-
-require 'clive/option'
-require 'clive/command'
-require 'clive/switch'
-require 'clive/flag'
-require 'clive/bool'
+require 'clive/parser'
+require 'clive/output'
 
 # Clive is a simple dsl for creating command line interfaces
 #

data/lib/clive/command.rb

@@ -235,7 +235,6 @@ class Clive
       @options << Bool.new(*args, true, &block)
       @options << Bool.new(*args, false, &block)
     end
-    alias_method :boolean, :bool
     
   # @group Help
     

data/lib/clive/output.rb

@@ -0,0 +1,56 @@
+# This should control the character output to the command line.
+# It will allow you to set different colours, using:
+#
+#   "I'm red".red
+#   "I'm red and bold".red.bold
+#
+#
+
+class Clive
+  module Output
+  
+  end
+end
+
+# Monkey patches for colour
+class String
+  
+  # @example
+  #
+  #   require 'clive/output'
+  #
+  #   puts "bold".bold
+  #   puts "underline".underline
+  #   puts "blink".blink
+  #   puts "green".green
+  #   puts "red".red
+  #   puts "magenta".magenta
+  #   puts "yellow".yellow
+  #   puts "blue".blue
+  #   puts "grey".grey
+  #
+  #   puts "combo".blue.bold.underline.blink
+  #
+  def colour(code)
+    "#{code}#{self}\e[0m"
+  end
+  
+  {
+    "bold"      => "1",
+    "underline" => "4",
+    "blink"     => "5",
+    "white"     => "37",
+    "green"     => "32",
+    "red"       => "31",
+    "magenta"   => "35",
+    "yellow"    => "33",
+    "blue"      => "34",
+    "grey"      => "90"
+  }.each do |name, code|
+    define_method(name) do
+      colour("\e[#{code}m")
+    end
+  end
+
+end
+

data/lib/clive/parser.rb

@@ -0,0 +1,65 @@
+require 'clive/exceptions'
+require 'clive/tokens'
+require 'clive/ext'
+
+require 'clive/option'
+require 'clive/command'
+require 'clive/switch'
+require 'clive/flag'
+require 'clive/bool'
+
+class Clive
+
+  # A module wrapping the command line parsing of clive. In the future this
+  # will be the only way of using clive.
+  #
+  # @example
+  #
+  #   require 'clive/parser'
+  # 
+  #   class CLI
+  #     include Clive::Parser
+  #   
+  #     @@opts ||= {}
+  #     def self.opts
+  #       @@opts
+  #     end
+  #   
+  #     switch :v, :verbose, "Run verbosely" do
+  #       opts[:verbose] = true
+  #     end
+  #   end
+  #
+  #   CLI.parse ARGV
+  #   p CLI.opts
+  #
+  module Parser
+  
+    def self.included(klass)
+      @@klass = klass
+      @@klass.extend(self)
+      @@base = Clive::Command.new(true)
+    end
+  
+    def parse(argv)
+      @@base.run(argv)
+    end
+    
+    def flag(*args, &block)
+      @@base.flag(*args, &block)
+    end
+    
+    def switch(*args, &block)
+      @@base.switch(*args, &block)
+    end
+    
+    def command(*args, &block)
+      @@base.command(*args, &block)
+    end
+    
+    def bool(*args, &block)
+      @@base.bool(*args, &block)
+    end
+
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 0
-  version: 0.5.0
+  - 6
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Joshua Hawxwell
@@ -14,77 +14,40 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-16 00:00:00 +00:00
+date: 2010-12-20 00:00:00 +00: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 
-        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 
-        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.
+dependencies: []
+
+description: "    Clive is a DSL for creating a command line interface. It is for people \n    who, like me, love OptionParser's syntax and love GLI's commands.\n"
 email: m@hawx.me
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
-- .document
-- .gitignore
-- LICENSE
 - README.md
 - Rakefile
-- VERSION
-- clive.gemspec
-- lib/clive.rb
+- LICENSE
 - lib/clive/bool.rb
 - lib/clive/command.rb
 - lib/clive/exceptions.rb
 - lib/clive/ext.rb
 - lib/clive/flag.rb
 - lib/clive/option.rb
+- lib/clive/output.rb
+- lib/clive/parser.rb
 - lib/clive/switch.rb
 - lib/clive/tokens.rb
-- test/bin_test
-- test/helper.rb
-- test/test_boolean.rb
-- test/test_clive.rb
-- test/test_command.rb
-- test/test_exceptions.rb
-- test/test_flag.rb
-- test/test_switch.rb
-- test/test_token.rb
-has_rdoc: true
+- lib/clive.rb
+has_rdoc: false
 homepage: http://github.com/hawx/clive
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -110,12 +73,5 @@ 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_boolean.rb
-- test/test_clive.rb
-- test/test_command.rb
-- test/test_exceptions.rb
-- test/test_flag.rb
-- test/test_switch.rb
-- test/test_token.rb
+test_files: []
+

data/.document

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

data/.gitignore

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

data/VERSION

@@ -1 +0,0 @@
-0.5.0

data/clive.gemspec

@@ -1,78 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{clive}
-  s.version = "0.5.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Joshua Hawxwell"]
-  s.date = %q{2010-11-16}
-  s.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.}
-  s.email = %q{m@hawx.me}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "clive.gemspec",
-     "lib/clive.rb",
-     "lib/clive/bool.rb",
-     "lib/clive/command.rb",
-     "lib/clive/exceptions.rb",
-     "lib/clive/ext.rb",
-     "lib/clive/flag.rb",
-     "lib/clive/option.rb",
-     "lib/clive/switch.rb",
-     "lib/clive/tokens.rb",
-     "test/bin_test",
-     "test/helper.rb",
-     "test/test_boolean.rb",
-     "test/test_clive.rb",
-     "test/test_command.rb",
-     "test/test_exceptions.rb",
-     "test/test_flag.rb",
-     "test/test_switch.rb",
-     "test/test_token.rb"
-  ]
-  s.homepage = %q{http://github.com/hawx/clive}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Imagine if optparse and gli had a son called clive.}
-  s.test_files = [
-    "test/helper.rb",
-     "test/test_boolean.rb",
-     "test/test_clive.rb",
-     "test/test_command.rb",
-     "test/test_exceptions.rb",
-     "test/test_flag.rb",
-     "test/test_switch.rb",
-     "test/test_token.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_development_dependency(%q<yard>, [">= 0"])
-    else
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-      s.add_dependency(%q<yard>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    s.add_dependency(%q<yard>, [">= 0"])
-  end
-end
-

data/test/bin_test

@@ -1,59 +0,0 @@
-#!/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" do
-    options[:verbose] = true
-  end
-  
-  flag :t, :type, "TYPE", "Change type to TYPE" do |i|
-    options[:type] = i
-  end
-  
-  flag(:long_only, "A flag with only a long") {}
-  
-  flag :p, :print, "[TEXT]", "Print TEXT, defaults to 'hey'" do |i|
-    i ||= 'hey'
-    p i
-  end
-  
-  flag(:z, :apple, "More applez") {}
-  
-  command :add, "Add something" do
-    
-    header "Usage: bin_test add [options]\n" +
-           "Use add to add things to add, which in turn can be added."
-    
-    switch :f, :full, "Use full" do
-      options[:full] = true
-    end
-    
-    # Use with app-name add -e
-    switch :e, :empty, "Use empty" do
-      options[:full] = false
-    end
-    
-    footer "If the header was a little confusing, don't worry the footer thought so too."
-  
-  end
-  
-  command :remove, :delete, "Get rid of something" do
-    switch :f, :force, "Force" do
-      p "deleting! now"
-    end
-  end
-  
-  
-  option_missing do |name|
-    puts "hi, #{name}"
-  end
-
-end
-
-p ARGV
-p c.parse(ARGV)
-p options
-

data/test/helper.rb

@@ -1,14 +0,0 @@
-require 'duvet'
-Duvet.start :filter => 'clive/lib'
-
-require 'test/unit'
-require 'shoulda'
-require 'rr'
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require File.join(File.dirname(__FILE__), '..', 'lib', 'clive')
-
-class Test::Unit::TestCase
-  include RR::Adapters::TestUnit
-end

data/test/test_boolean.rb

@@ -1,55 +0,0 @@
-require 'helper'
-
-class TestBoolean < Test::Unit::TestCase
-  
-  context "A new boolean switch" do
-  
-    setup do
-      @c = Clive.new do
-        bool(:v, :verbose, "Run verbosely") {|i| puts(i)}
-      end
-    end
-  
-    should "create two switches" do
-      assert_equal 2, @c.bools.length
-    end
-    
-    should "raise error when no long name given" do
-      assert_raise Clive::MissingLongName do
-        Clive::Bool.new(:v, "Run verbosely") {}
-      end
-    end
-    
-    context "the true switch" do
-      should "have a short name" do
-        assert_contains @c.bools["verbose"].names, "v"
-      end
-      
-      should "pass true to the block" do
-        mock($stdout).puts(true)
-        @c.parse(["--verbose"])
-      end
-      
-      should "create summary" do
-        assert_equal "-v, --[no-]verbose Run verbosely", @c.bools["verbose"].summary(0, 0)
-      end
-    end
-    
-    context "the false switch" do
-      should "not have short name" do
-        assert_does_not_contain @c.bools["no-verbose"].names, "v"
-      end
-      
-      should "pass false to the block" do
-        mock($stdout).puts(false)
-        @c.parse(["--no-verbose"])
-      end
-      
-      should "not create summary" do
-        assert_equal nil, @c.bools["no-verbose"].summary
-      end
-    end
-  
-  end
-  
-end

data/test/test_clive.rb

@@ -1,276 +0,0 @@
-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 2, c.switches.length # plus help
-    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
-  
-  should "create boolean" do
-    c = Clive.new do
-      boolean(:verbose) {}
-    end
-    assert_equal 2, c.bools.length
-    assert_instance_of Clive::Bool, c.bools[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 "recognise an argument" do
-      c = Clive.new do
-        bool(:v, :verbose, "Run verbosely") {}
-      end
-      args = c.parse ["argument"]
-      assert_equal ["argument"], args
-    end
-    
-    should "recognise a quoted argument" do
-      c = Clive.new {}
-      args = c.parse ['a quoted argument']
-      assert_equal ["a quoted argument"], args
-    end
-    
-    should "recognise multiple arguments" do
-      c = Clive.new do
-        bool(:v, :verbose, "Run verbosely") {}
-      end
-      args = c.parse ["argument", "and", "another"]
-      assert_equal ["argument", "and", "another"], args
-    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
-    
-    should "parse the one in the readme" do
-      opts = {}
-      c = Clive.new do
-        bool(:v, :verbose, "Run verbosely") {|i| opts[:verbose] = i}
-        
-        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(:w, :width) {|i| opts[:add][:width] = i.to_i}
-          end
-        
-        end
-        
-        switch(:version, "Show version") do
-          puts "1.0.0"
-          exit
-        end
-      end
-      argv = %w(-v add --framework=blueprint init -m -w 200 ~/Desktop/new_thing ~/Desktop/another_thing)
-      args = c.parse(argv)
-      
-      opts_r = {:add => {:min => true, :width => 200, :framework => ["blueprint"]}, :verbose => true}
-      assert_equal opts_r, opts
-      assert_equal ["~/Desktop/new_thing", "~/Desktop/another_thing"], args
-    end
-  
-  end
-end

data/test/test_command.rb

@@ -1,44 +0,0 @@
-require 'helper'
-
-class TestCommand < Test::Unit::TestCase
-
-  context "A new command" do
-  
-    setup do
-      @c = Clive.new do
-        command(:add, "Add something") {puts "called!"}
-      end
-    end
-    
-    context "with multiple names" do
-      setup do
-        @c = Clive.new do
-          command(:add, :init, :new, "Add something") {puts "called!"}
-        end
-      end
-      
-      should "be called with first name" do
-        mock($stdout).puts("called!")
-        @c.parse ["add"]
-      end
-      
-      should "be called with second name" do
-        mock($stdout).puts("called!")
-        @c.parse ["init"]
-      end
-      
-      should "be called with third name" do
-        mock($stdout).puts("called!")
-        @c.parse ["new"]
-      end
-    end
-  
-  
-    should "only execute it's block when called" do
-      mock($stdout).puts("called!")
-      @c.parse(["a"])
-      @c.parse(["add"])
-    end
-  
-  end 
-end

data/test/test_exceptions.rb

@@ -1,28 +0,0 @@
-require 'helper'
-
-class TestClive < Test::Unit::TestCase
-  
-  context "When given bad input" do
-  
-    should "warn of missing arguments" do
-      c = Clive.new do
-        flag(:hello) {}
-      end
-      assert_raise Clive::MissingArgument do
-        c.parse(["--hello"])
-      end
-    end
-    
-    should "warn of invalid options" do
-      c = Clive.new do
-        switch(:hello) {}
-      end
-      assert_raise Clive::InvalidOption do
-        c.parse(["--what"])
-      end
-    end
-  
-  
-  end
-  
-end

data/test/test_flag.rb

@@ -1,160 +0,0 @@
-require 'helper'
-
-class TestFlag < Test::Unit::TestCase
-  
-  context "A new flag" do
-    
-    setup do
-      @c = Clive.new do
-        flag(:t, :type, "TEXT", "Change type to TYPE") {|i| puts(i)}
-      end
-    end
-    
-    should "pass an argument to block" do
-      mock($stdout).puts("text")
-      @c.parse(["--type", "text"])
-    end
-    
-    should "have a arguments" do
-      r = {:name => "TEXT", :optional => false, :type => String}
-      assert_equal r, @c.flags["t"].args[0]
-    end
-    
-    should "not be optional" do
-      assert_equal false, @c.flags["t"].args[0][:optional]
-    end
-  end
-  
-  context "A new flag with default" do
-  
-    setup do
-      @c = Clive.new do
-        flag(:t, :type, "[TEXT]", "Change type to TYPE") do |i| 
-          i ||= 'dog'
-          $stdout.puts(i)
-        end
-      end
-    end
-    
-    should "have an arg name" do
-      r = {:name => "TEXT", :optional => true, :type => String}
-      assert_equal r, @c.flags["t"].args[0]
-    end
-    
-    should "be optional" do
-      assert_equal true, @c.flags["t"].args[0][:optional]
-    end
-    
-    should "pass an argument to block" do
-      mock($stdout).puts("text")
-      @c.parse(["--type", "text"])
-    end
-    
-    should "pass nil to the block if no argument" do
-      mock($stdout).puts("dog")
-      @c.parse(["--type"])
-    end
-  end
-  
-  context "A new flag with multiple arguments" do
-    
-    setup do
-      @c = Clive.new do
-        flag(:s, :send, "FROM TO", "Send the message from FROM to TO") do |from, to|
-          puts from
-          puts to
-        end
-      end
-    end 
-    
-    should "pass two arguments to the block" do
-      mock($stdout).puts("John")
-      mock($stdout).puts("Dave")
-      @c.parse(["--send", "John", "Dave"])
-    end
-    
-    should "have a useful summary" do
-      s = "-s, --send FROM TO Send the message from FROM to TO"
-      assert_equal s, @c.flags['s'].summary(0, 0)
-    end
-    
-    should "work for more than two arguments" do
-      mock($stdout).puts("from: Josh, to: John, via: Hong Kong, because: It's far away")
-      c = Clive.new do
-        flag(:s, :send, "FROM TO VIA BECAUSE", "Send the message...etc") do |f, t, v, b|
-          puts "from: #{f}, to: #{t}, via: #{v}, because: #{b}"
-        end
-      end
-      c.parse ['-s', 'Josh', 'John', "Hong Kong", "It's far away"]
-    end
-    
-    context "and optional arguments" do
-      setup do
-        @c = Clive.new do
-          flag(:s, :send, "FROM [VIA] TO [BECAUSE]", "Send the message...etc") do |f, v, t, b|
-            s = "from: #{f}"
-            s << ", via: #{v}" if v
-            s << ", to: #{t}"
-            s << ", because: #{b}" if b
-            puts s
-          end
-        end
-      end
-      
-      should "correctly parse argument string" do
-        r = [
-          {:name => "FROM",    :optional => false, :type => String},
-          {:name => "VIA",     :optional => true,  :type => String},
-          {:name => "TO",      :optional => false, :type => String},
-          {:name => "BECAUSE", :optional => true,  :type => String}
-        ]
-        assert_equal r, @c.flags[:s].args
-      end
-      
-      should "give all arguments when found in input" do
-        mock($stdout).puts("from: Josh, via: Hong Kong, to: John, because: It's far away")
-        @c.parse ["-s", "Josh", "Hong Kong", "John", "It's far away"]
-      end
-      
-      should "try to give only needed arguments if some missing" do
-        mock($stdout).puts("from: Josh, to: John")
-        @c.parse ["-s", "Josh", "John"]
-      end
-      
-      should "fill optional arguments starting from left" do
-        mock($stdout).puts("from: Josh, via: Hong Kong, to: John")
-        @c.parse ["-s", "Josh", "Hong Kong", "John"]
-      end
-      
-    end
-  end
-  
-  context "A new flag with a list of acceptable arguments" do
-    
-    setup do
-      @c = Clive.new do
-        flag(:t, :type, ["large", "medium", "small"], "Choose the type to use") {}
-      end
-    end
-    
-    should "raise error when correct argument not found" do
-      assert_raise Clive::InvalidArgument do
-        @c.parse(["--type", "apple"])
-      end
-    end
-    
-    should "not raise error when correct argument given" do
-      @c.parse(["--type", "large"])
-    end
-    
-    should "make list arguments" do
-      r = ["large", "medium", "small"]
-      assert_equal r, @c.flags['t'].args
-    end
-    
-    should "have a useful summary" do
-      s = "-t, --type {large, medium, small} Choose the type to use"
-      assert_equal s, @c.flags['t'].summary(0, 0)
-    end
-  end
-end

data/test/test_switch.rb

@@ -1,18 +0,0 @@
-require 'helper'
-
-class TestSwitch < Test::Unit::TestCase
-  
-  context "A new switch" do
-  
-    setup do
-      @c = Clive.new do
-        switch(:d, :debug, "Use debug mode") {}
-      end
-    end
-    
-    should "create summary" do
-      assert_equal "-d, --debug Use debug mode", @c.switches["d"].summary(0, 0)
-    end
-  
-  end
-end

data/test/test_token.rb

@@ -1,68 +0,0 @@
-require 'helper'
-
-class TestToken < Test::Unit::TestCase
-
-  context "When converting" do
-    setup do
-      @array = ["add", "-al", "--verbose"]
-      @array_split = ["add", "-a", "-l", "--verbose"]
-      @tokens = [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
-    end
-  
-    should "convert an array to tokens" do
-      assert_equal @tokens, Clive::Tokens.to_tokens(@array)
-    end
-    
-    should "convert tokens to an array" do
-      assert_equal @array_split, Clive::Tokens.to_array(@tokens)
-    end  
-  end
-  
-  context "A new tokens instance" do
-  
-    setup do
-      @array = ["add", "-al", "--verbose"]
-      @array_split = ["add", "-a", "-l", "--verbose"]
-      @tokens = [[:word, "add"], [:short, "a"], [:short, "l"], [:long, "verbose"]]
-    end
-    
-    should "be created from an array" do
-      t = Clive::Tokens.new(@tokens)
-      assert_equal @tokens, t.tokens
-      assert_equal @array_split, t.array
-    end
-    
-    should "be created from tokens" do
-      t = Clive::Tokens.new(@array)
-      assert_equal @tokens, t.tokens
-      assert_equal @array_split, t.array
-    end
-    
-    should "tell whether an array is a token" do
-      t = Clive::Tokens.new
-      assert_equal false, t.token?(["a", "normal", "array"])
-      assert_equal true, t.token?([:word, "help"])
-    end
-    
-    should "turn token to string" do
-      t = Clive::Tokens.new
-      assert_equal "-v", t.token_to_string([:short, "v"])
-      assert_equal "--verbose", t.token_to_string([:long, "verbose"])
-      assert_equal "word", t.token_to_string([:word, "word"])
-    end
-    
-    should "add new string values" do
-      t = Clive::Tokens.new
-      t << "add" << "-al" << "--verbose"
-      assert_equal @tokens, t.tokens
-    end
-    
-    should "add new token values" do
-      t = Clive::Tokens.new
-      t << [:word, "add"] << [:short, "a"] << [:short, "l"] << [:long, "verbose"]
-      assert_equal @array_split, t.array
-    end
-  
-  end
-  
-end