Moving logic for writing source maps from SourceMapBuilder into the Mapping 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.
 Mapping parse(String jsonMap, {Map<String, Map> otherMaps}) =>
   parseJson(JSON.decode(jsonMap), otherMaps: otherMaps);
 
@@ skipping 14 matching lines @@
         map.containsKey('names')) {
       throw new FormatException('map containing "sections" '
           'cannot contain "mappings", "sources", or "names".');
     }
     return new MultiSectionMapping.fromJson(map['sections'], otherMaps);
   }
   return new SingleMapping.fromJson(map);
 }
 
 
-/// A mapping parsed our of a source map.
+/// A mapping parsed out of a source map.
 abstract class Mapping {
   Span spanFor(int line, int column, {Map<String, SourceFile> files});
 
   Span spanForLocation(Location loc, {Map<String, SourceFile> files}) {
     return spanFor(loc.line, loc.column, files: files);
   }
 }
 
 /// A meta-level map containing sections.
 class MultiSectionMapping extends Mapping {
@@ skipping 69 matching lines @@
           ..write(':')
           ..write(_maps[i])
           ..write(')');
     }
     buff.write(']');
     return buff.toString();
   }
 }
 
 /// A map containing direct source mappings.
-// TODO(sigmund): integrate mapping and sourcemap builder?
 class SingleMapping extends Mapping {
   /// Url of the target file.
   final String targetUrl;
 
   /// 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 = <TargetLineEntry>[];
+  final List<TargetLineEntry> lines;
+
+  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`
+    var urls = new LinkedHashMap<String, int>();
+
+    // Indices associated with identifiers that will be part of the source map.
+    // We use a linked hash-map so that `_names.keys[_names[n]] == n`
+    var names = new LinkedHashMap<String, int>();
+
+    var lineNum;
+    var targetEntries;
+    for (var sourceEntry in sourceEntries) {
+      if (lineNum == null || sourceEntry.target.line > lineNum) {
+        lineNum = sourceEntry.target.line;
+        targetEntries = <TargetEntry>[];
+        lines.add(new TargetLineEntry(lineNum, targetEntries));
+      }
+
+      if (sourceEntry.source == null) {
+        targetEntries.add(new TargetEntry(sourceEntry.target.column));
+      } else {
+        var urlId = urls.putIfAbsent(
+            sourceEntry.source.sourceUrl, () => urls.length);
+        var srcNameId = sourceEntry.identifierName == null ? null :
+            names.putIfAbsent(sourceEntry.identifierName, () => names.length);
+        targetEntries.add(new TargetEntry(
+            sourceEntry.target.column,
+            urlId,
+            sourceEntry.source.line,
+            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'] {
+        names = map['names'],
+        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>[];
 
     while (tokenizer.hasTokens) {
@@ skipping 45 matching lines @@
               srcNameId));
         }
       }
       if (tokenizer.nextKind.isNewSegment) tokenizer._consumeNewSegment();
     }
     if (!entries.isEmpty) {
       lines.add(new TargetLineEntry(line, entries));
     }
   }
 
+  /// Encodes the Mapping mappings as a json map.
+  Map toJson() {
+    var buff = new StringBuffer();
+    var line = 0;
+    var column = 0;
+    var srcLine = 0;
+    var srcColumn = 0;
+    var srcUrlId = 0;
+    var srcNameId = 0;
+    var first = true;
+
+    for (var entry in lines) {
+      int nextLine = entry.line;
+      if (nextLine > line) {
+        for (int i = line; i < nextLine; ++i) {
+          buff.write(';');
+        }
+        line = nextLine;
+        column = 0;
+        first = true;
+      }
+
+      for (var segment in entry.entries) {
+        if (!first) buff.write(',');
+        first = false;
+        column = _append(buff, column, segment.column);
+
+        // Encoding can be just the column offset if there is no source
+        // information.
+        var newUrlId = segment.sourceUrlId;
+        if (newUrlId == null) continue;
+        srcUrlId = _append(buff, srcUrlId, newUrlId);
+        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': '',
+      'sources': urls,
+      'names' : names,
+      'mappings' : buff.toString()
+    };
+    if (targetUrl != null) {
+      result['file'] = targetUrl;
+    }
+    return result;
+  }
+
+  /// Appends to [buff] a VLQ encoding of [newValue] using the difference
+  /// between [oldValue] and [newValue]
+  static int _append(StringBuffer buff, int oldValue, int newValue) {
+    buff.writeAll(encodeVlq(newValue - oldValue));
+    return newValue;
+  }
+
   _segmentError(int seen, int line) => new StateError(
       'Invalid entry in sourcemap, expected 1, 4, or 5'
       ' values, but got $seen.\ntargeturl: $targetUrl, line: $line');
 
   /// Returns [TargetLineEntry] which includes the location in the target [line]
   /// number. In particular, the resulting entry is the last entry whose line
   /// number is lower or equal to [line].
   TargetLineEntry _findLine(int line) {
     int index = binarySearch(lines, (e) => e.line > line);
     return (index <= 0) ? null : lines[index - 1];
@@ skipping 73 matching lines @@
         buff.write('\n');
       }
     }
     return buff.toString();
   }
 }
 
 /// A line entry read from a source map.
 class TargetLineEntry {
   final int line;
-  List<TargetEntry> entries = <TargetEntry>[];
+  List<TargetEntry> entries;
   TargetLineEntry(this.line, this.entries);
 
   String toString() => '$runtimeType: $line $entries';
 }
 
 /// A target segment entry read from a source map
 class TargetEntry {
   final int column;
   final int sourceUrlId;
   final int sourceLine;
@@ skipping 59 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});
 }