added SourceNode.fromStringWithSourceMap.

Author: sokra

lib/source-map/source-node.js

@@ -32,6 +32,102 @@ define(function (require, exports, module) {
  if (aChunks != null) this.add(aChunks);
  }
 
+ /**
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
+ *
+ * @param aGeneratedCode The generated code
+ * @param aSourceMapConsumer The SourceMap for the generated code
+ */
+ SourceNode.fromStringWithSourceMap =
+ function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer) {
+ // The SourceNode we want to fill with the generated code
+ // and the SourceMap
+ var node = new SourceNode();
+
+ // The generated code
+ // Processed fragments are removed from this array.
+ var remainingLines = aGeneratedCode.split('\n');
+
+ // We need to remember the position of "remainingLines"
+ var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+
+ // The generate SourceNodes we need a code range.
+ // To extract it current and last mapping is used.
+ // Here we store the last mapping.
+ var lastMapping = null;
+
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ if(lastMapping === null) {
+ // We add the generated code until the first mapping
+ // to the SourceNode without any mapping.
+ // Each line is added as separate string.
+ while(lastGeneratedLine < mapping.generatedLine) {
+ node.add(remainingLines.shift() + "\n");
+ lastGeneratedLine++;
+ }
+ if(lastGeneratedColumn < mapping.generatedColumn) {
+ var nextLine = remainingLines[0];
+ node.add(nextLine.substr(0, mapping.generatedColumn));
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ }
+ } else {
+ // We add the code from "lastMapping" to "mapping":
+ // First check if there is a new line in between.
+ if(lastGeneratedLine < mapping.generatedLine) {
+ // Associate the remaining code in this line with "lastMapping"
+ addMappingWithCode(lastMapping, remainingLines.shift() + "\n");
+ lastGeneratedLine++;
+ lastGeneratedColumn = 0;
+ // More lines are not be mapped to any mapping
+ while(lastGeneratedLine < mapping.generatedLine) {
+ node.add(remainingLines.shift() + "\n");
+ lastGeneratedLine++;
+ }
+ // When we reached the correct line, we add code until we
+ // reach the correct column too.
+ // This code is not mapped.
+ if(lastGeneratedColumn < mapping.generatedColumn) {
+ var nextLine = remainingLines[0];
+ node.add(nextLine.substr(0, mapping.generatedColumn));
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ }
+ } else {
+ // There is no new line in between.
+ // Associate the code between "lastGeneratedColumn" and
+ // "mapping.generatedColumn" with "lastMapping"
+ var nextLine = remainingLines[0];
+ var code = nextLine.substr(0, mapping.generatedColumn -
+ lastGeneratedColumn);
+ remainingLines[0] = nextLine.substr(mapping.generatedColumn -
+ lastGeneratedColumn);
+ lastGeneratedColumn = mapping.generatedColumn;
+ addMappingWithCode(lastMapping, code);
+ }
+ }
+ lastMapping = mapping;
+ }, this);
+ // We have processed all mappings.
+ // Associate the remaining code in the current line with "lastMapping"
+ // and add the remaining lines without any mapping
+ addMappingWithCode(lastMapping, remainingLines.shift());
+ remainingLines.forEach(function(line) {
+ node.add("\n");
+ node.add(line);
+ });
+
+ return node;
+
+ function addMappingWithCode(mapping, code) {
+ if(mapping.source === undefined) {
+ node.add(code);
+ } else {
+ node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, mapping.source, code, mapping.name));
+ }
+ }
+ };
+
  /**
  * Add a chunk of generated JS to this source node.
  *

test/source-map/test-source-node.js

@@ -188,4 +188,57 @@ define(function (require, exports, module) {
  assert.equal(actual.column, null);
  };
 
+ exports['test .fromStringWithSourceMap()'] = function (assert, util) {
+ var node = SourceNode.fromStringWithSourceMap(
+ util.testGeneratedCode,
+ new SourceMapConsumer(util.testMap));
+
+ var result = node.toStringWithSourceMap({
+ file: 'min.js'
+ });
+ var map = result.map;
+ var code = result.code;
+
+ assert.equal(code, util.testGeneratedCode);
+ assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator');
+ map = map.toJSON();
+ assert.equal(map.version, util.testMap.version);
+ assert.equal(map.file, util.testMap.file);
+ assert.equal(map.mappings, util.testMap.mappings);
+ };
+
+ exports['test .fromStringWithSourceMap() complex version'] = function (assert, util) {
+ var input = new SourceNode(null, null, null, [
+ "(function() {\n",
+ " var Test = {};\n",
+ " ", new SourceNode(1, 0, "a.js", "Test.A = { value: 1234 };\n"),
+ " ", new SourceNode(2, 0, "a.js", "Test.A.x = 'xyz';"), "\n",
+ "}());\n",
+ "/* Generated Source */"]);
+ input = input.toStringWithSourceMap({
+ file: 'foo.js'
+ });
+
+ var node = SourceNode.fromStringWithSourceMap(
+ input.code,
+ new SourceMapConsumer(input.map.toString()));
+
+ var result = node.toStringWithSourceMap({
+ file: 'foo.js'
+ });
+ var map = result.map;
+ var code = result.code;
+
+ assert.equal(code, input.code);
+ assert.ok(map instanceof SourceMapGenerator, 'map instanceof SourceMapGenerator');
+ map = map.toJSON();
+ var inputMap = input.map.toJSON();
+ assert.equal(map.version, inputMap.version);
+ assert.equal(map.file, inputMap.file);
+ assert.equal(map.mappings, inputMap.mappings);
+ assert.deepEqual(map.sources, inputMap.sources);
+ assert.equal(map.sourceRoot, inputMap.sourceRoot);
+ assert.deepEqual(map.names, inputMap.names);
+ };
+
 });

test/source-map/util.js

@@ -28,6 +28,8 @@ define(function (require, exports, module) {
  //
  // ONE.foo=function(a){return baz(a);};
  // TWO.inc=function(a){return a+1;};
+ exports.testGeneratedCode = " ONE.foo=function(a){return baz(a);};\n"+
+ " TWO.inc=function(a){return a+1;};";
  exports.testMap = {
  version: 3,
  file: 'min.js',