jprichardson / node-fs-extra / 964

pending completion

Build # 964

Build Type

push

travis-ci

Committed by

RyanZim

Commit Message

<a href="https://github.com/jprichardson/node-fs-extra/commit/<a class=hub.com/jprichardson/node-fs-extra/commit/<a class="double-link" href="https://git"><a class=hub.com/jprichardson/node-fs-extra/commit/<a class="double-link" href="https://git"><a class=hub.com/jprichardson/node-fs-extra/commit/<a class="double-link" href="https://git"><a class=hub.com/jprichardson/node-fs-extra/commit/ddb5cb47a59798d09521668193b5436330beb5cc">ddb5cb47a">&lt;a href=&quot;https://github.com/jprichardson/node-fs-extra/commit/</a><a class="double-link" href="https://github.com/jprichardson/node-fs-extra/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jprichardson/node-fs-extra/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jprichardson/node-fs-extra/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jprichardson/node-fs-extra/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/jprichardson/node-fs-extra/commit/ddb5cb47a59798d09521668193b5436330beb5cc">ddb5cb47a</a><a href="https://github.com/jprichardson/node-fs-extra/commit/ddb5cb47a59798d09521668193b5436330beb5cc">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/jprichardson/node-fs-extra/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/jprichardson/node-fs-extra/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/jprichardson/node-fs-extra/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/jprichardson/node-fs-extra/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/jprichardson/node-fs-extra/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/jprichardson/node-fs-extra/commit/ddb5cb47a59798d09521668193b5436330beb5cc&quot;&gt;ddb5cb47a&lt;/a&gt;&lt;a href=&quot;https://github.com/jprichardson/node-fs-extra/commit/ddb5cb47a59798d09521668193b5436330beb5cc&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/jprichardson/node-fs-extra/co... (continued)

Run Details

435 of 604 branches covered (72.02%)

2 of 2 new or added lines in 1 file covered. (100.0%)

886 of 1014 relevant lines covered (87.38%)

318.82 hits per line

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

62.42

/lib/remove/rimraf.js

'use strict'

const fs = require('graceful-fs')
const path = require('path')
const assert = require('assert')

const isWindows = (process.platform === 'win32')

function defaults (options) {
  const methods = [
    'unlink',
    'chmod',
    'stat',
    'lstat',
    'rmdir',
    'readdir'
  ]
  methods.forEach(m => {
    options[m] = options[m] || fs[m]
    m = m + 'Sync'
    options[m] = options[m] || fs[m]
  })

  options.maxBusyTries = options.maxBusyTries || 3
}

function rimraf (p, options, cb) {
  let busyTries = 0

  if (typeof options === 'function') {
    cb = options
    options = {}
  }

  assert(p, 'rimraf: missing path')
  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
  assert.equal(typeof cb, 'function', 'rimraf: callback function required')
  assert(options, 'rimraf: invalid options argument provided')
  assert.equal(typeof options, 'object', 'rimraf: options should be object')

  defaults(options)

  rimraf_(p, options, function CB (er) {
    if (er) {
      if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
          busyTries < options.maxBusyTries) {
        busyTries++
        let time = busyTries * 100
        // try again, with the same exact callback as this one.
        return setTimeout(() => rimraf_(p, options, CB), time)
      }

      // already gone
      if (er.code === 'ENOENT') er = null
    }

    cb(er)
  })
}

// Two possible strategies.
// 1. Assume it's a file.  unlink it, then do the dir stuff on EPERM or EISDIR
// 2. Assume it's a directory.  readdir, then do the file stuff on ENOTDIR
//
// Both result in an extra syscall when you guess wrong.  However, there
// are likely far more normal files in the world than directories.  This
// is based on the assumption that a the average number of files per
// directory is >= 1.
//
// If anyone ever complains about this, then I guess the strategy could
// be made configurable somehow.  But until then, YAGNI.
function rimraf_ (p, options, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')

  // sunos lets the root user unlink directories, which is... weird.
  // so we have to lstat here and make sure it's not a dir.
  options.lstat(p, (er, st) => {
    if (er && er.code === 'ENOENT') {
      return cb(null)
    }

    // Windows can EPERM on stat.  Life is suffering.
    if (er && er.code === 'EPERM' && isWindows) {
      return fixWinEPERM(p, options, er, cb)
    }

    if (st && st.isDirectory()) {
      return rmdir(p, options, er, cb)
    }

    options.unlink(p, er => {
      if (er) {
        if (er.code === 'ENOENT') {
          return cb(null)
        }
        if (er.code === 'EPERM') {
          return (isWindows)
            ? fixWinEPERM(p, options, er, cb)
            : rmdir(p, options, er, cb)
        }
        if (er.code === 'EISDIR') {
          return rmdir(p, options, er, cb)
        }
      }
      return cb(er)
    })
  })
}

function fixWinEPERM (p, options, er, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')
  if (er) {
    assert(er instanceof Error)
  }

  options.chmod(p, 0o666, er2 => {
    if (er2) {
      cb(er2.code === 'ENOENT' ? null : er)
    } else {
      options.stat(p, (er3, stats) => {
        if (er3) {
          cb(er3.code === 'ENOENT' ? null : er)
        } else if (stats.isDirectory()) {
          rmdir(p, options, er, cb)
        } else {
          options.unlink(p, cb)
        }
      })
    }
  })
}

function fixWinEPERMSync (p, options, er) {
  let stats

  assert(p)
  assert(options)
  if (er) {
    assert(er instanceof Error)
  }

  try {
    options.chmodSync(p, 0o666)
  } catch (er2) {
    if (er2.code === 'ENOENT') {
      return
    } else {
      throw er
    }
  }

  try {
    stats = options.statSync(p)
  } catch (er3) {
    if (er3.code === 'ENOENT') {
      return
    } else {
      throw er
    }
  }

  if (stats.isDirectory()) {
    rmdirSync(p, options, er)
  } else {
    options.unlinkSync(p)
  }
}

function rmdir (p, options, originalEr, cb) {
  assert(p)
  assert(options)
  if (originalEr) {
    assert(originalEr instanceof Error)
  }
  assert(typeof cb === 'function')

  // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
  // if we guessed wrong, and it's not a directory, then
  // raise the original error.
  options.rmdir(p, er => {
    if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
      rmkids(p, options, cb)
    } else if (er && er.code === 'ENOTDIR') {
      cb(originalEr)
    } else {
      cb(er)
    }
  })
}

function rmkids (p, options, cb) {
  assert(p)
  assert(options)
  assert(typeof cb === 'function')

  options.readdir(p, (er, files) => {
    if (er) return cb(er)

    let n = files.length
    let errState

    if (n === 0) return options.rmdir(p, cb)

    files.forEach(f => {
      rimraf(path.join(p, f), options, er => {
        if (errState) {
          return
        }
        if (er) return cb(errState = er)
        if (--n === 0) {
          options.rmdir(p, cb)
        }
      })
    })
  })
}

// this looks simpler, and is strictly *faster*, but will
// tie up the JavaScript thread and fail on excessively
// deep directory trees.
function rimrafSync (p, options) {
  let st

  options = options || {}
  defaults(options)

  assert(p, 'rimraf: missing path')
  assert.equal(typeof p, 'string', 'rimraf: path should be a string')
  assert(options, 'rimraf: missing options')
  assert.equal(typeof options, 'object', 'rimraf: options should be object')

  try {
    st = options.lstatSync(p)
  } catch (er) {
    if (er.code === 'ENOENT') {
      return
    }

    // Windows can EPERM on stat.  Life is suffering.
    if (er.code === 'EPERM' && isWindows) {
      fixWinEPERMSync(p, options, er)
    }
  }

  try {
    // sunos lets the root user unlink directories, which is... weird.
    if (st && st.isDirectory()) {
      rmdirSync(p, options, null)
    } else {
      options.unlinkSync(p)
    }
  } catch (er) {
    if (er.code === 'ENOENT') {
      return
    } else if (er.code === 'EPERM') {
      return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
    } else if (er.code !== 'EISDIR') {
      throw er
    }
    rmdirSync(p, options, er)
  }
}

function rmdirSync (p, options, originalEr) {
  assert(p)
  assert(options)
  if (originalEr) {
    assert(originalEr instanceof Error)
  }

  try {
    options.rmdirSync(p)
  } catch (er) {
    if (er.code === 'ENOTDIR') {
      throw originalEr
    } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
      rmkidsSync(p, options)
    } else if (er.code !== 'ENOENT') {
      throw er
    }
  }
}

function rmkidsSync (p, options) {
  assert(p)
  assert(options)
  options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))

  // We only end up here once we got ENOTEMPTY at least once, and
  // at this point, we are guaranteed to have removed all the kids.
  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
  // try really hard to delete stuff on windows, because it has a
  // PROFOUNDLY annoying habit of not closing handles promptly when
  // files are deleted, resulting in spurious ENOTEMPTY errors.
  const retries = isWindows ? 100 : 1
  let i = 0
  do {
    let threw = true
    try {
      const ret = options.rmdirSync(p, options)
      threw = false
      return ret
    } finally {
      if (++i < retries && threw) continue // eslint-disable-line
    }
  } while (true)
}

module.exports = rimraf
rimraf.sync = rimrafSync

1	'use strict'
2
3	const fs = require('graceful-fs')	1✔
4	const path = require('path')	1✔
5	const assert = require('assert')	1✔
6
7	const isWindows = (process.platform === 'win32')	1✔
8
9	function defaults (options) {	1✔
10	const methods = [	4,471✔
11	'unlink',
12	'chmod',
13	'stat',
14	'lstat',
15	'rmdir',
16	'readdir'
17	]
18	methods.forEach(m => {	4,471✔
19	options[m] = options[m] \|\| fs[m]	26,826✔
20	m = m + 'Sync'	26,826✔
21	options[m] = options[m] \|\| fs[m]	26,826✔
22	})
23
24	options.maxBusyTries = options.maxBusyTries \|\| 3	4,471✔
25	}
26
27	function rimraf (p, options, cb) {	1✔
28	let busyTries = 0	3,909✔
29
30	if (typeof options === 'function') {	3,909✔
31	cb = options	1,927✔
32	options = {}	1,927✔
33	}
34
35	assert(p, 'rimraf: missing path')	3,909✔
36	assert.equal(typeof p, 'string', 'rimraf: path should be a string')	3,909✔
37	assert.equal(typeof cb, 'function', 'rimraf: callback function required')	3,908✔
38	assert(options, 'rimraf: invalid options argument provided')	3,908✔
39	assert.equal(typeof options, 'object', 'rimraf: options should be object')	3,908✔
40
41	defaults(options)	3,908✔
42
43	rimraf_(p, options, function CB (er) {	3,908✔
44	if (er) {	3,908!
45	if ((er.code === 'EBUSY' \|\| er.code === 'ENOTEMPTY' \|\| er.code === 'EPERM') &&	×
46	busyTries < options.maxBusyTries) {
47	busyTries++	×
48	let time = busyTries * 100	×
49	// try again, with the same exact callback as this one.
50	return setTimeout(() => rimraf_(p, options, CB), time)	×
51	}
52
53	// already gone
54	if (er.code === 'ENOENT') er = null	×
55	}
56
57	cb(er)	3,908✔
58	})
59	}
60
61	// Two possible strategies.
62	// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR
63	// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR
64	//
65	// Both result in an extra syscall when you guess wrong. However, there
66	// are likely far more normal files in the world than directories. This
67	// is based on the assumption that a the average number of files per
68	// directory is >= 1.
69	//
70	// If anyone ever complains about this, then I guess the strategy could
71	// be made configurable somehow. But until then, YAGNI.
72	function rimraf_ (p, options, cb) {	1✔
73	assert(p)	3,908✔
74	assert(options)	3,908✔
75	assert(typeof cb === 'function')	3,908✔
76
77	// sunos lets the root user unlink directories, which is... weird.
78	// so we have to lstat here and make sure it's not a dir.
79	options.lstat(p, (er, st) => {	3,908✔
80	if (er && er.code === 'ENOENT') {	3,908✔
81	return cb(null)	4✔
82	}
83
84	// Windows can EPERM on stat. Life is suffering.
85	if (er && er.code === 'EPERM' && isWindows) {	3,904!
86	return fixWinEPERM(p, options, er, cb)	×
87	}
88
89	if (st && st.isDirectory()) {	3,904✔
90	return rmdir(p, options, er, cb)	2,471✔
91	}
92
93	options.unlink(p, er => {	1,433✔
94	if (er) {	1,433!
95	if (er.code === 'ENOENT') {	×
96	return cb(null)	×
97	}
98	if (er.code === 'EPERM') {	×
99	return (isWindows)	×
100	? fixWinEPERM(p, options, er, cb)
101	: rmdir(p, options, er, cb)
102	}
103	if (er.code === 'EISDIR') {	×
104	return rmdir(p, options, er, cb)	×
105	}
106	}
107	return cb(er)	1,433✔
108	})
109	})
110	}
111
112	function fixWinEPERM (p, options, er, cb) {	1✔
113	assert(p)	×
114	assert(options)	×
115	assert(typeof cb === 'function')	×
116	if (er) {	×
117	assert(er instanceof Error)	×
118	}
119
120	options.chmod(p, 0o666, er2 => {	×
121	if (er2) {	×
122	cb(er2.code === 'ENOENT' ? null : er)	×
123	} else {
124	options.stat(p, (er3, stats) => {	×
125	if (er3) {	×
126	cb(er3.code === 'ENOENT' ? null : er)	×
127	} else if (stats.isDirectory()) {	×
128	rmdir(p, options, er, cb)	×
129	} else {
130	options.unlink(p, cb)	×
131	}
132	})
133	}
134	})
135	}
136
137	function fixWinEPERMSync (p, options, er) {	1✔
138	let stats	×
139
140	assert(p)	×
141	assert(options)	×
142	if (er) {	×
143	assert(er instanceof Error)	×
144	}
145
146	try {	×
147	options.chmodSync(p, 0o666)	×
148	} catch (er2) {
149	if (er2.code === 'ENOENT') {	×
150	return	×
151	} else {
152	throw er	×
153	}
154	}
155
156	try {	×
157	stats = options.statSync(p)	×
158	} catch (er3) {
159	if (er3.code === 'ENOENT') {	×
160	return	×
161	} else {
162	throw er	×
163	}
164	}
165
166	if (stats.isDirectory()) {	×
167	rmdirSync(p, options, er)	×
168	} else {
169	options.unlinkSync(p)	×
170	}
171	}
172
173	function rmdir (p, options, originalEr, cb) {	1✔
174	assert(p)	2,471✔
175	assert(options)	2,471✔
176	if (originalEr) {	2,471!
177	assert(originalEr instanceof Error)	×
178	}
179	assert(typeof cb === 'function')	2,471✔
180
181	// try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
182	// if we guessed wrong, and it's not a directory, then
183	// raise the original error.
184	options.rmdir(p, er => {	2,471✔
185	if (er && (er.code === 'ENOTEMPTY' \|\| er.code === 'EEXIST' \|\| er.code === 'EPERM')) {	2,471!
186	rmkids(p, options, cb)	1,780✔
187	} else if (er && er.code === 'ENOTDIR') {	691!
188	cb(originalEr)	×
189	} else {
190	cb(er)	691✔
191	}
192	})
193	}
194
195	function rmkids (p, options, cb) {	1✔
196	assert(p)	1,780✔
197	assert(options)	1,780✔
198	assert(typeof cb === 'function')	1,780✔
199
200	options.readdir(p, (er, files) => {	1,780✔
201	if (er) return cb(er)	1,780!
202
203	let n = files.length	1,780✔
204	let errState	1,780✔
205
206	if (n === 0) return options.rmdir(p, cb)	1,780!
207
208	files.forEach(f => {	1,780✔
209	rimraf(path.join(p, f), options, er => {	1,981✔
210	if (errState) {	1,981!
211	return	×
212	}
213	if (er) return cb(errState = er)	1,981!
214	if (--n === 0) {	1,981✔
215	options.rmdir(p, cb)	1,780✔
216	}
217	})
218	})
219	})
220	}
221
222	// this looks simpler, and is strictly faster, but will
223	// tie up the JavaScript thread and fail on excessively
224	// deep directory trees.
225	function rimrafSync (p, options) {	1✔
226	let st	563✔
227
228	options = options \|\| {}	563✔
229	defaults(options)	563✔
230
231	assert(p, 'rimraf: missing path')	563✔
232	assert.equal(typeof p, 'string', 'rimraf: path should be a string')	563✔
233	assert(options, 'rimraf: missing options')	563✔
234	assert.equal(typeof options, 'object', 'rimraf: options should be object')	563✔
235
236	try {	563✔
237	st = options.lstatSync(p)	563✔
238	} catch (er) {
239	if (er.code === 'ENOENT') {	×
240	return	×
241	}
242
243	// Windows can EPERM on stat. Life is suffering.
244	if (er.code === 'EPERM' && isWindows) {	×
245	fixWinEPERMSync(p, options, er)	×
246	}
247	}
248
249	try {	563✔
250	// sunos lets the root user unlink directories, which is... weird.
251	if (st && st.isDirectory()) {	563✔
252	rmdirSync(p, options, null)	340✔
253	} else {
254	options.unlinkSync(p)	223✔
255	}
256	} catch (er) {
257	if (er.code === 'ENOENT') {	×
258	return	×
259	} else if (er.code === 'EPERM') {	×
260	return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)	×
261	} else if (er.code !== 'EISDIR') {	×
262	throw er	×
263	}
264	rmdirSync(p, options, er)	×
265	}
266	}
267
268	function rmdirSync (p, options, originalEr) {	1✔
269	assert(p)	340✔
270	assert(options)	340✔
271	if (originalEr) {	340!
272	assert(originalEr instanceof Error)	×
273	}
274
275	try {	340✔
276	options.rmdirSync(p)	340✔
277	} catch (er) {
278	if (er.code === 'ENOTDIR') {	330!
279	throw originalEr	×
280	} else if (er.code === 'ENOTEMPTY' \|\| er.code === 'EEXIST' \|\| er.code === 'EPERM') {	330!
281	rmkidsSync(p, options)	330✔
282	} else if (er.code !== 'ENOENT') {	×
283	throw er	×
284	}
285	}
286	}
287
288	function rmkidsSync (p, options) {	1✔
289	assert(p)	330✔
290	assert(options)	330✔
291	options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))	491✔
292
293	// We only end up here once we got ENOTEMPTY at least once, and
294	// at this point, we are guaranteed to have removed all the kids.
295	// So, we know that it won't be ENOENT or ENOTDIR or anything else.
296	// try really hard to delete stuff on windows, because it has a
297	// PROFOUNDLY annoying habit of not closing handles promptly when
298	// files are deleted, resulting in spurious ENOTEMPTY errors.
299	const retries = isWindows ? 100 : 1	330!
300	let i = 0	330✔
301	do {	330✔
302	let threw = true	330✔
303	try {	330✔
304	const ret = options.rmdirSync(p, options)	330✔
305	threw = false	330✔
306	return ret	330✔
307	} finally {
308	if (++i < retries && threw) continue // eslint-disable-line	330!
309	}
310	} while (true)
311	}
312
313	module.exports = rimraf	1✔
314	rimraf.sync = rimrafSync	1✔

jprichardson / node-fs-extra / 964

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