Merge pull request #165 from electron/cut-snapshot

v1: Cut mksnapshot, update dependencies, promisify

bin/asar.js

@@ -3,73 +3,68 @@ var asar = require('../lib/asar')
 var program = require('commander')
 
 program.version('v' + require('../package.json').version)
-       .description('Manipulate asar archive files')
+  .description('Manipulate asar archive files')
 
 program.command('pack <dir> <output>')
-       .alias('p')
-       .description('create asar archive')
-       .option('--ordering <file path>', 'path to a text file for ordering contents')
-       .option('--unpack <expression>', 'do not pack files matching glob <expression>')
-       .option('--unpack-dir <expression>', 'do not pack dirs matching glob <expression> or starting with literal <expression>')
-       .option('--snapshot', 'create snapshot')
-       .option('--exclude-hidden', 'exclude hidden files')
-       .option('--sv <version>', '(snapshot) version of Electron')
-       .option('--sa <arch>', '(snapshot) arch of Electron')
-       .option('--sb <builddir>', '(snapshot) where to put downloaded files')
-       .action(function (dir, output, options) {
-         options = {
-           unpack: options.unpack,
-           unpackDir: options.unpackDir,
-           snapshot: options.snapshot,
-           ordering: options.ordering,
-           version: options.sv,
-           arch: options.sa,
-           builddir: options.sb,
-           dot: !options.excludeHidden
-         }
-         asar.createPackageWithOptions(dir, output, options, function (error) {
-           if (error) {
-             console.error(error.stack)
-             process.exit(1)
-           }
-         })
-       })
+  .alias('p')
+  .description('create asar archive')
+  .option('--ordering <file path>', 'path to a text file for ordering contents')
+  .option('--unpack <expression>', 'do not pack files matching glob <expression>')
+  .option('--unpack-dir <expression>', 'do not pack dirs matching glob <expression> or starting with literal <expression>')
+  .option('--exclude-hidden', 'exclude hidden files')
+  .action(function (dir, output, options) {
+    options = {
+      unpack: options.unpack,
+      unpackDir: options.unpackDir,
+      ordering: options.ordering,
+      version: options.sv,
+      arch: options.sa,
+      builddir: options.sb,
+      dot: !options.excludeHidden
+    }
+    asar.createPackageWithOptions(dir, output, options, function (error) {
+      if (error) {
+        console.error(error.stack)
+        process.exit(1)
+      }
+    })
+  })
 
 program.command('list <archive>')
-       .alias('l')
-       .description('list files of asar archive')
-       .option('-i, --is-pack', 'each file in the asar is pack or unpack')
-       .action(function (archive, options) {
-         options = {
-           isPack: options.isPack
-         }
-         var files = asar.listPackage(archive, options)
-         for (var i in files) {
-           console.log(files[i])
-         }
-         // This is in order to disappear help
-         process.exit(0)
-       })
+  .alias('l')
+  .description('list files of asar archive')
+  .option('-i, --is-pack', 'each file in the asar is pack or unpack')
+  .action(function (archive, options) {
+    options = {
+      isPack: options.isPack
+    }
+    var files = asar.listPackage(archive, options)
+    for (var i in files) {
+      console.log(files[i])
+    }
+    // This is in order to disappear help
+    process.exit(0)
+  })
 
 program.command('extract-file <archive> <filename>')
-       .alias('ef')
-       .description('extract one file from archive')
-       .action(function (archive, filename) {
-         require('fs').writeFileSync(require('path').basename(filename),
-                                     asar.extractFile(archive, filename))
-       })
+  .alias('ef')
+  .description('extract one file from archive')
+  .action(function (archive, filename) {
+    require('fs').writeFileSync(require('path').basename(filename),
+      asar.extractFile(archive, filename))
+  })
 
 program.command('extract <archive> <dest>')
-       .alias('e')
-       .description('extract archive')
-       .action(function (archive, dest) {
-         asar.extractAll(archive, dest)
-       })
+  .alias('e')
+  .description('extract archive')
+  .action(function (archive, dest) {
+    asar.extractAll(archive, dest)
+  })
 
 program.command('*')
-       .action(function (cmd) {
-         console.log('asar: \'%s\' is not an asar command. See \'asar --help\'.', cmd)
-       })
+  .action(function (cmd) {
+    console.log('asar: \'%s\' is not an asar command. See \'asar --help\'.', cmd)
+  })
 
 program.parse(process.argv)
 

lib/asar.js

@@ -1,42 +1,39 @@
 'use strict'
+
+const pify = require('pify')
+
 const fs = process.versions.electron ? require('original-fs') : require('fs')
 const path = require('path')
 const minimatch = require('minimatch')
-const mkdirp = require('mkdirp')
+const mkdirp = pify(require('mkdirp'))
 
 const Filesystem = require('./filesystem')
 const disk = require('./disk')
 const crawlFilesystem = require('./crawlfs')
-const createSnapshot = require('./snapshot')
-
-// Return whether or not a directory should be excluded from packing due to
-// "--unpack-dir" option
-//
-// @param {string} path - diretory path to check
-// @param {string} pattern - literal prefix [for backward compatibility] or glob pattern
-// @param {array} unpackDirs - Array of directory paths previously marked as unpacked
-//
-const isUnpackDir = function (path, pattern, unpackDirs) {
-  if (path.indexOf(pattern) === 0 || minimatch(path, pattern)) {
-    if (unpackDirs.indexOf(path) === -1) {
-      unpackDirs.push(path)
+
+/**
+ * Whether a directory should be excluded from packing due to the `--unpack-dir" option.
+ *
+ * @param {string} dirPath - directory path to check
+ * @param {string} pattern - literal prefix [for backward compatibility] or glob pattern
+ * @param {array} unpackDirs - Array of directory paths previously marked as unpacked
+ */
+function isUnpackedDir (dirPath, pattern, unpackDirs) {
+  if (dirPath.startsWith(pattern) || minimatch(dirPath, pattern)) {
+    if (!unpackDirs.includes(dirPath)) {
+      unpackDirs.push(dirPath)
     }
     return true
   } else {
-    for (let i = 0; i < unpackDirs.length; i++) {
-      if (path.indexOf(unpackDirs[i]) === 0) {
-        return true
-      }
-    }
-    return false
+    return unpackDirs.some(unpackDir => dirPath.startsWith(unpackDir))
   }
 }
 
-module.exports.createPackage = function (src, dest, callback) {
-  return module.exports.createPackageWithOptions(src, dest, {}, callback)
+module.exports.createPackage = function (src, dest) {
+  return module.exports.createPackageWithOptions(src, dest, {})
 }
 
-module.exports.createPackageWithOptions = function (src, dest, options, callback) {
+module.exports.createPackageWithOptions = function (src, dest, options) {
   const globOptions = options.globOptions ? options.globOptions : {}
   globOptions.dot = options.dot === undefined ? true : options.dot
 
@@ -45,10 +42,8 @@ module.exports.createPackageWithOptions = function (src, dest, options, callback
     pattern = src + options.pattern
   }
 
-  return crawlFilesystem(pattern, globOptions, function (error, filenames, metadata) {
-    if (error) { return callback(error) }
-    module.exports.createPackageFromFiles(src, dest, filenames, metadata, options, callback)
-  })
+  return crawlFilesystem(pattern, globOptions)
+    .then(([filenames, metadata]) => module.exports.createPackageFromFiles(src, dest, filenames, metadata, options))
 }
 
 /*
@@ -58,9 +53,8 @@ dest: Archive filename (& path).
 filenames: Array of filenames relative to src.
 metadata: Object with filenames as keys and {type='directory|file|link', stat: fs.stat} as values. (Optional)
 options: The options.
-callback: The callback function. Accepts (err).
 */
-module.exports.createPackageFromFiles = function (src, dest, filenames, metadata, options, callback) {
+module.exports.createPackageFromFiles = function (src, dest, filenames, metadata, options) {
   if (typeof metadata === 'undefined' || metadata === null) { metadata = {} }
   if (typeof options === 'undefined' || options === null) { options = {} }
 
@@ -112,67 +106,58 @@ module.exports.createPackageFromFiles = function (src, dest, filenames, metadata
     filenamesSorted = filenames
   }
 
-  const handleFile = function (filename, done) {
+  const handleFile = function (filename) {
     let file = metadata[filename]
     let type
     if (!file) {
       const stat = fs.lstatSync(filename)
       if (stat.isDirectory()) { type = 'directory' }
       if (stat.isFile()) { type = 'file' }
       if (stat.isSymbolicLink()) { type = 'link' }
-      file = {stat, type}
+      file = { stat, type }
       metadata[filename] = file
     }
 
     let shouldUnpack
     switch (file.type) {
       case 'directory':
-        shouldUnpack = options.unpackDir
-          ? isUnpackDir(path.relative(src, filename), options.unpackDir, unpackDirs)
-          : false
+        if (options.unpackDir) {
+          shouldUnpack = isUnpackedDir(path.relative(src, filename), options.unpackDir, unpackDirs)
+        } else {
+          shouldUnpack = false
+        }
         filesystem.insertDirectory(filename, shouldUnpack)
         break
       case 'file':
         shouldUnpack = false
         if (options.unpack) {
-          shouldUnpack = minimatch(filename, options.unpack, {matchBase: true})
+          shouldUnpack = minimatch(filename, options.unpack, { matchBase: true })
         }
         if (!shouldUnpack && options.unpackDir) {
           const dirName = path.relative(src, path.dirname(filename))
-          shouldUnpack = isUnpackDir(dirName, options.unpackDir, unpackDirs)
+          shouldUnpack = isUnpackedDir(dirName, options.unpackDir, unpackDirs)
         }
-        files.push({filename: filename, unpack: shouldUnpack})
-        filesystem.insertFile(filename, shouldUnpack, file, options, done)
-        return
+        files.push({ filename: filename, unpack: shouldUnpack })
+        return filesystem.insertFile(filename, shouldUnpack, file, options)
       case 'link':
         filesystem.insertLink(filename, file.stat)
         break
     }
-    return process.nextTick(done)
+    return Promise.resolve()
   }
 
   const insertsDone = function () {
-    return mkdirp(path.dirname(dest), function (error) {
-      if (error) { return callback(error) }
-      return disk.writeFilesystem(dest, filesystem, files, metadata, function (error) {
-        if (error) { return callback(error) }
-        if (options.snapshot) {
-          return createSnapshot(src, dest, filenames, metadata, options, callback)
-        } else {
-          return callback(null)
-        }
-      })
-    })
+    return mkdirp(path.dirname(dest))
+      .then(() => disk.writeFilesystem(dest, filesystem, files, metadata))
   }
 
   const names = filenamesSorted.slice()
 
   const next = function (name) {
     if (!name) { return insertsDone() }
 
-    return handleFile(name, function () {
-      return next(names.shift())
-    })
+    return handleFile(name)
+      .then(() => next(names.shift()))
   }
 
   return next(names.shift())
@@ -203,7 +188,7 @@ module.exports.extractAll = function (archive, dest) {
   mkdirp.sync(dest)
 
   return filenames.map((filename) => {
-    filename = filename.substr(1)  // get rid of leading slash
+    filename = filename.substr(1) // get rid of leading slash
     const destFilename = path.join(dest, filename)
     const file = filesystem.getFile(filename, followLinks)
     if (file.files) {

lib/crawlfs.js

@@ -1,21 +1,37 @@
 'use strict'
-const fs = process.versions.electron ? require('original-fs') : require('fs')
-const glob = require('glob')
 
-module.exports = function (dir, options, callback) {
-  const metadata = {}
-  return glob(dir, options, function (error, filenames) {
-    if (error) { return callback(error) }
-    for (const filename of filenames) {
-      const stat = fs.lstatSync(filename)
+const pify = require('pify')
+
+const fs = pify(process.versions.electron ? require('original-fs') : require('fs'))
+const glob = pify(require('glob'))
+
+function determineFileType (filename) {
+  return fs.lstat(filename)
+    .then(stat => {
       if (stat.isFile()) {
-        metadata[filename] = {type: 'file', stat: stat}
+        return [filename, { type: 'file', stat: stat }]
       } else if (stat.isDirectory()) {
-        metadata[filename] = {type: 'directory', stat: stat}
+        return [filename, { type: 'directory', stat: stat }]
       } else if (stat.isSymbolicLink()) {
-        metadata[filename] = {type: 'link', stat: stat}
+        return [filename, { type: 'link', stat: stat }]
+      }
+
+      return [filename, undefined]
+    })
+}
+
+module.exports = function (dir, options) {
+  const metadata = {}
+  return glob(dir, options)
+    .then(filenames => Promise.all(filenames.map(filename => determineFileType(filename))))
+    .then(results => {
+      const filenames = []
+      for (const [filename, type] of results) {
+        filenames.push(filename)
+        if (type) {
+          metadata[filename] = type
+        }
       }
-    }
-    return callback(null, filenames, metadata)
-  })
+      return [filenames, metadata]
+    })
 }