trollop 1.8 → 1.8.1

data/FAQ.txt

@@ -1,15 +1,26 @@
 Trollop FAQ
 -----------
 
-Q: Whither Trollop?
-A: There are more than a few pre-existing commandline argument
-   processing libraries for Ruby. I was never too happy with any of
-   them. They all seemed to want me to type way too much for what I
-   wanted to get done. I just wanted to parse some options and be
-   done with it.
-
-Q: Whither "Trollop"?
-A: No reason. Just thought it sounded funny.
+Q: Why should I use Trollop?
+A: Because it will take you FEWER LINES OF CODE to do reasonable option
+   parsing than any other option parser in existence.
+
+   Look:
+
+     opts = Trollop::options do
+       opt :monkey, "Use monkey mode"
+       opt :goat, "Use goat mode", :default => true
+       opt :num_limbs, "Set number of limbs", :default => 4
+     end
+
+   That's it. And opts is a hash and you do whatever you want with it.
+   Trivial. You don't have to mix option processing code blocks with the
+   declarations. You don't have to make a class for every option (what is
+   this, Java?). You don't have to write more than 1 line of code per
+   option.
+
+Q: Why is it called "Trollop"?
+A: No reason.
 
 Q: Why does Trollop disallow numeric short argument names, like '-1'
    and '-9'?

data/History.txt

@@ -1,3 +1,12 @@
+== 1.8.1 / 2008-06-24
+
+* Bugfix for short option autocreation
+* More aggressive documentation
+
+== 1.8 / 2008-06-16
+
+* Sub-command support via Parser#stop_on
+
 == 1.7.2 / 2008-01-16
 * Ruby 1.9-ify. Apparently this means replacing :'s with ;'s.
 

data/README.txt

@@ -8,19 +8,14 @@ Documentation quickstart: See Trollop::Parser.
 
 == DESCRIPTION
 
-Trollop is YAFCLAP --- yet another fine commandline argument processor
-for Ruby. Trollop is designed to provide the maximal amount of GNU-style
-argument processing in the minimum number of lines of code (for you, the
-programmer).
-
-Trollop provides a nice automatically-generated help page, robust option
-parsing, and sensible defaults for everything you don't specify.
-
-Trollop: getting you 90% of the way there with only 10% of the effort.
+Trollop is a commandline option parser for Ruby that just gets out of your
+way. One line of code per option is all you need to write. For that, you get
+a nice automatically-generated help page, robust option parsing, command
+subcompletion, and sensible defaults for everything you don't specify.
 
 == FEATURES/PROBLEMS
 
-- Simple usage.
+- Dirt-simple usage.
 - Sensible defaults. No tweaking necessary, much tweaking possible.
 - Support for long options, short options, short option bundling,
   and automatic type validation and conversion.
@@ -30,7 +25,9 @@ Trollop: getting you 90% of the way there with only 10% of the effort.
 
 == SYNOPSIS
 
+  ####################
   ###### simple ######
+  ####################
 
   require 'trollop'
   opts = Trollop::options do
@@ -39,9 +36,11 @@ Trollop: getting you 90% of the way there with only 10% of the effort.
     opt :num_limbs, "Set number of limbs", :default => 4
   end
 
-  p opts
+  p opts # { :monkey => false, :goat => true, :num_limbs => 4 }
 
+  ####################
   ###### medium ######
+  ####################
 
   require 'trollop'
   opts = Trollop::options do
@@ -61,8 +60,9 @@ Trollop: getting you 90% of the way there with only 10% of the effort.
   end
   Trollop::die :volume, "must be non-negative" if opts[:volume] < 0
   Trollop::die :file, "must exist" unless File.exist?(opts[:file]) if opts[:file]
-
+  ################################
   ##### sub-command support ######
+  ################################
 
   require 'trollop'
   global_opts = Trollop::options do
@@ -75,11 +75,13 @@ Trollop: getting you 90% of the way there with only 10% of the effort.
     opt :cmd_option, "This is an option only for the subcommand"
   end
 
-  puts "global: #{global_opts.inspect}, cmd: #{cmd.inspect}, cmd options: #{cmd_opts.inspect}"
+  p global_opts
+  p cmd
+  p cmd_opts
 
 == REQUIREMENTS
 
-* none!
+* A burning desire to write less code.
 
 == INSTALL
 

data/Rakefile

@@ -27,7 +27,7 @@ task :upload_webpage => WWW_FILES do |t|
 end
 
 task :upload_docs => [:docs] do |t|
-  sh "scp -Cr doc wmorgan@rubyforge.org:/var/www/gforge-projects/trollop/trollop"
+  sh "rsync -Paz -essh doc/* wmorgan@rubyforge.org:/var/www/gforge-projects/trollop/trollop/"
 end
 
 # vim: syntax=ruby

data/lib/trollop.rb

@@ -5,7 +5,7 @@
 
 module Trollop
 
-VERSION = "1.8"
+VERSION = "1.8.1"
 
 ## Thrown by Parser in the event of a commandline error. Not needed if
 ## you're using the Trollop::options entry.
@@ -33,6 +33,9 @@ class Parser
   ## The set of values specifiable as the :type parameter to #opt.
   TYPES = [:flag, :boolean, :bool, :int, :integer, :string, :double, :float]
 
+  ## :nodoc:
+  INVALID_SHORT_ARG_REGEX = /[\d-]/
+
   ## The values from the commandline that were not interpreted by #parse.
   attr_reader :leftovers
 
@@ -137,7 +140,7 @@ class Parser
     opts[:short] =
       case opts[:short]
       when nil
-        c = opts[:long].split(//).find { |c| c !~ /[\d]/ && !@short.member?(c) }
+        c = opts[:long].split(//).find { |c| c !~ INVALID_SHORT_ARG_REGEX && !@short.member?(c) }
         raise ArgumentError, "can't generate a short option name for #{opts[:long].inspect}: out of unique characters" unless c
         c
       when /^-(.)$/
@@ -151,7 +154,7 @@ class Parser
       end
     if opts[:short]
       raise ArgumentError, "short option name #{opts[:short].inspect} is already taken; please specify a (different) :short" if @short[opts[:short]]
-      raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ /[\d-]/
+      raise ArgumentError, "a short option name can't be a number or a dash" if opts[:short] =~ INVALID_SHORT_ARG_REGEX
     end
 
     ## fill in :default for flags

data/test/test_trollop.rb

@@ -109,7 +109,7 @@ class Trollop < ::Test::Unit::TestCase
     assert_raise(ArgumentError) { @p.opt "badarg3", "desc", :short => "--t" }
   end
 
-  def test_short_names_determined_automatically
+  def test_short_names_created_automatically
     @p.opt "arg"
     @p.opt "arg2"
     @p.opt "arg3"
@@ -120,6 +120,29 @@ class Trollop < ::Test::Unit::TestCase
     assert_equal true, opts["arg3"]
   end
 
+  def test_short_autocreation_skips_dashes_and_numbers
+    @p.opt :arg # auto: a
+    @p.opt :arg_potato # auto: r
+    @p.opt :arg_muffin # auto: g
+    assert_nothing_raised { @p.opt :arg_daisy } # auto: d (not _)!
+    assert_nothing_raised { @p.opt :arg_r2d2f } # auto: f (not 2)!
+
+    opts = @p.parse %w(-f -d)
+    assert_equal true, opts[:arg_daisy]
+    assert_equal true, opts[:arg_r2d2f]
+    assert_equal false, opts[:arg]
+    assert_equal false, opts[:arg_potato]
+    assert_equal false, opts[:arg_muffin]
+  end
+
+  def test_short_autocreation_detects_running_out
+    @p.opt :arg1 # auto: a
+    @p.opt :arg2 # auto: r
+    @p.opt :arg3 # auto: g
+    assert_raises(ArgumentError) { @p.opt :arg4 }
+    assert_nothing_raised { @p.opt :argf }
+  end
+
   def test_short_can_be_nothing
     assert_nothing_raised do
       @p.opt "arg", "desc", :short => :none

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: trollop
 version: !ruby/object:Gem::Version 
-  version: "1.8"
+  version: 1.8.1
 platform: ruby
 authors: 
 - William Morgan
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-16 00:00:00 -07:00
+date: 2008-06-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: "== DESCRIPTION  Trollop is YAFCLAP --- yet another fine commandline argument processor for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer).  - Simple usage. - Sensible defaults. No tweaking necessary, much tweaking possible. - Support for long options, short options, short option bundling, and automatic type validation and conversion. - Support for subcommands. - Automatic help message generation, wrapped to current screen width. - Lots of unit tests.  Synopsis  ###### simple ######  require 'trollop' opts = Trollop::options do opt :monkey, \"Use monkey mode\" opt :goat, \"Use goat mode\", :default => true opt :num_limbs, \"Set number of limbs\", :default => 4 end  p opts  ###### medium ######  require 'trollop' opts = Trollop::options do version \"test 1.2.3 (c) 2007 William Morgan\" banner <<-EOS Test is an awesome program that does something very, very important.  Usage: test [options] <filenames>+ where [options] are: EOS  opt :ignore, \"Ignore incorrect values\" opt :file, \"Extra data filename to read in, with a very long option description like this one\", :type => String opt :volume, \"Volume level\", :default => 3.0 opt :iters, \"Number of iterations\", :default => 5 end Trollop::die :volume, \"must be non-negative\" if opts[:volume] < 0 Trollop::die :file, \"must exist\" unless File.exist?(opts[:file]) if opts[:file]  ##### sub-command support ######"
+description: "== DESCRIPTION  Trollop is a commandline option parser for Ruby that just gets out of your way. One line of code per option is all you need to write. For that, you get a nice automatically-generated help page, robust option parsing, command subcompletion, and sensible defaults for everything you don't specify.  #################### ###### simple ###### ####################  require 'trollop' opts = Trollop::options do opt :monkey, \"Use monkey mode\" opt :goat, \"Use goat mode\", :default => true opt :num_limbs, \"Set number of limbs\", :default => 4 end  p opts # { :monkey => false, :goat => true, :num_limbs => 4 }  #################### ###### medium ###### ####################  require 'trollop' opts = Trollop::options do version \"test 1.2.3 (c) 2007 William Morgan\" banner <<-EOS Test is an awesome program that does something very, very important.  Usage: test [options] <filenames>+ where [options] are: EOS  opt :ignore, \"Ignore incorrect values\" opt :file, \"Extra data filename to read in, with a very long option description like this one\", :type => String opt :volume, \"Volume level\", :default => 3.0 opt :iters, \"Number of iterations\", :default => 5 end Trollop::die :volume, \"must be non-negative\" if opts[:volume] < 0 Trollop::die :file, \"must exist\" unless File.exist?(opts[:file]) if opts[:file] ################################ ##### sub-command support ###### ################################  require 'trollop' global_opts = Trollop::options do opt :global_option, \"This is a global option\" stop_on %w(sub-command-1 sub-command-2) end  cmd = ARGV.shift cmd_opts = Trollop::options do opt :cmd_option, \"This is an option only for the subcommand\" end  p global_opts p cmd p cmd_opts"
 email: wmorgan-trollop@masanjin.net
 executables: []
 
@@ -55,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: trollop
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: Trollop is YAFCLAP --- yet another fine commandline argument processing library for Ruby. Trollop is designed to provide the maximal amount of GNU-style argument processing in the minimum number of lines of code (for you, the programmer).