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}';
+    }
     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});
 }