-
Notifications
You must be signed in to change notification settings - Fork 19
/
index.js
235 lines (211 loc) · 7.27 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
var fs = require('fs')
var path = require('path')
var crypto = require('crypto')
var mkdirp = require('mkdirp')
var glob = require('glob')
var isWindows = process.platform === 'win32'
var pathSep = path.sep
var keysForTreeWarningPrinted = false
exports.hashTree = hashTree
// This function is used by the watcher. It makes the following guarantees:
//
// (1) It never throws an exception.
//
// (2) It does not miss changes. In other words, if after this function returns,
// any part of the directory hierarchy changes, a subsequent call must
// return a different hash.
//
// (1) and (2) hold even in the face of a constantly-changing file system.
function hashTree (fullPath) {
return hashStrings(keysForTree(fullPath))
}
exports.keysForTree = keysForTree
function keysForTree (fullPath, initialRelativePath) {
var relativePath = initialRelativePath || '.'
var stats
var statKeys
stats = fs.statSync(fullPath)
var childKeys = []
statKeys = ['stats', stats.mode]
if (stats.isDirectory()) {
var entries
try {
entries = fs.readdirSync(fullPath).sort()
} catch (err) {
console.warn('Warning: Failed to read directory ' + fullPath)
console.warn(err.stack)
childKeys = ['readdir failed']
// That's all there is to say about this directory.
}
if (entries != null) {
for (var i = 0; i < entries.length; i++) {
var keys
try {
keys = keysForTree(
path.join(fullPath, entries[i]),
path.join(relativePath, entries[i])
)
} catch (err) {
if (!keysForTreeWarningPrinted) {
console.warn('Warning: failed to stat ' + path.join(fullPath, entries[i]))
keysForTreeWarningPrinted = true
}
// The child has probably ceased to exist since we called
// `readdirSync`, or it is a broken symlink.
keys = ['missing']
}
childKeys = childKeys.concat(keys)
}
}
} else if (stats.isFile()) {
statKeys.push(stats.mtime.getTime())
statKeys.push(stats.size)
} else {
throw new Error(fullPath + ': Unexpected file type')
}
return ['path', relativePath]
.concat(statKeys)
.concat(childKeys)
}
exports.hashStats = hashStats
function hashStats (stats, path) {
// Both stats and path can be null
var keys = []
if (stats != null) {
keys.push(stats.mode, stats.size, stats.mtime.getTime())
}
if (path != null) {
keys.push(path)
}
return hashStrings(keys)
}
exports.hashStrings = hashStrings
function hashStrings (strings) {
var joinedStrings = strings.join('\x00')
return crypto.createHash('md5').update(new Buffer(joinedStrings, 'utf8')).digest('hex')
}
// If src is a file, dest is a file name. If src is a directory, dest is the
// directory that the contents of src will be copied into.
//
// This function refuses to overwrite files, but accepts if directories exist
// already.
//
// This function dereferences symlinks.
//
// Note that unlike cp(1), we do not special-case if dest is an existing
// directory, because relying on things to exist when we're in the middle of
// assembling a new tree is too brittle.
//
// This function is deprecated in favor of
// https://github.com/broccolijs/node-copy-dereference
//
// copy-dereference differs from copyRecursivelySync in that it won't call
// mkdirp to create the target directory (or the parent directory of the
// target file), which makes it stricter: (1) It's not OK for the target
// directory to exist already, and (2) missing parent directories will not
// automatically be created.
exports.copyRecursivelySync = copyRecursivelySync
function copyRecursivelySync (src, dest, _mkdirp) {
if (_mkdirp == null) _mkdirp = true
// Note: We could try readdir'ing and catching ENOTDIR exceptions, but that
// is 3x slower than stat'ing in the common case that we have a file.
var srcStats = fs.statSync(src)
if (srcStats.isDirectory()) {
mkdirp.sync(dest)
var entries = fs.readdirSync(src).sort()
for (var i = 0; i < entries.length; i++) {
// Set _mkdirp to false when recursing to avoid extra mkdirp calls.
copyRecursivelySync(src + '/' + entries[i], dest + '/' + entries[i], false)
}
} else {
if (_mkdirp) {
mkdirp.sync(path.dirname(dest))
}
copyPreserveSync(src, dest, srcStats)
}
}
// This function is deprecated in favor of
// https://github.com/broccolijs/node-copy-dereference
//
// srcStats is optional; use it as an optimization to avoid double stats
// This function refuses to overwrite files.
exports.copyPreserveSync = copyPreserveSync
function copyPreserveSync (src, dest, srcStats) {
if (srcStats == null) srcStats = fs.statSync(src)
if (srcStats.isFile()) {
var content = fs.readFileSync(src)
fs.writeFileSync(dest, content, { flag: 'wx' })
fs.utimesSync(dest, srcStats.atime, srcStats.mtime)
} else {
throw new Error('Unexpected file type for ' + src)
}
}
exports.linkRecursivelySync = linkRecursivelySync
function linkRecursivelySync () {
throw new Error('linkRecursivelySync has been removed; use copyRecursivelySync instead (note: it does not overwrite)')
}
exports.linkAndOverwrite = linkAndOverwrite
function linkAndOverwrite () {
throw new Error('linkAndOverwrite has been removed; use copyPreserveSync instead (note: it does not overwrite)')
}
exports.assertAbsolutePaths = assertAbsolutePaths
function assertAbsolutePaths (paths) {
for (var i = 0; i < paths.length; i++) {
if (paths[i][0] !== '/') {
throw new Error('Path must be absolute: "' + paths[i] + '"')
}
}
}
// Multi-glob with reasonable defaults, so APIs all behave the same
exports.multiGlob = multiGlob
function multiGlob (globs, globOptions) {
if (!Array.isArray(globs)) {
throw new TypeError("multiGlob's first argument must be an array");
}
var options = {
follow: true,
nomount: true,
strict: true
}
for (var key in globOptions) {
if (globOptions.hasOwnProperty(key)) {
options[key] = globOptions[key]
}
}
var pathSet = {}
var paths = []
for (var i = 0; i < globs.length; i++) {
if (options.nomount && globs[i][0] === '/') {
throw new Error('Absolute paths not allowed (`nomount` is enabled): ' + globs[i])
}
var matches = glob.sync(globs[i], options)
if (matches.length === 0) {
throw new Error('Path or pattern "' + globs[i] + '" did not match any files')
}
for (var j = 0; j < matches.length; j++) {
if (!pathSet[matches[j]]) {
pathSet[matches[j]] = true
paths.push(matches[j])
}
}
}
return paths
}
// This function is deprecated in favor of
// https://github.com/broccolijs/node-symlink-or-copy
exports.symlinkOrCopyPreserveSync = symlinkOrCopyPreserveSync
function symlinkOrCopyPreserveSync (sourcePath, destPath) {
if (isWindows) {
copyRecursivelySync(sourcePath, destPath)
} else {
if (fs.lstatSync(sourcePath).isSymbolicLink()) {
// When we encounter symlinks, follow them. This prevents indirection
// from growing out of control. Note: At the moment `realpath` on Node
// is 70x slower than native: https://github.com/joyent/node/issues/7902
sourcePath = fs.realpathSync(sourcePath)
} else if (sourcePath[0] !== pathSep) {
sourcePath = process.cwd() + pathSep + sourcePath
}
fs.symlinkSync(sourcePath, destPath)
}
}