Adding support for `sourceRoot` to the SingleMapping class.

pkg/source_maps/lib/parser.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.
 
 /// Contains the top-level function to parse source maps version 3.
 library source_maps.parser;
 
 import 'dart:collection';
 import 'dart:convert';
 
 import 'builder.dart' as builder;
 import 'span.dart';
 import 'src/utils.dart';
 import 'src/vlq.dart';
 
 /// Parses a source map directly from a json string.
 // TODO(sigmund): evaluate whether other maps should have the json parsed, or
 // the string represenation.
+// TODO(tjblasi): Ignore the first line of [jsonMap] if the JSON safety string
+// `)]}'` begins the string representation of the map.
 Mapping parse(String jsonMap, {Map<String, Map> otherMaps}) =>
   parseJson(JSON.decode(jsonMap), otherMaps: otherMaps);
 
 /// Parses a source map directly from a json map object.
 Mapping parseJson(Map map, {Map<String, Map> otherMaps}) {
   if (map['version'] != 3) {
     throw new ArgumentError(
         'unexpected source map version: ${map["version"]}. '
         'Only version 3 is supported.');
   }
@@ skipping 110 matching lines @@
 
   /// Source urls used in the mapping, indexed by id.
   final List<String> urls;
 
   /// Source names used in the mapping, indexed by id.
   final List<String> names;
 
   /// Entries indicating the beginning of each span.
   final List<TargetLineEntry> lines;
 
+  /// Source root appended to the start of all entries in [urls].
+  String sourceRoot = null;
+
   SingleMapping._internal(this.targetUrl, this.urls, this.names, this.lines);
 
   factory SingleMapping.fromEntries(
       Iterable<builder.Entry> entries, [String fileUrl]) {
     // The entries needs to be sorted by the target offsets.
     var sourceEntries = new List.from(entries)..sort();
     var lines = <TargetLineEntry>[];
 
     // Indices associated with file urls that will be part of the source map. We
     // use a linked hash-map so that `_urls.keys[_urls[u]] == u`
@@ skipping 26 matching lines @@
             sourceEntry.source.column,
             srcNameId));
       }
     }
     return new SingleMapping._internal(
         fileUrl, urls.keys.toList(), names.keys.toList(), lines);
   }
 
   SingleMapping.fromJson(Map map)
       : targetUrl = map['file'],
-        // TODO(sigmund): add support for 'sourceRoot'
         urls = map['sources'],
         names = map['names'],
+        sourceRoot = map['sourceRoot'],
         lines = <TargetLineEntry>[] {
     int line = 0;
     int column = 0;
     int srcUrlId = 0;
     int srcLine = 0;
     int srcColumn = 0;
     int srcNameId = 0;
     var tokenizer = new _MappingTokenizer(map['mappings']);
     var entries = <TargetEntry>[];
 
@@ skipping 88 matching lines @@
         srcLine = _append(buff, srcLine, segment.sourceLine);
         srcColumn = _append(buff, srcColumn, segment.sourceColumn);
 
         if (segment.sourceNameId == null) continue;
         srcNameId = _append(buff, srcNameId, segment.sourceNameId);
       }
     }
 
     var result = {
       'version': 3,
-      'sourceRoot': '',
+      'sourceRoot': sourceRoot == null ? '' : sourceRoot,
       'sources': urls,
       'names' : names,
       'mappings' : buff.toString()
     };
     if (targetUrl != null) {
       result['file'] = targetUrl;
     }
     return result;
   }
 
@@ skipping 26 matching lines @@
     if (lineEntry.line != line) return lineEntry.entries.last;
     var entries = lineEntry.entries;
     int index = binarySearch(entries, (e) => e.column > column);
     return (index <= 0) ? null : entries[index - 1];
   }
 
   Span spanFor(int line, int column, {Map<String, SourceFile> files}) {
     var entry = _findColumn(line, column, _findLine(line));
     if (entry == null || entry.sourceUrlId == null) return null;
     var url = urls[entry.sourceUrlId];
+    if (sourceRoot != null) {
+      url = sourceRoot + url;

[Siggi Cherem (dart-lang), 2014/07/14 22:46:53]

is source root guaranteed to be have the trailing slash or should we use
something like path.url.join(sourceRoot, url)?

[tjblasi, 2014/07/15 00:13:58]

I wasn't sure how aware `sourceRoot` processing is supposed to be. The spec just
says "This value is prepended to the individual entries in the “source” field.",
so I wasn't sure if given two files:

/packages/aFile.dart
/packages/anotherFile.dart

It would be legal (if ill-advised) to do:

sourceRoot = "/packages/a"
sources = ["File.dart", "notherFile.dart"]


If you know one way or another, great! Otherwise, I could ping John Lenz.

[Siggi Cherem (dart-lang), 2014/07/15 00:29:38]

minor nit: rewrite to use string interolation instead:

  url = '$sourceRoot$url';

[Siggi Cherem (dart-lang), 2014/07/15 00:29:38]

I honestly don't know :). Let's check with John about it. It might also be a
good idea to clarify this in the spec document.

I'm OK submitting either one or the other for the time being and follow up once
we get more details from John.

[tjblasi, 2014/07/15 16:45:10]

From John:
"No, it isn't specifically a directory although I would expect that is the
common use case.  It is simply a string prepended."

[tjblasi, 2014/07/15 16:45:10]

Done.

+    }
     if (files != null && files[url] != null) {
       var file = files[url];
       var start = file.getOffset(entry.sourceLine, entry.sourceColumn);
       if (entry.sourceNameId != null) {
         var text = names[entry.sourceNameId];
         return new FileSpan(files[url], start, start + text.length, true);
       } else {
         return new FileSpan(files[url], start);
       }
     } else {
       // Offset and other context is not available.
       if (entry.sourceNameId != null) {
         return new FixedSpan(url, 0, entry.sourceLine, entry.sourceColumn,
             text: names[entry.sourceNameId], isIdentifier: true);
       } else {
         return new FixedSpan(url, 0, entry.sourceLine, entry.sourceColumn);
       }
     }
   }
 
   String toString() {
     return (new StringBuffer("$runtimeType : [")
         ..write('targetUrl: ')
         ..write(targetUrl)
+        ..write(', sourceRoot: ')
+        ..write(sourceRoot)
         ..write(', urls: ')
         ..write(urls)
         ..write(', names: ')
         ..write(names)
         ..write(', lines: ')
         ..write(lines)
         ..write(']')).toString();
   }
 
   String get debugString {
     var buff = new StringBuffer();
     for (var lineEntry in lines) {
       var line = lineEntry.line;
       for (var entry in lineEntry.entries) {
         buff..write(targetUrl)
             ..write(': ')
             ..write(line)
             ..write(':')
-            ..write(entry.column)
-            ..write('   -->   ')
-            ..write(urls[entry.sourceUrlId])
-            ..write(': ')
-            ..write(entry.sourceLine)
-            ..write(':')
-            ..write(entry.sourceColumn);
+            ..write(entry.column);
+        if (entry.sourceUrlId != null) {
+          buff..write('   -->   ')
+              ..write(sourceRoot)
+              ..write(urls[entry.sourceUrlId])
+              ..write(': ')
+              ..write(entry.sourceLine)
+              ..write(':')
+              ..write(entry.sourceColumn);
+        }
         if (entry.sourceNameId != null) {
           buff..write(' (')
               ..write(names[entry.sourceNameId])
               ..write(')');
         }
         buff.write('\n');
       }
     }
     return buff.toString();
   }
@@ skipping 75 matching lines @@
   static const _TokenKind EOF = const _TokenKind(isEof: true);
   static const _TokenKind VALUE = const _TokenKind();
   final bool isNewLine;
   final bool isNewSegment;
   final bool isEof;
   bool get isValue => !isNewLine && !isNewSegment && !isEof;
 
   const _TokenKind(
       {this.isNewLine: false, this.isNewSegment: false, this.isEof: false});
 }