DevTools: edit SASS through SourceMaps.

Source/devtools/front_end/sdk/SourceMap.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 46 matching lines @@
 {
     /** @type {number} */ this.line;
     /** @type {number} */ this.column;
 }
 
 /**
  * Implements Source Map V3 model. See http://code.google.com/p/closure-compiler/wiki/SourceMaps
  * for format description.
  * @constructor
  * @param {string} sourceMappingURL
- * @param {!SourceMapV3} payload
+ * @param {?SourceMapV3} payload
  */
 WebInspector.SourceMap = function(sourceMappingURL, payload)
 {
     if (!WebInspector.SourceMap.prototype._base64Map) {
         const base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         WebInspector.SourceMap.prototype._base64Map = {};
         for (var i = 0; i < base64Digits.length; ++i)
             WebInspector.SourceMap.prototype._base64Map[base64Digits.charAt(i)] = i;
     }
 
     this._sourceMappingURL = sourceMappingURL;
     this._reverseMappingsBySourceURL = new Map();
     this._mappings = [];
     this._sources = {};
     this._sourceContentByURL = {};
-    this._parseMappingPayload(payload);
+    if (payload)
+        this._parseMappingPayload(payload);
 }
 
 /**
  * @param {string} sourceMapURL
  * @param {string} compiledURL
  * @param {function(?WebInspector.SourceMap)} callback
  * @this {WebInspector.SourceMap}
  */
 WebInspector.SourceMap.load = function(sourceMapURL, compiledURL, callback)
 {
@@ skipping 28 matching lines @@
             callback(new WebInspector.SourceMap(baseURL, payload));
         } catch(e) {
             console.error(e.message);
             callback(null);
         }
     }
 }
 
 WebInspector.SourceMap.prototype = {
     /**
+     * @return {!WebInspector.SourceMap}
+     */
+    clone: function()
+    {
+        var map = new WebInspector.SourceMap(this._sourceMappingURL, null);
+        map._sources = this._sources;
+        map._sourceContentByURL = this._sourceContentByURL;
+        for (var i = 0; i < this._mappings.length; ++i)
+            map._mappings.push(this._mappings[i].clone());
+        map._initializedReversedMappings();
+        return map;
+    },
+
+    /**
+     * @param {!WebInspector.TextRange} oldRange
+     * @param {!WebInspector.TextRange} newRange
+     */
+    compiledRangeEdited: function(oldRange, newRange)
+    {
+        console.assert(oldRange.startLine === newRange.startLine);
+        console.assert(oldRange.startColumn === newRange.startColumn);
+
+        var columnOffset = newRange.endColumn - oldRange.endColumn;
+        var lineOffset = newRange.endLine - oldRange.endLine;
+
+        var newMappings = [];
+        for (var i = 0; i < this._mappings.length; ++i) {
+            var mapping = this._mappings[i];
+            // Edit destroys mapping.
+            if (oldRange.containsLocation(mapping.lineNumber, mapping.columnNumber))
+                continue;
+            newMappings.push(mapping);
+            // Update compiled mapping coordinates if needed.
+            if (mapping.lineNumber === oldRange.endLine && mapping.columnNumber >= oldRange.endColumn) {
+                mapping.columnNumber += columnOffset;
+                mapping.lineNumber += lineOffset;
+            } else if (mapping.lineNumber > oldRange.endLine) {
+                mapping.lineNumber += lineOffset;
+            }
+        }
+        this._mappings = newMappings;
+        this._initializedReversedMappings();
+    },
+
+    /**
+     * @param {string} sourceURL
+     * @param {!WebInspector.TextRange} oldRange
+     * @param {!WebInspector.TextRange} newRange
+     * @return {boolean}
+     */
+    sourceRangeEdited: function(sourceURL, oldRange, newRange)
+    {
+        console.assert(oldRange.startLine === newRange.startLine);
+        console.assert(oldRange.startColumn === newRange.startColumn);
+
+        var columnOffset = newRange.endColumn - oldRange.endColumn;
+        var lineOffset = newRange.endLine - oldRange.endLine;
+        var newMappings = [];
+        for (var i = 0; i < this._mappings.length; ++i) {
+            var mapping = this._mappings[i];
+            if (mapping.sourceURL !== sourceURL) {
+                newMappings.push(mapping);
+                continue;
+            }
+            if (oldRange.containsLocation(mapping.sourceLineNumber, mapping.sourceColumnNumber))
+                continue;
+            newMappings.push(mapping);
+            // Update source mapping coordinates if needed.
+            if (mapping.sourceLineNumber === oldRange.endLine && mapping.sourceColumnNumber >= oldRange.endColumn) {
+                mapping.sourceColumnNumber += columnOffset;
+                mapping.sourceLineNumber += lineOffset;
+            } else if (mapping.sourceLineNumber > oldRange.endLine)
+                mapping.sourceLineNumber += lineOffset;
+        }
+        this._mappings = newMappings;
+        this._initializedReversedMappings();
+    },
+
+    ensureHasMapping: function(newEntry)
+    {
+        var entry = this.findEntry(newEntry.lineNumber, newEntry.columnNumber);
+        if (entry && entry.equals(newEntry))
+            return;
+        if (entry && entry.lineNumber === newEntry.lineNumber && entry.columnNumber === newEntry.columnNumber) {
+            entry.sourceURL = newEntry.sourceURL;
+            entry.sourceLineNumber = newEntry.sourceLineNumber;
+            entry.sourceColumnNumber = newEntry.sourceColumnNumber;
+            this._initializedReversedMappings();
+            return;
+        }
+        var newMappings = [];
+        var i = 0;
+        while (this._mappings[i] !== entry)
+            newMappings.push(this._mappings[i++]);
+        newMappings.push(entry);
+        newMappings.push(newEntry);
+        ++i;
+        while (i < this._mappings.length)
+            newMappings.push(this._mappings[i++]);
+
+        var reverseMappings = this._reverseMappingsBySourceURL.get(newEntry.sourceURL);
+        reverseMappings.push(newEntry);
+        reverseMappings._sorted = false;
+        this._mappings = newMappings;
+    },
+
+    /**
      * @return {string}
      */
     url: function()
     {
         return this._sourceMappingURL;
     },
 
    /**
      * @return {!Array.<string>}
      */
@@ skipping 65 matching lines @@
               first = middle;
               count -= step;
           }
         }
         var entry = this._mappings[first];
         if (!first && entry && (lineNumber < entry.lineNumber || (lineNumber === entry.lineNumber && columnNumber < entry.columnNumber)))
             return null;
         return entry;
     },
 
+    findEntriesReversed: function(sourceURL, lineNumber, columnNumber)
+    {
+        var mappings = this._reversedMappings(sourceURL);
+        var first = 0;
+        var count = mappings.length;
+        while (count > 1) {
+          var step = count >> 1;
+          var middle = first + step;
+          var mapping = mappings[middle];
+          if (lineNumber < mapping.sourceLineNumber || (lineNumber === mapping.sourceLineNumber && columnNumber < mapping.sourceColumnNumber))
+              count = step;
+          else {
+              first = middle;
+              count -= step;
+          }
+        }
+        var entry = mappings[first];
+        if (!first && entry && (lineNumber < entry.sourceLineNumber || (lineNumber === entry.sourceLineNumber && columnNumber < entry.sourceColumnNumber)))
+            return [];
+        var results = [];
+        for (var i = first; i >= 0 && mappings[i].sourceLineNumber === entry.sourceLineNumber && mappings[i].sourceColumnNumber === entry.sourceColumnNumber; --i)
+            results.push(mappings[i]);
+        return results;
+    },
+
     /**
      * @param {string} sourceURL
      * @param {number} lineNumber
      * @return {?WebInspector.SourceMap.Entry}
      */
     firstSourceLineMapping: function(sourceURL, lineNumber)
     {
         var mappings = this._reversedMappings(sourceURL);
         var index = mappings.lowerBound(lineNumber, lineComparator);
         if (index >= mappings.length || mappings[index].sourceLineNumber !== lineNumber)
@@ skipping 101 matching lines @@
                 sourceURL = sources[sourceIndex];
             }
             sourceLineNumber += this._decodeVLQ(stringCharIterator);
             sourceColumnNumber += this._decodeVLQ(stringCharIterator);
             if (!this._isSeparator(stringCharIterator.peek()))
                 nameIndex += this._decodeVLQ(stringCharIterator);
 
             this._mappings.push(new WebInspector.SourceMap.Entry(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber));
         }
 
+        this._initializedReversedMappings();
+    },
+
+    _initializedReversedMappings: function()
+    {
+        this._reverseMappingsBySourceURL.clear();
         for (var i = 0; i < this._mappings.length; ++i) {
             var mapping = this._mappings[i];
             var url = mapping.sourceURL;
             if (!url)
                 continue;
             if (!this._reverseMappingsBySourceURL.has(url))
                 this._reverseMappingsBySourceURL.set(url, []);
             var reverseMappings = this._reverseMappingsBySourceURL.get(url);
             reverseMappings.push(mapping);
         }
@@ skipping 79 matching lines @@
  * @param {number=} sourceColumnNumber
  */
 WebInspector.SourceMap.Entry = function(lineNumber, columnNumber, sourceURL, sourceLineNumber, sourceColumnNumber)
 {
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber;
     this.sourceURL = sourceURL;
     this.sourceLineNumber = sourceLineNumber;
     this.sourceColumnNumber = sourceColumnNumber;
 }
+
+WebInspector.SourceMap.Entry.prototype = {
+    /**
+     * @param {!WebInspector.SourceMap.Entry} other
+     * @return {boolean}
+     */
+    equals: function(other)
+    {
+        return this.lineNumber === other.lineNumber &&
+            this.columnNumber === other.columnNumber &&
+            this.sourceURL === other.sourceURL &&
+            this.sourceLineNumber === other.sourceLineNumber &&
+            this.sourceColumnNumber === other.sourceColumnNumber;
+    },
+
+    /**
+     * @return {!WebInspector.SourceMap.Entry}
+     */
+    clone: function()
+    {
+        return new WebInspector.SourceMap.Entry(this.lineNumber, this.columnNumber, this.sourceURL, this.sourceLineNumber, this.sourceColumnNumber);
+    },
+}