@gjsify/fs 0.1.15 → 0.3.0

package/src/dir.spec.ts

@@ -0,0 +1,204 @@
+// Ported from refs/bun/test/js/node/fs/dir.test.ts
+// Original: MIT, Oven & contributors.
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+
+import { describe, it, expect } from '@gjsify/unit';
+import {
+  Dir,
+  opendirSync,
+  opendir,
+  promises,
+  mkdirSync,
+  writeFileSync,
+  mkdtempSync,
+  rmSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+function makeTmp(): string {
+  return mkdtempSync(join(tmpdir(), 'gjsify-dir-'));
+}
+
+export default async () => {
+  await describe('fs.opendirSync', async () => {
+    await it('returns a Dir instance', async () => {
+      const tmp = makeTmp();
+      const dir = opendirSync(tmp);
+      expect(dir).toBeDefined();
+      expect(dir instanceof Dir).toBe(true);
+      dir.closeSync();
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('dir.path reflects the opened path', async () => {
+      const tmp = makeTmp();
+      const dir = opendirSync(tmp);
+      expect(dir.path).toBe(tmp);
+      dir.closeSync();
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('readSync returns null on empty directory', async () => {
+      const tmp = makeTmp();
+      const dir = opendirSync(tmp);
+      const entry = dir.readSync();
+      expect(entry).toBeNull();
+      dir.closeSync();
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('readSync returns Dirent entries for directory contents', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'a.txt'), 'a');
+      writeFileSync(join(tmp, 'b.txt'), 'b');
+
+      const dir = opendirSync(tmp);
+      const names: string[] = [];
+      let entry = dir.readSync();
+      while (entry !== null) {
+        names.push(entry.name);
+        entry = dir.readSync();
+      }
+      dir.closeSync();
+
+      expect(names.sort()).toStrictEqual(['a.txt', 'b.txt']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('Dirent has correct type flags', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'file.txt'), 'x');
+      mkdirSync(join(tmp, 'subdir'));
+
+      const dir = opendirSync(tmp);
+      const entries: { name: string; isFile: boolean; isDirectory: boolean }[] = [];
+      let entry = dir.readSync();
+      while (entry !== null) {
+        entries.push({ name: entry.name, isFile: entry.isFile(), isDirectory: entry.isDirectory() });
+        entry = dir.readSync();
+      }
+      dir.closeSync();
+
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      expect(entries).toStrictEqual([
+        { name: 'file.txt', isFile: true, isDirectory: false },
+        { name: 'subdir', isFile: false, isDirectory: true },
+      ]);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('closeSync throws after close', async () => {
+      const tmp = makeTmp();
+      const dir = opendirSync(tmp);
+      dir.closeSync();
+
+      let threw = false;
+      try {
+        dir.closeSync();
+      } catch (e: any) {
+        threw = true;
+        expect(e.code).toBe('ERR_DIR_CLOSED');
+      }
+      expect(threw).toBe(true);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('readSync throws after close', async () => {
+      const tmp = makeTmp();
+      const dir = opendirSync(tmp);
+      dir.closeSync();
+
+      let threw = false;
+      try {
+        dir.readSync();
+      } catch (e: any) {
+        threw = true;
+        expect(e.code).toBe('ERR_DIR_CLOSED');
+      }
+      expect(threw).toBe(true);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('read() returns Dirent or null asynchronously', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'hello.txt'), 'hi');
+
+      const dir = opendirSync(tmp);
+      const entry = await dir.read();
+      expect(entry).toBeDefined();
+      expect(entry!.name).toBe('hello.txt');
+
+      const next = await dir.read();
+      expect(next).toBeNull();
+      await dir.close();
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('[Symbol.asyncIterator] iterates all entries', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'x.ts'), '');
+      writeFileSync(join(tmp, 'y.ts'), '');
+
+      const dir = opendirSync(tmp);
+      const names: string[] = [];
+      for await (const entry of dir) {
+        names.push(entry.name);
+      }
+
+      expect(names.sort()).toStrictEqual(['x.ts', 'y.ts']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+  });
+
+  await describe('fs.opendir (callback)', async () => {
+    await it('opens directory and returns Dir instance via callback', async () => {
+      const tmp = makeTmp();
+      await new Promise<void>((resolve, reject) => {
+        opendir(tmp, (err, dir) => {
+          if (err) return reject(err);
+          expect(dir instanceof Dir).toBe(true);
+          expect(dir.path).toBe(tmp);
+          dir.closeSync();
+          rmSync(tmp, { recursive: true, force: true });
+          resolve();
+        });
+      });
+    });
+
+    await it('throws if callback is not a function', async () => {
+      let threw = false;
+      try {
+        (opendir as any)('/tmp');
+      } catch (e: any) {
+        threw = true;
+      }
+      expect(threw).toBe(true);
+    });
+  });
+
+  await describe('fs.promises.opendir', async () => {
+    await it('opens directory and returns Dir instance', async () => {
+      const tmp = makeTmp();
+      const dir = await promises.opendir(tmp);
+      expect(dir instanceof Dir).toBe(true);
+      await dir.close();
+      rmSync(tmp, { recursive: true, force: true });
+    });
+
+    await it('async iterates directory entries', async () => {
+      const tmp = makeTmp();
+      writeFileSync(join(tmp, 'alpha.txt'), '');
+      writeFileSync(join(tmp, 'beta.txt'), '');
+
+      const dir = await promises.opendir(tmp);
+      const names: string[] = [];
+      for await (const entry of dir) {
+        names.push(entry.name);
+      }
+
+      expect(names.sort()).toStrictEqual(['alpha.txt', 'beta.txt']);
+      rmSync(tmp, { recursive: true, force: true });
+    });
+  });
+};

package/src/dir.ts

@@ -0,0 +1,199 @@
+// Reference: Node.js lib/internal/fs/dir.js
+// Reimplemented for GJS using Gio.FileEnumerator
+
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+import { normalizePath } from './utils.js';
+import { Dirent } from './dirent.js';
+import { createNodeError } from './errors.js';
+import type { PathLike } from 'node:fs';
+
+const DIR_ATTRS = 'standard::name,standard::type,standard::is-symlink,standard::size,standard::symlink-target,unix::uid,unix::gid,unix::mode,time::modified,time::access,time::created';
+
+export class Dir {
+  readonly path: string;
+  private _enumerator: Gio.FileEnumerator | null;
+  private _closed = false;
+
+  constructor(path: string, enumerator: Gio.FileEnumerator) {
+    this.path = path;
+    this._enumerator = enumerator;
+  }
+
+  private _assertOpen(): void {
+    if (this._closed) {
+      const err = new Error('Directory handle was closed') as NodeJS.ErrnoException;
+      err.code = 'ERR_DIR_CLOSED';
+      throw err;
+    }
+  }
+
+  readSync(): Dirent | null {
+    this._assertOpen();
+    try {
+      const info = this._enumerator!.next_file(null);
+      if (info === null) return null;
+      const name = info.get_name();
+      const fileType = info.get_file_type();
+      const childPath = this.path.endsWith('/') ? this.path + name : this.path + '/' + name;
+      return new Dirent(childPath, name, fileType);
+    } catch (err: unknown) {
+      throw createNodeError(err, 'readdir', this.path);
+    }
+  }
+
+  read(): Promise<Dirent | null>;
+  read(callback: (err: NodeJS.ErrnoException | null, dirent: Dirent | null) => void): void;
+  read(callback?: (err: NodeJS.ErrnoException | null, dirent: Dirent | null) => void): Promise<Dirent | null> | void {
+    if (callback !== undefined) {
+      if (typeof callback !== 'function') {
+        throw new TypeError('The "callback" argument must be of type function');
+      }
+      try {
+        this._assertOpen();
+        const dirent = this.readSync();
+        Promise.resolve().then(() => callback(null, dirent));
+      } catch (err: unknown) {
+        Promise.resolve().then(() => callback(err as NodeJS.ErrnoException, null));
+      }
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        this._assertOpen();
+        resolve(this.readSync());
+      } catch (err: unknown) {
+        reject(err);
+      }
+    });
+  }
+
+  closeSync(): void {
+    this._assertOpen();
+    this._closed = true;
+    try {
+      this._enumerator!.close(null);
+    } catch {
+      // ignore close errors
+    }
+    this._enumerator = null;
+  }
+
+  close(): Promise<void>;
+  close(callback: (err: NodeJS.ErrnoException | null) => void): void;
+  close(callback?: (err: NodeJS.ErrnoException | null) => void): Promise<void> | void {
+    if (callback !== undefined) {
+      if (typeof callback !== 'function') {
+        throw new TypeError('The "callback" argument must be of type function');
+      }
+      try {
+        this.closeSync();
+        Promise.resolve().then(() => callback(null));
+      } catch (err: unknown) {
+        Promise.resolve().then(() => callback(err as NodeJS.ErrnoException));
+      }
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        this.closeSync();
+        resolve();
+      } catch (err: unknown) {
+        reject(err);
+      }
+    });
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterableIterator<Dirent> {
+    try {
+      while (true) {
+        const dirent = await this.read();
+        if (dirent === null) break;
+        yield dirent;
+      }
+    } finally {
+      if (!this._closed) {
+        await this.close();
+      }
+    }
+  }
+}
+
+function _openDir(pathStr: string): Dir {
+  const file = Gio.File.new_for_path(pathStr);
+  let enumerator: Gio.FileEnumerator;
+  try {
+    enumerator = file.enumerate_children(DIR_ATTRS, Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
+  } catch (err: unknown) {
+    throw createNodeError(err, 'opendir', pathStr);
+  }
+  return new Dir(pathStr, enumerator);
+}
+
+export function opendirSync(path: PathLike): Dir {
+  return _openDir(normalizePath(path));
+}
+
+export function opendir(
+  path: PathLike,
+  callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
+): void;
+export function opendir(
+  path: PathLike,
+  options: { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean },
+  callback: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
+): void;
+export function opendir(
+  path: PathLike,
+  optionsOrCallback:
+    | { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean }
+    | ((err: NodeJS.ErrnoException | null, dir: Dir) => void),
+  callback?: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
+): void {
+  let cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void;
+  if (typeof optionsOrCallback === 'function') {
+    cb = optionsOrCallback;
+  } else {
+    cb = callback!;
+  }
+
+  if (typeof cb !== 'function') {
+    throw new TypeError('The "callback" argument must be of type function');
+  }
+
+  Promise.resolve().then(() => {
+    try {
+      const dir = opendirSync(path);
+      cb(null, dir);
+    } catch (err: unknown) {
+      cb(err as NodeJS.ErrnoException, null as unknown as Dir);
+    }
+  });
+}
+
+// promises.opendir
+export async function opendirAsync(
+  path: PathLike,
+  _options?: { encoding?: BufferEncoding | null; bufferSize?: number; recursive?: boolean },
+): Promise<Dir> {
+  return new Promise<Dir>((resolve, reject) => {
+    const pathStr = normalizePath(path);
+    const file = Gio.File.new_for_path(pathStr);
+    file.enumerate_children_async(
+      DIR_ATTRS,
+      Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+      GLib.PRIORITY_DEFAULT,
+      null,
+      (_source: unknown, result: Gio.AsyncResult) => {
+        try {
+          const enumerator = file.enumerate_children_finish(result);
+          resolve(new Dir(pathStr, enumerator));
+        } catch (err: unknown) {
+          reject(createNodeError(err, 'opendir', pathStr));
+        }
+      },
+    );
+  });
+}

package/src/fd-ops.spec.ts

@@ -0,0 +1,234 @@
+// Ported from refs/node-test/parallel/test-fs-read-sync.js + test-fs-write-sync.js (behavior)
+// Original: MIT, Node.js contributors.
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+
+import { describe, it, expect } from '@gjsify/unit';
+import {
+  openSync, closeSync,
+  fstatSync, fstat,
+  ftruncateSync,
+  fdatasync, fsync,
+  fchmodSync,
+  readSync, writeSync,
+  readv, writev,
+  exists,
+  openAsBlob,
+  promises,
+  writeFileSync, unlinkSync, readFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const TMP = tmpdir();
+
+function tmpFile(name: string, content = 'hello world'): string {
+  const p = join(TMP, `gjsify-fdops-${name}-${process.pid}`);
+  writeFileSync(p, content);
+  return p;
+}
+
+export default async () => {
+  await describe('fs fd-based operations', async () => {
+    await it('fstatSync returns Stats with correct size', async () => {
+      const f = tmpFile('fstat', 'hello');
+      const fd = openSync(f, 'r');
+      try {
+        const st = fstatSync(fd);
+        expect(st.size).toBe(5);
+        expect(typeof st.mtime).toBe('object');
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('fstat callback returns Stats', async () => {
+      const f = tmpFile('fstat-cb', 'world');
+      const fd = openSync(f, 'r');
+      try {
+        const st = await new Promise<any>((resolve, reject) => {
+          fstat(fd, (err, s) => err ? reject(err) : resolve(s));
+        });
+        expect(st.size).toBe(5);
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('promises.fstat returns Stats', async () => {
+      const f = tmpFile('fstat-p', 'gjsify');
+      const fh = await promises.open(f, 'r');
+      try {
+        const st = await fh.stat();
+        expect(st.size).toBe(6);
+      } finally {
+        await fh.close();
+        unlinkSync(f);
+      }
+    });
+
+    await it('ftruncateSync truncates file', async () => {
+      const f = tmpFile('ftrunc', '0123456789');
+      const fd = openSync(f, 'r+');
+      try {
+        ftruncateSync(fd, 4);
+        const data = readFileSync(f, 'utf8');
+        expect(data).toBe('0123');
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('fdatasync callback completes without error', async () => {
+      const f = tmpFile('fdatasync', 'data');
+      const fd = openSync(f, 'r+');
+      try {
+        await new Promise<void>((resolve, reject) => {
+          fdatasync(fd, (err) => err ? reject(err) : resolve());
+        });
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('fsync callback completes without error', async () => {
+      const f = tmpFile('fsync', 'data');
+      const fd = openSync(f, 'r+');
+      try {
+        await new Promise<void>((resolve, reject) => {
+          fsync(fd, (err) => err ? reject(err) : resolve());
+        });
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('fchmodSync changes file permissions', async () => {
+      const f = tmpFile('fchmod', 'x');
+      const fd = openSync(f, 'r');
+      try {
+        fchmodSync(fd, 0o600);
+        const st = fstatSync(fd);
+        expect(st.mode & 0o777).toBe(0o600);
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('closeSync closes the fd', async () => {
+      const f = tmpFile('close', 'c');
+      const fd = openSync(f, 'r');
+      closeSync(fd);
+      expect(() => fstatSync(fd)).toThrow();
+      unlinkSync(f);
+    });
+
+    await it('readSync reads bytes from position 0', async () => {
+      const f = tmpFile('rsync', 'abcdef');
+      const fd = openSync(f, 'r');
+      try {
+        const buf = Buffer.alloc(3);
+        const n = readSync(fd, buf, 0, 3, 0);
+        expect(n).toBe(3);
+        expect(buf.toString()).toBe('abc');
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('readSync reads into buffer at offset', async () => {
+      const f = tmpFile('rsync-off', 'hello');
+      const fd = openSync(f, 'r');
+      try {
+        const buf = Buffer.alloc(8);
+        const n = readSync(fd, buf, 2, 5, 0);
+        expect(n).toBe(5);
+        expect(buf.slice(2, 7).toString()).toBe('hello');
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('writeSync writes bytes to file', async () => {
+      const f = tmpFile('wsync', '-----');
+      const fd = openSync(f, 'r+');
+      try {
+        const n = writeSync(fd, Buffer.from('XYZ'), 0, 3, 0);
+        expect(n).toBe(3);
+        closeSync(fd);
+        expect(readFileSync(f, 'utf8').slice(0, 3)).toBe('XYZ');
+      } finally {
+        unlinkSync(f);
+      }
+    });
+
+    await it('readv reads into multiple buffers', async () => {
+      const f = tmpFile('readv', 'abcdef');
+      const fd = openSync(f, 'r');
+      try {
+        const b1 = Buffer.alloc(2);
+        const b2 = Buffer.alloc(3);
+        await new Promise<void>((resolve, reject) => {
+          readv(fd, [b1, b2], 0, (err, bytesRead) => {
+            if (err) return reject(err);
+            expect(bytesRead).toBe(5);
+            expect(b1.toString()).toBe('ab');
+            expect(b2.toString()).toBe('cde');
+            resolve();
+          });
+        });
+      } finally {
+        closeSync(fd);
+        unlinkSync(f);
+      }
+    });
+
+    await it('writev writes multiple buffers', async () => {
+      const f = tmpFile('writev', '------');
+      const fd = openSync(f, 'r+');
+      try {
+        const b1 = Buffer.from('AB');
+        const b2 = Buffer.from('CDE');
+        await new Promise<void>((resolve, reject) => {
+          writev(fd, [b1, b2], 0, (err, bytesWritten) => {
+            if (err) return reject(err);
+            expect(bytesWritten).toBe(5);
+            resolve();
+          });
+        });
+        closeSync(fd);
+        expect(readFileSync(f, 'utf8').slice(0, 5)).toBe('ABCDE');
+      } finally {
+        unlinkSync(f);
+      }
+    });
+
+    await it('exists returns true for existing path, false for missing', async () => {
+      const f = tmpFile('exists', 'e');
+      const existing = await new Promise<boolean>((resolve) => {
+        exists(f, (v) => resolve(v));
+      });
+      expect(existing).toBe(true);
+      const missing = await new Promise<boolean>((resolve) => {
+        exists(join(TMP, 'gjsify-nonexistent-xyz-123'), (v) => resolve(v));
+      });
+      expect(missing).toBe(false);
+      unlinkSync(f);
+    });
+
+    await it('openAsBlob returns Blob with correct size', async () => {
+      const f = tmpFile('blob', 'blobdata');
+      const blob = await openAsBlob(f);
+      expect(blob.size).toBe(8);
+      expect(blob instanceof Blob).toBe(true);
+      unlinkSync(f);
+    });
+  });
+};