Breaking: Replace flag option with append option

erikkemperman · phated · commit e739f6c62ef6 · 2017-11-30T15:06:16.000-07:00
diff --git a/README.md b/README.md
@@ -181,6 +181,14 @@ Type: `Boolean`
 
 Default: `true` (always overwrite existing files)
 
+##### `options.append`
+
+Whether or not new data should be appended after existing file contents (if any).
+
+Type: `Boolean`
+
+Default: `false` (always replace existing contents, if any)
+
 ##### `options.sourcemaps`
 
 Enables sourcemap support on files passed through the stream.  Will write inline soucemaps if specified as `true`.
diff --git a/lib/dest/options.js b/lib/dest/options.js
@@ -18,12 +18,9 @@ var config = {
     type: 'boolean',
     default: true,
   },
-  flag: {
-    type: 'string',
-    default: function(file) {
-      var overwrite = this.resolve('overwrite', file);
-      return (overwrite ? 'w': 'wx');
-    },
+  append: {
+    type: 'boolean',
+    default: false,
   },
   sourcemaps: {
     type: ['string', 'boolean'],
diff --git a/lib/dest/write-contents/index.js b/lib/dest/write-contents/index.js
@@ -40,8 +40,11 @@ function writeContents(optResolver) {
     // This is invoked by the various writeXxx modules when they've finished
     // writing the contents.
     function onWritten(writeErr) {
-      var flag = optResolver.resolve('flag', file);
-      if (fo.isFatalOverwriteError(writeErr, flag)) {
+      var flags = fo.getFlags({
+        overwrite: optResolver.resolve('overwrite', file),
+        append: optResolver.resolve('append', file),
+      });
+      if (fo.isFatalOverwriteError(writeErr, flags)) {
         return callback(writeErr);
       }
 
diff --git a/lib/dest/write-contents/write-buffer.js b/lib/dest/write-contents/write-buffer.js
@@ -3,9 +3,13 @@
 var fo = require('../../file-operations');
 
 function writeBuffer(file, optResolver, onWritten) {
+  var flags = fo.getFlags({
+    overwrite: optResolver.resolve('overwrite', file),
+    append: optResolver.resolve('append', file),
+  });
   var opt = {
     mode: file.stat.mode,
-    flag: optResolver.resolve('flag', file),
+    flags: flags,
   };
 
   fo.writeFile(file.path, file.contents, opt, onWriteFile);
diff --git a/lib/dest/write-contents/write-stream.js b/lib/dest/write-contents/write-stream.js
@@ -4,10 +4,14 @@ var fo = require('../../file-operations');
 var readStream = require('../../src/read-contents/read-stream');
 
 function writeStream(file, optResolver, onWritten) {
+  var flags = fo.getFlags({
+    overwrite: optResolver.resolve('overwrite', file),
+    append: optResolver.resolve('append', file),
+  });
   var opt = {
     mode: file.stat.mode,
-    // TODO: need to test this (node calls this `flags` property)
-    flag: optResolver.resolve('flag', file),
+    // TODO: need to test this
+    flags: flags,
   };
 
   // TODO: is this the best API?
diff --git a/lib/dest/write-contents/write-symbolic-link.js b/lib/dest/write-contents/write-symbolic-link.js
@@ -13,7 +13,10 @@ function writeSymbolicLink(file, optResolver, onWritten) {
   }
 
   var isRelative = optResolver.resolve('relativeSymlinks', file);
-  var flag = optResolver.resolve('flag', file);
+  var flags = fo.getFlags({
+    overwrite: optResolver.resolve('overwrite', file),
+    append: optResolver.resolve('append', file),
+  });
 
   if (!isWindows) {
     // On non-Windows, just use 'file'
@@ -56,7 +59,7 @@ function writeSymbolicLink(file, optResolver, onWritten) {
     }
 
     var opts = {
-      flag: flag,
+      flags: flags,
       type: type,
     };
     fo.symlink(file.symlink, file.path, opts, onSymlink);
diff --git a/lib/file-operations.js b/lib/file-operations.js
@@ -39,12 +39,20 @@ function isValidUnixId(id) {
   return true;
 }
 
-function isFatalOverwriteError(err, flag) {
+function getFlags(options) {
+  var flags = !options.append ? 'w' : 'a';
+  if (!options.overwrite) {
+    flags += 'x';
+  }
+  return flags;
+}
+
+function isFatalOverwriteError(err, flags) {
   if (!err) {
     return false;
   }
 
-  if (err.code === 'EEXIST' && flag === 'wx') {
+  if (err.code === 'EEXIST' && flags[1] === 'x') {
     // Handle scenario for file overwrite failures.
     return false;
   }
@@ -274,7 +282,7 @@ function updateMetadata(fd, file, callback) {
 function symlink(srcPath, destPath, opts, callback) {
   // Because fs.symlink does not allow atomic overwrite option with flags, we
   // delete and recreate if the link already exists and overwrite is true.
-  if (opts.flag === 'w') {
+  if (opts.flags === 'w') {
     // TODO What happens when we call unlink with windows junctions?
     fs.unlink(destPath, onUnlink);
   } else {
@@ -289,7 +297,7 @@ function symlink(srcPath, destPath, opts, callback) {
   }
 
   function onSymlink(symlinkErr) {
-    if (isFatalOverwriteError(symlinkErr, opts.flag)) {
+    if (isFatalOverwriteError(symlinkErr, opts.flags)) {
       return callback(symlinkErr);
     }
     callback();
@@ -317,10 +325,10 @@ function writeFile(filepath, data, options, callback) {
 
   // Default the same as node
   var mode = options.mode || constants.DEFAULT_FILE_MODE;
-  var flag = options.flag || 'w';
-  var position = APPEND_MODE_REGEXP.test(flag) ? null : 0;
+  var flags = options.flags || 'w';
+  var position = APPEND_MODE_REGEXP.test(flags) ? null : 0;
 
-  fs.open(filepath, flag, mode, onOpen);
+  fs.open(filepath, flags, mode, onOpen);
 
   function onOpen(openErr, fd) {
     if (openErr) {
@@ -357,7 +365,7 @@ function WriteStream(path, options, flush) {
   this.path = path;
 
   this.mode = options.mode || constants.DEFAULT_FILE_MODE;
-  this.flag = options.flag || 'w';
+  this.flags = options.flags || 'w';
 
   // Used by node's `fs.WriteStream`
   this.fd = null;
@@ -374,7 +382,7 @@ util.inherits(WriteStream, FlushWriteStream);
 WriteStream.prototype.open = function() {
   var self = this;
 
-  fs.open(this.path, this.flag, this.mode, onOpen);
+  fs.open(this.path, this.flags, this.mode, onOpen);
 
   function onOpen(openErr, fd) {
     if (openErr) {
@@ -435,6 +443,7 @@ function cleanup(callback) {
 module.exports = {
   closeFd: closeFd,
   isValidUnixId: isValidUnixId,
+  getFlags: getFlags,
   isFatalOverwriteError: isFatalOverwriteError,
   isFatalUnlinkError: isFatalUnlinkError,
   getModeDiff: getModeDiff,
diff --git a/lib/symlink/link-file.js b/lib/symlink/link-file.js
@@ -13,7 +13,10 @@ function linkStream(optResolver) {
 
   function linkFile(file, enc, callback) {
     var isRelative = optResolver.resolve('relativeSymlinks', file);
-    var flag = optResolver.resolve('flag', file);
+    var flags = fo.getFlags({
+      overwrite: optResolver.resolve('overwrite', file),
+      append: false,
+    });
 
     if (!isWindows) {
       // On non-Windows, just use 'file'
@@ -57,7 +60,7 @@ function linkStream(optResolver) {
       }
 
       var opts = {
-        flag: flag,
+        flags: flags,
         type: type,
       };
       fo.symlink(file.symlink, file.path, opts, onSymlink);
diff --git a/lib/symlink/options.js b/lib/symlink/options.js
@@ -21,13 +21,6 @@ var config = {
     type: 'boolean',
     default: true,
   },
-  flag: {
-    type: 'string',
-    default: function(file) {
-      var overwrite = this.resolve('overwrite', file);
-      return (overwrite ? 'w': 'wx');
-    },
-  },
 };
 
 module.exports = config;
diff --git a/test/dest.js b/test/dest.js
@@ -606,6 +606,65 @@ describe('.dest()', function() {
     ], done);
   });
 
+  it('appends content with append option set to true', function(done) {
+    var existingContents = 'Lorem Ipsum';
+
+    var file = new File({
+      base: inputBase,
+      path: inputPath,
+      contents: new Buffer(contents),
+    });
+
+    function assert(files) {
+      var outputContents = fs.readFileSync(outputPath, 'utf8');
+
+      expect(files.length).toEqual(1);
+      expect(outputContents).toEqual(existingContents + contents);
+    }
+
+    // This should be overwritten
+    fs.mkdirSync(outputBase);
+    fs.writeFileSync(outputPath, existingContents);
+
+    pipe([
+      from.obj([file]),
+      vfs.dest(outputBase, { append: true }),
+      concat(assert),
+    ], done);
+  });
+
+  it('appends content with append option set to a function that returns true', function(done) {
+    var existingContents = 'Lorem Ipsum';
+
+    var file = new File({
+      base: inputBase,
+      path: inputPath,
+      contents: new Buffer(contents),
+    });
+
+    function append(f) {
+      expect(f).toEqual(file);
+      return true;
+    }
+
+    function assert(files) {
+      var outputContents = fs.readFileSync(outputPath, 'utf8');
+
+      expect(files.length).toEqual(1);
+      expect(outputContents).toEqual(existingContents + contents);
+    }
+
+    // This should be overwritten
+    fs.mkdirSync(outputBase);
+    fs.writeFileSync(outputPath, existingContents);
+
+    pipe([
+      from.obj([file]),
+      vfs.dest(outputBase, { append: append }),
+      concat(assert),
+    ], done);
+  });
+
   it('emits a finish event', function(done) {
     var destStream = vfs.dest(outputBase);
 
diff --git a/test/file-operations.js b/test/file-operations.js
