Ignore unhandled arguments instead of stopping parsing.

pkg/args/test/parse_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library args_test;
 
 import 'package:unittest/unittest.dart';
 import 'package:args/args.dart';
 
 main() {
@@ skipping 18 matching lines @@
       });
 
       test('are false if missing with no default', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         var args = parser.parse([]);
         expect(args['verbose'], isFalse);
       });
 
-      test('throws if given a value', () {
+      test('throw if given a value', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         throwsFormat(parser, ['--verbose=true']);
       });
     });
 
     group('flags negated with "no-"', () {
       test('set the flag to false', () {
         var parser = new ArgParser();
@@ skipping 181 matching lines @@
       });
 
       test('allow non-option characters in the value', () {
         var parser = new ArgParser();
         parser.addOption('apple', abbr: 'a');
 
         var args = parser.parse(['-ab?!c']);
         expect(args['apple'], equals('b?!c'));
       });
 
+      test('are case-sensitive', () {
+        var parser = new ArgParser();
+        parser.addFlag('recurse', defaultsTo: false, abbr:'R');
+
+        var results = parser.parse(['-R']);
+        expect(results['recurse'], isTrue);
+        expect(results.rest, []);
+
+        throwsFormat(parser, ['-r']);
+      });
+
       test('throw if unknown', () {
         var parser = new ArgParser();
         throwsFormat(parser, ['-f']);
       });
 
       test('throw if the value is missing', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
 
         throwsFormat(parser, ['-f']);
@@ skipping 92 matching lines @@
         var args = parser.parse(['--mode=debug']);
         expect(args['mode'], equals('debug'));
       });
 
       test('throw if the value is not in the allowed set', () {
         var parser = new ArgParser();
         parser.addOption('mode', allowed: ['debug', 'release']);
         throwsFormat(parser, ['--mode=profile']);
       });
 
-      test('returns last provided value', () {
+      test('return last provided value', () {
         var parser = new ArgParser();
         parser.addOption('define');
         var args = parser.parse(['--define=1', '--define=2']);
         expect(args['define'], equals('2'));
       });
 
-      test('returns a List if multi-valued', () {
+      test('return a list if multi-valued', () {
         var parser = new ArgParser();
         parser.addOption('define', allowMultiple: true);
         var args = parser.parse(['--define=1']);
         expect(args['define'], equals(['1']));
         args = parser.parse(['--define=1', '--define=2']);
         expect(args['define'], equals(['1','2']));
       });
 
-      test('returns the default value for multi-valued arguments '
-           'if not explicitly set', () {
+      test('return the default value for multi-valued arguments if not '
+           'explicitly set', () {
         var parser = new ArgParser();
         parser.addOption('define', defaultsTo: '0', allowMultiple: true);
         var args = parser.parse(['']);
         expect(args['define'], equals(['0']));
       });
     });
 
     group('remaining args', () {
-      test('stops parsing args when a non-option-like arg is encountered', () {
+      test('accumulates unhandled arguments', () {
         var parser = new ArgParser();
         parser.addFlag('woof');
         parser.addOption('meow');
-        parser.addOption('tweet', defaultsTo: 'bird');
-
-        var results = parser.parse(['--woof', '--meow', 'v', 'not', 'option']);
+        var results = parser.parse(['a', '--woof', 'b', '--meow', 'c', 'd']);
         expect(results['woof'], isTrue);
-        expect(results['meow'], equals('v'));
-        expect(results['tweet'], equals('bird'));
-        expect(results.rest, orderedEquals(['not', 'option']));
+        expect(results['meow'], equals('c'));
+        expect(results.rest, orderedEquals(['a', 'b', 'd']));

[ahe, 2013/01/10 19:51:40]

Could you add a test that you reject unknown arguments that look like options?

[Bob Nystrom, 2013/01/10 23:16:40]

The tests on 252 and 329 should cover that, I think.

[ahe, 2013/01/11 05:37:28]

Yes. I guess I was skipping exceptions when I scanned for this.

Would it be possible to provide an onError callback so you can handle these
situations without throwing an exception?

I have two use cases in mind:

* You wrap another application, but want to add a few additional arguments. So
the facade will pass everything through that it doesn't understand.

* You can easily provide a "showUsageAndExit" method.

       });
 
       test('stops parsing at "--"', () {
         var parser = new ArgParser();
         parser.addFlag('woof', defaultsTo: false);
         parser.addOption('meow', defaultsTo: 'kitty');
 
         var results = parser.parse(['--woof', '--', '--meow']);
         expect(results['woof'], isTrue);
         expect(results['meow'], equals('kitty'));
         expect(results.rest, orderedEquals(['--meow']));
       });
-
-      test('handles options with case-sensitivity', () {
-        var parser = new ArgParser();
-        parser.addFlag('recurse', defaultsTo: false, abbr:'R');
-        var results = parser.parse(['-R']);
-        expect(results['recurse'], isTrue);
-        expect(results.rest, [ ]);
-        throwsFormat(parser, ['-r']);
-      });
     });
   });
 }
 
 throwsIllegalArg(function) {
   expect(function, throwsArgumentError);
 }
 
 throwsFormat(ArgParser parser, List<String> args) {
   expect(() => parser.parse(args), throwsFormatException);
 }