feat: split VirtualTar to VirtualTarParser and VirtualTarGenerator

Author: aryanjassal

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matrixai/js-virtualtar",
-  "version": "0.0.1",
+  "version": "1.16.3",
   "author": "Matrix AI",
   "contributors": [
     {

src/Generator.ts

@@ -1,5 +1,5 @@
 import type { FileType, FileStat } from './types';
-import { GeneratorState, HeaderSize } from './types';
+import { GeneratorState } from './types';
 import * as constants from './constants';
 import * as errors from './errors';
 import * as utils from './utils';
@@ -106,18 +106,21 @@ class Generator {
       );
     }
 
-    if (stat?.uname != null && stat?.uname.length > HeaderSize.OWNER_USERNAME) {
+    if (
+      stat?.uname != null &&
+      stat?.uname.length > constants.HEADER_SIZE.OWNER_USERNAME
+    ) {
       throw new errors.ErrorVirtualTarGeneratorInvalidStat(
-        `The username must not exceed ${HeaderSize.OWNER_USERNAME} bytes`,
+        `The username must not exceed ${constants.HEADER_SIZE.OWNER_USERNAME} bytes`,
       );
     }
 
     if (
       stat?.gname != null &&
-      stat?.gname.length > HeaderSize.OWNER_GROUPNAME
+      stat?.gname.length > constants.HEADER_SIZE.OWNER_GROUPNAME
     ) {
       throw new errors.ErrorVirtualTarGeneratorInvalidStat(
-        `The groupname must not exceed ${HeaderSize.OWNER_GROUPNAME} bytes`,
+        `The groupname must not exceed ${constants.HEADER_SIZE.OWNER_GROUPNAME} bytes`,
       );
     }
 
@@ -129,16 +132,16 @@ class Generator {
     }
 
     // Write the relevant sections in the header with the provided data
-    utils.writeUstarMagic(header);
-    utils.writeFileType(header, type);
     utils.writeFilePath(header, filePath);
     utils.writeFileMode(header, stat.mode);
     utils.writeOwnerUid(header, stat.uid);
     utils.writeOwnerGid(header, stat.gid);
-    utils.writeOwnerUserName(header, stat.uname);
-    utils.writeOwnerGroupName(header, stat.gname);
     utils.writeFileSize(header, stat.size);
     utils.writeFileMtime(header, stat.mtime);
+    utils.writeFileType(header, type);
+    utils.writeUstarMagic(header);
+    utils.writeOwnerUserName(header, stat.uname);
+    utils.writeOwnerGroupName(header, stat.gname);
 
     // The checksum can only be calculated once the entire header has been
     // written. This is why the checksum is calculated and written at the end.
@@ -307,18 +310,17 @@ class Generator {
     switch (this.state) {
       case GeneratorState.HEADER:
         this.state = GeneratorState.NULL;
-        break;
+        return new Uint8Array(constants.BLOCK_SIZE);
       case GeneratorState.NULL:
         this.state = GeneratorState.ENDED;
-        break;
+        return new Uint8Array(constants.BLOCK_SIZE);
       default:
         throw new errors.ErrorVirtualTarGeneratorInvalidState(
           `Expected state ${GeneratorState[GeneratorState.HEADER]} or ${
             GeneratorState[GeneratorState.NULL]
           } but got ${GeneratorState[this.state]}`,
         );
     }
-    return new Uint8Array(constants.BLOCK_SIZE);
   }
 }
 

src/Parser.ts

@@ -84,41 +84,41 @@ class Parser {
   protected state: ParserState = ParserState.HEADER;
   protected remainingBytes = 0;
 
-  protected parseHeader(array: Uint8Array): TokenHeader {
+  protected parseHeader(header: Uint8Array): TokenHeader {
     // Validate header by checking checksum and magic string
-    const headerChecksum = utils.decodeChecksum(array);
-    const calculatedChecksum = utils.calculateChecksum(array);
+    const headerChecksum = utils.decodeChecksum(header);
+    const calculatedChecksum = utils.calculateChecksum(header);
 
     if (headerChecksum !== calculatedChecksum) {
       throw new errors.ErrorVirtualTarParserInvalidHeader(
         `Expected checksum to be ${calculatedChecksum} but received ${headerChecksum}`,
       );
     }
 
-    const ustarMagic = utils.decodeUstarMagic(array);
+    const ustarMagic = utils.decodeUstarMagic(header);
     if (ustarMagic !== constants.USTAR_NAME) {
       throw new errors.ErrorVirtualTarParserInvalidHeader(
         `Expected ustar magic to be '${constants.USTAR_NAME}', got '${ustarMagic}'`,
       );
     }
 
-    const ustarVersion = utils.decodeUstarVersion(array);
+    const ustarVersion = utils.decodeUstarVersion(header);
     if (ustarVersion !== constants.USTAR_VERSION) {
       throw new errors.ErrorVirtualTarParserInvalidHeader(
         `Expected ustar version to be '${constants.USTAR_VERSION}', got '${ustarVersion}'`,
       );
     }
 
     // Extract the relevant metadata from the header
-    const filePath = utils.decodeFilePath(array);
-    const fileSize = utils.decodeFileSize(array);
-    const fileMtime = utils.decodeFileMtime(array);
-    const fileMode = utils.decodeFileMode(array);
-    const ownerUid = utils.decodeOwnerUid(array);
-    const ownerGid = utils.decodeOwnerGid(array);
-    const ownerUserName = utils.decodeOwnerUserName(array);
-    const ownerGroupName = utils.decodeOwnerGroupName(array);
-    const fileType = utils.decodeFileType(array);
+    const filePath = utils.decodeFilePath(header);
+    const fileMode = utils.decodeFileMode(header);
+    const ownerUid = utils.decodeOwnerUid(header);
+    const ownerGid = utils.decodeOwnerGid(header);
+    const fileSize = utils.decodeFileSize(header);
+    const fileMtime = utils.decodeFileMtime(header);
+    const fileType = utils.decodeFileType(header);
+    const ownerUserName = utils.decodeOwnerUserName(header);
+    const ownerGroupName = utils.decodeOwnerGroupName(header);
 
     return {
       type: 'header',
@@ -212,6 +212,12 @@ class Parser {
           this.state = ParserState.DATA;
           this.remainingBytes = headerToken.fileSize;
         }
+
+        // Only the file header and the extended header can potentially have
+        // additional data blocks following them. This needs to be tracked in
+        // the parser state. Directory headers don't have this issue and doesn't
+        // need any additional processing.
+
         return headerToken;
       }
 
@@ -225,7 +231,7 @@ class Parser {
       case ParserState.NULL: {
         if (utils.isNullBlock(data)) {
           this.state = ParserState.ENDED;
-          return { type: 'end' } as TokenEnd;
+          return { type: 'end' };
         } else {
           throw new errors.ErrorVirtualTarParserEndOfArchive(
             'Received garbage data after first end marker',
@@ -234,7 +240,7 @@ class Parser {
       }
 
       default:
-        utils.never('Unexpected state');
+        utils.never(`Unexpected state: ${this.state}`);
     }
   }
 }