trollop 1.4 → 1.5

data/FAQ.txt

@@ -20,12 +20,14 @@ A: Because it's ambiguous whether these are arguments or negative
 
    I could be very clever and detect when there are no arguments
    that require floating-point parameters, and allow such short option
-   names in those cases, but I'd rather be simple and consistent.
+   names in those cases, but opted for simplicity and consistency.
 
 Q: Why does Trollop disallow options appearing multiple times, despite
    the POSIX standard allowing it?
 A: Because basically I think it's confusing, and more often than
    not, a symptom of you making a mistake (e.g. getting lost in a long
-   command line and accidentally setting the same thing twice.)  Given
-   that, I really don't see that much advantage to "-vvvvv" over "-v
-   5", so Trollop will produce an error if it happens.
+   command line and accidentally setting the same thing twice.) 
+   I also don't see that much advantage to "-vvvvv" over "-v 5", so
+   Trollop will produce an error if you try to use the same argument
+   multiple times.
+

data/History.txt

@@ -1,3 +1,10 @@
+== 1.5 / 2007-03-31
+* --help and --version do the right thing even if the rest of the
+  command line is incorrect.
+* Added #conflicts and #depends to model dependencies and exclusivity
+  between arguments.
+* Minor bugfixes.
+
 == 1.4 / 2007-03-26
 * Disable short options with :short => :none.
 * Minor bugfixes and error message improvements.

data/lib/trollop.rb

@@ -5,7 +5,7 @@
 
 module Trollop
 
-VERSION = "1.4"
+VERSION = "1.5"
 
 ## Thrown by Parser in the event of a commandline error. Not needed if
 ## you're using the Trollop::options entry.
@@ -47,6 +47,7 @@ class Parser
     @long = {}
     @short = {}
     @order = []
+    @constraints = []
 
     #instance_eval(&b) if b # can't take arguments
     cloaker(&b).bind(self).call(*a) if b
@@ -170,6 +171,20 @@ class Parser
   def banner s; @order << [:text, s] end
   alias :text :banner
 
+  ## Marks two (or more!) options as requiring each other. Only
+  ## handles undirected dependcies. Directed dependencies are better
+  ## modeled with #die.
+  def depends *syms
+    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
+    @constraints << [:depends, syms]
+  end
+  
+  ## Marks two (or more!) options as conflicting.
+  def conflicts *syms
+    syms.each { |sym| raise ArgumentError, "unknown option '#{sym}'" unless @specs[sym] }
+    @constraints << [:conflicts, syms]
+  end
+
   ## yield successive arg, parameter pairs
   def each_arg args # :nodoc:
     remains = []
@@ -210,7 +225,7 @@ class Parser
     remains
   end
 
-  def parse args #:nodoc:
+  def parse cmdline #:nodoc:
     vals = {}
     required = {}
     found = {}
@@ -218,13 +233,15 @@ class Parser
     opt :version, "Print version and exit" if @version unless @specs[:version] || @long["version"]
     opt :help, "Show this message" unless @specs[:help] || @long["help"]
 
-    @specs.each do |name, opts|
-      required[name] = true if opts[:required]
-      vals[name] = opts[:default]
+    @specs.each do |sym, opts|
+      required[sym] = true if opts[:required]
+      vals[sym] = opts[:default]
     end
 
-   @leftovers = each_arg args do |arg, param|
-      name = 
+    ## resolve symbols
+    args = []
+    @leftovers = each_arg cmdline do |arg, param|
+      sym = 
         case arg
         when /^-([^-])$/
           @short[$1]
@@ -233,37 +250,53 @@ class Parser
         else
           raise CommandlineError, "invalid argument syntax: '#{arg}'"
         end
-      raise CommandlineError, "unknown argument '#{arg}'" unless name
-      raise CommandlineError, "option '#{arg}' specified multiple times" if found[name]
+      raise CommandlineError, "unknown argument '#{arg}'" unless sym
+      raise CommandlineError, "option '#{arg}' specified multiple times" if found[sym]
+      args << [sym, arg, param]
+      found[sym] = true
+
+      @specs[sym][:type] != :flag # take params on all except flags
+    end
+
+    ## check for version and help args
+    raise VersionNeeded if args.any? { |sym, *a| sym == :version }
+    raise HelpNeeded if args.any? { |sym, *a| sym == :help }
+
+    ## check constraint satisfaction
+    @constraints.each do |type, syms|
+      constraint_sym = syms.find { |sym| found[sym] }
+      next unless constraint_sym
+
+      case type
+      when :depends
+        syms.each { |sym| raise CommandlineError, "--#{@long[constraint_sym]} requires --#{@long[sym]}" unless found[sym] }
+      when :conflicts
+        syms.each { |sym| raise CommandlineError, "--#{@long[constraint_sym]} conflicts with --#{@long[sym]}" if found[sym] && sym != constraint_sym }
+      end
+    end
+
+    raise CommandlineError, "option '#{required.keys.first}' must be specified" if required.any? { |sym, x| !found[sym] }
 
-      raise VersionNeeded if name == :version
-      raise HelpNeeded if name == :help
+    ## parse parameters
+    args.each do |sym, arg, param|
+      opts = @specs[sym]
 
-      found[name] = true
-      opts = @specs[name]
+      raise CommandlineError, "option '#{arg}' needs a parameter" unless param || opts[:type] == :flag
 
       case opts[:type]
       when :flag
-        vals[name] = !opts[:default]
-        false
+        vals[sym] = !opts[:default]
       when :int
-        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
         raise CommandlineError, "option '#{arg}' needs an integer" unless param =~ /^\d+$/
-        vals[name] = param.to_i
-        true
+        vals[sym] = param.to_i
       when :float
-        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
         raise CommandlineError, "option '#{arg}' needs a floating-point number" unless param =~ FLOAT_RE
-        vals[name] = param.to_f
-        true
+        vals[sym] = param.to_f
       when :string
-        raise CommandlineError, "option '#{arg}' needs a parameter" unless param
-        vals[name] = param
-        true
+        vals[sym] = param.to_s
       end
     end
 
-    raise CommandlineError, "option '#{required.keys.first}' must be specified" if required.any? { |name, x| !found[name] }
     vals
   end
 
@@ -422,7 +455,7 @@ end
 ##   Trollop::die "need at least one filename" if ARGV.empty?
 def die arg, msg=nil
   if msg
-    $stderr.puts "Error: parameter for option '--#{@p.specs[arg][:long]}' or '-#{@p.specs[arg][:short]}' #{msg}."
+    $stderr.puts "Error: argument --#{@p.specs[arg][:long]} #{msg}."
   else
     $stderr.puts "Error: #{arg}."
   end

data/test/test_trollop.rb

@@ -17,13 +17,13 @@ class Trollop < ::Test::Unit::TestCase
 
   def test_unknown_arguments
     assert_raise(CommandlineError) { @p.parse(%w(--arg)) }
-    @p.opt "arg", "desc"
+    @p.opt "arg"
     assert_nothing_raised { @p.parse(%w(--arg)) }
     assert_raise(CommandlineError) { @p.parse(%w(--arg2)) }
   end
 
   def test_syntax_check
-    @p.opt "arg", "desc"
+    @p.opt "arg"
 
     assert_nothing_raised { @p.parse(%w(--arg)) }
     assert_nothing_raised { @p.parse(%w(arg)) }
@@ -54,8 +54,8 @@ class Trollop < ::Test::Unit::TestCase
 
   ## flags that don't take arguments ignore them
   def test_arglessflags_refuse_args
-    @p.opt "goodarg", "desc"
-    @p.opt "goodarg2", "desc"
+    @p.opt "goodarg"
+    @p.opt "goodarg2"
     assert_nothing_raised { @p.parse(%w(--goodarg)) }
     assert_nothing_raised { @p.parse(%w(--goodarg --goodarg2)) }
     opts = @p.parse %w(--goodarg a)
@@ -135,8 +135,8 @@ class Trollop < ::Test::Unit::TestCase
 
   ## two args can't have the same name
   def test_conflicting_names_are_detected
-    assert_nothing_raised { @p.opt "goodarg", "desc" }
-    assert_raise(ArgumentError) { @p.opt "goodarg", "desc" }
+    assert_nothing_raised { @p.opt "goodarg" }
+    assert_raise(ArgumentError) { @p.opt "goodarg" }
   end
 
   ## two args can't have the same :long
@@ -195,7 +195,7 @@ class Trollop < ::Test::Unit::TestCase
   end
 
   def test_version_only_appears_if_set
-    @p.opt "arg", "desc"
+    @p.opt "arg"
     assert_raise(CommandlineError) { @p.parse %w(-v) }
     @p.version "trollop 1.2.3.4"
     assert_raise(VersionNeeded) { @p.parse %w(-v) }
@@ -376,6 +376,72 @@ EOM
     assert_nothing_raised { @p.parse %w(-v) }
   end
 
+  def test_version_and_help_override_errors
+    @p.opt :asdf, "desc", :type => String
+    @p.version "version"
+    assert_nothing_raised { @p.parse %w(--asdf goat) }
+    assert_raises(CommandlineError) { @p.parse %w(--asdf) }
+    assert_raises(HelpNeeded) { @p.parse %w(--asdf --help) }
+    assert_raises(VersionNeeded) { @p.parse %w(--asdf --version) }
+  end
+
+  def test_conflicts
+    @p.opt :one
+    assert_raises(ArgumentError) { @p.conflicts :one, :two }
+    @p.opt :two
+    assert_nothing_raised { @p.conflicts :one, :two }
+    assert_nothing_raised { @p.parse %w(--one) }
+    assert_nothing_raised { @p.parse %w(--two) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--one --two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.conflicts :hello, :yellow, :mellow, :jello
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
+
+    assert_nothing_raised { opts = @p.parse %w(--hello) }
+    assert_nothing_raised { opts = @p.parse %w(--jello) }
+    assert_nothing_raised { opts = @p.parse %w(--yellow) }
+    assert_nothing_raised { opts = @p.parse %w(--mellow) }
+
+    assert_nothing_raised { opts = @p.parse %w(--mellow --one) }
+    assert_nothing_raised { opts = @p.parse %w(--mellow --two) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--one --mellow --two --jello) }
+  end
+
+  def test_depends
+    @p.opt :one
+    assert_raises(ArgumentError) { @p.depends :one, :two }
+    @p.opt :two
+    assert_nothing_raised { @p.depends :one, :two }
+    assert_nothing_raised { opts = @p.parse %w(--one --two) }
+    assert_raises(CommandlineError) { @p.parse %w(--one) }
+    assert_raises(CommandlineError) { @p.parse %w(--two) }
+
+    @p.opt :hello
+    @p.opt :yellow
+    @p.opt :mellow
+    @p.opt :jello
+    @p.depends :hello, :yellow, :mellow, :jello
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --mellow --jello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello --jello) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--hello) }
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow) }
+
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two) }
+    assert_nothing_raised { opts = @p.parse %w(--hello --yellow --mellow --jello --one --two a b c) }
+
+    assert_raises(CommandlineError) { opts = @p.parse %w(--mellow --two --jello --one) }
+  end
+
 end
 
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: trollop
 version: !ruby/object:Gem::Version 
-  version: "1.4"
-date: 2007-03-26 00:00:00 -07:00
+  version: "1.5"
+date: 2007-03-31 00:00:00 -07:00
 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).
 require_paths: 
 - lib