aboutsummaryrefslogtreecommitdiff
path: root/node_modules/fs-extra/lib/copy-sync
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/fs-extra/lib/copy-sync')
-rw-r--r--node_modules/fs-extra/lib/copy-sync/copy-sync.js209
-rw-r--r--node_modules/fs-extra/lib/copy-sync/index.js3
2 files changed, 212 insertions, 0 deletions
diff --git a/node_modules/fs-extra/lib/copy-sync/copy-sync.js b/node_modules/fs-extra/lib/copy-sync/copy-sync.js
new file mode 100644
index 0000000..c4742db
--- /dev/null
+++ b/node_modules/fs-extra/lib/copy-sync/copy-sync.js
@@ -0,0 +1,209 @@
+'use strict'
+
+const fs = require('graceful-fs')
+const path = require('path')
+const mkdirpSync = require('../mkdirs').mkdirsSync
+const utimesSync = require('../util/utimes.js').utimesMillisSync
+
+const notExist = Symbol('notExist')
+const existsReg = Symbol('existsReg')
+
+function copySync (src, dest, opts) {
+ if (typeof opts === 'function') {
+ opts = {filter: opts}
+ }
+
+ opts = opts || {}
+ opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now
+ opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber
+
+ // Warn about using preserveTimestamps on 32-bit node
+ if (opts.preserveTimestamps && process.arch === 'ia32') {
+ console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n
+ see https://github.com/jprichardson/node-fs-extra/issues/269`)
+ }
+
+ src = path.resolve(src)
+ dest = path.resolve(dest)
+
+ // don't allow src and dest to be the same
+ if (src === dest) throw new Error('Source and destination must not be the same.')
+
+ if (opts.filter && !opts.filter(src, dest)) return
+
+ const destParent = path.dirname(dest)
+ if (!fs.existsSync(destParent)) mkdirpSync(destParent)
+ return startCopy(src, dest, opts)
+}
+
+function startCopy (src, dest, opts) {
+ if (opts.filter && !opts.filter(src, dest)) return
+ return getStats(src, dest, opts)
+}
+
+function getStats (src, dest, opts) {
+ const statSync = opts.dereference ? fs.statSync : fs.lstatSync
+ const st = statSync(src)
+
+ if (st.isDirectory()) return onDir(st, src, dest, opts)
+ else if (st.isFile() ||
+ st.isCharacterDevice() ||
+ st.isBlockDevice()) return onFile(st, src, dest, opts)
+ else if (st.isSymbolicLink()) return onLink(src, dest, opts)
+}
+
+function onFile (srcStat, src, dest, opts) {
+ const resolvedPath = checkDest(dest)
+ if (resolvedPath === notExist) {
+ return copyFile(srcStat, src, dest, opts)
+ } else if (resolvedPath === existsReg) {
+ return mayCopyFile(srcStat, src, dest, opts)
+ } else {
+ if (src === resolvedPath) return
+ return mayCopyFile(srcStat, src, dest, opts)
+ }
+}
+
+function mayCopyFile (srcStat, src, dest, opts) {
+ if (opts.overwrite) {
+ fs.unlinkSync(dest)
+ return copyFile(srcStat, src, dest, opts)
+ } else if (opts.errorOnExist) {
+ throw new Error(`'${dest}' already exists`)
+ }
+}
+
+function copyFile (srcStat, src, dest, opts) {
+ if (typeof fs.copyFileSync === 'function') {
+ fs.copyFileSync(src, dest)
+ fs.chmodSync(dest, srcStat.mode)
+ if (opts.preserveTimestamps) {
+ return utimesSync(dest, srcStat.atime, srcStat.mtime)
+ }
+ return
+ }
+ return copyFileFallback(srcStat, src, dest, opts)
+}
+
+function copyFileFallback (srcStat, src, dest, opts) {
+ const BUF_LENGTH = 64 * 1024
+ const _buff = require('../util/buffer')(BUF_LENGTH)
+
+ const fdr = fs.openSync(src, 'r')
+ const fdw = fs.openSync(dest, 'w', srcStat.mode)
+ let bytesRead = 1
+ let pos = 0
+
+ while (bytesRead > 0) {
+ bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
+ fs.writeSync(fdw, _buff, 0, bytesRead)
+ pos += bytesRead
+ }
+
+ if (opts.preserveTimestamps) fs.futimesSync(fdw, srcStat.atime, srcStat.mtime)
+
+ fs.closeSync(fdr)
+ fs.closeSync(fdw)
+}
+
+function onDir (srcStat, src, dest, opts) {
+ const resolvedPath = checkDest(dest)
+ if (resolvedPath === notExist) {
+ if (isSrcSubdir(src, dest)) {
+ throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`)
+ }
+ return mkDirAndCopy(srcStat, src, dest, opts)
+ } else if (resolvedPath === existsReg) {
+ if (isSrcSubdir(src, dest)) {
+ throw new Error(`Cannot copy '${src}' to a subdirectory of itself, '${dest}'.`)
+ }
+ return mayCopyDir(src, dest, opts)
+ } else {
+ if (src === resolvedPath) return
+ return copyDir(src, dest, opts)
+ }
+}
+
+function mayCopyDir (src, dest, opts) {
+ if (!fs.statSync(dest).isDirectory()) {
+ throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
+ }
+ return copyDir(src, dest, opts)
+}
+
+function mkDirAndCopy (srcStat, src, dest, opts) {
+ fs.mkdirSync(dest, srcStat.mode)
+ fs.chmodSync(dest, srcStat.mode)
+ return copyDir(src, dest, opts)
+}
+
+function copyDir (src, dest, opts) {
+ fs.readdirSync(src).forEach(item => {
+ startCopy(path.join(src, item), path.join(dest, item), opts)
+ })
+}
+
+function onLink (src, dest, opts) {
+ let resolvedSrcPath = fs.readlinkSync(src)
+
+ if (opts.dereference) {
+ resolvedSrcPath = path.resolve(process.cwd(), resolvedSrcPath)
+ }
+
+ let resolvedDestPath = checkDest(dest)
+ if (resolvedDestPath === notExist || resolvedDestPath === existsReg) {
+ // if dest already exists, fs throws error anyway,
+ // so no need to guard against it here.
+ return fs.symlinkSync(resolvedSrcPath, dest)
+ } else {
+ if (opts.dereference) {
+ resolvedDestPath = path.resolve(process.cwd(), resolvedDestPath)
+ }
+ if (resolvedDestPath === resolvedSrcPath) return
+
+ // prevent copy if src is a subdir of dest since unlinking
+ // dest in this case would result in removing src contents
+ // and therefore a broken symlink would be created.
+ if (fs.statSync(dest).isDirectory() && isSrcSubdir(resolvedDestPath, resolvedSrcPath)) {
+ throw new Error(`Cannot overwrite '${resolvedDestPath}' with '${resolvedSrcPath}'.`)
+ }
+ return copyLink(resolvedSrcPath, dest)
+ }
+}
+
+function copyLink (resolvedSrcPath, dest) {
+ fs.unlinkSync(dest)
+ return fs.symlinkSync(resolvedSrcPath, dest)
+}
+
+// check if dest exists and/or is a symlink
+function checkDest (dest) {
+ let resolvedPath
+ try {
+ resolvedPath = fs.readlinkSync(dest)
+ } catch (err) {
+ if (err.code === 'ENOENT') return notExist
+
+ // dest exists and is a regular file or directory, Windows may throw UNKNOWN error
+ if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return existsReg
+
+ throw err
+ }
+ return resolvedPath // dest exists and is a symlink
+}
+
+// return true if dest is a subdir of src, otherwise false.
+// extract dest base dir and check if that is the same as src basename
+function isSrcSubdir (src, dest) {
+ const baseDir = dest.split(path.dirname(src) + path.sep)[1]
+ if (baseDir) {
+ const destBasename = baseDir.split(path.sep)[0]
+ if (destBasename) {
+ return src !== dest && dest.indexOf(src) > -1 && destBasename === path.basename(src)
+ }
+ return false
+ }
+ return false
+}
+
+module.exports = copySync
diff --git a/node_modules/fs-extra/lib/copy-sync/index.js b/node_modules/fs-extra/lib/copy-sync/index.js
new file mode 100644
index 0000000..ebc7e0b
--- /dev/null
+++ b/node_modules/fs-extra/lib/copy-sync/index.js
@@ -0,0 +1,3 @@
+module.exports = {
+ copySync: require('./copy-sync')
+}