CoCalc -- test-source-map-generator.js

Summer of Sage Days 2015: San Diego (sd64.25), etc.
react / wstein / node_modules / browserify / node_modules / insert-module-globals / node_modules / combine-source-map / node_modules / source-map / test / source-map / test-source-map-generator.js
⁸⁰⁵⁵⁹ views
1
/* -*- Mode: js; js-indent-level: 2; -*- */
2
/*
3
 * Copyright 2011 Mozilla Foundation and contributors
4
 * Licensed under the New BSD license. See LICENSE or:
5
 * http://opensource.org/licenses/BSD-3-Clause
6
 */
7
if (typeof define !== 'function') {
8
    var define = require('amdefine')(module, require);
9
}
10
define(function (require, exports, module) {
11

12
  var SourceMapGenerator = require('../../lib/source-map/source-map-generator').SourceMapGenerator;
13
  var SourceMapConsumer = require('../../lib/source-map/source-map-consumer').SourceMapConsumer;
14
  var SourceNode = require('../../lib/source-map/source-node').SourceNode;
15
  var util = require('./util');
16

17
  exports['test some simple stuff'] = function (assert, util) {
18
    var map = new SourceMapGenerator({
19
      file: 'foo.js',
20
      sourceRoot: '.'
21
    });
22
    assert.ok(true);
23

24
    var map = new SourceMapGenerator().toJSON();
25
    assert.ok(!('file' in map));
26
    assert.ok(!('sourceRoot' in map));
27
  };
28

29
  exports['test JSON serialization'] = function (assert, util) {
30
    var map = new SourceMapGenerator({
31
      file: 'foo.js',
32
      sourceRoot: '.'
33
    });
34
    assert.equal(map.toString(), JSON.stringify(map));
35
  };
36

37
  exports['test adding mappings (case 1)'] = function (assert, util) {
38
    var map = new SourceMapGenerator({
39
      file: 'generated-foo.js',
40
      sourceRoot: '.'
41
    });
42

43
    assert.doesNotThrow(function () {
44
      map.addMapping({
45
        generated: { line: 1, column: 1 }
46
      });
47
    });
48
  };
49

50
  exports['test adding mappings (case 2)'] = function (assert, util) {
51
    var map = new SourceMapGenerator({
52
      file: 'generated-foo.js',
53
      sourceRoot: '.'
54
    });
55

56
    assert.doesNotThrow(function () {
57
      map.addMapping({
58
        generated: { line: 1, column: 1 },
59
        source: 'bar.js',
60
        original: { line: 1, column: 1 }
61
      });
62
    });
63
  };
64

65
  exports['test adding mappings (case 3)'] = function (assert, util) {
66
    var map = new SourceMapGenerator({
67
      file: 'generated-foo.js',
68
      sourceRoot: '.'
69
    });
70

71
    assert.doesNotThrow(function () {
72
      map.addMapping({
73
        generated: { line: 1, column: 1 },
74
        source: 'bar.js',
75
        original: { line: 1, column: 1 },
76
        name: 'someToken'
77
      });
78
    });
79
  };
80

81
  exports['test adding mappings (invalid)'] = function (assert, util) {
82
    var map = new SourceMapGenerator({
83
      file: 'generated-foo.js',
84
      sourceRoot: '.'
85
    });
86

87
    // Not enough info.
88
    assert.throws(function () {
89
      map.addMapping({});
90
    });
91

92
    // Original file position, but no source.
93
    assert.throws(function () {
94
      map.addMapping({
95
        generated: { line: 1, column: 1 },
96
        original: { line: 1, column: 1 }
97
      });
98
    });
99
  };
100

101
  exports['test adding mappings with skipValidation'] = function (assert, util) {
102
    var map = new SourceMapGenerator({
103
      file: 'generated-foo.js',
104
      sourceRoot: '.',
105
      skipValidation: true
106
    });
107

108
    // Not enough info, caught by `util.getArgs`
109
    assert.throws(function () {
110
      map.addMapping({});
111
    });
112

113
    // Original file position, but no source. Not checked.
114
    assert.doesNotThrow(function () {
115
      map.addMapping({
116
        generated: { line: 1, column: 1 },
117
        original: { line: 1, column: 1 }
118
      });
119
    });
120
  };
121

122
  exports['test that the correct mappings are being generated'] = function (assert, util) {
123
    var map = new SourceMapGenerator({
124
      file: 'min.js',
125
      sourceRoot: '/the/root'
126
    });
127

128
    map.addMapping({
129
      generated: { line: 1, column: 1 },
130
      original: { line: 1, column: 1 },
131
      source: 'one.js'
132
    });
133
    map.addMapping({
134
      generated: { line: 1, column: 5 },
135
      original: { line: 1, column: 5 },
136
      source: 'one.js'
137
    });
138
    map.addMapping({
139
      generated: { line: 1, column: 9 },
140
      original: { line: 1, column: 11 },
141
      source: 'one.js'
142
    });
143
    map.addMapping({
144
      generated: { line: 1, column: 18 },
145
      original: { line: 1, column: 21 },
146
      source: 'one.js',
147
      name: 'bar'
148
    });
149
    map.addMapping({
150
      generated: { line: 1, column: 21 },
151
      original: { line: 2, column: 3 },
152
      source: 'one.js'
153
    });
154
    map.addMapping({
155
      generated: { line: 1, column: 28 },
156
      original: { line: 2, column: 10 },
157
      source: 'one.js',
158
      name: 'baz'
159
    });
160
    map.addMapping({
161
      generated: { line: 1, column: 32 },
162
      original: { line: 2, column: 14 },
163
      source: 'one.js',
164
      name: 'bar'
165
    });
166

167
    map.addMapping({
168
      generated: { line: 2, column: 1 },
169
      original: { line: 1, column: 1 },
170
      source: 'two.js'
171
    });
172
    map.addMapping({
173
      generated: { line: 2, column: 5 },
174
      original: { line: 1, column: 5 },
175
      source: 'two.js'
176
    });
177
    map.addMapping({
178
      generated: { line: 2, column: 9 },
179
      original: { line: 1, column: 11 },
180
      source: 'two.js'
181
    });
182
    map.addMapping({
183
      generated: { line: 2, column: 18 },
184
      original: { line: 1, column: 21 },
185
      source: 'two.js',
186
      name: 'n'
187
    });
188
    map.addMapping({
189
      generated: { line: 2, column: 21 },
190
      original: { line: 2, column: 3 },
191
      source: 'two.js'
192
    });
193
    map.addMapping({
194
      generated: { line: 2, column: 28 },
195
      original: { line: 2, column: 10 },
196
      source: 'two.js',
197
      name: 'n'
198
    });
199

200
    map = JSON.parse(map.toString());
201

202
    util.assertEqualMaps(assert, map, util.testMap);
203
  };
204

205
  exports['test that adding a mapping with an empty string name does not break generation'] = function (assert, util) {
206
    var map = new SourceMapGenerator({
207
      file: 'generated-foo.js',
208
      sourceRoot: '.'
209
    });
210

211
    map.addMapping({
212
      generated: { line: 1, column: 1 },
213
      source: 'bar.js',
214
      original: { line: 1, column: 1 },
215
      name: ''
216
    });
217

218
    assert.doesNotThrow(function () {
219
      JSON.parse(map.toString());
220
    });
221
  };
222

223
  exports['test that source content can be set'] = function (assert, util) {
224
    var map = new SourceMapGenerator({
225
      file: 'min.js',
226
      sourceRoot: '/the/root'
227
    });
228
    map.addMapping({
229
      generated: { line: 1, column: 1 },
230
      original: { line: 1, column: 1 },
231
      source: 'one.js'
232
    });
233
    map.addMapping({
234
      generated: { line: 2, column: 1 },
235
      original: { line: 1, column: 1 },
236
      source: 'two.js'
237
    });
238
    map.setSourceContent('one.js', 'one file content');
239

240
    map = JSON.parse(map.toString());
241
    assert.equal(map.sources[0], 'one.js');
242
    assert.equal(map.sources[1], 'two.js');
243
    assert.equal(map.sourcesContent[0], 'one file content');
244
    assert.equal(map.sourcesContent[1], null);
245
  };
246

247
  exports['test .fromSourceMap'] = function (assert, util) {
248
    var map = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(util.testMap));
249
    util.assertEqualMaps(assert, map.toJSON(), util.testMap);
250
  };
251

252
  exports['test .fromSourceMap with sourcesContent'] = function (assert, util) {
253
    var map = SourceMapGenerator.fromSourceMap(
254
      new SourceMapConsumer(util.testMapWithSourcesContent));
255
    util.assertEqualMaps(assert, map.toJSON(), util.testMapWithSourcesContent);
256
  };
257

258
  exports['test applySourceMap'] = function (assert, util) {
259
    var node = new SourceNode(null, null, null, [
260
      new SourceNode(2, 0, 'fileX', 'lineX2\n'),
261
      'genA1\n',
262
      new SourceNode(2, 0, 'fileY', 'lineY2\n'),
263
      'genA2\n',
264
      new SourceNode(1, 0, 'fileX', 'lineX1\n'),
265
      'genA3\n',
266
      new SourceNode(1, 0, 'fileY', 'lineY1\n')
267
    ]);
268
    var mapStep1 = node.toStringWithSourceMap({
269
      file: 'fileA'
270
    }).map;
271
    mapStep1.setSourceContent('fileX', 'lineX1\nlineX2\n');
272
    mapStep1 = mapStep1.toJSON();
273

274
    node = new SourceNode(null, null, null, [
275
      'gen1\n',
276
      new SourceNode(1, 0, 'fileA', 'lineA1\n'),
277
      new SourceNode(2, 0, 'fileA', 'lineA2\n'),
278
      new SourceNode(3, 0, 'fileA', 'lineA3\n'),
279
      new SourceNode(4, 0, 'fileA', 'lineA4\n'),
280
      new SourceNode(1, 0, 'fileB', 'lineB1\n'),
281
      new SourceNode(2, 0, 'fileB', 'lineB2\n'),
282
      'gen2\n'
283
    ]);
284
    var mapStep2 = node.toStringWithSourceMap({
285
      file: 'fileGen'
286
    }).map;
287
    mapStep2.setSourceContent('fileB', 'lineB1\nlineB2\n');
288
    mapStep2 = mapStep2.toJSON();
289

290
    node = new SourceNode(null, null, null, [
291
      'gen1\n',
292
      new SourceNode(2, 0, 'fileX', 'lineA1\n'),
293
      new SourceNode(2, 0, 'fileA', 'lineA2\n'),
294
      new SourceNode(2, 0, 'fileY', 'lineA3\n'),
295
      new SourceNode(4, 0, 'fileA', 'lineA4\n'),
296
      new SourceNode(1, 0, 'fileB', 'lineB1\n'),
297
      new SourceNode(2, 0, 'fileB', 'lineB2\n'),
298
      'gen2\n'
299
    ]);
300
    var expectedMap = node.toStringWithSourceMap({
301
      file: 'fileGen'
302
    }).map;
303
    expectedMap.setSourceContent('fileX', 'lineX1\nlineX2\n');
304
    expectedMap.setSourceContent('fileB', 'lineB1\nlineB2\n');
305
    expectedMap = expectedMap.toJSON();
306

307
    // apply source map "mapStep1" to "mapStep2"
308
    var generator = SourceMapGenerator.fromSourceMap(new SourceMapConsumer(mapStep2));
309
    generator.applySourceMap(new SourceMapConsumer(mapStep1));
310
    var actualMap = generator.toJSON();
311

312
    util.assertEqualMaps(assert, actualMap, expectedMap);
313
  };
314

315
  exports['test applySourceMap throws when file is missing'] = function (assert, util) {
316
    var map = new SourceMapGenerator({
317
      file: 'test.js'
318
    });
319
    var map2 = new SourceMapGenerator();
320
    assert.throws(function() {
321
      map.applySourceMap(new SourceMapConsumer(map2.toJSON()));
322
    });
323
  };
324

325
  exports['test the two additional parameters of applySourceMap'] = function (assert, util) {
326
    // Assume the following directory structure:
327
    //
328
    // http://foo.org/
329
    //   bar.coffee
330
    //   app/
331
    //     coffee/
332
    //       foo.coffee
333
    //     temp/
334
    //       bundle.js
335
    //       temp_maps/
336
    //         bundle.js.map
337
    //     public/
338
    //       bundle.min.js
339
    //       bundle.min.js.map
340
    //
341
    // http://www.example.com/
342
    //   baz.coffee
343

344
    var bundleMap = new SourceMapGenerator({
345
      file: 'bundle.js'
346
    });
347
    bundleMap.addMapping({
348
      generated: { line: 3, column: 3 },
349
      original: { line: 2, column: 2 },
350
      source: '../../coffee/foo.coffee'
351
    });
352
    bundleMap.setSourceContent('../../coffee/foo.coffee', 'foo coffee');
353
    bundleMap.addMapping({
354
      generated: { line: 13, column: 13 },
355
      original: { line: 12, column: 12 },
356
      source: '/bar.coffee'
357
    });
358
    bundleMap.setSourceContent('/bar.coffee', 'bar coffee');
359
    bundleMap.addMapping({
360
      generated: { line: 23, column: 23 },
361
      original: { line: 22, column: 22 },
362
      source: 'http://www.example.com/baz.coffee'
363
    });
364
    bundleMap.setSourceContent(
365
      'http://www.example.com/baz.coffee',
366
      'baz coffee'
367
    );
368
    bundleMap = new SourceMapConsumer(bundleMap.toJSON());
369

370
    var minifiedMap = new SourceMapGenerator({
371
      file: 'bundle.min.js',
372
      sourceRoot: '..'
373
    });
374
    minifiedMap.addMapping({
375
      generated: { line: 1, column: 1 },
376
      original: { line: 3, column: 3 },
377
      source: 'temp/bundle.js'
378
    });
379
    minifiedMap.addMapping({
380
      generated: { line: 11, column: 11 },
381
      original: { line: 13, column: 13 },
382
      source: 'temp/bundle.js'
383
    });
384
    minifiedMap.addMapping({
385
      generated: { line: 21, column: 21 },
386
      original: { line: 23, column: 23 },
387
      source: 'temp/bundle.js'
388
    });
389
    minifiedMap = new SourceMapConsumer(minifiedMap.toJSON());
390

391
    var expectedMap = function (sources) {
392
      var map = new SourceMapGenerator({
393
        file: 'bundle.min.js',
394
        sourceRoot: '..'
395
      });
396
      map.addMapping({
397
        generated: { line: 1, column: 1 },
398
        original: { line: 2, column: 2 },
399
        source: sources[0]
400
      });
401
      map.setSourceContent(sources[0], 'foo coffee');
402
      map.addMapping({
403
        generated: { line: 11, column: 11 },
404
        original: { line: 12, column: 12 },
405
        source: sources[1]
406
      });
407
      map.setSourceContent(sources[1], 'bar coffee');
408
      map.addMapping({
409
        generated: { line: 21, column: 21 },
410
        original: { line: 22, column: 22 },
411
        source: sources[2]
412
      });
413
      map.setSourceContent(sources[2], 'baz coffee');
414
      return map.toJSON();
415
    }
416

417
    var actualMap = function (aSourceMapPath) {
418
      var map = SourceMapGenerator.fromSourceMap(minifiedMap);
419
      // Note that relying on `bundleMap.file` (which is simply 'bundle.js')
420
      // instead of supplying the second parameter wouldn't work here.
421
      map.applySourceMap(bundleMap, '../temp/bundle.js', aSourceMapPath);
422
      return map.toJSON();
423
    }
424

425
    util.assertEqualMaps(assert, actualMap('../temp/temp_maps'), expectedMap([
426
      'coffee/foo.coffee',
427
      '/bar.coffee',
428
      'http://www.example.com/baz.coffee'
429
    ]));
430

431
    util.assertEqualMaps(assert, actualMap('/app/temp/temp_maps'), expectedMap([
432
      '/app/coffee/foo.coffee',
433
      '/bar.coffee',
434
      'http://www.example.com/baz.coffee'
435
    ]));
436

437
    util.assertEqualMaps(assert, actualMap('http://foo.org/app/temp/temp_maps'), expectedMap([
438
      'http://foo.org/app/coffee/foo.coffee',
439
      'http://foo.org/bar.coffee',
440
      'http://www.example.com/baz.coffee'
441
    ]));
442

443
    // If the third parameter is omitted or set to the current working
444
    // directory we get incorrect source paths:
445

446
    util.assertEqualMaps(assert, actualMap(), expectedMap([
447
      '../coffee/foo.coffee',
448
      '/bar.coffee',
449
      'http://www.example.com/baz.coffee'
450
    ]));
451

452
    util.assertEqualMaps(assert, actualMap(''), expectedMap([
453
      '../coffee/foo.coffee',
454
      '/bar.coffee',
455
      'http://www.example.com/baz.coffee'
456
    ]));
457

458
    util.assertEqualMaps(assert, actualMap('.'), expectedMap([
459
      '../coffee/foo.coffee',
460
      '/bar.coffee',
461
      'http://www.example.com/baz.coffee'
462
    ]));
463

464
    util.assertEqualMaps(assert, actualMap('./'), expectedMap([
465
      '../coffee/foo.coffee',
466
      '/bar.coffee',
467
      'http://www.example.com/baz.coffee'
468
    ]));
469
  };
470

471
  exports['test applySourceMap name handling'] = function (assert, util) {
472
    // Imagine some CoffeeScript code being compiled into JavaScript and then
473
    // minified.
474

475
    var assertName = function(coffeeName, jsName, expectedName) {
476
      var minifiedMap = new SourceMapGenerator({
477
        file: 'test.js.min'
478
      });
479
      minifiedMap.addMapping({
480
        generated: { line: 1, column: 4 },
481
        original: { line: 1, column: 4 },
482
        source: 'test.js',
483
        name: jsName
484
      });
485

486
      var coffeeMap = new SourceMapGenerator({
487
        file: 'test.js'
488
      });
489
      coffeeMap.addMapping({
490
        generated: { line: 1, column: 4 },
491
        original: { line: 1, column: 0 },
492
        source: 'test.coffee',
493
        name: coffeeName
494
      });
495

496
      minifiedMap.applySourceMap(new SourceMapConsumer(coffeeMap.toJSON()));
497

498
      new SourceMapConsumer(minifiedMap.toJSON()).eachMapping(function(mapping) {
499
        assert.equal(mapping.name, expectedName);
500
      });
501
    };
502

503
    // `foo = 1` -> `var foo = 1;` -> `var a=1`
504
    // CoffeeScript doesn’t rename variables, so there’s no need for it to
505
    // provide names in its source maps. Minifiers do rename variables and
506
    // therefore do provide names in their source maps. So that name should be
507
    // retained if the original map lacks names.
508
    assertName(null, 'foo', 'foo');
509

510
    // `foo = 1` -> `var coffee$foo = 1;` -> `var a=1`
511
    // Imagine that CoffeeScript prefixed all variables with `coffee$`. Even
512
    // though the minifier then also provides a name, the original name is
513
    // what corresponds to the source.
514
    assertName('foo', 'coffee$foo', 'foo');
515

516
    // `foo = 1` -> `var coffee$foo = 1;` -> `var coffee$foo=1`
517
    // Minifiers can turn off variable mangling. Then there’s no need to
518
    // provide names in the source map, but the names from the original map are
519
    // still needed.
520
    assertName('foo', null, 'foo');
521

522
    // `foo = 1` -> `var foo = 1;` -> `var foo=1`
523
    // No renaming at all.
524
    assertName(null, null, null);
525
  };
526

527
  exports['test sorting with duplicate generated mappings'] = function (assert, util) {
528
    var map = new SourceMapGenerator({
529
      file: 'test.js'
530
    });
531
    map.addMapping({
532
      generated: { line: 3, column: 0 },
533
      original: { line: 2, column: 0 },
534
      source: 'a.js'
535
    });
536
    map.addMapping({
537
      generated: { line: 2, column: 0 }
538
    });
539
    map.addMapping({
540
      generated: { line: 2, column: 0 }
541
    });
542
    map.addMapping({
543
      generated: { line: 1, column: 0 },
544
      original: { line: 1, column: 0 },
545
      source: 'a.js'
546
    });
547

548
    util.assertEqualMaps(assert, map.toJSON(), {
549
      version: 3,
550
      file: 'test.js',
551
      sources: ['a.js'],
552
      names: [],
553
      mappings: 'AAAA;A;AACA'
554
    });
555
  };
556

557
  exports['test ignore duplicate mappings.'] = function (assert, util) {
558
    var init = { file: 'min.js', sourceRoot: '/the/root' };
559
    var map1, map2;
560

561
    // null original source location
562
    var nullMapping1 = {
563
      generated: { line: 1, column: 0 }
564
    };
565
    var nullMapping2 = {
566
      generated: { line: 2, column: 2 }
567
    };
568

569
    map1 = new SourceMapGenerator(init);
570
    map2 = new SourceMapGenerator(init);
571

572
    map1.addMapping(nullMapping1);
573
    map1.addMapping(nullMapping1);
574

575
    map2.addMapping(nullMapping1);
576

577
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
578

579
    map1.addMapping(nullMapping2);
580
    map1.addMapping(nullMapping1);
581

582
    map2.addMapping(nullMapping2);
583

584
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
585

586
    // original source location
587
    var srcMapping1 = {
588
      generated: { line: 1, column: 0 },
589
      original: { line: 11, column: 0 },
590
      source: 'srcMapping1.js'
591
    };
592
    var srcMapping2 = {
593
      generated: { line: 2, column: 2 },
594
      original: { line: 11, column: 0 },
595
      source: 'srcMapping2.js'
596
    };
597

598
    map1 = new SourceMapGenerator(init);
599
    map2 = new SourceMapGenerator(init);
600

601
    map1.addMapping(srcMapping1);
602
    map1.addMapping(srcMapping1);
603

604
    map2.addMapping(srcMapping1);
605

606
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
607

608
    map1.addMapping(srcMapping2);
609
    map1.addMapping(srcMapping1);
610

611
    map2.addMapping(srcMapping2);
612

613
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
614

615
    // full original source and name information
616
    var fullMapping1 = {
617
      generated: { line: 1, column: 0 },
618
      original: { line: 11, column: 0 },
619
      source: 'fullMapping1.js',
620
      name: 'fullMapping1'
621
    };
622
    var fullMapping2 = {
623
      generated: { line: 2, column: 2 },
624
      original: { line: 11, column: 0 },
625
      source: 'fullMapping2.js',
626
      name: 'fullMapping2'
627
    };
628

629
    map1 = new SourceMapGenerator(init);
630
    map2 = new SourceMapGenerator(init);
631

632
    map1.addMapping(fullMapping1);
633
    map1.addMapping(fullMapping1);
634

635
    map2.addMapping(fullMapping1);
636

637
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
638

639
    map1.addMapping(fullMapping2);
640
    map1.addMapping(fullMapping1);
641

642
    map2.addMapping(fullMapping2);
643

644
    util.assertEqualMaps(assert, map1.toJSON(), map2.toJSON());
645
  };
646

647
  exports['test github issue #72, check for duplicate names or sources'] = function (assert, util) {
648
    var map = new SourceMapGenerator({
649
      file: 'test.js'
650
    });
651
    map.addMapping({
652
      generated: { line: 1, column: 1 },
653
      original: { line: 2, column: 2 },
654
      source: 'a.js',
655
      name: 'foo'
656
    });
657
    map.addMapping({
658
      generated: { line: 3, column: 3 },
659
      original: { line: 4, column: 4 },
660
      source: 'a.js',
661
      name: 'foo'
662
    });
663
    util.assertEqualMaps(assert, map.toJSON(), {
664
      version: 3,
665
      file: 'test.js',
666
      sources: ['a.js'],
667
      names: ['foo'],
668
      mappings: 'CACEA;;GAEEA'
669
    });
670
  };
671

672
  exports['test setting sourcesContent to null when already null'] = function (assert, util) {
673
    var smg = new SourceMapGenerator({ file: "foo.js" });
674
    assert.doesNotThrow(function() {
675
      smg.setSourceContent("bar.js", null);
676
    });
677
  };
678

679
});
680

681
Product

Resources

Company
