move polymer.dart into dart svn

pkg/polymer/lib/component_build.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.
+
+/**
+ * Common logic to make it easy to create a `build.dart` for your project.
+ *
+ * The `build.dart` script is invoked automatically by the Editor whenever a
+ * file in the project changes. It must be placed in the root of a project
+ * (where pubspec.yaml lives) and should be named exactly 'build.dart'.
+ *
+ * A common `build.dart` would look as follows:
+ *
+ *     import 'dart:io';
+ *     import 'package:polymer/component_build.dart';
+ *
+ *     main() => build(new Options().arguments, ['web/index.html']);
+ */
+library build_utils;
+
+import 'dart:async';
+import 'dart:io';
+import 'dart:json' as json;
+import 'package:args/args.dart';
+
+import 'dwc.dart' as dwc;
+import 'src/utils.dart';
+import 'src/compiler_options.dart';
+
+/**
+ * Set up 'build.dart' to compile with the dart web components compiler every
+ * [entryPoints] listed. On clean commands, the directory where [entryPoints]
+ * live will be scanned for generated files to delete them.
+ */
+// TODO(jmesserly): we need a better way to automatically detect input files
+Future<List<dwc.CompilerResult>> build(List<String> arguments,
+    List<String> entryPoints,
+    {bool printTime: true, bool shouldPrint: true}) {
+  bool useColors = stdioType(stdout) == StdioType.TERMINAL;
+  return asyncTime('Total time', () {
+    var args = _processArgs(arguments);
+    var tasks = new FutureGroup();
+    var lastTask = new Future.value(null);
+    tasks.add(lastTask);
+
+    var changedFiles = args["changed"];
+    var removedFiles = args["removed"];
+    var cleanBuild = args["clean"];
+    var machineFormat = args["machine"];
+    // Also trigger a full build if the script was run from the command line
+    // with no arguments
+    var fullBuild = args["full"] || (!machineFormat && changedFiles.isEmpty &&
+        removedFiles.isEmpty && !cleanBuild);
+
+    var options = CompilerOptions.parse(args.rest, checkUsage: false);
+
+    // [outputOnlyDirs] contains directories known to only have output files.
+    // When outputDir is not specified, we create a new directory which only
+    // contains output files. If options.outputDir is specified, we don't know
+    // if the output directory may also have input files. In which case,
+    // [_handleCleanCommand] and [_isInputFile] are more conservative.
+    //
+    // TODO(sigmund): get rid of this. Instead, use the compiler to understand
+    // which files are input or output files.
+    var outputOnlyDirs = options.outputDir == null ? []
+        : entryPoints.map((e) => _outDir(e)).toList();
+
+    if (cleanBuild) {
+      _handleCleanCommand(outputOnlyDirs);
+    } else if (fullBuild
+        || changedFiles.any((f) => _isInputFile(f, outputOnlyDirs))
+        || removedFiles.any((f) => _isInputFile(f, outputOnlyDirs))) {
+      for (var file in entryPoints) {
+        var dwcArgs = new List.from(args.rest);
+        if (machineFormat) dwcArgs.add('--json_format');
+        if (!useColors) dwcArgs.add('--no-colors');
+        // We'll set 'out/' as the out folder, unless an output directory was
+        // already specified in the command line.
+        if (options.outputDir == null) dwcArgs.addAll(['-o', _outDir(file)]);
+        dwcArgs.add(file);
+        // Chain tasks to that we run one at a time.
+        lastTask = lastTask.then((_) => dwc.run(dwcArgs, printTime: printTime,
+            shouldPrint: shouldPrint));
+        if (machineFormat) {
+          lastTask = lastTask.then((res) {
+            appendMessage(Map jsonMessage) {
+              var message = json.stringify([jsonMessage]);
+              if (shouldPrint) print(message);
+              res.messages.add(message);
+            }
+            // Print for the Editor messages about mappings and generated files
+            res.outputs.forEach((out, input) {
+              if (out.endsWith(".html") && input != null) {
+                appendMessage({
+                  "method": "mapping",
+                  "params": {"from": input, "to": out},
+                });
+              }
+              appendMessage({"method": "generated", "params": {"file": out}});
+            });
+            return res;
+          });
+        }
+        tasks.add(lastTask);
+      }
+    }
+    return tasks.future.then((r) => r.where((v) => v != null));
+  }, printTime: printTime, useColors: useColors);
+}
+
+String _outDir(String file) => path.join(path.dirname(file), 'out');
+
+/** Tell whether [filePath] is a generated file. */
+bool _isGeneratedFile(String filePath, List<String> outputOnlyDirs) {
+  var dirPrefix = path.dirname(filePath);
+  for (var outDir in outputOnlyDirs) {
+    if (dirPrefix.startsWith(outDir)) return true;
+  }
+  return path.basename(filePath).startsWith('_');
+}
+
+/** Tell whether [filePath] is an input file. */
+bool _isInputFile(String filePath, List<String> outputOnlyDirs) {
+  var ext = path.extension(filePath);
+  return (ext == '.dart' || ext == '.html') &&
+      !_isGeneratedFile(filePath, outputOnlyDirs);
+}
+
+/**
+ * Delete all generated files. Currently we only delete files under directories
+ * that are known to contain only generated code.
+ */
+void _handleCleanCommand(List<String> outputOnlyDirs) {
+  for (var dirPath in outputOnlyDirs) {
+    var dir = new Directory(dirPath);
+    if (!dir.existsSync()) continue;
+    for (var f in dir.listSync(recursive: false)) {
+      if (f is File && _isGeneratedFile(f.path, outputOnlyDirs)) f.deleteSync();
+    }
+  }
+}
+
+/** Process the command-line arguments. */
+ArgResults _processArgs(List<String> arguments) {
+  var parser = new ArgParser()
+    ..addOption("changed", help: "the file has changed since the last build",
+        allowMultiple: true)
+    ..addOption("removed", help: "the file was removed since the last build",
+        allowMultiple: true)
+    ..addFlag("clean", negatable: false, help: "remove any build artifacts")
+    ..addFlag("full", negatable: false, help: "perform a full build")
+    ..addFlag("machine", negatable: false,
+        help: "produce warnings in a machine parseable format")
+    ..addFlag("help", abbr: 'h',
+        negatable: false, help: "displays this help and exit");
+  var args = parser.parse(arguments);
+  if (args["help"]) {
+    print('A build script that invokes the web-ui compiler (dwc).');
+    print('Usage: dart build.dart [options] [-- [dwc-options]]');
+    print('\nThese are valid options expected by build.dart:');
+    print(parser.getUsage());
+    print('\nThese are valid options expected by dwc:');
+    dwc.run(['-h']).then((_) => exit(0));
+  }
+  return args;
+}