3245071883

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/gulpjs/vinyl-sourcemap/commit/<a class=hub.com/gulpjs/vinyl-sourcemap/commit/<a class="double-link" href="https://git"><a class=hub.com/gulpjs/vinyl-sourcemap/commit/<a class="double-link" href="https://git"><a class=hub.com/gulpjs/vinyl-sourcemap/commit/<a class="double-link" href="https://git"><a class=hub.com/gulpjs/vinyl-sourcemap/commit/5009e5847a6f788a2a93437a0cddbe94d2449440">5009e5847">&lt;a href=&quot;https://github.com/gulpjs/vinyl-sourcemap/commit/</a><a class="double-link" href="https://github.com/gulpjs/vinyl-sourcemap/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gulpjs/vinyl-sourcemap/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gulpjs/vinyl-sourcemap/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gulpjs/vinyl-sourcemap/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/gulpjs/vinyl-sourcemap/commit/5009e5847a6f788a2a93437a0cddbe94d2449440">5009e5847</a><a href="https://github.com/gulpjs/vinyl-sourcemap/commit/5009e5847a6f788a2a93437a0cddbe94d2449440">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/gulpjs/vinyl-sourcemap/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/gulpjs/vinyl-sourcemap/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gulpjs/vinyl-sourcemap/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gulpjs/vinyl-sourcemap/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gulpjs/vinyl-sourcemap/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/gulpjs/vinyl-sourcemap/commit/5009e5847a6f788a2a93437a0cddbe94d2449440&quot;&gt;5009e5847&lt;/a&gt;&lt;a href=&quot;https://github.com/gulpjs/vinyl-sourcemap/commit/5009e5847a6f788a2a93437a0cddbe94d2449440&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/gulpjs/vinyl-sourcemap/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp... (continued)

Pull Request Pull Request #33: Streaming support (ref #32)

Run Details

67 of 76 branches covered (88.16%)

Branch coverage included in aggregate %.

44 of 53 new or added lines in 2 files covered. (83.02%)

153 of 162 relevant lines covered (94.44%)

17.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.0

/lib/helpers.js

'use strict';

var path = require('path');
var os = require('os');
var TextDecoder = require('util').TextDecoder;

var fs = require('graceful-fs');
var Readable = require('stream').Readable;
var nal = require('now-and-later');
var File = require('vinyl');
var through = require('through2');
var convert = require('convert-source-map');

var urlRegex = /^(https?|webpack(-[^:]+)?):\/\//;

var bufCR = Buffer.from('\r');
var bufCRLF = Buffer.from('\r\n');
var bufLF = Buffer.from('\n');
var bufEOL = Buffer.from(os.EOL);

var decoder = new TextDecoder('utf-8', { ignoreBOM: false });

function isRemoteSource(source) {
  return source.match(urlRegex);
}

function parse(data) {
  try {
    return JSON.parse(decoder.decode(data));
  } catch (err) {
    // TODO: should this log a debug?
  }
}

function loadSourceMap(file, state, callback) {
  // Try to read inline source map
  state.map = convert.fromSource(state.content);

  if (state.map) {
    state.map = state.map.toObject();
    // Sources in map are relative to the source file
    state.path = file.dirname;
    state.content = convert.removeComments(state.content);
    // Remove source map comment from source
    if (file.isStream()) {
      file.contents = Readable.from(state.content);
    } else {
      file.contents = Buffer.from(state.content, 'utf8');
    }
    return callback();
  }

  // Look for source map comment referencing a source map file
  var mapComment = convert.mapFileCommentRegex.exec(state.content);

  var mapFile;
  if (mapComment) {
    mapFile = path.resolve(file.dirname, mapComment[1] || mapComment[2]);
    state.content = convert.removeMapFileComments(state.content);
    // Remove source map comment from source
    if (file.isStream()) {
      file.contents = Readable.from(state.content);
    } else {
      file.contents = Buffer.from(state.content, 'utf8');
    }
  } else {
    // If no comment try map file with same name as source file
    mapFile = file.path + '.map';
  }

  // Sources in external map are relative to map file
  state.path = path.dirname(mapFile);

  fs.readFile(mapFile, onRead);

  function onRead(err, data) {
    if (err) {
      return callback();
    }
    state.map = parse(data);
    callback();
  }
}

// Fix source paths and sourceContent for imported source map
function fixImportedSourceMap(file, state, callback) {
  if (!state.map) {
    return callback();
  }

  state.map.sourcesContent = state.map.sourcesContent || [];

  nal.map(state.map.sources, normalizeSourcesAndContent, callback);

  function assignSourcesContent(sourceContent, idx) {
    state.map.sourcesContent[idx] = sourceContent;
  }

  function normalizeSourcesAndContent(sourcePath, idx, cb) {
    var sourceRoot = state.map.sourceRoot || '';
    var sourceContent = state.map.sourcesContent[idx] || null;

    if (isRemoteSource(sourcePath)) {
      assignSourcesContent(sourceContent, idx);
      return cb();
    }

    if (state.map.sourcesContent[idx]) {
      return cb();
    }

    if (sourceRoot && isRemoteSource(sourceRoot)) {
      assignSourcesContent(sourceContent, idx);
      return cb();
    }

    var basePath = path.resolve(file.base, sourceRoot);
    var absPath = path.resolve(state.path, sourceRoot, sourcePath);
    var relPath = path.relative(basePath, absPath);
    var unixRelPath = normalizeRelpath(relPath);

    state.map.sources[idx] = unixRelPath;

    if (absPath !== file.path) {
      // Load content from file async
      return fs.readFile(absPath, onRead);
    }

    // If current file: use content
    assignSourcesContent(state.content, idx);
    cb();

    function onRead(err, data) {
      if (err) {
        assignSourcesContent(null, idx);
        return cb();
      }
      assignSourcesContent(decoder.decode(data), idx);
      cb();
    }
  }
}

function mapsLoaded(file, state, callback) {
  if (!state.map) {
    state.map = {
      version: 3,
      names: [],
      mappings: '',
      sources: [normalizeRelpath(file.relative)],
      sourcesContent: [state.content],
    };
  }

  state.map.file = normalizeRelpath(file.relative);
  file.sourceMap = state.map;

  callback();
}

function addSourceMaps(file, state, callback) {
  var tasks = [loadSourceMap, fixImportedSourceMap, mapsLoaded];

  function apply(fn, key, cb) {
    fn(file, state, cb);
  }

  nal.mapSeries(tasks, apply, done);

  function done() {
    callback(null, file);
  }
}

/* Write Helpers */
function createSourceMapFile(opts) {
  return new File({
    cwd: opts.cwd,
    base: opts.base,
    path: opts.path,
    contents: Buffer.from(JSON.stringify(opts.content)),
    stat: {
      isFile: function () {
        return true;
      },
      isDirectory: function () {
        return false;
      },
      isBlockDevice: function () {
        return false;
      },
      isCharacterDevice: function () {
        return false;
      },
      isSymbolicLink: function () {
        return false;
      },
      isFIFO: function () {
        return false;
      },
      isSocket: function () {
        return false;
      },
    },
  });
}

var needsMultiline = ['.css'];

function getCommentOptions(extname) {
  var opts = {
    multiline: needsMultiline.indexOf(extname) !== -1,
  };

  return opts;
}

function writeSourceMaps(file, destPath, callback) {
  var sourceMapFile;
  var commentOpts = getCommentOptions(file.extname);

  var comment;
  if (destPath == null) {
    // Encode source map into comment
    comment = convert.fromObject(file.sourceMap).toComment(commentOpts);
  } else {
    var mapFile = path.join(destPath, file.relative) + '.map';
    var sourceMapPath = path.join(file.base, mapFile);

    // Create new sourcemap File
    sourceMapFile = createSourceMapFile({
      cwd: file.cwd,
      base: file.base,
      path: sourceMapPath,
      content: file.sourceMap,
    });

    var sourcemapLocation = path.relative(file.dirname, sourceMapPath);

    sourcemapLocation = normalizeRelpath(sourcemapLocation);

    comment = convert.generateMapFileComment(sourcemapLocation, commentOpts);
  }

  // Append source map comment
  file = append(file, Buffer.from(comment));

  callback(null, file, sourceMapFile);
}

function append(file, comment) {
  if (file.isBuffer()) {
    file.contents = appendBuffer(file.contents, comment);
  }

  if (file.isStream()) {
    file.contents = file.contents.pipe(appendStream(comment));
  }

  return file;
}

function appendBuffer(buf1, buf2) {
  var eol;
  if (buf1.slice(-2).equals(bufCRLF)) {
    eol = bufCRLF;
  } else if (buf1.slice(-1).equals(bufLF)) {
    eol = bufLF;
  } else {
    eol = bufEOL;
  }
  return Buffer.concat([buf1, buf2, eol]);
}

// Implementation heavily inspired by https://github.com/maxogden/eol-stream/blob/master/index.js
function appendStream(text) {
  var crAtEnd = false;
  var detected = false;
  var eol = bufEOL;

  return through(detect, flush);

  function detect(chunk, _, callback) {
    if (detected) {
      return callback(null, chunk);
    }

    if (crAtEnd) {
      if (chunk[0] === bufLF[0]) {
        eol = bufCRLF;
      } else {
        eol = bufCR;
      }
      return callback(null, chunk);
    }

    for (var i = 0; i < chunk.length; i++) {
      if (chunk[i] === bufCR[0]) {
        if (i === chunk.length - 1) {
          crAtEnd = true;
        } else if (chunk[i + 1] === bufLF[0]) {
          eol = bufCRLF;
        } else {
          eol = bufCR;
        }
        break;
      }

      if (chunk[i] === bufLF[0]) {
        eol = bufLF;
        break;
      }
    }

    callback(null, chunk);
  }

  function flush(cb) {
    if (eol) {
      text = text + eol;
    }

    cb(null, text);
  }
}

function normalizeRelpath(fp) {
  // Since we only ever operate on relative paths,
  // this utility shouldn't need to handle path roots
  return path.posix.normalize(fp.replace(/\\/g, '/'));
}

module.exports = {
  addSourceMaps: addSourceMaps,
  writeSourceMaps: writeSourceMaps,
};

1	'use strict';
2
3	var path = require('path');	12✔
4	var os = require('os');	12✔
5	var TextDecoder = require('util').TextDecoder;	12✔
6
7	var fs = require('graceful-fs');	12✔
8	var Readable = require('stream').Readable;	12✔
9	var nal = require('now-and-later');	12✔
10	var File = require('vinyl');	12✔
11	var through = require('through2');	12✔
12	var convert = require('convert-source-map');	12✔
13
14	var urlRegex = /^(https?\|webpack(-[^:]+)?):\/\//;	12✔
15
16	var bufCR = Buffer.from('\r');	12✔
17	var bufCRLF = Buffer.from('\r\n');	12✔
18	var bufLF = Buffer.from('\n');	12✔
19	var bufEOL = Buffer.from(os.EOL);	12✔
20
21	var decoder = new TextDecoder('utf-8', { ignoreBOM: false });	12✔
22
23	function isRemoteSource(source) {
24	return source.match(urlRegex);	720✔
25	}
26
27	function parse(data) {
28	try {	336✔
29	return JSON.parse(decoder.decode(data));	336✔
30	} catch (err) {
31	// TODO: should this log a debug?
32	}
33	}
34
35	function loadSourceMap(file, state, callback) {
36	// Try to read inline source map
37	state.map = convert.fromSource(state.content);	540✔
38
39	if (state.map) {	540✔
40	state.map = state.map.toObject();	72✔
41	// Sources in map are relative to the source file
42	state.path = file.dirname;	72✔
43	state.content = convert.removeComments(state.content);	72✔
44	// Remove source map comment from source
45	if (file.isStream()) {	72✔
46	file.contents = Readable.from(state.content);	24✔
47	} else {
48	file.contents = Buffer.from(state.content, 'utf8');	48✔
49	}
50	return callback();	72✔
51	}
52
53	// Look for source map comment referencing a source map file
54	var mapComment = convert.mapFileCommentRegex.exec(state.content);	468✔
55
56	var mapFile;
57	if (mapComment) {	468✔
58	mapFile = path.resolve(file.dirname, mapComment[1] \|\| mapComment[2]);	312✔
59	state.content = convert.removeMapFileComments(state.content);	312✔
60	// Remove source map comment from source
61	if (file.isStream()) {	312!
NEW 62	file.contents = Readable.from(state.content);	×
63	} else {
64	file.contents = Buffer.from(state.content, 'utf8');	312✔
65	}
66	} else {
67	// If no comment try map file with same name as source file
68	mapFile = file.path + '.map';	156✔
69	}
70
71	// Sources in external map are relative to map file
72	state.path = path.dirname(mapFile);	468✔
73
74	fs.readFile(mapFile, onRead);	468✔
75
76	function onRead(err, data) {
77	if (err) {	468✔
78	return callback();	132✔
79	}
80	state.map = parse(data);	336✔
81	callback();	336✔
82	}
83	}
84
85	// Fix source paths and sourceContent for imported source map
86	function fixImportedSourceMap(file, state, callback) {
87	if (!state.map) {	540✔
88	return callback();	132✔
89	}
90
91	state.map.sourcesContent = state.map.sourcesContent \|\| [];	408✔
92
93	nal.map(state.map.sources, normalizeSourcesAndContent, callback);	408✔
94
95	function assignSourcesContent(sourceContent, idx) {
96	state.map.sourcesContent[idx] = sourceContent;	288✔
97	}
98
99	function normalizeSourcesAndContent(sourcePath, idx, cb) {
100	var sourceRoot = state.map.sourceRoot \|\| '';	600✔
101	var sourceContent = state.map.sourcesContent[idx] \|\| null;	600✔
102
103	if (isRemoteSource(sourcePath)) {	600✔
104	assignSourcesContent(sourceContent, idx);	24✔
105	return cb();	24✔
106	}
107
108	if (state.map.sourcesContent[idx]) {	576✔
109	return cb();	312✔
110	}
111
112	if (sourceRoot && isRemoteSource(sourceRoot)) {	264✔
113	assignSourcesContent(sourceContent, idx);	24✔
114	return cb();	24✔
115	}
116
117	var basePath = path.resolve(file.base, sourceRoot);	240✔
118	var absPath = path.resolve(state.path, sourceRoot, sourcePath);	240✔
119	var relPath = path.relative(basePath, absPath);	240✔
120	var unixRelPath = normalizeRelpath(relPath);	240✔
121
122	state.map.sources[idx] = unixRelPath;	240✔
123
124	if (absPath !== file.path) {	240✔
125	// Load content from file async
126	return fs.readFile(absPath, onRead);	168✔
127	}
128
129	// If current file: use content
130	assignSourcesContent(state.content, idx);	72✔
131	cb();	72✔
132
133	function onRead(err, data) {
134	if (err) {	168✔
135	assignSourcesContent(null, idx);	72✔
136	return cb();	72✔
137	}
138	assignSourcesContent(decoder.decode(data), idx);	96✔
139	cb();	96✔
140	}
141	}
142	}
143
144	function mapsLoaded(file, state, callback) {
145	if (!state.map) {	540✔
146	state.map = {	132✔
147	version: 3,
148	names: [],
149	mappings: '',
150	sources: [normalizeRelpath(file.relative)],
151	sourcesContent: [state.content],
152	};
153	}
154
155	state.map.file = normalizeRelpath(file.relative);	540✔
156	file.sourceMap = state.map;	540✔
157
158	callback();	540✔
159	}
160
161	function addSourceMaps(file, state, callback) {
162	var tasks = [loadSourceMap, fixImportedSourceMap, mapsLoaded];	540✔
163
164	function apply(fn, key, cb) {
165	fn(file, state, cb);	1,620✔
166	}
167
168	nal.mapSeries(tasks, apply, done);	540✔
169
170	function done() {
171	callback(null, file);	540✔
172	}
173	}
174
175	/* Write Helpers */
176	function createSourceMapFile(opts) {
177	return new File({	72✔
178	cwd: opts.cwd,
179	base: opts.base,
180	path: opts.path,
181	contents: Buffer.from(JSON.stringify(opts.content)),
182	stat: {
183	isFile: function () {
184	return true;	36✔
185	},
186	isDirectory: function () {
187	return false;	36✔
188	},
189	isBlockDevice: function () {
190	return false;	36✔
191	},
192	isCharacterDevice: function () {
193	return false;	36✔
194	},
195	isSymbolicLink: function () {
196	return false;	36✔
197	},
198	isFIFO: function () {
199	return false;	36✔
200	},
201	isSocket: function () {
202	return false;	36✔
203	},
204	},
205	});
206	}
207
208	var needsMultiline = ['.css'];	12✔
209
210	function getCommentOptions(extname) {
211	var opts = {	240✔
212	multiline: needsMultiline.indexOf(extname) !== -1,
213	};
214
215	return opts;	240✔
216	}
217
218	function writeSourceMaps(file, destPath, callback) {
219	var sourceMapFile;
220	var commentOpts = getCommentOptions(file.extname);	240✔
221
222	var comment;
223	if (destPath == null) {	240✔
224	// Encode source map into comment
225	comment = convert.fromObject(file.sourceMap).toComment(commentOpts);	168✔
226	} else {
227	var mapFile = path.join(destPath, file.relative) + '.map';	72✔
228	var sourceMapPath = path.join(file.base, mapFile);	72✔
229
230	// Create new sourcemap File
231	sourceMapFile = createSourceMapFile({	72✔
232	cwd: file.cwd,
233	base: file.base,
234	path: sourceMapPath,
235	content: file.sourceMap,
236	});
237
238	var sourcemapLocation = path.relative(file.dirname, sourceMapPath);	72✔
239
240	sourcemapLocation = normalizeRelpath(sourcemapLocation);	72✔
241
242	comment = convert.generateMapFileComment(sourcemapLocation, commentOpts);	72✔
243	}
244
245	// Append source map comment
246	file = append(file, Buffer.from(comment));	240✔
247
248	callback(null, file, sourceMapFile);	240✔
249	}
250
251	function append(file, comment) {
252	if (file.isBuffer()) {	240✔
253	file.contents = appendBuffer(file.contents, comment);	156✔
254	}
255
256	if (file.isStream()) {	240✔
257	file.contents = file.contents.pipe(appendStream(comment));	84✔
258	}
259
260	return file;	240✔
261	}
262
263	function appendBuffer(buf1, buf2) {
264	var eol;
265	if (buf1.slice(-2).equals(bufCRLF)) {	156✔
266	eol = bufCRLF;	12✔
267	} else if (buf1.slice(-1).equals(bufLF)) {	144✔
268	eol = bufLF;	132✔
269	} else {
270	eol = bufEOL;	12✔
271	}
272	return Buffer.concat([buf1, buf2, eol]);	156✔
273	}
274
275	// Implementation heavily inspired by https://github.com/maxogden/eol-stream/blob/master/index.js
276	function appendStream(text) {
277	var crAtEnd = false;	84✔
278	var detected = false;	84✔
279	var eol = bufEOL;	84✔
280
281	return through(detect, flush);	84✔
282
283	function detect(chunk, _, callback) {
284	if (detected) {	951!
NEW 285	return callback(null, chunk);	×
286	}
287
288	if (crAtEnd) {	951✔
NEW 289	if (chunk[0] === bufLF[0]) {	90✔
NEW 290	eol = bufCRLF;	6✔
291	} else {
NEW 292	eol = bufCR;	84✔
293	}
NEW 294	return callback(null, chunk);	90✔
295	}
296
297	for (var i = 0; i < chunk.length; i++) {	861✔
298	if (chunk[i] === bufCR[0]) {	1,680✔
299	if (i === chunk.length - 1) {	12✔
NEW 300	crAtEnd = true;	3✔
301	} else if (chunk[i + 1] === bufLF[0]) {	9!
302	eol = bufCRLF;	9✔
303	} else {
NEW 304	eol = bufCR;	×
305	}
306	break;	12✔
307	}
308
309	if (chunk[i] === bufLF[0]) {	1,668✔
310	eol = bufLF;	90✔
311	break;	90✔
312	}
313	}
314
315	callback(null, chunk);	861✔
316	}
317
318	function flush(cb) {
319	if (eol) {	84!
320	text = text + eol;	84✔
321	}
322
323	cb(null, text);	84✔
324	}
325	}
326
327	function normalizeRelpath(fp) {
328	// Since we only ever operate on relative paths,
329	// this utility shouldn't need to handle path roots
330	return path.posix.normalize(fp.replace(/\\/g, '/'));	984✔
331	}
332
333	module.exports = {	12✔
334	addSourceMaps: addSourceMaps,
335	writeSourceMaps: writeSourceMaps,
336	};

gulpjs / vinyl-sourcemap / 3245071883

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous