pkg/args: expose immutable collections

pkg/args/lib/args.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.
 
 /**
  * This library lets you define parsers for parsing raw command-line arguments
  * into a set of options and values using [GNU][] and [POSIX][] style options.
  *
  * ## Installing ##
  *
@@ skipping 237 matching lines @@
  * be followed by a single new line. Options with multi-line help text
  * will be followed by two new lines. This provides spatial diversity between
  * options.
  *
  * [posix]: http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap12.html#tag_12_02
  * [gnu]: http://www.gnu.org/prep/standards/standards.html#Command_002dLine-Interfaces
  * [pub]: http://pub.dartlang.org
  */
 library args;
 
+import 'package:unmodifiable_collection/unmodifiable_collection.dart';
+
 import 'src/parser.dart';
 import 'src/usage.dart';
 import 'src/options.dart';
 export 'src/options.dart';
 
 /**
  * A class for taking a list of raw command line arguments and parsing out
  * options and flags from them.
  */
 class ArgParser {
+  final Map<String, Option> _options;
+  final Map<String, ArgParser> _commands;
+
   /**
    * The options that have been defined for this parser.
    */
-  final Map<String, Option> options = <String, Option>{};
+  final Map<String, Option> options;
 
   /**
    * The commands that have been defined for this parser.
    */
-  final Map<String, ArgParser> commands = <String, ArgParser>{};
+  final Map<String, ArgParser> commands;
 
   /** Creates a new ArgParser. */
-  ArgParser();
+  factory ArgParser() =>
+      new ArgParser._(<String, Option>{}, <String, ArgParser>{});
+
+  ArgParser._(Map<String, Option> options, Map<String, ArgParser> commands) :
+    this._options = options,
+    this.options = new UnmodifiableMapView(options),
+    this._commands = commands,
+    this.commands = new UnmodifiableMapView(commands);
 
   /**
    * Defines a command.
    *
    * A command is a named argument which may in turn define its own options and
    * subcommands using the given parser. If [parser] is omitted, implicitly
    * creates a new one. Returns the parser for the command.
    */
   ArgParser addCommand(String name, [ArgParser parser]) {
     // Make sure the name isn't in use.
-    if (commands.containsKey(name)) {
+    if (_commands.containsKey(name)) {
       throw new ArgumentError('Duplicate command "$name".');
     }
 
     if (parser == null) parser = new ArgParser();
-    commands[name] = parser;
+    _commands[name] = parser;
     return parser;
   }
 
   /**
    * Defines a flag. Throws an [ArgumentError] if:
    *
    * * There is already an option named [name].
    * * There is already an option using abbreviation [abbr].
    */
   void addFlag(String name, {String abbr, String help, bool defaultsTo: false,
@@ skipping 13 matching lines @@
       void callback(value), bool allowMultiple: false}) {
     _addOption(name, abbr, help, allowed, allowedHelp, defaultsTo,
         callback, isFlag: false, allowMultiple: allowMultiple);
   }
 
   void _addOption(String name, String abbr, String help, List<String> allowed,
       Map<String, String> allowedHelp, defaultsTo,
       void callback(value), {bool isFlag, bool negatable: false,
       bool allowMultiple: false}) {
     // Make sure the name isn't in use.
-    if (options.containsKey(name)) {
+    if (_options.containsKey(name)) {
       throw new ArgumentError('Duplicate option "$name".');
     }
 
     // Make sure the abbreviation isn't too long or in use.
     if (abbr != null) {
       var existing = findByAbbreviation(abbr);
       if (existing != null) {
         throw new ArgumentError(
             'Abbreviation "$abbr" is already used by "${existing.name}".');
       }
     }
 
-    options[name] = new Option(name, abbr, help, allowed, allowedHelp,
+    _options[name] = new Option(name, abbr, help, allowed, allowedHelp,
         defaultsTo, callback, isFlag: isFlag, negatable: negatable,
         allowMultiple: allowMultiple);
   }
 
   /**
    * Parses [args], a list of command-line arguments, matches them against the
    * flags and options defined by this parser, and returns the result.
    *
    * If [allowTrailingOptions] is set, the parser will continue parsing even
    * after it finds an argument that is neither an option nor a command.
@@ skipping 35 matching lines @@
         orElse: () => null);
   }
 }
 
 /**
  * The results of parsing a series of command line arguments using
  * [ArgParser.parse()]. Includes the parsed options and any remaining unparsed
  * command line arguments.
  */
 class ArgResults {
-  final Map _options;
+  final Map<String, dynamic> _options;
 
   /**
    * If these are the results for parsing a command's options, this will be
    * the name of the command. For top-level results, this returns `null`.
    */
   final String name;
 
   /**
    * The command that was selected, or `null` if none was. This will contain
    * the options that were selected for that command.
    */
   final ArgResults command;
 
   /**
    * The remaining command-line arguments that were not parsed as options or
    * flags. If `--` was used to separate the options from the remaining
    * arguments, it will not be included in this list.
    */
   final List<String> rest;
 
   /** Creates a new [ArgResults]. */
-  ArgResults(this._options, this.name, this.command, this.rest);
+  ArgResults(this._options, this.name, this.command, List<String> rest)
+    : this.rest = new UnmodifiableListView(rest);
 
   /** Gets the parsed command-line option named [name]. */
   operator [](String name) {
     if (!_options.containsKey(name)) {
       throw new ArgumentError(
           'Could not find an option named "$name".');
     }
 
     return _options[name];
   }
 
   /** Get the names of the options as an [Iterable]. */
   Iterable<String> get options => _options.keys;
 }