Parse comma-separated multiple values.

lib/src/parser.dart

 // Copyright (c) 2013, 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.src.parser;
 
 import 'arg_parser.dart';
 import 'arg_results.dart';
 import 'option.dart';
 
@@ skipping 113 matching lines @@
     if (option == null) {
       // Walk up to the parent command if possible.
       validate(
           parent != null, 'Could not find an option or flag "-${soloOpt[1]}".');
       return parent.parseSoloOption();
     }
 
     args.removeAt(0);
 
     if (option.isFlag) {
-      setOption(results, option, true);
+      setFlag(results, option, true);
     } else {
       readNextArgAsValue(option);
     }
 
     return true;
   }
 
   /// Tries to parse the current argument as a series of collapsed abbreviations
   /// (like "-abc") or a single abbreviation with the value directly attached
   /// to it (like "-mrelease").
@@ skipping 44 matching lines @@
           parent != null, 'Could not find an option with short name "-$c".');
       parent.parseShortFlag(c);
       return;
     }
 
     // In a list of short options, only the first can be a non-flag. If
     // we get here we've checked that already.
     validate(
         option.isFlag, 'Option "-$c" must be a flag to be in a collapsed "-".');
 
-    setOption(results, option, true);
+    setFlag(results, option, true);
   }
 
   /// Tries to parse the current argument as a long-form named option, which
   /// may include a value like "--mode=release" or "--mode release".
   bool parseLongOption() {
     var longOpt = _LONG_OPT.firstMatch(current);
     if (longOpt == null) return false;
 
     var name = longOpt[1];
     var option = grammar.options[name];
     if (option != null) {
       args.removeAt(0);
       if (option.isFlag) {
         validate(longOpt[3] == null,
             'Flag option "$name" should not be given a value.');
 
-        setOption(results, option, true);
+        setFlag(results, option, true);
       } else if (longOpt[3] != null) {
         // We have a value like --foo=bar.
         setOption(results, option, longOpt[3]);
       } else {
         // Option like --foo, so look for the value as the next arg.
         readNextArgAsValue(option);
       }
     } else if (name.startsWith('no-')) {
       // See if it's a negated flag.
       name = name.substring('no-'.length);
       option = grammar.options[name];
       if (option == null) {
         // Walk up to the parent command if possible.
         validate(parent != null, 'Could not find an option named "$name".');
         return parent.parseLongOption();
       }
 
       args.removeAt(0);
       validate(option.isFlag, 'Cannot negate non-flag option "$name".');
       validate(option.negatable, 'Cannot negate option "$name".');
 
-      setOption(results, option, false);
+      setFlag(results, option, false);
     } else {
       // Walk up to the parent command if possible.
       validate(parent != null, 'Could not find an option named "$name".');
       return parent.parseLongOption();
     }
 
     return true;
   }
 
   /// Called during parsing to validate the arguments.
   ///
   /// Throws a [FormatException] if [condition] is `false`.
   void validate(bool condition, String message) {
     if (!condition) throw new FormatException(message);
   }
 
-  /// Validates and stores [value] as the value for [option].
-  void setOption(Map results, Option option, value) {
-    // See if it's one of the allowed values.
-    if (option.allowed != null) {
-      validate(option.allowed.any((allow) => allow == value),
-          '"$value" is not an allowed value for option "${option.name}".');
+  /// Validates and stores [value] as the value for [option], which must not be
+  /// a flag.
+  void setOption(Map results, Option option, String value) {
+    assert(!option.isFlag);
+
+    if (!option.isMultiple) {
+      _validateAllowed(option, value);
+      results[option.name] = value;
+      return;
     }
 
-    if (option.isMultiple) {
-      var list = results.putIfAbsent(option.name, () => []);
+    var list = results.putIfAbsent(option.name, () => []);
+
+    if (option.splitCommas) {
+      for (var element in value.split(",")) {
+        _validateAllowed(option, element);
+        list.add(element);
+      }
+    } else {
+      _validateAllowed(option, value);
       list.add(value);
-    } else {
-      results[option.name] = value;
     }
   }
+
+  /// Validates and stores [value] as the value for [option], which must be a
+  /// flag.
+  void setFlag(Map results, Option option, bool value) {
+    assert(option.isFlag);
+    results[option.name] = value;
+  }
+
+  /// Validates that [value] is allowed as a value of [option].
+  void _validateAllowed(Option option, String value) {
+    if (option.allowed == null) return;
+
+    validate(option.allowed.contains(value),
+        '"$value" is not an allowed value for option "${option.name}".');
+  }
 }