gyomu 0.1.0 → 0.2.0

package/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/index');

package/lib/archive/abstract.d.ts

@@ -1,7 +1,7 @@
-export declare abstract class AbstractBaseArchive {
-    readonly archiveFileName: string;
-    constructor(tarFilename: string);
-    protected __massageEntryPath(fileName: string): string;
-    protected __createDirectoryFromFileNameIfNotExist(destinationFilename: string): void;
-    protected __createDirectoryIfNotExist(destinationPath: string): void;
-}
+export declare abstract class AbstractBaseArchive {
+    readonly archiveFileName: string;
+    constructor(tarFilename: string);
+    protected __massageEntryPath(fileName: string): string;
+    protected __createDirectoryFromFileNameIfNotExist(destinationFilename: string): void;
+    protected __createDirectoryIfNotExist(destinationPath: string): void;
+}

package/lib/archive/abstract.js

@@ -1,30 +1,23 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractBaseArchive = void 0;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-class AbstractBaseArchive {
-    constructor(tarFilename) {
-        this.archiveFileName = tarFilename;
-    }
-    __massageEntryPath(fileName) {
-        return fileName.replace(/\\/g, '/');
-    }
-    __createDirectoryFromFileNameIfNotExist(destinationFilename) {
-        let directoryName = path_1.default.dirname(destinationFilename);
-        if (destinationFilename.endsWith(path_1.default.sep))
-            directoryName = destinationFilename;
-        return this.__createDirectoryIfNotExist(directoryName);
-    }
-    __createDirectoryIfNotExist(destinationPath) {
-        let directoryName = destinationPath;
-        if (!fs_1.default.existsSync(directoryName)) {
-            //console.log(directoryName + ' to be created');
-            fs_1.default.mkdirSync(directoryName);
-        }
-    }
-}
-exports.AbstractBaseArchive = AbstractBaseArchive;
+import { platform } from '../platform';
+export class AbstractBaseArchive {
+    archiveFileName;
+    constructor(tarFilename) {
+        this.archiveFileName = tarFilename;
+    }
+    __massageEntryPath(fileName) {
+        return fileName.replace(/\\/g, '/');
+    }
+    __createDirectoryFromFileNameIfNotExist(destinationFilename) {
+        let directoryName = platform.dirname(destinationFilename);
+        if (destinationFilename.endsWith(platform.sep))
+            directoryName = destinationFilename;
+        return this.__createDirectoryIfNotExist(directoryName);
+    }
+    __createDirectoryIfNotExist(destinationPath) {
+        const directoryName = destinationPath;
+        if (!platform.existsSync(directoryName)) {
+            //console.log(directoryName + ' to be created');
+            platform.mkdirSync(directoryName);
+        }
+    }
+}

package/lib/archive/gz.d.ts

@@ -1,16 +1,15 @@
-/// <reference types="node" />
-import { ArchiveError } from '../errors';
-import { PromiseResult } from '../result';
-import { AbstractBaseArchive } from './abstract';
-import zlib from 'zlib';
-/**
- * @remarks
- * This class (extract side) doesn't support stream based retrieval yet
- */
-export declare class GzipArchive extends AbstractBaseArchive {
-    static create(gzipFilename: string, sourceFilename: string): PromiseResult<boolean, ArchiveError>;
-    static extract(gzipFilename: string, destinationFilename: string): PromiseResult<boolean, ArchiveError>;
-    static getGzipTransform(): zlib.Gzip;
-    static getGunzipTransform(): zlib.Gunzip;
-    static extractStream(gzipFilename: string): zlib.Gunzip;
-}
+import { ArchiveError } from '../errors';
+import { ResultAsync } from '../result';
+import { AbstractBaseArchive } from './abstract';
+import zlib from 'zlib';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export declare class GzipArchive extends AbstractBaseArchive {
+    static create(gzipFilename: string, sourceFilename: string): ResultAsync<boolean, ArchiveError>;
+    static extract(gzipFilename: string, destinationFilename: string): ResultAsync<boolean, ArchiveError>;
+    static getGzipTransform(): zlib.Gzip;
+    static getGunzipTransform(): zlib.Gunzip;
+    static extractStream(gzipFilename: string): zlib.Gunzip;
+}

package/lib/archive/gz.js

@@ -1,66 +1,49 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GzipArchive = void 0;
-const fs_1 = __importDefault(require("fs"));
-const errors_1 = require("../errors");
-const result_1 = require("../result");
-const abstract_1 = require("./abstract");
-const zlib_1 = __importDefault(require("zlib"));
-/**
- * @remarks
- * This class (extract side) doesn't support stream based retrieval yet
- */
-class GzipArchive extends abstract_1.AbstractBaseArchive {
-    static create(gzipFilename, sourceFilename) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                fs_1.default.createReadStream(sourceFilename)
-                    .pipe(zlib_1.default.createGzip())
-                    .pipe(fs_1.default.createWriteStream(gzipFilename))
-                    .on('error', (err) => {
-                    resolve(new result_1.Failure(new errors_1.ArchiveError('Error on gzip compression', err)));
-                })
-                    .on('finish', () => {
-                    resolve((0, result_1.success)(true));
-                });
-            });
-        });
-    }
-    static extract(gzipFilename, destinationFilename) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                fs_1.default.createReadStream(gzipFilename)
-                    .pipe(zlib_1.default.createGunzip())
-                    .pipe(fs_1.default.createWriteStream(destinationFilename))
-                    .on('error', (err) => {
-                    resolve(new result_1.Failure(new errors_1.ArchiveError('Error on gzip uncompression', err)));
-                })
-                    .on('finish', () => {
-                    resolve((0, result_1.success)(true));
-                });
-            });
-        });
-    }
-    static getGzipTransform() {
-        return zlib_1.default.createGzip();
-    }
-    static getGunzipTransform() {
-        return zlib_1.default.createGunzip();
-    }
-    static extractStream(gzipFilename) {
-        return fs_1.default.createReadStream(gzipFilename).pipe(zlib_1.default.createGunzip());
-    }
-}
-exports.GzipArchive = GzipArchive;
+import { ArchiveError } from '../errors';
+// import { fail, Result, success, PromiseResult, Failure } from '../result';
+import { ResultAsync } from '../result';
+import { AbstractBaseArchive } from './abstract';
+import zlib from 'zlib';
+import { platform } from '../platform';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export class GzipArchive extends AbstractBaseArchive {
+    static create(gzipFilename, sourceFilename) {
+        return ResultAsync.fromSafePromise(new Promise((resolve, reject) => {
+            platform
+                .createReadStream(sourceFilename)
+                .pipe(zlib.createGzip())
+                .pipe(platform.createWriteStream(gzipFilename))
+                .on('error', (err) => {
+                reject(new ArchiveError('Error on gzip compression', err));
+            })
+                .on('finish', () => {
+                resolve(true);
+            });
+        }));
+    }
+    static extract(gzipFilename, destinationFilename) {
+        return ResultAsync.fromSafePromise(new Promise((resolve, reject) => {
+            platform
+                .createReadStream(gzipFilename)
+                .pipe(zlib.createGunzip())
+                .pipe(platform.createWriteStream(destinationFilename))
+                .on('error', (err) => {
+                reject(new ArchiveError('Error on gzip uncompression', err));
+            })
+                .on('finish', () => {
+                resolve(true);
+            });
+        }));
+    }
+    static getGzipTransform() {
+        return zlib.createGzip();
+    }
+    static getGunzipTransform() {
+        return zlib.createGunzip();
+    }
+    static extractStream(gzipFilename) {
+        return platform.createReadStream(gzipFilename).pipe(zlib.createGunzip());
+    }
+}

package/lib/archive/index.d.ts

@@ -1,3 +1,3 @@
-export * from './gz';
-export * from './tar';
-export * from './zip';
+export * from './gz';
+export * from './tar';
+export * from './zip';

package/lib/archive/index.js

@@ -1,19 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./gz"), exports);
-__exportStar(require("./tar"), exports);
-__exportStar(require("./zip"), exports);
+export * from './gz';
+export * from './tar';
+export * from './zip';

package/lib/archive/tar.d.ts

@@ -1,17 +1,17 @@
-import { FileTransportInfo } from '../fileModel';
-import { ArchiveError } from '../errors';
-import { PromiseResult } from '../result';
-import { AbstractBaseArchive } from './abstract';
-/**
- * @remarks
- * This class (extract side) doesn't support stream based retrieval yet
- */
-export declare class TarArchive extends AbstractBaseArchive {
-    static create(tarFileName: string, transferInformation: FileTransportInfo, needGZipCompression?: boolean): PromiseResult<boolean, ArchiveError>;
-    constructor(tarFilename: string);
-    fileExists(fileName: string): PromiseResult<boolean, ArchiveError>;
-    extractSingileFile(sourceEntryFullName: string, destinationFolderName: string): PromiseResult<boolean, ArchiveError>;
-    extractDirectory(sourceDirectory: string, destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
-    extractAll(destinationDirectory: string): PromiseResult<boolean, ArchiveError>;
-    extract(transferInformation: FileTransportInfo): PromiseResult<boolean, ArchiveError>;
-}
+import { FileTransportInfo } from '../fileModel';
+import { ArchiveError } from '../errors';
+import { ResultAsync } from '../result';
+import { AbstractBaseArchive } from './abstract';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export declare class TarArchive extends AbstractBaseArchive {
+    static create(tarFileName: string, transferInformation: FileTransportInfo, needGZipCompression?: boolean): ResultAsync<boolean, ArchiveError>;
+    constructor(tarFilename: string);
+    fileExists(fileName: string): ResultAsync<boolean, ArchiveError>;
+    extractSingileFile(sourceEntryFullName: string, destinationFolderName: string): ResultAsync<boolean, ArchiveError>;
+    extractDirectory(sourceDirectory: string, destinationDirectory: string): ResultAsync<boolean, ArchiveError>;
+    extractAll(destinationDirectory: string): ResultAsync<boolean, ArchiveError>;
+    extract(transferInformation: FileTransportInfo): ResultAsync<boolean, ArchiveError>;
+}

package/lib/archive/tar.js

@@ -1,165 +1,128 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TarArchive = void 0;
-const path_1 = __importDefault(require("path"));
-const errors_1 = require("../errors");
-const result_1 = require("../result");
-// import tarStream from 'tar-stream';
-// import tar from 'tar-fs';
-const tar_1 = __importDefault(require("tar"));
-const abstract_1 = require("./abstract");
-/**
- * @remarks
- * This class (extract side) doesn't support stream based retrieval yet
- */
-class TarArchive extends abstract_1.AbstractBaseArchive {
-    static create(tarFileName, transferInformation, needGZipCompression = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let currentDirectory = path_1.default.dirname(transferInformation.sourceFullNameWithBasePath);
-            let targetPathForTar = transferInformation.sourceFullNameWithBasePath.substring(currentDirectory.length + path_1.default.sep.length);
-            // console.log('current', currentDirectory);
-            // console.log('target', targetPathForTar);
-            if (!transferInformation.isSourceDirectory) {
-                return (0, result_1.fail)('Single File is not supported', errors_1.ArchiveError);
-            }
-            let tarOptions;
-            tarOptions = {
-                file: tarFileName,
-                cwd: transferInformation.sourceFullNameWithBasePath,
-            };
-            if (needGZipCompression) {
-                tarOptions = {
-                    file: tarFileName,
-                    cwd: transferInformation.sourceFullNameWithBasePath,
-                    gzip: true,
-                };
-            }
-            return new Promise((resolve, reject) => {
-                let result;
-                if (!needGZipCompression) {
-                    result = tar_1.default.create({
-                        file: tarFileName,
-                        cwd: transferInformation.sourceFullNameWithBasePath,
-                    }, ['']);
-                }
-                else {
-                    result = tar_1.default.create({
-                        file: tarFileName,
-                        cwd: transferInformation.sourceFullNameWithBasePath,
-                        gzip: true,
-                    }, ['']);
-                }
-                result
-                    .then(() => {
-                    return resolve((0, result_1.success)(true));
-                })
-                    .catch((err) => {
-                    return resolve((0, result_1.fail)('Fail to Tar archive', errors_1.ArchiveError));
-                });
-            });
-        });
-    }
-    constructor(tarFilename) {
-        super(tarFilename);
-    }
-    fileExists(fileName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            fileName = this.__massageEntryPath(fileName);
-            let isExist = false;
-            const extract = yield tar_1.default.list({
-                file: this.archiveFileName,
-                onentry: (entry) => {
-                    if (entry.header.path === fileName)
-                        isExist = true;
-                },
-            });
-            return (0, result_1.success)(isExist);
-        });
-    }
-    extractSingileFile(sourceEntryFullName, destinationFolderName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const targetEntryName = this.__massageEntryPath(sourceEntryFullName);
-            const numPathElementToSkip = (targetEntryName.match(/\//g) || []).length;
-            this.__createDirectoryIfNotExist(destinationFolderName);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                yield tar_1.default
-                    .extract({
-                    cwd: destinationFolderName,
-                    file: this.archiveFileName,
-                    filter: (path, stat) => {
-                        return path === targetEntryName;
-                    },
-                    strip: numPathElementToSkip,
-                })
-                    .then(() => {
-                    return resolve((0, result_1.success)(true));
-                })
-                    .catch((reason) => {
-                    return resolve(new result_1.Failure(new errors_1.ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason)));
-                });
-            }));
-        });
-    }
-    extractDirectory(sourceDirectory, destinationDirectory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const targetEntryName = this.__massageEntryPath(sourceDirectory);
-            const numPathElementToSkip = !sourceDirectory
-                ? 0
-                : (targetEntryName.match(/\//g) || []).length + 1;
-            //let directoryName = path.dirname(destinationDirectory);
-            this.__createDirectoryIfNotExist(destinationDirectory);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                yield tar_1.default
-                    .extract({
-                    cwd: destinationDirectory,
-                    file: this.archiveFileName,
-                    filter: (path, stat) => {
-                        return !targetEntryName || path.startsWith(targetEntryName);
-                    },
-                    strip: numPathElementToSkip,
-                })
-                    .then(() => {
-                    resolve((0, result_1.success)(true));
-                })
-                    .catch((reason) => {
-                    resolve(new result_1.Failure(new errors_1.ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason)));
-                });
-            }));
-        });
-    }
-    extractAll(destinationDirectory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.extractDirectory('', destinationDirectory);
-        });
-    }
-    extract(transferInformation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //console.log('directory', directory);
-            const targetEntryName = this.__massageEntryPath(transferInformation.sourceFullName);
-            if (transferInformation.sourceFileName !==
-                transferInformation.destinationFileName)
-                return (0, result_1.fail)('Destination filename must be same as original filename', errors_1.ArchiveError);
-            //console.log('targetEntryName:', targetEntryName, ':');
-            //const directory = await unzipper.Open.file(this.zipFilename);
-            if (!transferInformation.isSourceDirectory) {
-                return yield this.extractSingileFile(transferInformation.sourceFullName, transferInformation.destinationPath);
-            }
-            else {
-                return yield this.extractDirectory(transferInformation.sourceFullName, transferInformation.destinationFullName);
-            }
-        });
-    }
-}
-exports.TarArchive = TarArchive;
+import { ArchiveError } from '../errors';
+//import { fail, Result, success, PromiseResult, Failure } from '../result';
+import { ResultAsync, errAsync, okAsync } from '../result';
+// import tarStream from 'tar-stream';
+// import tar from 'tar-fs';
+import * as tar from 'tar';
+import { AbstractBaseArchive } from './abstract';
+/**
+ * @remarks
+ * This class (extract side) doesn't support stream based retrieval yet
+ */
+export class TarArchive extends AbstractBaseArchive {
+    static create(tarFileName, transferInformation, needGZipCompression = false) {
+        // let currentDirectory = path.dirname(
+        //   transferInformation.sourceFullNameWithBasePath
+        // );
+        // let targetPathForTar =
+        //   transferInformation.sourceFullNameWithBasePath.substring(
+        //     currentDirectory.length + path.sep.length
+        //   );
+        // console.log('current', currentDirectory);
+        // console.log('target', targetPathForTar);
+        if (!transferInformation.isSourceDirectory) {
+            return errAsync(new ArchiveError('Single File is not supported'));
+        }
+        // let tarOptions: tar.CreateOptions & tar.FileOptions;
+        // tarOptions = {
+        //   file: tarFileName,
+        //   cwd: transferInformation.sourceFullNameWithBasePath,
+        // };
+        // if (needGZipCompression) {
+        //   tarOptions = {
+        //     file: tarFileName,
+        //     cwd: transferInformation.sourceFullNameWithBasePath,
+        //     gzip: true,
+        //   };
+        // }
+        return ResultAsync.fromSafePromise(new Promise((resolve, reject) => {
+            let result;
+            if (!needGZipCompression) {
+                result = tar.create({
+                    file: tarFileName,
+                    cwd: transferInformation.sourceFullNameWithBasePath,
+                }, ['']);
+            }
+            else {
+                result = tar.create({
+                    file: tarFileName,
+                    cwd: transferInformation.sourceFullNameWithBasePath,
+                    gzip: true,
+                }, ['']);
+            }
+            result
+                .then(() => {
+                return resolve(true);
+            })
+                .catch((err) => {
+                return reject(new ArchiveError('Fail to Tar archive', err));
+            });
+        }));
+    }
+    constructor(tarFilename) {
+        super(tarFilename);
+    }
+    fileExists(fileName) {
+        fileName = this.__massageEntryPath(fileName);
+        let isExist = false;
+        return ResultAsync.fromPromise(tar.list({
+            file: this.archiveFileName,
+            onentry: (entry) => {
+                if (entry.path === fileName)
+                    isExist = true;
+            },
+        }), () => new ArchiveError('Fail to list tar archive')).andThen(() => okAsync(isExist));
+    }
+    extractSingileFile(sourceEntryFullName, destinationFolderName) {
+        const targetEntryName = this.__massageEntryPath(sourceEntryFullName);
+        const numPathElementToSkip = (targetEntryName.match(/\//g) || []).length;
+        this.__createDirectoryIfNotExist(destinationFolderName);
+        return ResultAsync.fromSafePromise(tar
+            .extract({
+            cwd: destinationFolderName,
+            file: this.archiveFileName,
+            filter: (path) => path === targetEntryName,
+            strip: numPathElementToSkip,
+        })
+            .then(() => true)
+            .catch((reason) => {
+            throw new ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason);
+        }));
+    }
+    extractDirectory(sourceDirectory, destinationDirectory) {
+        const targetEntryName = this.__massageEntryPath(sourceDirectory);
+        const numPathElementToSkip = !sourceDirectory
+            ? 0
+            : (targetEntryName.match(/\//g) || []).length + 1;
+        //let directoryName = path.dirname(destinationDirectory);
+        this.__createDirectoryIfNotExist(destinationDirectory);
+        return ResultAsync.fromPromise(tar
+            .extract({
+            cwd: destinationDirectory,
+            file: this.archiveFileName,
+            filter: (path) => !targetEntryName || path.startsWith(targetEntryName),
+            strip: numPathElementToSkip,
+        })
+            .then(() => true), (reason) => new ArchiveError(`Fail to untar ${this.archiveFileName} -> ${targetEntryName}`, reason));
+    }
+    extractAll(destinationDirectory) {
+        return this.extractDirectory('', destinationDirectory);
+    }
+    extract(transferInformation) {
+        //console.log('directory', directory);
+        // const targetEntryName = this.__massageEntryPath(
+        //   transferInformation.sourceFullName
+        // );
+        if (transferInformation.sourceFileName !==
+            transferInformation.destinationFileName)
+            return errAsync(new ArchiveError('Destination filename must be same as original filename'));
+        //console.log('targetEntryName:', targetEntryName, ':');
+        //const directory = await unzipper.Open.file(this.zipFilename);
+        if (!transferInformation.isSourceDirectory) {
+            return this.extractSingileFile(transferInformation.sourceFullName, transferInformation.destinationPath);
+        }
+        else {
+            return this.extractDirectory(transferInformation.sourceFullName, transferInformation.destinationFullName);
+        }
+    }
+}