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

pkg/polymer/lib/src/build/import_inliner.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.
 
 /// Transfomer that inlines polymer-element definitions from html imports.
 library polymer.src.build.import_inliner;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/assets.dart';
 import 'package:path/path.dart' as path;
 import 'package:html5lib/dom.dart' show
     Document, DocumentFragment, Element, Node;
 import 'package:html5lib/dom_parsing.dart' show TreeVisitor;
 import 'package:source_maps/refactor.dart' show TextEditTransaction;
 import 'package:source_span/source_span.dart';
 
 import 'common.dart';
+import 'wrapped_logger.dart';
 
 // TODO(sigmund): move to web_components package (dartbug.com/18037).
 class _HtmlInliner extends PolymerTransformer {
   final TransformOptions options;
   final Transform transform;
   final TransformLogger logger;
   final AssetId docId;
   final seen = new Set<AssetId>();
   final scriptIds = <AssetId>[];
   final extractedFiles = new Set<AssetId>();
   bool experimentalBootstrap = false;
 
   /// The number of extracted inline Dart scripts. Used as a counter to give
   /// unique-ish filenames.
   int inlineScriptCounter = 0;
 
-  _HtmlInliner(this.options, Transform transform)
-      : transform = transform,
-        logger = transform.logger,
+  _HtmlInliner(TransformOptions options, Transform transform)
+      : options = options,
+        transform = transform,
+        logger = options.releaseMode ? transform.logger :
+            new WrappedLogger(transform, convertErrorsToWarnings: true),
         docId = transform.primaryInput.id;
 
   Future apply() {
     seen.add(docId);
 
     Document document;
     bool changed = false;
 
     return readPrimaryAsHtml(transform).then((doc) {
       document = doc;
-      changed = new _UrlNormalizer(transform, docId).visit(document) || changed;
+      changed = new _UrlNormalizer(transform, docId, logger).visit(document)
+        || changed;
       
       experimentalBootstrap = document.querySelectorAll('link').any((link) =>
           link.attributes['rel'] == 'import' &&
           link.attributes['href'] == POLYMER_EXPERIMENTAL_HTML);
       changed = _extractScripts(document) || changed;
       return _visitImports(document);
     }).then((importsFound) {
       changed = changed || importsFound;
       return _removeScripts(document);
     }).then((scriptsRemoved) {
       changed = changed || scriptsRemoved;
 
       var output = transform.primaryInput;
       if (changed) output = new Asset.fromString(docId, document.outerHtml);
       transform.addOutput(output);
 
       // We produce a secondary asset with extra information for later phases.
       transform.addOutput(new Asset.fromString(
           docId.addExtension('._data'),
           JSON.encode({
             'experimental_bootstrap': experimentalBootstrap,
             'script_ids': scriptIds,
           }, toEncodable: (id) => id.serialize())));
+
+      // Write out the logs collected by our [WrappedLogger].
+      if (options.injectBuildLogsInOutput && logger is WrappedLogger) {

[Siggi Cherem (dart-lang), 2014/08/06 17:25:22]

I'm guessing our invariants guarantee that the second condition is always true?

[jakemac, 2014/08/06 19:41:22]

Technically not any more, when in release mode we don't wrap it any more,
regardless of the injectBuildLogsInOutput setting.

[Siggi Cherem (dart-lang), 2014/08/06 19:50:22]

Ah ok - for some reason I thought we didn't let the option to be true in release
mode, that's why I assumed it was enough.

I'm ok leaving it as it is. In case you like it better, an alternative is to
change it above to only wrap when both release & inject are true, then here we
just need the instance-of check.

[jakemac, 2014/08/06 19:59:37]

I do want to keep the same semantics around converting errors to warnings though
when not in release mode, so unfortunately I think this is about as good as its
going to get :(.

+        return logger.writeOutput();
+      }
     });
   }
 
   /// Visits imports in [document] and add the imported documents to documents.
   /// Documents are added in the order they appear, transitive imports are added
   /// first.
   ///
   /// Returns `true` if and only if the document was changed and should be
   /// written out.
   Future<bool> _visitImports(Document document) {
     bool changed = false;
 
     _moveHeadToBody(document);
 
     // Note: we need to preserve the import order in the generated output.
     return Future.forEach(document.querySelectorAll('link'), (Element tag) {
       var rel = tag.attributes['rel'];
       if (rel != 'import' && rel != 'stylesheet') return null;
 
       // Note: URL has already been normalized so use docId.
       var href = tag.attributes['href'];
-      var id = uriToAssetId(docId, href, transform.logger, tag.sourceSpan,
+      var id = uriToAssetId(docId, href, logger, tag.sourceSpan,
           errorOnAbsolute: rel != 'stylesheet');
 
       if (rel == 'import') {
         changed = true;
         if (id == null || !seen.add(id)) {
           tag.remove();
           return null;
         }
         return _inlineImport(id, tag);
 
@@ skipping 31 matching lines @@
         // Move the node into the body, where its contents will be placed.
         doc.body.insertBefore(node, insertionPoint);
       }
     }
   }
 
   /// Loads an asset identified by [id], visits its imports and collects its
   /// html imports. Then inlines it into the main document.
   Future _inlineImport(AssetId id, Element link) {
     return readAsHtml(id, transform).catchError((error) {
-      transform.logger.error(
+      logger.error(
           "Failed to inline html import: $error", asset: id,
           span: link.sourceSpan);
     }).then((doc) {
       if (doc == null) return false;
-      new _UrlNormalizer(transform, id).visit(doc);
+      new _UrlNormalizer(transform, id, logger).visit(doc);
       return _visitImports(doc).then((_) {
         // _UrlNormalizer already ensures there is a library name.
         _extractScripts(doc, injectLibraryName: false);
 
         // TODO(jmesserly): figure out how this is working in vulcanizer.
         // Do they produce a <body> tag with a <head> and <body> inside?
         var imported = new DocumentFragment();
         imported.nodes..addAll(doc.head.nodes)..addAll(doc.body.nodes);
         link.replaceWith(imported);
       });
     });
   }
 
   Future _inlineStylesheet(AssetId id, Element link) {
     return transform.readInputAsString(id).catchError((error) {
       // TODO(jakemac): Move this warning to the linter once we can make it run
       // always (see http://dartbug.com/17199). Then hide this error and replace
       // with a comment pointing to the linter error (so we don't double warn).
-      transform.logger.warning(
+      logger.warning(
           "Failed to inline stylesheet: $error", asset: id,
           span: link.sourceSpan);
     }).then((css) {
       if (css == null) return;
-      css = new _UrlNormalizer(transform, id).visitCss(css);
+      css = new _UrlNormalizer(transform, id, logger).visitCss(css);
       var styleElement = new Element.tag('style')..text = css;
       // Copy over the extra attributes from the link tag to the style tag.
       // This adds support for no-shim, shim-shadowdom, etc.
       link.attributes.forEach((key, value) {
         if (!IGNORED_LINKED_STYLE_ATTRS.contains(key)) {
           styleElement.attributes[key] = value;
         }
       });
       link.replaceWith(styleElement);
     });
@@ skipping 131 matching lines @@
   /// Counter used to ensure that every library name we inject is unique.
   int _count = 0;
 
   /// Path to the top level folder relative to the transform primaryInput.
   /// This should just be some arbitrary # of ../'s.
   final String topLevelPath;
 
   /// Whether or not the normalizer has changed something in the tree.
   bool changed = false;
 
-  _UrlNormalizer(transform, this.sourceId)
+  final TransformLogger logger;
+
+  _UrlNormalizer(transform, this.sourceId, this.logger)
       : transform = transform,
         topLevelPath =
           '../' * (transform.primaryInput.id.path.split('/').length - 2);
 
   visit(Node node) {
     super.visit(node);
     return changed;
   }
 
   visitElement(Element node) {
     // TODO(jakemac): Support custom elements that extend html elements which
     // have url-like attributes. This probably means keeping a list of which
     // html elements support each url-like attribute.
     if (!isCustomTagName(node.localName)) {
       node.attributes.forEach((name, value) {
         if (_urlAttributes.contains(name)) {
           if (!name.startsWith('_') && value.contains(_BINDING_REGEX)) {
-            transform.logger.warning(
+            logger.warning(
                 'When using bindings with the "$name" attribute you may '
                 'experience errors in certain browsers. Please use the '
                 '"_$name" attribute instead. For more information, see '
                 'http://goo.gl/5av8cU', span: node.sourceSpan, asset: sourceId);
           } else if (name.startsWith('_') && !value.contains(_BINDING_REGEX)) {
-            transform.logger.warning(
+            logger.warning(
                 'The "$name" attribute is only supported when using bindings. '
                 'Please change to the "${name.substring(1)}" attribute.',
                 span: node.sourceSpan, asset: sourceId);
           }
           if (value != '' && !value.trim().startsWith(_BINDING_REGEX)) {
             node.attributes[name] = _newUrl(value, node.sourceSpan);
             changed = changed || value != node.attributes[name];
           }
         }
       });
@@ skipping 35 matching lines @@
   String visitInlineDart(String code) {
     var unit = parseDirectives(code, suppressErrors: true);
     var file = new SourceFile(code, url: spanUrlFor(sourceId, transform));
     var output = new TextEditTransaction(code, file);
     var foundLibraryDirective = false;
     for (Directive directive in unit.directives) {
       if (directive is UriBasedDirective) {
         var uri = directive.uri.stringValue;
         var span = _getSpan(file, directive.uri);
 
-        var id = uriToAssetId(sourceId, uri, transform.logger, span,
+        var id = uriToAssetId(sourceId, uri, logger, span,
             errorOnAbsolute: false);
         if (id == null) continue;
 
         var primaryId = transform.primaryInput.id;
-        var newUri = assetUrlFor(id, primaryId, transform.logger);
+        var newUri = assetUrlFor(id, primaryId, logger);
         if (newUri != uri) {
           output.edit(span.start.offset, span.end.offset, "'$newUri'");
         }
       } else if (directive is LibraryDirective) {
         foundLibraryDirective = true;
       }
     }
 
     if (!foundLibraryDirective) {
       // Ensure all inline scripts also have a library name.
@@ skipping 23 matching lines @@
       hrefToParse = '${href.substring(0, firstBinding)}$placeholder';
     }
 
     var uri = Uri.parse(hrefToParse);
     if (uri.isAbsolute) return href;
     if (!uri.scheme.isEmpty) return href;
     if (!uri.host.isEmpty) return href;
     if (uri.path.isEmpty) return href;  // Implies standalone ? or # in URI.
     if (path.isAbsolute(href)) return href;
 
-    var id = uriToAssetId(sourceId, hrefToParse, transform.logger, span);
+    var id = uriToAssetId(sourceId, hrefToParse, logger, span);
     if (id == null) return href;
     var primaryId = transform.primaryInput.id;
 
     // Build the new path, placing back any suffixes that we stripped earlier.
     var prefix = (firstBinding == -1) ? id.path
         : id.path.substring(0, id.path.length - placeholder.length);
     var suffix = (firstBinding == -1) ? '' : href.substring(firstBinding);
     var newPath = '$prefix$suffix';
 
     if (newPath.startsWith('lib/')) {
       return '${topLevelPath}packages/${id.package}/${newPath.substring(4)}';
     }
 
     if (newPath.startsWith('asset/')) {
       return '${topLevelPath}assets/${id.package}/${newPath.substring(6)}';
     }
 
     if (primaryId.package != id.package) {
       // Techincally we shouldn't get there
-      transform.logger.error("don't know how to include $id from $primaryId",
-          span: span);
+      logger.error("don't know how to include $id from $primaryId", span: span);
       return href;
     }
 
     var builder = path.url;
     return builder.relative(builder.join('/', newPath),
         from: builder.join('/', builder.dirname(primaryId.path)));
   }
 }
 
 /// HTML attributes that expect a URL value.
@@ skipping 21 matching lines @@
 /// style tag except these ones.
 const IGNORED_LINKED_STYLE_ATTRS =
     const ['charset', 'href', 'href-lang', 'rel', 'rev'];
 
 /// Global RegExp objects.
 final _INVALID_LIB_CHARS_REGEX = new RegExp('[^a-z0-9_]');
 final _NUM_REGEX = new RegExp('[0-9]');
 final _BINDING_REGEX = new RegExp(r'(({{.*}})|(\[\[.*\]\]))');
 
 _getSpan(SourceFile file, AstNode node) => file.span(node.offset, node.end);