pwd-fs 3.1.3 → 3.1.4

package/lib/test/stat.spec.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('stat(src [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        const cwd = process.cwd();
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/digest/': { type: 'directory' },
+            './tmpdir/flexapp': {
+                type: 'symlink',
+                target: `${cwd}/tmpdir/tings.txt`
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must return information a file', async () => {
+        const stats = await src_1.pfs.stat('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(stats.isFile());
+    });
+    it('Positive: Must return information a directory', async () => {
+        const stats = await src_1.pfs.stat('./tmpdir/digest');
+        (0, node_assert_1.default)(stats.isDirectory());
+    });
+    it('Positive: Must return information a symlink', async () => {
+        const stats = await src_1.pfs.stat('./tmpdir/flexapp');
+        (0, node_assert_1.default)(stats.isSymbolicLink());
+    });
+    it('Negative: Throw if not exists resource', async () => {
+        const guid = chance.guid();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.stat(`./tmpdir/${guid}`);
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Must return information a file', () => {
+        const stats = src_1.pfs.stat('./tmpdir/tings.txt', {
+            sync: true
+        });
+        (0, node_assert_1.default)(stats.isFile());
+    });
+    it('[sync] Positive: Must return information a directory in ', () => {
+        const stats = src_1.pfs.stat('./tmpdir/digest', {
+            sync: true
+        });
+        (0, node_assert_1.default)(stats.isDirectory());
+    });
+    it('[sync] Positive: Must return information a symlink', () => {
+        const stats = src_1.pfs.stat('./tmpdir/flexapp', {
+            sync: true
+        });
+        (0, node_assert_1.default)(stats.isSymbolicLink());
+    });
+    it('[sync] Negative: Throw if not exists resource', () => {
+        const guid = chance.guid();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.stat(`./tmpdir/${guid}`, {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/symlink.spec.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('symlink(src, use [, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        const cwd = process.cwd();
+        const frame = {
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/digest/': { type: 'directory' },
+            './tmpdir/flexapp': {
+                type: 'symlink',
+                target: `${cwd}/tmpdir/tings.txt`
+            }
+        };
+        const counter = chance.natural({ max: 7 });
+        for (let i = 0; i < counter; i++) {
+            frame[`./tmpdir/${i}`] = { type: 'directory' };
+        }
+        (0, __fmock_1.fmock)(frame);
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must be created a symbolic link', async () => {
+        await src_1.pfs.symlink('./tmpdir/tings.txt', './tmpdir/linkapp');
+        const stat = node_fs_1.default.lstatSync('./tmpdir/linkapp');
+        (0, node_assert_1.default)(stat.isSymbolicLink());
+    });
+    it('Positive: Must be created a symbolic link for directory', async () => {
+        await src_1.pfs.symlink('./tmpdir/digest', './tmpdir/linkapp');
+        const stat = node_fs_1.default.lstatSync('./tmpdir/linkapp');
+        (0, node_assert_1.default)(stat.isSymbolicLink());
+    });
+    it('Negative: Throw if destination already exists', async () => {
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.symlink('./tmpdir/tings.txt', './tmpdir/flexapp');
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Must be created a symbolic link', () => {
+        src_1.pfs.symlink('./tmpdir/tings.txt', './tmpdir/linkapp', {
+            sync: true
+        });
+        const stat = node_fs_1.default.lstatSync('./tmpdir/linkapp');
+        (0, node_assert_1.default)(stat.isSymbolicLink());
+    });
+    it('[sync] Positive: Must be created a symbolic link for directory', () => {
+        src_1.pfs.symlink('./tmpdir/digest', './tmpdir/linkapp', {
+            sync: true
+        });
+        const stat = node_fs_1.default.lstatSync('./tmpdir/linkapp');
+        (0, node_assert_1.default)(stat.isSymbolicLink());
+    });
+    it('[sync] Negative: Throw if destination already exists', () => {
+        node_assert_1.default.throws(() => {
+            src_1.pfs.symlink('./tmpdir/tings.txt', './tmpdir/flexapp', {
+                sync: true
+            });
+        });
+    });
+});

package/lib/test/test.spec.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const chance_1 = __importDefault(require("chance"));
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('test(src[, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            },
+            './tmpdir/digest/': { type: 'directory' }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it(`Positive: Should return 'true' for current working directory`, async () => {
+        const exist = await src_1.pfs.test('.');
+        (0, node_assert_1.default)(exist);
+    });
+    it(`Positive: For existing file should return 'true'`, async () => {
+        const exist = await src_1.pfs.test('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(exist);
+    });
+    it(`Positive: For existing directory should return 'true'`, async () => {
+        const exist = await src_1.pfs.test('./tmpdir/digest');
+        (0, node_assert_1.default)(exist);
+    });
+    it(`Positive: A non-existent file must return 'false'`, async () => {
+        const guid = chance.guid();
+        const exist = await src_1.pfs.test(`./tmpdir/${guid}`);
+        (0, node_assert_1.default)(exist === false);
+    });
+    it(`Positive: For existing file should return 'true'`, () => {
+        const exist = src_1.pfs.test('./tmpdir/tings.txt', {
+            sync: true
+        });
+        (0, node_assert_1.default)(exist);
+    });
+    it(`[sync] Positive: For existing directory should return 'true'`, () => {
+        const exist = src_1.pfs.test('./tmpdir/digest', {
+            sync: true
+        });
+        (0, node_assert_1.default)(exist);
+    });
+    it(`[sync] Positive: A non-existent file must return 'false'`, () => {
+        const guid = chance.guid();
+        const exist = src_1.pfs.test(`./tmpdir/${guid}`, {
+            sync: true
+        });
+        (0, node_assert_1.default)(exist === false);
+    });
+});

package/lib/test/write.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const chance_1 = __importDefault(require("chance"));
+const expect_1 = require("expect");
+const __fmock_1 = require("./__fmock");
+const src_1 = require("../src");
+describe('write(src, data[, options])', () => {
+    const chance = new chance_1.default();
+    beforeEach(() => {
+        (0, __fmock_1.fmock)({
+            './tmpdir/tings.txt': {
+                type: 'file',
+                data: chance.string()
+            }
+        });
+    });
+    afterEach(() => {
+        (0, __fmock_1.restore)('./tmpdir');
+    });
+    it('Positive: Must write content to file', async () => {
+        const payload = chance.paragraph();
+        const guid = chance.guid();
+        await src_1.pfs.write(`./tmpdir/${guid}.txt`, payload);
+        const { size } = node_fs_1.default.lstatSync(`./tmpdir/${guid}.txt`);
+        (0, node_assert_1.default)(payload.length === size);
+    });
+    it('Positive: Must rewrite content if file already exists', async () => {
+        const payload = chance.paragraph();
+        await src_1.pfs.write('./tmpdir/tings.txt', payload);
+        const { size } = node_fs_1.default.lstatSync('./tmpdir/tings.txt');
+        (0, node_assert_1.default)(payload.length === size);
+    });
+    it('Negative: Throw if resource is directory', async () => {
+        const payload = chance.paragraph();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.write('./tmpdir', payload);
+        })
+            .rejects
+            .toThrow();
+    });
+    it(`Negative: Unexpected option 'flag' returns Error`, async () => {
+        const payload = chance.paragraph();
+        await (0, expect_1.expect)(async () => {
+            await src_1.pfs.write('./tmpdir/tings.txt', payload, {
+                flag: 'r'
+            });
+        })
+            .rejects
+            .toThrow();
+    });
+    it('[sync] Positive: Write contents even to a non-existent file', () => {
+        const payload = chance.paragraph();
+        const guid = chance.guid();
+        src_1.pfs.write(`./tmpdir/${guid}.txt`, payload, {
+            sync: true
+        });
+        const content = node_fs_1.default.readFileSync(`./tmpdir/${guid}.txt`, 'utf8');
+        (0, node_assert_1.default)(payload === content);
+    });
+    it('[sync] Negative: Throw if resource is directory', () => {
+        const payload = chance.paragraph();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.write('./tmpdir', payload, {
+                sync: true
+            });
+        });
+    });
+    it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+        const payload = chance.paragraph();
+        node_assert_1.default.throws(() => {
+            src_1.pfs.write('./tmpdir/tings.txt', payload, {
+                sync: true,
+                flag: 'r'
+            });
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pwd-fs",
-  "version": "3.1.3",
+  "version": "3.1.4",
   "description": "Extend the file system the capabilities of declaring the present working directory and recursive execution",
   "keywords": [
     "umask",
@@ -29,25 +29,18 @@
   "engines": {
     "node": ">=13.2.0"
   },
-  "type": "module",
-  "main": "./lib/index.js",
+  "main": "./lib/src/index.js",
   "types": "./lib/src/index.d.ts",
   "scripts": {
-    "build": "rollup -c",
-    "test": "jest"
+    "build": "tsc",
+    "test": "mocha ./lib/test"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^11.1.6",
     "@types/chance": "^1.1.6",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.12.7",
+    "@types/mocha": "^10.0.6",
     "chance": "^1.1.11",
-    "jest": "^29.7.0",
-    "rollup": "^4.14.3",
-    "ts-jest": "^29.1.2",
-    "ts-node": "^10.9.2",
-    "tslib": "^2.6.2",
+    "expect": "^29.7.0",
+    "mocha": "^10.4.0",
     "typescript": "^5.4.5"
   }
 }

package/readme.md

@@ -19,7 +19,7 @@ To improve reliability and maintainability the code is migrated to [TypeScript](
 To use `Powered File System` in your project, run:
 
 ```bash
-npm i pwd-fs
+npm install pwd-fs
 ```
 
 #### Table of Contents
@@ -63,19 +63,17 @@ This class implemented by following the [ECMAScript® 2018 Language Specificatio
 String form paths are interpreted as UTF-8 character sequences identifying the absolute or relative filename.
 
 ```ts
-import PoweredFileSystem from 'pwd-fs';
+import { pfs } from 'pwd-fs';
 
 /**
  * pfs.pwd === process.cwd()
  */
-
-const pfs = new PoweredFileSystem();
 ```
 
 Relative paths will be resolved relative to the current working directory as specified by `process.cwd()`:
 
 ```ts
-import PoweredFileSystem from 'pwd-fs';
+import { PoweredFileSystem } from 'pwd-fs';
 
 /**
  * pfs.pwd === `${process.cwd()}/foo/bar`
@@ -87,7 +85,7 @@ const pfs = new PoweredFileSystem('./foo/bar');
 Absolute paths:
 
 ```ts
-import PoweredFileSystem from 'pwd-fs';
+import { PoweredFileSystem } from 'pwd-fs';
 
 /**
  * pfs.pwd === __dirname
@@ -141,10 +139,12 @@ These functions return information about a resource in the file system.
 Asynchronously changes the permissions of a file.
 
 ```ts
+import { bitmask } from 'pwd-fs';
+
 await pfs.chmod('./path', 0o750);
 const { mode } = await pfs.stat('./path');
 
-console.log(PoweredFileSystem.bitmask(mode) === 0o750); // true
+console.log(bitmask(mode) === 0o750); // true
 ```
 
 > **Caveats:** on Windows only the write permission can be changed, and the distinction among the permissions of group, owner or others is not implemented.
@@ -194,10 +194,12 @@ See manuals [symlink(2)](http://man7.org/linux/man-pages/man2/symlink.2.html).
 Asynchronously recursively copy a file or directory.
 
 ```ts
+import { bitmask } from 'pwd-fs';
+
 await pfs.copy('./path/file.txt', './dist');
 const { mode } = await pfs.stat('./dist/path/file.txt');
 
-console.log(PoweredFileSystem.bitmask(mode) === 0o666); // true
+console.log(bitmask(mode) === 0o666); // true
 ```
 
 #### pfs.rename(src, use[, options])

package/src/index.ts

@@ -1,29 +1,7 @@
-import {
-  type Mode as TMode,
-  type Flag as TFlag,
-  type Stats as TStats,
-  PoweredFileSystem
-} from './powered-file-system';
+import { PoweredFileSystem } from './powered-file-system';
 
-export type Mode = TMode;
-export type Flag = TFlag;
-export type Stats = TStats;
+export const pfs = new PoweredFileSystem();
 
-// const pfs = new PoweredFileSystem();
+export default PoweredFileSystem;
 
-// export const test = pfs.test;
-// export const stat = pfs.stat;
-// export const chmod = pfs.chmod;
-// export const chown = pfs.chown;
-// export const symlink = pfs.symlink;
-// export const copy = pfs.copy;
-// export const rename = pfs.rename;
-// export const remove = pfs.remove;
-// export const read = pfs.read;
-// export const write = pfs.write;
-// export const append = pfs.append;
-// export const readdir = pfs.readdir;
-// export const mkdir = pfs.mkdir;
-
-export const bitmask = PoweredFileSystem.bitmask;
-export default PoweredFileSystem;
+export * from './powered-file-system';

package/src/powered-file-system.ts

@@ -26,6 +26,26 @@ const permissions: number[] = [
   0o001  // OTHERS_EXECUTE
 ];
 
+export function bitmask(mode: number) {
+  const type = typeof mode;
+
+  if (type !== 'number') {
+    throw new Error(
+      `Argument of type '${type}' is not assignable to parameter of type 'number'.`
+    );
+  }
+
+  let umask = 0o000;
+
+  for (const flag of permissions) {
+    if (mode & flag) {
+      umask += flag;
+    }
+  }
+
+  return umask;
+}
+
 export class PoweredFileSystem {
   readonly pwd: string;
 
@@ -36,6 +56,8 @@ export class PoweredFileSystem {
     x: fs.constants.X_OK
   };
 
+  static bitmask = bitmask;
+
   constructor(pwd?: string) {
     this.pwd = pwd ? path.resolve(pwd) : process.cwd();
   }
@@ -43,26 +65,6 @@ export class PoweredFileSystem {
   private resolve(src: string) {
     return path.resolve(this.pwd, src);
   }
-  
-  static bitmask(mode: number) {
-    const type = typeof mode;
-
-    if (type !== 'number') {
-      throw new Error(
-        `Argument of type '${type}' is not assignable to parameter of type 'number'.`
-      );
-    }
-
-    let umask = 0o000;
-
-    for (const flag of permissions) {
-      if (mode & flag) {
-        umask += flag;
-      }
-    }
-
-    return umask;
-  }
 
   test(src: string, options: {
     sync: true,

package/{__tests__ → test}/append.spec.ts

@@ -1,12 +1,11 @@
 import assert from 'node:assert';
-import { sep } from 'node:path';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { pfs } from '../src';
 
 describe('append(src, data [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
 
   beforeEach(() => {

package/{__tests__ → test}/chmod.spec.ts

@@ -1,12 +1,11 @@
 import assert from 'node:assert';
-import { sep } from 'node:path';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem, { bitmask } from '../src';
+import { pfs, bitmask } from '../src';
 
 describe('chmod(src, mode [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
 
   beforeEach(() => {

package/{__tests__ → test}/chown.spec.ts

@@ -1,11 +1,11 @@
 import assert from 'node:assert';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { pfs } from '../src';
 
 describe('chown(src, uid, gid [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
 
   beforeEach(() => {
@@ -25,7 +25,6 @@ describe('chown(src, uid, gid [, options])', () => {
   
   it('Positive: Changes the permissions of a file', async () => {
     const { uid, gid } = fs.statSync('./tmpdir/tings.txt');
-    
     await pfs.chown('./tmpdir/tings.txt', uid, gid);
 
     assert(uid && gid);
@@ -34,7 +33,6 @@ describe('chown(src, uid, gid [, options])', () => {
   
   it('Positive: Changes the permissions of a directory', async () => {
     const { uid, gid } = fs.statSync('./tmpdir/digest');
-
     await pfs.chown('./tmpdir/digest', uid, gid);
 
     assert(uid && gid);

package/{__tests__ → test}/constructor.spec.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import PoweredFileSystem from '../src';
+import { PoweredFileSystem } from '../src';
 
 describe('#constructor: new PoweredFileSystem(pwd?)', () => {
   it('Positive: An empty path must match the context of the cwd', () => {

package/{__tests__ → test}/copy.spec.ts

@@ -1,12 +1,11 @@
 import assert from 'node:assert';
-import { sep } from 'node:path';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem, { bitmask } from '../src';
+import { pfs } from '../src';
 
 describe('copy(src, dir [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
   
   beforeEach(() => {

package/{__tests__ → test}/mkdir.spec.ts

@@ -1,8 +1,9 @@
 import assert from 'node:assert';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { PoweredFileSystem } from '../src';
 
 describe('mkdir(src [, options])', () => {
   const pfs = new PoweredFileSystem();

package/{__tests__ → test}/read.spec.ts

@@ -1,11 +1,10 @@
 import assert from 'node:assert';
-import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { pfs } from '../src';
 
 describe('read(src [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
   let sentences = 0;
 

package/{__tests__ → test}/readdir.spec.ts

@@ -1,11 +1,10 @@
 import assert from 'node:assert';
-import fs from 'node:fs';
 import Chance  from 'chance';
-import { type Iframe, fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { Iframe, fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('readdir(src[, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
   let counter = 0;
 

package/{__tests__ → test}/remove.spec.ts

@@ -1,11 +1,11 @@
 import assert from 'node:assert';
 import fs from 'node:fs';
 import Chance  from 'chance';
-import { type Iframe, fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { Iframe, fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('remove(src [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
   
   beforeEach(() => {

package/{__tests__ → test}/rename.spec.ts

@@ -1,11 +1,11 @@
 import assert from 'node:assert';
 import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import {pfs } from '../src';
 
 describe('rename(src, use [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
 
   beforeEach(() => {

package/{__tests__ → test}/stat.spec.ts

@@ -1,11 +1,10 @@
 import assert from 'node:assert';
-import fs from 'node:fs';
 import Chance  from 'chance';
+import { expect } from 'expect';
 import { fmock, restore } from './__fmock';
-import PoweredFileSystem from '../src';
+import { pfs } from '../src';
 
 describe('stat(src [, options])', () => {
-  const pfs = new PoweredFileSystem();
   const chance = new Chance();
 
   beforeEach(() => {