clip 0.0.6 → 1.0.0

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.0.7 / 2008-07-14
+
+* remainder now works with Clip.hash method.
+
 === 0.0.6 / 2008-07-10
 
 * Fixed a bug with getting the 'remainder' when only flags are declared.

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+clip.gemspec
+lib/clip.rb
+spec/clip_spec.rb

data/{README.txt → README.rdoc}

@@ -31,8 +31,13 @@ And it goes a little something like this...
     p.optional 'p', 'port', :desc => 'The port', :default => 8080 do |v|
       v.to_i # always deal with integers
     end
-    p.required 'f', 'files', :multi => true, :desc => 'Files to send'
-    p.flag     'v', 'verbose', :desc => 'Make it chatty'
+    p.required 'f', 'files', :multi => true, :desc => 'Files to send' do |files|
+      files.each do |f|
+        raise("unable to read file #{f}") unless File::readable? f
+        f
+      end
+    end
+    p.flag 'v', 'verbose', :desc => 'Make it chatty'
   end
 
   if options.valid?
@@ -56,7 +61,9 @@ deal with when you're parsing command-line parameters.
 You can optionally process parsed arguments by passing a block to the
 <tt>required</tt> or <tt>optional</tt> methods which will set the value of the
 option to the result of the block. The block will receive the parsed value and
-should return whatever transformed value that is appropriate to your use case.
+should return whatever transformed value that is appropriate to your use case.  If
+the passed value fails validation you can raise an error which will be reported
+correctly.
 
 Simply invoking the <tt>to_s</tt> method on a parser instance will dump both the
 correct usage and any errors encountered during parsing. No need for you to manage

data/Rakefile

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'hoe'
+require './lib/clip.rb'
+
+Hoe.new('clip', Clip::VERSION) do |p|
+  p.name = 'clip'
+  p.developer('Alex Vollmer', 'alex.vollmer@gmail.com')
+  p.description = p.paragraphs_of('README.rdoc', 5..5).join("\n\n")
+  p.summary = 'Command-line parsing made short and sweet'
+  p.url = 'http://clip.rubyforge.org'
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+end
+
+require "spec/rake/spectask"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+HERE = "web"
+THERE = "avollmer@clip.rubyforge.org:/var/www/gforge-projects/clip"
+
+desc "Sync web files here"
+task :sync_here do
+  puts %x(rsync \
+      --verbose \
+      --recursive \
+      #{THERE}/ #{HERE})
+end
+
+desc "Sync web files there"
+task :sync_there do
+  puts %x(rsync \
+      --verbose \
+      --recursive \
+      --delete \
+      #{HERE}/ #{THERE}})
+end
+
+desc "Code statistics"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(['lib'], ['spec']).to_s
+end
+
+task :default => :spec

data/clip.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name = %q{clip}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alex Vollmer"]
+  s.date = %q{2008-09-19}
+  s.description = %q{You like command-line parsing, but you hate all of the bloat. Why should you have to create a Hash, then create a parser, fill the Hash out then throw the parser away (unless you want to print out a usage message) and deal with a Hash? Why, for Pete's sake, should the parser and the parsed values be handled by two different objects?}
+  s.email = ["alex.vollmer@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.rdoc", "Rakefile", "clip.gemspec", "lib/clip.rb", "spec/clip_spec.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://clip.rubyforge.org}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{clip}
+  s.rubygems_version = %q{1.2.0}
+  s.summary = %q{Command-line parsing made short and sweet}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if current_version >= 3 then
+      s.add_development_dependency(%q<hoe>, [">= 1.7.0"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.7.0"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.7.0"])
+  end
+end

data/lib/clip.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'shellwords'
+
 ##
 # Parse arguments (defaults to <tt>ARGV</tt>) with the Clip::Parser
 # configured in the given block. This is the main method you
@@ -13,7 +15,7 @@ def Clip(args=ARGV)
 end
 
 module Clip
-  VERSION = "0.0.6"
+  VERSION = "1.0.0"
 
   ##
   # Indicates that the parser was incorrectly configured in the
@@ -33,6 +35,16 @@ module Clip
     # If the value is set this completely replaces the default
     attr_accessor :banner
 
+    ##
+    # Override the flag to trigger help usage. By default the short
+    # flag '-h' and long flag '--help' will trigger displaying usage.
+    # If you need to override this, particularly in the case of '-h',
+    # call this method
+    def help_with(short, long="--help")
+      @help_short = short
+      @help_long = long
+    end
+
     ##
     # Declare an optional parameter for your parser. This creates an accessor
     # method matching the <tt>long</tt> parameter. The <tt>short</tt> parameter
@@ -55,28 +67,33 @@ module Clip
     # comma-separated value can be specified which will then be broken up into
     # separate tokens.
     def optional(short, long, options={}, &block)
-      short = short.to_sym
-      long = long.to_sym
       check_args(short, long)
 
+      short = short.to_sym
+      long = long.gsub('-', '_').to_sym
+
       var_name = "@#{long}".to_sym
-      if block
-        self.class.send(:define_method, "#{long}=".to_sym) do |v|
-          instance_variable_set(var_name, block.call(v))
+      self.class.class_eval do
+        define_method("#{long}=".to_sym) do |v|
+          begin
+            v = yield(v) if block_given?
+            instance_variable_set(var_name, v)
+          rescue StandardError => e
+            @valid = false
+            @errors[long] = e.message
+          end
         end
-      else
-        self.class.send(:define_method, "#{long}=".to_sym) do |v|
-          instance_variable_set(var_name, v)
+
+        define_method(long.to_sym) do
+          instance_variable_get(var_name)
         end
       end
 
-      self.class.send(:define_method, long.to_sym) do
-        instance_variable_get(var_name)        
-      end
+      self.options[short] = self.options[long] =
+        Option.new(short, long, options)
 
-      self.options[long] = Option.new(short, long, options)
-      self.options[short] = self.options[long]
       self.order << self.options[long]
+      check_longest(long)
     end
 
     alias_method :opt, :optional
@@ -102,29 +119,32 @@ module Clip
     # Valid options are:
     # * <tt>desc</tt>: Descriptive text for the flag
     def flag(short, long, options={})
-      short = short.to_sym
-      long = long.to_sym
-
       check_args(short, long)
 
-      eval <<-EOF
-        def flag_#{long}
-          @#{long} = true
+      short = short.to_sym
+      long = long.gsub('-', '_').to_sym
+      self.class.class_eval do
+        define_method("flag_#{long}") do
+          instance_variable_set("@#{long}", true)
         end
 
-        def #{long}?
-          return @#{long} || false
+        define_method("#{long}?") do
+          instance_variable_get("@#{long}")
         end
-      EOF
+      end
 
       self.options[long] = Flag.new(short, long, options)
       self.options[short] = self.options[long]
       self.order << self.options[long]
+      check_longest(long)
     end
 
     def initialize # :nodoc:
       @errors = {}
       @valid = true
+      @longest = 10
+      @help_long = "--help"
+      @help_short = "-h"
     end
 
     ##
@@ -133,21 +153,25 @@ module Clip
     # you can get them from the <tt>Hash</tt> returned by the +errors+ method.
     def parse(args)
       @valid = true
-      args = args.split(/\s+/) unless args.kind_of?(Array)
+      args = Shellwords::shellwords(args) unless args.kind_of?(Array)
       consumed = []
-      if args.member?("--help")
-        puts help
-        exit 0
-      end
       option = nil
-    
+
       args.each do |token|
         case token
+        when @help_long, @help_short
+          puts help
+          exit 0
+
+        when /\A--\z/
+          consumed << token
+          break
+
         when /^-(-)?\w/
           consumed << token
-          param = token.sub(/^-(-)?/, '').sub('-', '_').to_sym
+          param = token.sub(/^-(-)?/, '').gsub('-', '_').to_sym
           option = options[param]
-          unless option
+          if option.nil?
             @errors[param] = "Unrecognized parameter"
             @valid = false
             next
@@ -199,7 +223,8 @@ module Clip
     end
 
     ##
-    # Returns a formatted <tt>String</tt> indicating the usage of the parser
+    # Returns a formatted <tt>String</tt> indicating the usage of the parser,
+    # formatted to fit within 80 display columns.
     def help
       out = ""
       if banner
@@ -209,7 +234,38 @@ module Clip
       end
 
       order.each do |option|
-        out << "#{option.usage}\n"
+        line = sprintf("-%-2s --%-#{@longest}s  ",
+                       option.short,
+                       option.long.to_s.gsub('_', '-'))
+
+        out << line
+        if line.length + option.description.length <= 80
+          out << option.description
+        else
+          rem = 80 - line.length
+          desc = option.description
+          i = 0
+          while i < desc.length
+            out << "\n" if i > 0
+            j = [i + rem, desc.length - 1].min
+            while desc[j..j] =~ /[\w\d]/
+              j -= 1
+            end
+            chunk = desc[i..j].strip
+            out << " " * line.length if i > 0
+            out << chunk
+            i = j + 1
+          end
+        end
+
+        if option.has_default?
+          out << " (default: #{option.default})"
+        end
+
+        if option.required?
+          out << " REQUIRED"
+        end
+        out << "\n"
       end
       out
     end
@@ -237,8 +293,20 @@ module Clip
       (@order ||= [])
     end
 
-    private 
+    private
     def check_args(short, long)
+      if short.size != 1
+        raise IllegalConfiguration.new("Short options must be a single character.")
+      end
+
+      if short !~ /[\w]+/
+        raise IllegalConfiguration.new("Illegal option: #{short}.  Option names can only use [a-zA-Z_-]")
+      end
+
+      if long !~ /\A\w[\w-]*\z/
+        raise IllegalConfiguration.new("Illegal option: #{long}'.  Parameter names can only use [a-zA-Z_-]")
+      end
+
       short = short.to_sym
       long = long.to_sym
 
@@ -246,8 +314,8 @@ module Clip
         raise IllegalConfiguration.new("You cannot override the built-in 'help' parameter")
       end
 
-      if short == :h
-        raise IllegalConfiguration.new("You cannot override the built-in 'h' parameter")
+      if short == '?'.to_sym
+        raise IllegalConfiguration.new("You cannot override the built-in '?' parameter")
       end
 
       if self.options.has_key?(long)
@@ -258,6 +326,11 @@ module Clip
         raise IllegalConfiguration.new("You already have a defined parameter/flag for the short key '#{short}")
       end
     end
+
+    def check_longest(name)
+      l = name.to_s.length
+      @longest = l if l > @longest
+    end
   end
 
   class Option # :nodoc:
@@ -293,7 +366,7 @@ module Clip
     def multi?
       @multi == true
     end
-  
+
     def usage
       out = sprintf('-%-2s --%-10s %s',
                     @short,
@@ -306,7 +379,7 @@ module Clip
   end
 
   class Flag # :nodoc:
-    
+
     attr_accessor :long, :short, :description
 
     ##
@@ -328,13 +401,9 @@ module Clip
     def has_default?
       false
     end
-  
-    def usage
-      sprintf('-%-2s --%-10s %s', @short, @long, @description)
-    end
   end
 
-  HASHER_REGEX = /^--?\w+/
+  HASHER_REGEX = /^--?(\w+)/
   ##
   # Turns ARGV into a hash.
   #
@@ -343,17 +412,34 @@ module Clip
   #  my_clip_script com -c config.yml -d # Clip.hash == { 'c' => 'config.yml' }
   #  my_clip_script -c config.yml --mode optimistic
   #  # Clip.hash == { 'c' => 'config.yml', 'mode' => 'optimistic' }
-  def self.hash(argv = ARGV.dup, values = [])
-    @hash ||= begin
-      argv.shift until argv.first =~ HASHER_REGEX or argv.empty?
-      while argv.first =~ HASHER_REGEX and argv.size >= 2 do
-        values += [argv.shift.sub(/^--?/, ''), argv.shift]
+  #
+  # The returned hash also has a +remainder+ method that contains
+  # unparsed values.
+  #
+  def self.hash(argv = ARGV.dup, keys = [])
+    return @hash if @hash # used the cached value if available
+
+    opts = Clip(argv) do |clip|
+      keys = argv.select{ |a| a =~ HASHER_REGEX }.map do |a|
+        a = a.sub(HASHER_REGEX, '\\1')
+        clip.optional(a[0,1], a); a
       end
-      Hash[*values]
     end
+
+    # The "|| true" on the end is for when no value is found for a
+    # key; it's assumed that a flag was meant instead of an optional
+    # argument, so it's set to true. A bit weird-looking, but more useful.
+    @hash = keys.inject({}) { |h, key| h.merge(key => opts.send(key) || true) }
+
+    # module_eval is necessary to define a singleton method using a closure =\
+    (class << @hash; self; end).module_eval do
+      define_method(:remainder) { opts.remainder }
+    end
+
+    return @hash
   end
 
   ##
   # Clear the cached hash value. Probably only useful for tests, but whatever.
-  def Clip.reset_hash!; @hash = nil end
+  def self.reset_hash!; @hash = nil end
 end

data/spec/clip_spec.rb

@@ -54,10 +54,13 @@ describe Clip do
       p.optional 'p', 'port', :desc => 'The port number', :default => 8080
       p.required 'f', 'files', :desc => 'Files to upload', :multi => true
       p.optional 'e', 'exclude_from', :desc => 'Directories to exclude'
+      p.optional 'x', 'exclude_from_all', :desc => 'Directories to exclude'
+      p.flag 'd', 'allow-dashes', :desc => 'Dashes allowed in definition'
+      p.flag 'z', 'allow-dashes-all', :desc => 'Dashes allowed in definition'
     end
   end
 
-  describe "When long command-line parameters are parsed" do  
+  describe "When long command-line parameters are parsed" do
 
     it "should create accessor methods for declarations" do
       parser = parse('')
@@ -69,6 +72,8 @@ describe Clip do
       parser.should respond_to(:files=)
       parser.should respond_to(:verbose?)
       parser.should respond_to(:flag_verbose)
+      parser.should respond_to(:allow_dashes?)
+      parser.should respond_to(:allow_dashes_all?)
     end
 
     it "should set fields for flags to 'true'" do
@@ -77,8 +82,8 @@ describe Clip do
       parser.should be_valid
       parser.should_not have_errors
     end
-  
-    it "should set fields for flags with the given values" do
+
+    it "should set fields for options with the given values" do
       parser = parse('--server localhost --port 8080 --files foo')
       parser.server.should eql("localhost")
       parser.port.should eql("8080")
@@ -86,14 +91,27 @@ describe Clip do
       parser.should_not have_errors
     end
 
-    it "should map flags with '-' to methods with '_'" do
+    it "should map options with '-' to methods with '_'" do
       parser = parse('--exclude-from /Users --files foo')
       parser.exclude_from.should eql("/Users")
       parser.should be_valid
       parser.should_not have_errors
     end
+    
+    it "should map flags with '-' to methods with '_'" do
+      parser = parse('--allow-dashes')
+      parser.should be_allow_dashes
+      parser.should_not be_allow_dashes_all
+    end
+
+    it "should map options with multiple '-' to methods with '_'" do
+      parser = parse('--exclude-from-all /Users --files foo')
+      parser.exclude_from_all.should eql("/Users")
+      parser.should be_valid
+      parser.should_not have_errors
+    end
 
-    it "should be invalid for unknown flags" do
+    it "should be invalid for unknown options" do
       parser = parse('--non-existent')
       parser.should_not be_valid
       parser.should have_errors_on(:non_existent)
@@ -101,14 +119,14 @@ describe Clip do
   end
 
   describe "When short (single-letter) command-line parse are parsed" do
-  
+
     it "should set flags to true" do
       parser = parse("-v --files foo")
       parser.should be_verbose
       parser.should_not have_errors
       parser.should be_valid
     end
-  
+
     it "should set fields for short options" do
       parser = parse("-s localhost -p 8080 --files foo")
       parser.should_not have_errors
@@ -119,8 +137,8 @@ describe Clip do
     end
   end
 
-  describe "When parameters are marked as required" do
-  
+  describe "When options are marked as required" do
+
     it "should be invalid when there are missing arguments" do
       parser = parse('--server localhost')
       parser.should_not be_valid
@@ -128,9 +146,9 @@ describe Clip do
     end
   end
 
-  describe "When parameters are marked with defaults" do
-  
-    it "should provide default parameter values when none are parsed" do
+  describe "When options are marked with defaults" do
+
+    it "should provide default option values when none are parsed" do
       parser = parse('--files foo')
       parser.should be_valid
       parser.should_not have_errors
@@ -139,9 +157,9 @@ describe Clip do
     end
   end
 
-  describe "Multi-valued parameters" do
+  describe "Multi-valued options" do
 
-    it "should handle multiple value for the same parameter" do
+    it "should handle multiple value for the same option" do
       parser = parse("--files foo --files bar --files baz")
       parser.should be_valid
       parser.should_not have_errors
@@ -157,14 +175,43 @@ describe Clip do
   end
 
   describe "Help output" do
+    def opts(args=nil)
+      Clip(args) do |o|
+        o.req 's', 'server', :desc => 'The server name'
+        o.opt 'p', 'port', :desc => 'The port number', :default => 80
+        o.flag 'v', 'verbose', :desc => 'Enables verbose output'
+        yield o if block_given?
+      end
+    end
+
     it "should print out some sensible usage info for to_s" do
-      out = parse('--files foo').to_s.split("\n")
-      out[0].should match(/Usage/)
-      out[1].should match(/-v\s+--verbose\s+Provide verbose output/)
-      out[2].should match(/-s\s+--server\s+The hostname.*default.*localhost/)
-      out[3].should match(/-p\s+--port\s+The port number/)
-      out[4].should match(/-f\s+--files\s+Files to upload.*REQUIRED/)
-      out[5].should match(/-e\s+--exclude-from\s+Directories to exclude/)
+      help = opts("-s localhost").to_s.split("\n")
+      help[0].should match(/Usage/)
+      help[1].should == "-s  --server      The server name REQUIRED"
+      help[2].should == "-p  --port        The port number (default: 80)"
+      help[3].should == "-v  --verbose     Enables verbose output"
+    end
+
+    it "should expand columns to largest option name" do
+      help = opts("-s localhost") do |o|
+        o.opt 'b', 'big-honking-file-list', :desc => 'The file list'
+      end.to_s.split("\n")
+      help[0].should match(/Usage/)
+      help[1].should == "-s  --server                 The server name REQUIRED"
+      help[2].should == "-p  --port                   The port number (default: 80)"
+      help[3].should == "-v  --verbose                Enables verbose output"
+      help[4].should == "-b  --big-honking-file-list  The file list"
+    end
+
+    it "should wrap column descriptions to fit 80 columns" do
+      opts = Clip do |o|
+        o.opt 'd', 'description',
+              :desc => 'An unending stream of words that goes on endlessly for an eternity until, at last, they stop.',
+              :default => 'wordy'
+      end
+      help = opts.to_s.split("\n")
+      help[1].should == "-d  --description  An unending stream of words that goes on endlessly for an"
+      help[2].should == "                   eternity until, at last, they stop. (default: wordy)"
     end
 
     it "should include error messages in to_s" do
@@ -184,15 +231,31 @@ describe Clip do
       out = opts.to_s.split("\n")
       out[0].should == 'USAGE foo bar baz'
     end
+
+    it "should support overriding help flags" do
+      opts = Clip('-?') do |p|
+        p.opt 'h', 'host', :desc => 'The hostname'
+        p.help_with '?'
+      end
+      help = opts.to_s.split("\n")
+      help[0].should match(/Usage/)
+      help[1].should match(/-h\s+--host\s+The hostname/)
+    end
   end
 
   describe "Remaining arguments" do
-    it "should be made available" do
+    it "should be taken following parsed arguments" do
       parser = parse('--files foo alpha bravo')
       parser.files.should == %w[foo]
       parser.remainder.should == %w[alpha bravo]
     end
 
+    it "should be taken preceeding parsed arguments" do
+      parser = parse('alpha bravo --files foo')
+      parser.files.should == %w[foo]
+      parser.remainder.should == %w[alpha bravo]
+    end
+
     it "should be available when only flags are declared" do
       opts = Clip('foobar') do |p|
         p.flag 'v', 'verbose'
@@ -212,6 +275,32 @@ describe Clip do
       opts.should be_verbose
       opts.should_not be_debug
     end
+
+    it "Should handle quoted strings correctly" do
+      opts = Clip(%q(-- "param 1" 'param 2' param\ 3)) {|p|}
+      opts.remainder.should include('param 1', 'param 2', 'param 3')
+    end
+  end
+  describe "Remaining arguments for Clip.hash" do
+    setup { Clip.reset_hash! }
+
+    it "should be populated" do
+      Clip.hash(['captain', 'lieutenant', '-c', 'jorge']).remainder.
+        should == ['captain', 'lieutenant']
+    end
+
+    it "should be empty for an empty arg list" do
+      Clip.hash([]).remainder.should be_empty
+    end
+
+    it "should be empty for a completely-parsed arg list" do
+      Clip.hash(['-c', '/etc/clip.yml']).remainder.should be_empty
+    end
+
+    it "should be the arg list for an unparsed arg list" do
+      Clip.hash(['git', 'bzr', 'hg', 'darcs', 'arch']).remainder.
+        should == ['git', 'bzr', 'hg', 'darcs', 'arch']
+    end
   end
 
   describe "Declaring bad options and flags" do
@@ -224,6 +313,26 @@ describe Clip do
       end.should raise_error(Clip::IllegalConfiguration)
     end
 
+    it "should reject '-' as a short option" do
+      misconfig_parser { |c| c.flag '-', 'foo' }
+    end
+
+    it "should reject long parameters that do not start with a word character" do
+      misconfig_parser { |c| c.optional 'o', '-foo' }
+      misconfig_parser { |c| c.optional 'o', '-' }
+    end
+
+    it "should reject options with non-word characters '-' ok" do
+      misconfig_parser { |c| c.flag '#', 'count' }
+      misconfig_parser { |c| c.flag 'c', 'bang!' }
+      misconfig_parser { |c| c.optional '#', 'count' }
+      misconfig_parser { |c| c.optional 'c', 'bang!' }
+    end
+
+    it "should reject short params that aren't single characters" do
+      misconfig_parser { |c| c.optional 'foo', 'foo' }
+    end
+
     it "should reject :help as a flag name" do
       misconfig_parser { |c| c.flag 'x', 'help' }
     end
@@ -232,12 +341,12 @@ describe Clip do
       misconfig_parser { |c| c.optional 'x', 'help' }
     end
 
-    it "should reject 'h' as a short flag name" do
-      misconfig_parser { |c| c.flag 'h', 'foo' }
+    it "should reject '?' as a short flag name" do
+      misconfig_parser { |c| c.flag '?', 'foo' }
     end
 
-    it "should reject 'h' as a short parameter name" do
-      misconfig_parser { |c| c.optional 'h', 'foo' }
+    it "should reject '?' as a short parameter name" do
+      misconfig_parser { |c| c.optional '?', 'foo' }
     end
 
     it "should reject redefining an existing long name for two options" do
@@ -304,21 +413,31 @@ describe Clip do
           v.to_i
         end
       end
-      
+
       opts.value.should == 123
     end
+
+    it "should trap exceptions from block and report error" do
+      opts = Clip("-v 123") do |c|
+        c.req('v', 'value') {|v| raise("a good error message") }
+      end
+
+      opts.should_not be_valid
+      opts.should have_errors
+      opts.should have_errors_on(:value)
+    end
   end
 
   describe "when parsing ARGV as a hash" do
     setup { Clip.reset_hash! }
-    
+
     it "should make sense of '-c my_config.yml'" do
       Clip.hash(['-c', 'config.yml']).should == { 'c' => 'config.yml' }
     end
 
-    it "should only use pairs of dash + value args" do
-      Clip.hash(['-c', 'config.yml',
-                 '-d']).should == { 'c' => 'config.yml' }
+    it "should treat flag-style arguments as booleans" do
+      Clip.hash(['-f', '-c', 'config.yml', '-d']).
+        should == { 'c' => 'config.yml', 'd' => true, 'f' => true }
     end
 
     it "should ignore leading/trailing non-dashed arguments" do
@@ -330,9 +449,32 @@ describe Clip do
       Clip.hash(['-c', 'config.yml', '--mode', 'optimistic']).
         should == { 'c' => 'config.yml', 'mode' => 'optimistic' }
     end
-    
+
     it "should return an empty hash for empty ARGV" do
       Clip.hash([]).should == {}
     end
   end
+
+  describe "stopping parsing after finding --" do
+    it "should not blow up" do
+      opts = Clip('--') {|p|}
+      opts.should be_valid
+      opts.remainder.should be_empty
+    end
+
+    it "should not parse after --" do
+      opts = Clip('-- --help') {|p|}
+      opts.should be_valid
+      opts.remainder.should include('--help')
+    end
+
+    it "should parse args before --" do
+      opts = Clip('-v -- other stuff') do |p|
+        p.flag 'v', 'verbose'
+      end
+      opts.should be_valid
+      opts.should be_verbose
+      opts.remainder.should include('other', 'stuff')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: clip
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - Alex Vollmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-10 00:00:00 -07:00
+date: 2008-09-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,10 +31,13 @@ extensions: []
 
 extra_rdoc_files: 
 - History.txt
-- README.txt
+- Manifest.txt
 files: 
 - History.txt
-- README.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- clip.gemspec
 - lib/clip.rb
 - spec/clip_spec.rb
 has_rdoc: true