pwd-fs 2.4.2 → 3.1.4

package/src/recurse-io.ts

@@ -1,234 +1,239 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 
-type Files = Array<string>
+export type Files = Array<string>;
+export type NoParamCallback = fs.NoParamCallback;
 
-const {sep} = path;
+const { sep } = path;
 
-export default {
-  chmod(src: string, mode: number, callback: fs.NoParamCallback): void {
-    let reduce = 0;
-
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
-          if (err) {
-            return callback(err);
-          }
+function chmod(src: string, mode: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-          if (list.length === 0) {
-            return fs.chmod(src, mode, callback);
-          }
+  fs.stat(src, (err, stat) => {
+    if (err) {
+      return callback(err);
+    }
 
-          reduce += list.length;
+    if (stat.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-          for (const loc of list) {
-            this.chmod(`${src}${sep}${loc}`, mode, (err) => {
-              if (err) {
-                return callback(err);
-              }
+        if (list.length === 0) {
+          return fs.chmod(src, mode, callback);
+        }
 
-              if (--reduce === 0) {
-                fs.chmod(src, mode, callback);
-              }
-            });
-          }
-        });
-      }
-      else {
-        fs.chmod(src, mode, callback);
-      }
-    });
-  },
-
-  chown(src: string, uid: number, gid: number, callback: fs.NoParamCallback): void {
-    let reduce = 0;
-
-    fs.stat(src, (err, stats) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (stats.isDirectory()) {
-        fs.readdir(src, (err, list) => {
-          if (err) {
-            return callback(err);
-          }
+        reduce += list.length;
 
-          if (list.length === 0) {
-            return fs.chown(src, uid, gid, callback);
-          }
+        for (const loc of list) {
+          chmod(`${src}${sep}${loc}`, mode, (err) => {
+            if (err) {
+              return callback(err);
+            }
 
-          reduce += list.length;
+            if (--reduce === 0) {
+              fs.chmod(src, mode, callback);
+            }
+          });
+        }
+      });
+    }
+    else {
+      fs.chmod(src, mode, callback);
+    }
+  });
+}
 
-          for (const loc of list) {
-            this.chown(`${src}${sep}${loc}`, uid, gid, (err) => {
-              if (err) {
-                return callback(err);
-              }
+function chown(src: string, uid: number, gid: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-              if (--reduce === 0) {
-                fs.chown(src, uid, gid, callback);
-              }
-            });
-          }
-        });
-      }
-      else {
-        fs.chown(src, uid, gid, callback);
-      }
-    });
-  },
-
-  copy(src: string, dir: string, umask: number, callback: fs.NoParamCallback): void {
-    let reduce = 0;
-
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
-
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
-          if (err) {
-            return callback(err);
-          }
+  fs.stat(src, (err, stats) => {
+    if (err) {
+      return callback(err);
+    }
 
-          reduce += list.length;
+    if (stats.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-          const paths = src.split(sep);
-          const loc = paths[paths.length - 1];
-          const mode = 0o777 - umask;
+        if (list.length === 0) {
+          return fs.chown(src, uid, gid, callback);
+        }
 
-          dir = `${dir}${sep}${loc}`;
+        reduce += list.length;
 
-          fs.mkdir(dir, { mode }, (err) => {
+        for (const loc of list) {
+          chown(`${src}${sep}${loc}`, uid, gid, (err) => {
             if (err) {
               return callback(err);
             }
 
-            if (reduce === 0) {
-              return callback(null);
-            }
-
-            for (const loc of list) {
-              this.copy(`${src}${sep}${loc}`, dir, umask, (err) => {
-                if (err) {
-                  return callback(err);
-                }
-
-                if (--reduce === 0) {
-                  callback(null);
-                }
-              });
+            if (--reduce === 0) {
+              fs.chown(src, uid, gid, callback);
             }
           });
-        });
-      }
-      else {
-        const mode = 0o666 - umask;
-        const loc = path.basename(src);
-
-        const readStream = fs.createReadStream(src);
-        const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
-          mode
-        });
+        }
+      });
+    }
+    else {
+      fs.chown(src, uid, gid, callback);
+    }
+  });
+}
 
-        readStream.on('error', callback);
-        writeStream.on('error', callback);
+function copy(src: string, dir: string, umask: number, callback: NoParamCallback) {
+  let reduce = 0;
 
-        writeStream.on('close', () => {
-          callback(null);
-        });
+  fs.stat(src, (err, stat) => {
+    if (err) {
+      return callback(err);
+    }
 
-        readStream.pipe(writeStream);
-      }
-    });
-  },
+    if (stat.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
 
-  remove(src: string, callback: fs.NoParamCallback): void {
-    let reduce = 0;
+        reduce += list.length;
 
-    fs.stat(src, (err, stat) => {
-      if (err) {
-        return callback(err);
-      }
+        const paths = src.split(sep);
+        const loc = paths[paths.length - 1];
+        const mode = 0o777 - umask;
 
-      if (stat.isDirectory()) {
-        fs.readdir(src, (err, list) => {
+        dir = `${dir}${sep}${loc}`;
+
+        fs.mkdir(dir, { mode }, (err) => {
           if (err) {
             return callback(err);
           }
 
-          if (list.length === 0) {
-            return fs.rmdir(src, callback);
+          if (reduce === 0) {
+            return callback(null);
           }
 
-          reduce += list.length;
-
           for (const loc of list) {
-            this.remove(`${src}${sep}${loc}`, (err) => {
+            copy(`${src}${sep}${loc}`, dir, umask, (err) => {
               if (err) {
                 return callback(err);
               }
 
               if (--reduce === 0) {
-                fs.rmdir(src, callback);
+                callback(null);
               }
             });
           }
         });
-      }
-      else {
-        fs.unlink(src, callback);
-      }
-    });
-  },
-
-  mkdir(dir: string, umask: number, callback: fs.NoParamCallback): void {
-    const cwd = process.cwd();
-
-    if (dir === cwd) {
-      return callback(null);
+      });
     }
+    else {
+      const mode = 0o666 - umask;
+      const loc = path.basename(src);
 
-    const sequence = function* (dir: string, files: Files, mode: number): Generator<void, void, Generator> {
-      const iter = yield;
+      const readStream = fs.createReadStream(src);
+      const writeStream = fs.createWriteStream(`${dir}${sep}${loc}`, {
+        mode
+      });
 
-      for (const item of files) {
-        dir += `${sep}${item}`;
+      readStream.on('error', callback);
+      writeStream.on('error', callback);
 
-        fs.mkdir(dir, { mode }, (err) => {
-          if (err && err.errno !== -17) {
-            return callback(err);
-          }
+      writeStream.on('close', () => {
+        callback(null);
+      });
 
-          iter.next();
-        });
+      readStream.pipe(writeStream);
+    }
+  });
+}
+
+function remove(src: string, callback: NoParamCallback) {
+  fs.stat(src, (err, stat) => {
+    if (err) {
+      return callback(err);
+    }
+
+    if (stat.isDirectory()) {
+      fs.readdir(src, (err, list) => {
+        if (err) {
+          return callback(err);
+        }
+        
+        let reduce = list.length;
 
-        yield;
-      }
+        if (reduce === 0) {
+          return fs.rmdir(src, callback);
+        }
 
-      callback(null);
-    };
+        for (const loc of list) {
+          remove(`${src}${sep}${loc}`, (err) => {
+            if (err) {
+              return callback(err);
+            }
 
-    let use = '';
+            if (--reduce === 0) {
+              fs.rmdir(src, callback);
+            }
+          });
+        }
+      });
+    }
+    else {
+      fs.unlink(src, callback);
+    }
+  });
+}
+
+function mkdir(dir: string, umask: number, callback: NoParamCallback) {
+  const cwd = process.cwd();
+
+  if (dir === cwd) {
+    return callback(null);
+  }
 
-    if (dir.indexOf(cwd) === 0) {
-      use = cwd;
-      dir = dir.substr(cwd.length);
+  const sequence = function* (dir: string, files: Files, mode: number): Generator<void, void, Generator> {
+    const iter = yield;
+
+    for (const item of files) {
+      dir += `${sep}${item}`;
+
+      fs.mkdir(dir, { mode }, (err) => {
+        if (err && err.errno !== -17) {
+          return callback(err);
+        }
+
+        iter.next();
+      });
+
+      yield;
     }
 
-    const files = dir.split(sep);
-    const mode = 0o777 - umask;
+    callback(null);
+  };
 
-    const iter = sequence(use, files, mode);
+  let use = '';
 
-    iter.next();
-    iter.next(iter);
+  if (dir.indexOf(cwd) === 0) {
+    use = cwd;
+    dir = dir.substr(cwd.length);
   }
+
+  const files = dir.split(sep);
+  const mode = 0o777 - umask;
+
+  const iter = sequence(use, files, mode);
+
+  iter.next();
+  iter.next(iter);
+}
+
+export default {
+  chmod,
+  chown,
+  copy,
+  remove,
+  mkdir
 }

package/test/__fmock.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export interface Iframe {
+  [key: string]: any
+}
+
+export function fmock(frame: Iframe) {  
+  for (const src of Object.keys(frame)) {
+    const { dir } = path.parse(src);
+    const value = frame[src];
+
+    fs.mkdirSync(dir, { recursive: true });
+    
+    if (value.type === 'directory') {
+      fs.mkdirSync(src);
+    }
+    
+    if (value.type === 'file') {
+      fs.writeFileSync(src, value.data);
+    }
+    
+    if (value.type === 'symlink') {
+      fs.symlinkSync(value.target, src);
+    }
+  }
+}
+
+export function restore(tmpDir: string) {
+  const removeRecursive = (src: string) => {
+    if (fs.existsSync(src)) {
+      fs.readdirSync(src).forEach((item) => {
+        const curl = `${src}/${item}`;
+
+        fs.lstatSync(curl).isDirectory()
+          ? removeRecursive(curl)
+          : fs.unlinkSync(curl);
+      });
+
+      fs.rmdirSync(src);
+    }
+  };
+
+  removeRecursive(tmpDir);
+}

package/test/append.spec.ts

@@ -1,125 +1,71 @@
-import assert from 'assert';
-import { sep } from 'path';
-import mockFs from 'mock-fs';
+import assert from 'node:assert';
+import fs from 'node:fs';
 import Chance  from 'chance';
-import PoweredFileSystem from '../src';
+import { expect } from 'expect';
+import { fmock, restore } from './__fmock';
+import { pfs } from '../src';
 
 describe('append(src, data [, options])', () => {
-  beforeEach(() => {
-    const chance = new Chance();
+  const chance = new Chance();
 
-    mockFs({
-      'tmpdir': {
-        'binapp': chance.string(),
-        'libxbase': mockFs.directory()
-      },
-      'flexapp': mockFs.symlink({
-        path: 'tmpdir/binapp'
-      })
+  beforeEach(() => {
+    fmock({
+      './tmpdir/tings.txt': {
+        type: 'file',
+        data: 'hoodie'
+      }
     });
   });
+  
+  afterEach(() => {
+    restore('./tmpdir');
+  });
 
-  afterEach(mockFs.restore);
 
   it('Positive: Must append content to file', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
+    const payload = chance.paragraph();
 
-    const before = await pfs.stat('./tmpdir/binapp');
+    await pfs.append('./tmpdir/tings.txt', payload);
+    const { size } = fs.statSync('./tmpdir/tings.txt');
 
-    const payload = chance.string();
-    await pfs.append('./tmpdir/binapp', payload);
-
-    const after = await pfs.stat('./tmpdir/binapp');
-
-    assert(after.size > before.size);
+    assert(payload.length + 6 === size);
   });
 
-  it('Positive: Must append content to file when path is absolute', async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    const before = await pfs.stat('./tmpdir/binapp');
-
-    const cwd = process.cwd();
-    const payload = chance.string();
-
-    await pfs.append(`${cwd}${sep}tmpdir${sep}binapp`, payload, {
-      resolve: false
-    });
-
-    const after = await pfs.stat('./tmpdir/binapp');
-
-    assert(after.size > before.size);
-  });
 
   it(`Negative: Unexpected option 'flag' returns Error`, async () => {
-    const pfs = new PoweredFileSystem();
-    const chance = new Chance();
-
-    try {
-      const payload = chance.string();
-
-      await pfs.append('./tmpdir/binapp', payload, {
+    const payload = chance.paragraph();
+    
+    await expect(async () => {
+      await pfs.append('./tmpdir/tings.txt', payload, {
         flag: 'r'
       });
-    }
-    catch (err) {
-      assert(err.errno === -9);
-    }
+    })
+    .rejects
+    .toThrow();
   });
+  
+  
+  it(`[sync] Positive: Must append content to file`, () => {
+    const payload = chance.paragraph();
 
-  describe('sync mode', () => {
-    it(`Positive: Must append content to file`, async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      const before = await pfs.stat('./tmpdir/binapp');
-      const payload = chance.string();
-
-      pfs.append('./tmpdir/binapp', payload, {
-        sync: true
-      });
-
-      const after = await pfs.stat('./tmpdir/binapp');
-
-      assert(after.size > before.size);
+    pfs.append('./tmpdir/tings.txt', payload, {
+      sync: true
     });
 
-    it('Positive: Must append content to file when path is absolute', async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
+    const { size } = fs.statSync('./tmpdir/tings.txt');
 
-      const before = await pfs.stat('./tmpdir/binapp');
-
-      const cwd = process.cwd();
-      const payload = chance.string();
-
-      pfs.append(`${cwd}${sep}tmpdir${sep}binapp`, payload, {
+    assert(payload.length + 6 === size);
+  });
+  
+  
+  it(`[sync] Negative: Unexpected option 'flag' returns Error`, () => {
+    const payload = chance.paragraph();
+    
+    assert.throws(() => {
+      pfs.append('./tmpdir/tings.txt', payload, {
         sync: true,
-        resolve: false
+        flag: 'r'
       });
-
-      const after = await pfs.stat('./tmpdir/binapp');
-
-      assert(after.size > before.size);
-    });
-
-    it(`Negative: Unexpected option 'flag' returns Error`, async () => {
-      const pfs = new PoweredFileSystem();
-      const chance = new Chance();
-
-      try {
-        const payload = chance.string();
-
-        pfs.append('./tmpdir/binapp', payload, {
-          sync: true,
-          flag: 'r'
-        });
-      }
-      catch (err) {
-        assert(err.errno === -9);
-      }
     });
   });
 });

package/test/bitmask.spec.ts

@@ -1,26 +1,23 @@
-import assert from 'assert';
-import PoweredFileSystem from '../src';
+import assert from 'node:assert';
+import { bitmask } from '../src';
 
 describe('static bitmask(mode: number)', () => {
   it('Positive: Calculate bitmask', () => {
-    assert(PoweredFileSystem.bitmask(33024) === 0o400); // (r--------)
-    assert(PoweredFileSystem.bitmask(33152) === 0o600); // (rw-------)
-    assert(PoweredFileSystem.bitmask(33216) === 0o700); // (rwx------)
-    assert(PoweredFileSystem.bitmask(32800) === 0o040); // (---r-----)
-    assert(PoweredFileSystem.bitmask(32816) === 0o060); // (---rw----)
-    assert(PoweredFileSystem.bitmask(32824) === 0o070); // (---rwx---)
-    assert(PoweredFileSystem.bitmask(32772) === 0o004); // (------r--)
-    assert(PoweredFileSystem.bitmask(32774) === 0o006); // (------rw-)
-    assert(PoweredFileSystem.bitmask(32775) === 0o007); // (------rwx)
+    assert(bitmask(33024) === 0o400); // (r--------)
+    assert(bitmask(33152) === 0o600); // (rw-------)
+    assert(bitmask(33216) === 0o700); // (rwx------)
+    assert(bitmask(32800) === 0o040); // (---r-----)
+    assert(bitmask(32816) === 0o060); // (---rw----)
+    assert(bitmask(32824) === 0o070); // (---rwx---)
+    assert(bitmask(32772) === 0o004); // (------r--)
+    assert(bitmask(32774) === 0o006); // (------rw-)
+    assert(bitmask(32775) === 0o007); // (------rwx)
   });
 
   it(`Negative: Throw an exception if the argument is 'null' type`, () => {
-    try {
+    assert.throws(() => {
       // @ts-ignore
-      PoweredFileSystem.bitmask(null);
-    }
-    catch (err) {
-      assert(err);
-    }
+      bitmask(null);
+    });
   });
 });