feat: support uncompressing symlink

.gitignore

@@ -4,5 +4,6 @@ coverage
 .vscode
 test/fixtures/types/*.js
 test/fixtures/chinese-path-test.zip
-yarn.lock
 .DS_Store
+yarn.lock
+!test/fixtures/symlink/node_modules

lib/utils.js

@@ -118,11 +118,20 @@
                 entryCount++;
                 pump(stream, fs.createWriteStream(fullpath, { mode: opts.mode || header.mode }), err => {
                   if (err) return reject(err);
-
                   successCount++;
                   done();
                 });
               });
+            } else if (header.type === 'symlink') {
+              // symlink
+              const src = path.join(destDir, header.name);
+              const target = path.resolve(path.dirname(src), header.linkname);
+              entryCount++;
+              fs.symlink(target, src, err => {
+                if (err) return reject(err);
+                successCount++;
+                stream.resume();
+              });
             } else { // directory
               mkdirp(path.join(destDir, header.name), err => {
                 if (err) return reject(err);

test/fixtures/symlink/README.md

@@ -0,0 +1 @@
+./node_modules/_enums@1.0.3@enums/README.md

test/fixtures/symlink/cli

@@ -0,0 +1 @@
+node_modules/cli

test/gzip/index.test.js

@@ -6,100 +6,116 @@ const path = require('path');
 const uuid = require('uuid');
 const compressing = require('../..');
 const assert = require('assert');
+const isWindows = os.platform() === 'win32';
 
 describe('test/gzip/index.test.js', () => {
   describe('gzip.compressFile()', () => {
-    it('gzip.compressFile(file, stream)', function* () {
+    it('gzip.compressFile(file, stream)', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log.gz');
       console.log('destFile', destFile);
       const fileStream = fs.createWriteStream(destFile);
-      yield compressing.gzip.compressFile(sourceFile, fileStream);
+      await compressing.gzip.compressFile(sourceFile, fileStream);
       assert(fs.existsSync(destFile));
     });
 
-    it('gzip.compressFile(file, destStream) should error if destStream emit error', function* () {
+    it('gzip.compressFile(file, destStream) should error if destStream emit error', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.gz');
       const fileStream = fs.createWriteStream(destFile);
       setImmediate(() => fileStream.emit('error', new Error('xx')));
 
       let err;
       try {
-        yield compressing.gzip.compressFile(sourceFile, fileStream);
+        await compressing.gzip.compressFile(sourceFile, fileStream);
       } catch (e) {
         err = e;
       }
       assert(err && err.message === 'xx');
     });
 
-    it('gzip.compressFile(buffer, stream)', function* () {
+    it('gzip.compressFile(buffer, stream)', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const sourceBuffer = fs.readFileSync(sourceFile);
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log.gz');
       console.log('destFile', destFile);
       const fileStream = fs.createWriteStream(destFile);
-      yield compressing.gzip.compressFile(sourceBuffer, fileStream);
+      await compressing.gzip.compressFile(sourceBuffer, fileStream);
       assert(fs.existsSync(destFile));
     });
 
-    it('gzip.compressFile(sourceStream, destStream)', function* () {
+    it('gzip.compressFile(sourceStream, destStream)', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const sourceStream = fs.createReadStream(sourceFile);
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log.gz');
       console.log('destFile', destFile);
       const fileStream = fs.createWriteStream(destFile);
-      yield compressing.gzip.compressFile(sourceStream, fileStream);
+      await compressing.gzip.compressFile(sourceStream, fileStream);
       assert(fs.existsSync(destFile));
     });
   });
 
   describe('gzip.uncompress()', () => {
-    it('gzip.uncompress(sourceFile, destStream)', function* () {
+    it('gzip.uncompress(sourceFile, destStream)', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log.gz');
       const originalFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log');
       const fileStream = fs.createWriteStream(destFile);
-      yield compressing.gzip.uncompress(sourceFile, fileStream);
+      await compressing.gzip.uncompress(sourceFile, fileStream);
       assert(fs.existsSync(destFile));
-      assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      if (!isWindows) {
+        // EOL not equal to linux
+        assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      }
     });
 
-    it('gzip.uncompress(sourceStream, destStream)', function* () {
+    it('gzip.uncompress(sourceStream, destStream)', async () => {
       const sourceStream = fs.createReadStream(path.join(__dirname, '..', 'fixtures', 'xx.log.gz'));
       const originalFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log');
       const fileStream = fs.createWriteStream(destFile);
-      yield compressing.gzip.uncompress(sourceStream, fileStream);
+      await compressing.gzip.uncompress(sourceStream, fileStream);
       assert(fs.existsSync(destFile));
-      assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      if (!isWindows) {
+        // EOL not equal to linux
+        assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      }
     });
 
-    it('gzip.uncompress(sourceStream, destFile)', function* () {
+    it('gzip.uncompress(sourceStream, destFile)', async () => {
       const sourceStream = fs.createReadStream(path.join(__dirname, '..', 'fixtures', 'xx.log.gz'));
       const originalFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log');
-      yield compressing.gzip.uncompress(sourceStream, destFile);
+      await compressing.gzip.uncompress(sourceStream, destFile);
       assert(fs.existsSync(destFile));
-      assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      if (!isWindows) {
+        // EOL not equal to linux
+        assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      }
     });
 
-    it('gzip.uncompress(sourceFile, destFile)', function* () {
+    it('gzip.uncompress(sourceFile, destFile)', async () => {
       const sourceFile = path.join(__dirname, '..', 'fixtures', 'xx.log.gz');
       const originalFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log');
-      yield compressing.gzip.uncompress(sourceFile, destFile);
+      await compressing.gzip.uncompress(sourceFile, destFile);
       assert(fs.existsSync(destFile));
-      assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      if (!isWindows) {
+        // EOL not equal to linux
+        assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      }
     });
 
-    it('gzip.uncompress(buffer, destFile)', function* () {
+    it('gzip.uncompress(buffer, destFile)', async () => {
       const sourceBuffer = fs.readFileSync(path.join(__dirname, '..', 'fixtures', 'xx.log.gz'));
       const originalFile = path.join(__dirname, '..', 'fixtures', 'xx.log');
       const destFile = path.join(os.tmpdir(), uuid.v4() + '.log');
-      yield compressing.gzip.uncompress(sourceBuffer, destFile);
+      await compressing.gzip.uncompress(sourceBuffer, destFile);
       assert(fs.existsSync(destFile));
-      assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      if (!isWindows) {
+        // EOL not equal to linux
+        assert(fs.readFileSync(destFile, 'utf8') === fs.readFileSync(originalFile, 'utf8'));
+      }
     });
   });
 });