Add a mapUrl parameter to parse() and parseJson().

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 'package:source_span/source_span.dart';
 
 import 'builder.dart' as builder;
 import 'src/source_map_span.dart';
 import 'src/utils.dart';
 import 'src/vlq.dart';
 
 /// Parses a source map directly from a json string.
+///
+/// [mapUrl], which may be either a [String] or a [Uri], indicates the URL of
+/// the source map file itself. If it's passed, any URLs in the source
+/// map will be interpreted as relative to this URL when generating spans.
 // 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);
+Mapping parse(String jsonMap, {Map<String, Map> otherMaps, mapUrl}) =>
+  parseJson(JSON.decode(jsonMap), otherMaps: otherMaps, mapUrl: mapUrl);
 
 /// Parses a source map directly from a json map object.
-Mapping parseJson(Map map, {Map<String, Map> otherMaps}) {
+///
+/// [mapUrl], which may be either a [String] or a [Uri], indicates the URL of
+/// the source map file itself. If it's passed, any URLs in the source
+/// map will be interpreted as relative to this URL when generating spans.
+Mapping parseJson(Map map, {Map<String, Map> otherMaps, mapUrl}) {
   if (map['version'] != 3) {
     throw new ArgumentError(
         'unexpected source map version: ${map["version"]}. '
         'Only version 3 is supported.');
   }
 
   if (map.containsKey('sections')) {
     if (map.containsKey('mappings') || map.containsKey('sources') ||
         map.containsKey('names')) {
       throw new FormatException('map containing "sections" '
           'cannot contain "mappings", "sources", or "names".');
     }
-    return new MultiSectionMapping.fromJson(map['sections'], otherMaps);
+    return new MultiSectionMapping.fromJson(map['sections'], otherMaps,
+        mapUrl: mapUrl);
   }
-  return new SingleMapping.fromJson(map);
+  return new SingleMapping.fromJson(map, mapUrl: mapUrl);
 }
 
 
 /// A mapping parsed out of a source map.
 abstract class Mapping {
   /// Returns the span associated with [line] and [column].
   SourceMapSpan spanFor(int line, int column, {Map<String, SourceFile> files});
 
   /// Returns the span associated with [location].
   SourceMapSpan spanForLocation(SourceLocation location,
       {Map<String, SourceFile> files}) {
     return spanFor(location.line, location.column, files: files);
   }
 }
 
 /// A meta-level map containing sections.
 class MultiSectionMapping extends Mapping {
   /// For each section, the start line offset.
   final List<int> _lineStart = <int>[];
 
   /// For each section, the start column offset.
   final List<int> _columnStart = <int>[];
 
   /// For each section, the actual source map information, which is not adjusted
   /// for offsets.
   final List<Mapping> _maps = <Mapping>[];
 
   /// Creates a section mapping from json.
-  MultiSectionMapping.fromJson(List sections, Map<String, Map> otherMaps) {
+  MultiSectionMapping.fromJson(List sections, Map<String, Map> otherMaps,
+      {mapUrl}) {
     for (var section in sections) {
       var offset = section['offset'];
       if (offset == null) throw new FormatException('section missing offset');
 
       var line = section['offset']['line'];
       if (line == null) throw new FormatException('offset missing line');
 
       var column = section['offset']['column'];
       if (column == null) throw new FormatException('offset missing column');
 
       _lineStart.add(line);
       _columnStart.add(column);
 
       var url = section['url'];
       var map = section['map'];
 
       if (url != null && map != null) {
         throw new FormatException("section can't use both url and map entries");
       } else if (url != null) {
         if (otherMaps == null || otherMaps[url] == null) {
           throw new FormatException(
               'section contains refers to $url, but no map was '
               'given for it. Make sure a map is passed in "otherMaps"');
         }
-        _maps.add(parseJson(otherMaps[url], otherMaps: otherMaps));
+        _maps.add(parseJson(otherMaps[url], otherMaps: otherMaps, mapUrl: url));
       } else if (map != null) {
-        _maps.add(parseJson(map, otherMaps: otherMaps));
+        _maps.add(parseJson(map, otherMaps: otherMaps, mapUrl: mapUrl));
       } else {
         throw new FormatException('section missing url or map');
       }
     }
     if (_lineStart.length == 0) {
       throw new FormatException('expected at least one section');
     }
   }
 
   int _indexFor(line, column) {
@@ skipping 33 matching lines @@
 
   /// Source names used in the mapping, indexed by id.
   final List<String> names;
 
   /// Entries indicating the beginning of each span.
   final List<TargetLineEntry> lines;
 
   /// Url of the target file.
   String targetUrl;
 
-  /// Source root appended to the start of all entries in [urls].
+  /// Source root prepended to all entries in [urls].
   String sourceRoot;
 
-  SingleMapping._(this.targetUrl, this.urls, this.names, this.lines);
+  final Uri _mapUrl;
+
+  SingleMapping._(this.targetUrl, this.urls, this.names, this.lines)
+      : _mapUrl = null;
 
   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`
     var urls = new LinkedHashMap<String, int>();
@@ skipping 24 matching lines @@
             urlId,
             sourceEntry.source.line,
             sourceEntry.source.column,
             srcNameId));
       }
     }
     return new SingleMapping._(
         fileUrl, urls.keys.toList(), names.keys.toList(), lines);
   }
 
-  SingleMapping.fromJson(Map map)
+  SingleMapping.fromJson(Map map, {mapUrl})
       : targetUrl = map['file'],
         urls = map['sources'],
         names = map['names'],
         sourceRoot = map['sourceRoot'],
-        lines = <TargetLineEntry>[] {
+        lines = <TargetLineEntry>[],
+        _mapUrl = mapUrl is String ? Uri.parse(mapUrl) : mapUrl {
     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>[];
 
     while (tokenizer.hasTokens) {
@@ skipping 150 matching lines @@
       if (entry.sourceNameId != null) {
         var text = names[entry.sourceNameId];
         return new SourceMapFileSpan(
             files[url].span(start, start + text.length),
             isIdentifier: true);
       } else {
         return new SourceMapFileSpan(files[url].location(start).pointSpan());
       }
     } else {
       var start = new SourceLocation(0,
-          sourceUrl: url, line: entry.sourceLine, column: entry.sourceColumn);
+          sourceUrl: _mapUrl == null ? url : _mapUrl.resolve(url),
+          line: entry.sourceLine,
+          column: entry.sourceColumn);
+
       // Offset and other context is not available.
       if (entry.sourceNameId != null) {
         return new SourceMapSpan.identifier(start, names[entry.sourceNameId]);
       } else {
         return new SourceMapSpan(start, start, '');
       }
     }
   }
 
   String toString() {
@@ skipping 118 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});
 }