Polymer transformer logs now show on the frontend for pub serve.

pkg/polymer/lib/src/build/linter.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.
 
 /// Logic to validate that developers are correctly using Polymer constructs.
 /// This is mainly used to produce warnings for feedback in the editor.
 library polymer.src.build.linter;
 
 import 'dart:async';
+import 'dart:convert';
 
 import 'package:barback/barback.dart';
 import 'package:code_transformers/assets.dart';
 import 'package:html5lib/dom.dart';
 import 'package:html5lib/dom_parsing.dart';
 import 'package:source_span/source_span.dart';
 
 import 'common.dart';
 import 'utils.dart';
+import 'wrapped_logger.dart';
 
 /// A linter that checks for common Polymer errors and produces warnings to
 /// show on the editor or the command line. Leaves sources unchanged, but
 /// creates a new asset containing all the warnings.
 class Linter extends Transformer with PolymerTransformer {
   final TransformOptions options;
 
   /// Only run on .html files.
   final String allowedExtensions = '.html';
 
   Linter(this.options);
 
   Future apply(Transform transform) {
     var seen = new Set<AssetId>();
     var primary = transform.primaryInput;
     var id = primary.id;
     transform.addOutput(primary); // this phase is analysis only
     seen.add(id);
+    bool isEntryPoint = options.isHtmlEntryPoint(id);
+
+    var logger = new WrappedLogger(transform,
+        convertErrorsToWarnings: !options.releaseMode);
+
     return readPrimaryAsHtml(transform).then((document) {
-      return _collectElements(document, id, transform, seen).then((elements) {
-        bool isEntrypoint = options.isHtmlEntryPoint(id);
-        new _LinterVisitor(id, transform.logger, elements, isEntrypoint)
-            .run(document);
+      return _collectElements(document, id, transform, logger, seen)
+          .then((elements) {
+        new _LinterVisitor(id, logger, elements, isEntryPoint).run(document);
+
+        // Write out the logs collected by our [WrappedLogger].
+        if (options.injectBuildLogsInOutput) return logger.writeOutput();
       });
     });
   }
 
   /// Collect into [elements] any data about each polymer-element defined in
   /// [document] or any of it's imports, unless they have already been [seen].
   /// Elements are added in the order they appear, transitive imports are added
   /// first.
   Future<Map<String, _ElementSummary>> _collectElements(
       Document document, AssetId sourceId, Transform transform,
-      Set<AssetId> seen, [Map<String, _ElementSummary> elements]) {
+      TransformLogger logger, Set<AssetId> seen,
+      [Map<String, _ElementSummary> elements]) {
     if (elements == null) elements = <String, _ElementSummary>{};
-    return _getImportedIds(document, sourceId, transform)
+    return _getImportedIds(document, sourceId, transform, logger)
         // Note: the import order is relevant, so we visit in that order.
         .then((ids) => Future.forEach(ids,
-              (id) => _readAndCollectElements(id, transform, seen, elements)))
+              (id) => _readAndCollectElements(
+                  id, transform, logger, seen, elements)))
         .then((_) {
           if (sourceId.package == 'polymer' &&
               sourceId.path == 'lib/src/js/polymer/polymer.html' &&
               elements['polymer-element'] == null) {
             elements['polymer-element'] =
                 new _ElementSummary('polymer-element', null, null);
           }
-          return _addElements(document, transform.logger, elements);
+          return _addElements(document, logger, elements);
         })
         .then((_) => elements);
   }
 
   Future _readAndCollectElements(AssetId id, Transform transform,
-      Set<AssetId> seen, Map<String, _ElementSummary> elements) {
+      TransformLogger logger, Set<AssetId> seen,
+      Map<String, _ElementSummary> elements) {
     if (id == null || seen.contains(id)) return new Future.value(null);
     seen.add(id);
     return readAsHtml(id, transform, showWarnings: false).then(
-        (doc) => _collectElements(doc, id, transform, seen, elements));
+        (doc) => _collectElements(doc, id, transform, logger, seen, elements));
   }
 
   Future<List<AssetId>> _getImportedIds(
-      Document document, AssetId sourceId, Transform transform) {
+      Document document, AssetId sourceId, Transform transform,
+      TransformLogger logger) {
     var importIds = [];
-    var logger = transform.logger;
     for (var tag in document.querySelectorAll('link')) {
       if (tag.attributes['rel'] != 'import') continue;
       var href = tag.attributes['href'];
       var span = tag.sourceSpan;
       var id = uriToAssetId(sourceId, href, logger, span);
       if (id == null) continue;
       importIds.add(assetExists(id, transform).then((exists) {
         if (exists) return id;
         if (sourceId == transform.primaryInput.id) {
           logger.warning('couldn\'t find imported asset "${id.path}" in package'
@@ skipping 54 matching lines @@
   String toString() => "($tagName <: $extendsTag)";
 }
 
 class _LinterVisitor extends TreeVisitor {
   TransformLogger _logger;
   AssetId _sourceId;
   bool _inPolymerElement = false;
   bool _dartTagSeen = false;
   bool _polymerHtmlSeen = false;
   bool _polymerExperimentalHtmlSeen = false;
-  bool _isEntrypoint;
+  bool _isEntryPoint;
   Map<String, _ElementSummary> _elements;
 
   _LinterVisitor(
-      this._sourceId, this._logger, this._elements, this._isEntrypoint) {
+      this._sourceId, this._logger, this._elements, this._isEntryPoint) {
     // We normalize the map, so each element has a direct reference to any
     // element it extends from.
     for (var tag in _elements.values) {
       var extendsTag = tag.extendsTag;
       if (extendsTag == null) continue;
       tag.extendsType = _elements[extendsTag];
     }
   }
 
   void visitElement(Element node) {
     switch (node.localName) {
       case 'link': _validateLinkElement(node); break;
       case 'element': _validateElementElement(node); break;
       case 'polymer-element': _validatePolymerElement(node); break;
       case 'script': _validateScriptElement(node); break;
       default:
          _validateNormalElement(node);
          super.visitElement(node);
          break;
     }
   }
 
   void run(Document doc) {
     visit(doc);
 
-    if (_isEntrypoint && !_dartTagSeen && !_polymerExperimentalHtmlSeen) {
+    if (_isEntryPoint && !_dartTagSeen && !_polymerExperimentalHtmlSeen) {
       _logger.warning(USE_INIT_DART, span: doc.body.sourceSpan);
     }
   }
 
   /// Produce warnings for invalid link-rel tags.
   void _validateLinkElement(Element node) {
     var rel = node.attributes['rel'];
     if (rel != 'import' && rel != 'stylesheet') return;
 
     if (rel == 'import' && _dartTagSeen) {
@@ skipping 77 matching lines @@
   }
 
   /// Checks for multiple Dart script tags in the same page, which is invalid.
   void _validateScriptElement(Element node) {
     var scriptType = node.attributes['type'];
     var isDart = scriptType == 'application/dart';
     var src = node.attributes['src'];
 
     if (isDart) {
       if (_dartTagSeen) _logger.warning(ONLY_ONE_TAG, span: node.sourceSpan);
-      if (_isEntrypoint && _polymerExperimentalHtmlSeen) {
+      if (_isEntryPoint && _polymerExperimentalHtmlSeen) {
         _logger.warning(NO_DART_SCRIPT_AND_EXPERIMENTAL, span: node.sourceSpan);
       }
       _dartTagSeen = true;
     }
 
     var isEmpty = node.innerHtml.trim() == '';
 
     if (src == null) {
       if (isDart && isEmpty) {
         _logger.warning('script tag seems empty.', span: node.sourceSpan);
@@ skipping 154 matching lines @@
     'either include a generic script tag that does this for you:'
     '\'<script type="application/dart">export "package:polymer/init.dart";'
     '</script>\' or add your own script tag and call that function. '
     'Make sure the script tag is placed after all HTML imports.';
 
 const String NO_DART_SCRIPT_AND_EXPERIMENTAL =
     'The experimental bootstrap feature doesn\'t support script tags on '
     'the main document (for now).';
 
 const List<String> INTERNALLY_DEFINED_ELEMENTS = 
-    const ['auto-binding-dart', 'polymer-element'];
+    const ['auto-binding-dart', 'polymer-element'];