Merge pull request #581 from kevmoo/polymer

lib/dwc.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.
 
 /** The entry point to the compiler. Used to implement `bin/dwc.dart`. */
 library dwc;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:logging/logging.dart' show Level;
 
 import 'src/compiler.dart';
 import 'src/file_system.dart';
 import 'src/file_system/console.dart';
 import 'src/files.dart';
 import 'src/messages.dart';
 import 'src/compiler_options.dart';
 import 'src/utils.dart';
 
-FileSystem fileSystem;
+FileSystem _fileSystem;
 
 void main() {
   run(new Options().arguments).then((result) {
     exit(result.success ? 0 : 1);
   });
 }
 
 /** Contains the result of a compiler run. */
 class CompilerResult {
   final bool success;
@@ skipping 33 matching lines @@
  * See [CompilerOptions] for the definition of valid arguments.
  */
 // TODO(jmesserly): fix this to return a proper exit code
 // TODO(justinfagnani): return messages in the result
 Future<CompilerResult> run(List<String> args, {bool printTime,
     bool shouldPrint: true}) {
   var options = CompilerOptions.parse(args);
   if (options == null) return new Future.value(new CompilerResult());
   if (printTime == null) printTime = options.verbose;
 
-  fileSystem = new ConsoleFileSystem();
+  _fileSystem = new ConsoleFileSystem();
   var messages = new Messages(options: options, shouldPrint: shouldPrint);
 
   return asyncTime('Total time spent on ${options.inputFile}', () {
-    var compiler = new Compiler(fileSystem, options, messages);
+    var compiler = new Compiler(_fileSystem, options, messages);
     var res;
     return compiler.run()
       .then((_) {
         var success = messages.messages.every((m) => m.level != Level.SEVERE);
         var msgs = options.jsonFormat
             ? messages.messages.map((m) => m.toJson())
             : messages.messages.map((m) => m.toString());
         res = new CompilerResult._(success, msgs.toList(),
             compiler.output, compiler.files);
       })
-      .then((_) => symlinkPubPackages(res, options, messages))
-      .then((_) => emitFiles(compiler.output, options.clean))
+      .then((_) => _symlinkPubPackages(res, options, messages))
+      .then((_) => _emitFiles(compiler.output, options.clean))
       .then((_) => res);
   }, printTime: printTime, useColors: options.useColors);
 }
 
-Future emitFiles(List<OutputFile> outputs, bool clean) {
-  outputs.forEach((f) => writeFile(f.path, f.contents, clean));
-  return fileSystem.flush();
+Future _emitFiles(List<OutputFile> outputs, bool clean) {
+  outputs.forEach((f) => _writeFile(f.path, f.contents, clean));
+  return _fileSystem.flush();
 }
 
-void writeFile(String filePath, String contents, bool clean) {
+void _writeFile(String filePath, String contents, bool clean) {
   if (clean) {
     File fileOut = new File(filePath);
     if (fileOut.existsSync()) {
       fileOut.deleteSync();
     }
   } else {
     _createIfNeeded(path.dirname(filePath));
-    fileSystem.writeString(filePath, contents);
+    _fileSystem.writeString(filePath, contents);
   }
 }
 
 void _createIfNeeded(String outdir) {
   if (outdir.isEmpty) return;
   var outDirectory = new Directory(outdir);
   if (!outDirectory.existsSync()) {
     _createIfNeeded(path.dirname(outdir));
     outDirectory.createSync();
   }
 }
 
 /**
  * Creates a symlink to the pub packages directory in the output location. The
  * returned future completes when the symlink was created (or immediately if it
  * already exists).
  */
-Future symlinkPubPackages(CompilerResult result, CompilerOptions options,
+Future _symlinkPubPackages(CompilerResult result, CompilerOptions options,
     Messages messages) {
   if (options.outputDir == null || result.bootstrapFile == null
       || options.packageRoot != null) {
     // We don't need to copy the packages directory if the output was generated
     // in-place where the input lives, if the compiler was called without an
     // entry-point file, or if the compiler was called with a package-root
     // option.
     return new Future.value(null);
   }
 
@@ skipping 52 matching lines @@
     if (result.exitCode != 0) {
       var details = 'subprocess stdout:\n${result.stdout}\n'
                     'subprocess stderr:\n${result.stderr}';
       messages.error(
         'unable to create symlink\n target: $target\n link:$link\n$details',
         null);
     }
     return null;
   });
 }