Initial --modules=es6 support

lib/src/options.dart

 // Copyright (c) 2014, 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.
 
 /// Set of flags and options passed to the compiler
 library dev_compiler.src.options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
@@ skipping 38 matching lines @@
       {this.useMockSdk: false,
       this.dartSdkPath,
       this.useMultiPackage: false,
       this.customUrlMappings: const {},
       this.packageRoot: 'packages/',
       this.packagePaths: const <String>[],
       this.resources: const <String>[],
       this.useImplicitHtml: false});
 }
 
+enum ModuleFormat { es6, dart }

[Jennifer Messerly, 2016/01/22 18:29:01]

Heh, not sure the enum adds much value. More an issue with Dart enums, though.

e.g. with a custom enum class, we could add a method that knows how to
instantiate the right module builder, for example. And we wouldn't need to make
its internal name exactly match its option representation. And the parse method
wouldn't need to live as another top-level name.

But, we'd lose out on the static checking that all cases are covered in switch,
maybe.

So, not sure this is worth changing. Just throwing that out there for
discussion. :)

[ochafik, 2016/01/23 12:24:18]

I agree, *if only* we had Java enums...

+
+ModuleFormat parseModuleFormat(String s) =>
+    ModuleFormat.values.firstWhere((v) => s == '$v'.split('.')[1]);

[Jennifer Messerly, 2016/01/22 18:29:01]

if parsing fails, are we okay because args option parser will have already
issued a nice error message before we get to this point?

[ochafik, 2016/01/23 12:24:18]

Yes we are, but cleaned up utils (moved to utils.dart) + added tests to stay on
the safe side.

+
 // TODO(jmesserly): refactor all codegen options here.
 class CodegenOptions {
   /// Whether to emit the source map files.
   final bool emitSourceMaps;
 
   /// Whether to force compilation of code with static errors.
   final bool forceCompile;
 
   /// Output directory for generated code.
   final String outputDir;
 
   /// Emit Closure Compiler-friendly code.
   final bool closure;
 
   /// Enable ES6 destructuring of named parameters.
   final bool destructureNamedParams;
 
   /// Whether to emit a workaround for missing arrow function bind-this in
   /// other V8 builds
   final bool arrowFnBindThisWorkaround;
 
   /// Which module format to support.
   /// Currently 'es6' and 'dart' are supported.
-  final String moduleFormat;
+  final ModuleFormat moduleFormat;
 
   const CodegenOptions(
       {this.emitSourceMaps: true,
       this.forceCompile: false,
       this.closure: _CLOSURE_DEFAULT,
       this.destructureNamedParams: _DESTRUCTURE_NAMED_PARAMS_DEFAULT,
       this.outputDir,
       this.arrowFnBindThisWorkaround: false,
-      this.moduleFormat: 'dart'});
+      this.moduleFormat: ModuleFormat.dart});
 }
 
 /// Options for devrun.
 class RunnerOptions {
   /// V8-based binary to be used to run the .js output (d8, iojs, node).
   /// Can be just the executable name if it's in the path, or a path to the
   /// executable.
   final String v8Binary;
 
   const RunnerOptions({this.v8Binary: _V8_BINARY_DEFAULT});
@@ skipping 49 matching lines @@
   /// package (if we can infer where that is located).
   final String runtimeDir;
 
   /// The files to compile.
   final List<String> inputs;
 
   /// The base directory for [inputs]. Module imports will be generated relative
   /// to this directory.
   final String inputBaseDir;
 
-  CompilerOptions(
+  const CompilerOptions(
       {this.sourceOptions: const SourceResolverOptions(),
       this.codegenOptions: const CodegenOptions(),
       this.runnerOptions: const RunnerOptions(),
       this.checkSdk: false,
       this.dumpInfo: false,
       this.htmlReport: false,
       this.dumpInfoFile,
       this.useColors: true,
       this.help: false,
       this.version: false,
@@ skipping 60 matching lines @@
   if (serverMode && args.rest.length != 1) showUsage = true;
 
   return new CompilerOptions(
       codegenOptions: new CodegenOptions(
           emitSourceMaps: args['source-maps'],
           forceCompile: args['force-compile'] || serverMode,
           closure: args['closure'],
           destructureNamedParams: args['destructure-named-params'],
           outputDir: outputDir,
           arrowFnBindThisWorkaround: args['arrow-fn-bind-this'],
-          moduleFormat: args['modules']),
+          moduleFormat: parseModuleFormat(args['modules'])),
       sourceOptions: new SourceResolverOptions(
           useMockSdk: args['mock-sdk'],
           dartSdkPath: sdkPath,
           useImplicitHtml: serverMode &&
               args.rest.length == 1 &&
               args.rest[0].endsWith('.dart'),
           customUrlMappings: customUrlMappings,
           useMultiPackage: args['use-multi-package'],
           packageRoot: args['package-root'],
           packagePaths: args['package-paths'].split(','),
@@ skipping 49 matching lines @@
       help: 'Whether to emit source map files', defaultsTo: true)
   ..addOption('runtime-dir',
       help: 'Where to find dev_compiler\'s runtime files', defaultsTo: null)
   ..addFlag('arrow-fn-bind-this',
       help: 'Work around `this` binding in => functions')
   ..addOption('modules',
       help: 'Which module pattern to emit',
       allowed: ['es6', 'dart'],
       allowedHelp: {
         'es6': 'es6 modules',
-        'custom-dart': 'a custom format used by dartdevc, similar to AMD'
+        'dart': 'a custom format used by dartdevc, similar to AMD'

[Jennifer Messerly, 2016/01/22 18:29:01]

Hmmm, I don't like calling this format "dart" ... as it implies Dart needs its
own module format, or something.
Perhaps "legacy", to make it clear this is historical baggage?

[ochafik, 2016/01/23 12:24:17]

Done (+ tied these values to the enum with a getEnumName)

       },
       defaultsTo: 'dart')
 
   // general options
   ..addFlag('help', abbr: 'h', help: 'Display this message')
   ..addFlag('version',
       negatable: false, help: 'Display the Dev Compiler verion')
   ..addFlag('server', help: 'Run as a development server.', defaultsTo: false)
   ..addFlag('hashing',
       help: 'Enable hash-based file caching.', defaultsTo: null)
@@ skipping 80 matching lines @@
     // The pub-cache directory is two levels up, but we verify that the layout
     // looks correct.
     if (path.basename(dir) != 'dev_compiler') return null;
     dir = path.dirname(dir);
     if (path.basename(dir) != 'global_packages') return null;
     dir = path.dirname(dir);
     return path.join(dir, cacheDir, 'lib', 'runtime');
   }
   return null;
 }