skill-universe 1.1.0

package/build/dev/javascript/simplifile/simplifile_erl.erl

@@ -0,0 +1,244 @@
+%%% --------------------------------------------------
+%%% @author Benjamin Peinhardt <benjaminpeinhardt@gmail.com>
+%%% @doc Erlang ffi glue code for the simplifile Gleam package.
+%%% @end
+%%% --------------------------------------------------
+
+-module(simplifile_erl).
+
+-compile({no_auto_import,[link/2]}).
+
+%% API
+-export([
+    append_bits/2,
+    create_directory/1,
+    create_dir_all/1,
+    delete_file/1,
+    create_link/2,
+    create_symlink/2,
+    delete/1,
+    delete_directory/1,
+    file_info/1,
+    link_info/1,
+    is_directory/1,
+    is_file/1,
+    is_symlink/1,
+    read_bits/1,
+    read_directory/1,
+    rename_file/2,
+    set_permissions_octal/2,
+    write_bits/2
+]).
+
+-include_lib("kernel/include/file.hrl").
+
+%% A macro for checking whether the error returned is one of the atoms for a posixe error.
+-define(is_posix_error(Error),
+        Error =:= eacces
+        orelse Error =:= eagain
+        orelse Error =:= ebadf
+        orelse Error =:= ebadmsg
+        orelse Error =:= ebusy
+        orelse Error =:= edeadlk
+        orelse Error =:= edeadlock
+        orelse Error =:= edquot
+        orelse Error =:= eexist
+        orelse Error =:= efault
+        orelse Error =:= efbig
+        orelse Error =:= eftype
+        orelse Error =:= eintr
+        orelse Error =:= einval
+        orelse Error =:= eio
+        orelse Error =:= eisdir
+        orelse Error =:= eloop
+        orelse Error =:= emfile
+        orelse Error =:= emlink
+        orelse Error =:= emultihop
+        orelse Error =:= enametoolong
+        orelse Error =:= enfile
+        orelse Error =:= enobufs
+        orelse Error =:= enodev
+        orelse Error =:= enolck
+        orelse Error =:= enolink
+        orelse Error =:= enoent
+        orelse Error =:= enomem
+        orelse Error =:= enospc
+        orelse Error =:= enosr
+        orelse Error =:= enostr
+        orelse Error =:= enosys
+        orelse Error =:= enotblk
+        orelse Error =:= enotdir
+        orelse Error =:= enotsup
+        orelse Error =:= enxio
+        orelse Error =:= eopnotsupp
+        orelse Error =:= eoverflow
+        orelse Error =:= eperm
+        orelse Error =:= epipe
+        orelse Error =:= erange
+        orelse Error =:= erofs
+        orelse Error =:= espipe
+        orelse Error =:= esrch
+        orelse Error =:= estale
+        orelse Error =:= etxtbsy
+        orelse Error =:= exdev).
+
+%% Only return the error if it's a posix error. Also converts ok to {ok, nil},
+%% as gleam doesn't have atoms.
+posix_result(Result) ->
+    case Result of
+        ok ->
+            {ok, nil};
+        {ok, Value} ->
+            {ok, Value};
+        {error, Reason} when ?is_posix_error(Reason) ->
+            {error, Reason};
+        {error, Reason} ->
+            {error, {unknown, string:uppercase(atom_to_binary(Reason))}}
+    end.
+
+%% Read the binary contents of a file
+read_bits(Filename) ->
+    posix_result(file:read_file(Filename)).
+
+%% Write bytes to a file
+write_bits(Filename, Contents) ->
+    case bit_size(Contents) rem 8 of
+        0 -> posix_result(file:write_file(Filename, Contents));
+        _ -> {error, einval}
+    end.
+
+%% Append bytes to a file
+append_bits(Filename, Contents) ->
+    case bit_size(Contents) rem 8 of
+        0 -> posix_result(file:write_file(Filename, Contents, [append]));
+        _ -> {error, einval}
+    end.
+
+%% Delete the file at the given path
+delete_file(Filename) ->
+    posix_result(file:delete(Filename)).
+
+%% Create a directory at the given path. Missing parent directories are not created.
+create_directory(Dir) ->
+    posix_result(file:make_dir(Dir)).
+
+%% Create a symbolic link New to the file or directory Existing (does not need to exist).
+create_symlink(Existing, New) ->
+    posix_result(file:make_symlink(Existing, New)).
+
+%% Create a "hard link" New to the file or directory Existing.
+create_link(Existing, New) ->
+    posix_result(file:make_link(Existing, New)).
+
+%% List the contents of a directory
+read_directory(Dir) ->
+    case file:list_dir(Dir) of
+        {ok, Filenames} ->
+            {ok, [unicode:characters_to_binary(Filename) || Filename <- Filenames]};
+        {error, Reason} when ?is_posix_error(Reason) ->
+            {error, Reason}
+    end.
+
+%% Delete a directory at the given path. Directory must be empty.
+delete_directory(Dir) ->
+    posix_result(file:del_dir(Dir)).
+
+%% Deletes a file/directory and everything in it.
+delete(Dir) ->
+    posix_result(file:del_dir_r(Dir)).
+
+%% Creates the entire path for a given directory to exist
+create_dir_all(Filename) ->
+    posix_result(filelib:ensure_path(Filename)).
+
+%% Move file from one path to another
+rename_file(Source, Destination) ->
+    posix_result(file:rename(Source, Destination)).
+
+%% Set the permissions for the given file.
+set_permissions_octal(Filename, Permissions) ->
+    posix_result(file:change_mode(Filename, Permissions)).
+
+is_directory(Path) ->
+    case file:read_file_info(Path) of
+        {ok, FileInfo} ->
+            case FileInfo#file_info.type of
+                directory ->
+                    {ok, true};
+                _ ->
+                    {ok, false}
+            end;
+        {error, enoent} ->
+            {ok, false};
+        {error, Reason} ->
+            posix_result({error, Reason})
+    end.
+
+is_file(Path) ->
+    case file:read_file_info(Path) of
+        {ok, FileInfo} ->
+            case FileInfo#file_info.type of
+                regular ->
+                    {ok, true};
+                _ ->
+                    {ok, false}
+            end;
+        {error, enoent} ->
+            {ok, false};
+        {error, Reason} ->
+            posix_result({error, Reason})
+    end.
+
+is_symlink(Path) ->
+    case file:read_link_info(Path) of
+        {ok, FileInfo} ->
+            case FileInfo#file_info.type of
+                symlink ->
+                    {ok, true};
+                _ ->
+                    {ok, false}
+            end;
+        {error, enoent} ->
+            {ok, false};
+        {error, Reason} ->
+            posix_result({error, Reason})
+    end.
+
+file_info_result(Result) ->
+    case Result of
+        {ok,
+         {file_info,
+          Size,
+          _Type,
+          _Access,
+          Atime,
+          Mtime,
+          Ctime,
+          Mode,
+          Links,
+          MajorDevice,
+          _MinorDevice,
+          Inode,
+          Uid,
+          Gid}} ->
+            {ok,
+             {file_info,
+              Size,
+              Mode,
+              Links,
+              Inode,
+              Uid,
+              Gid,
+              MajorDevice,
+              Atime,
+              Mtime,
+              Ctime}};
+        {error, Reason} when ?is_posix_error(Reason) ->
+            Result
+    end.
+
+file_info(Filename) ->
+    file_info_result(file:read_file_info(Filename, [{time, posix}])).
+
+link_info(Filename) ->
+    file_info_result(file:read_link_info(Filename, [{time, posix}])).

package/build/dev/javascript/simplifile/simplifile_js.mjs

@@ -0,0 +1,400 @@
+// @ts-check
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { BitArray, Ok, Error as GError, toList } from "./gleam.mjs";
+import * as $simplifile from "./simplifile.mjs";
+
+/**
+ * Read the contents of a file as a BitArray
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError} A Result with the BitArray of the file contents
+ */
+export function readBits(filepath) {
+  return gleamResult(() => {
+    const contents = fs.readFileSync(path.normalize(filepath));
+    return new BitArray(new Uint8Array(contents));
+  });
+}
+
+/**
+ * Write the given BitArray to a file
+ *
+ * @param {string} filepath
+ * @param {BitArray} contents
+ * @returns {Ok | GError}
+ */
+export function writeBits(filepath, contents) {
+  return gleamResult(() =>
+    fs.writeFileSync(path.normalize(filepath), toUint8Array(contents))
+  );
+}
+
+/**
+ * Append the given BitArray to a file
+ *
+ * @param {string} filepath
+ * @param {BitArray} contents
+ * @returns {Ok | GError}
+ */
+export function appendBits(filepath, contents) {
+  return gleamResult(() =>
+    fs.appendFileSync(path.normalize(filepath), toUint8Array(contents))
+  );
+}
+
+/**
+ * Returns a BitArray as an aligned Uint8Array. Avoids a copy when possible.
+ *
+ * @param {BitArray} contents
+ * @returns Uint8Array
+ */
+function toUint8Array(contents) {
+  if (contents.bitSize % 8 !== 0) {
+    throw new GError(new $simplifile.Einval());
+  }
+
+  let buffer = contents.rawBuffer;
+  if (contents.bitOffset !== 0) {
+    buffer = new Uint8Array(contents.byteSize);
+    for (let i = 0; i < buffer.length; i++) {
+      buffer[i] = contents.byteAt(i);
+    }
+  }
+
+  return buffer;
+}
+
+/**
+ * Check whether a file exists at the given path
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function isFile(filepath) {
+  try {
+    return new Ok(fs.statSync(path.normalize(filepath)).isFile());
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return new Ok(false);
+    } else {
+      return new GError(cast_error(e.code));
+    }
+  }
+}
+
+/**
+ * Check whether a symbolic link exists at the given path
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function isSymlink(filepath) {
+  try {
+    return new Ok(fs.lstatSync(path.normalize(filepath)).isSymbolicLink());
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return new Ok(false);
+    } else {
+      return new GError(cast_error(e.code));
+    }
+  }
+}
+
+/**
+ * Check whether a directory exists at the given path
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function isDirectory(filepath) {
+  try {
+    return new Ok(fs.statSync(path.normalize(filepath)).isDirectory());
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return new Ok(false);
+    } else {
+      return new GError(cast_error(e.code));
+    }
+  }
+}
+
+/**
+ * Create the symbolic link called path pointing to target
+ *
+ * @param {string} target
+ * @param {string} path
+ * @returns {Ok | GError}
+ */
+export function createSymlink(target, path) {
+  return gleamResult(() => fs.symlinkSync(target, path));
+}
+
+/**
+ * Create the "hard link" called path pointing to the target
+ *
+ * @param {string} target
+ * @param {string} path
+ * returns {ok | GError}
+ */
+export function createLink(target, path) {
+  return gleamResult(() => fs.linkSync(target, path));
+}
+
+/**
+ * Create a directory at the given filepath
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function createDirectory(filepath) {
+  return gleamResult(() => fs.mkdirSync(path.normalize(filepath)));
+}
+
+/**
+ * Recursively create a directory structure from the given path.
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function createDirAll(filepath) {
+  return gleamResult(() => {
+    fs.mkdirSync(path.normalize(filepath), { recursive: true });
+  });
+}
+
+/**
+ * Recursively delete a directory or delete a file at the given path.
+ *
+ * @param {string} fileOrDirPath
+ * @returns {Ok | GError}
+ */
+export function delete_(fileOrDirPath) {
+  return gleamResult(() => {
+    const isDir = isDirectory(fileOrDirPath);
+    if (isDir instanceof Ok && isDir[0] === true) {
+      fs.rmSync(path.normalize(fileOrDirPath), { recursive: true });
+    } else {
+      fs.unlinkSync(path.normalize(fileOrDirPath));
+    }
+  });
+}
+
+/**
+ * List the contents of a directory.
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function readDirectory(filepath) {
+  return gleamResult(() => toList(fs.readdirSync(path.normalize(filepath))));
+}
+
+/**
+ * Copy a file to a new path.
+ *
+ * @param {string} srcpath
+ * @param {string} destpath
+ * @returns {Ok | GError}
+ */
+export function copyFile(srcpath, destpath) {
+  return gleamResult(() =>
+    fs.copyFileSync(path.normalize(srcpath), path.normalize(destpath)),
+  );
+}
+
+/**
+ * Move a file to the new path.
+ *
+ * @param {string} srcpath
+ * @param {string} destpath
+ * @returns {Ok | GError}
+ */
+export function renameFile(srcpath, destpath) {
+  return gleamResult(() =>
+    fs.renameSync(path.normalize(srcpath), path.normalize(destpath)),
+  );
+}
+
+/**
+ * Set the file permissions. Octal number should be in base 8.
+ *
+ * @param {string} filepath
+ * @param {number} octalNumber
+ * @returns {Ok | GError}
+ */
+export function setPermissionsOctal(filepath, octalNumber) {
+  return gleamResult(() => fs.chmodSync(path.normalize(filepath), octalNumber));
+}
+
+/**
+ * Return the current directory.
+ *
+ * @returns {Ok | GError} The current directory
+ */
+export function currentDirectory() {
+  return gleamResult(() => process.cwd());
+}
+
+/**
+ *
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function fileInfo(filepath) {
+  return gleamResult(() => {
+    const stat = fs.statSync(path.normalize(filepath));
+    return new FileInfo(stat);
+  });
+}
+
+/**
+ * @param {string} filepath
+ * @returns {Ok | GError}
+ */
+export function linkInfo(filepath) {
+  return gleamResult(() => {
+    const stat = fs.lstatSync(path.normalize(filepath));
+    return new FileInfo(stat);
+  });
+}
+
+class FileInfo {
+  /**
+   * @param {fs.Stats} stat
+   */
+  constructor(stat) {
+    this.size = stat.size;
+    this.mode = stat.mode;
+    this.nlinks = stat.nlink;
+    this.inode = stat.ino;
+    this.user_id = stat.uid;
+    this.group_id = stat.gid;
+    this.dev = stat.dev;
+    this.atime_seconds = Math.floor(stat.atimeMs / 1000);
+    this.mtime_seconds = Math.floor(stat.mtimeMs / 1000);
+    this.ctime_seconds = Math.floor(stat.ctimeMs / 1000);
+  }
+}
+
+/**
+ * Perform some operation and return a Gleam `Result(a, String)`
+ * where `a` is the type returned by the operation and the `String`
+ * is the error code.
+ *
+ * @param {function():any} op
+ * @returns {Ok | GError}
+ */
+function gleamResult(op) {
+  try {
+    const val = op();
+    return new Ok(val);
+  } catch (e) {
+    return new GError(cast_error(e.code));
+  }
+}
+
+function cast_error(error_code) {
+  switch (error_code) {
+    case "EACCES":
+      return new $simplifile.Eacces();
+    case "EAGAIN":
+      return new $simplifile.Eagain();
+    case "EBADF":
+      return new $simplifile.Ebadf();
+    case "EBADMSG":
+      return new $simplifile.Ebadmsg();
+    case "EBUSY":
+      return new $simplifile.Ebusy();
+    case "EDEADLK":
+      return new $simplifile.Edeadlk();
+    case "EDEADLOCK":
+      return new $simplifile.Edeadlock();
+    case "EDQUOT":
+      return new $simplifile.Edquot();
+    case "EEXIST":
+      return new $simplifile.Eexist();
+    case "EFAULT":
+      return new $simplifile.Efault();
+    case "EFBIG":
+      return new $simplifile.Efbig();
+    case "EFTYPE":
+      return new $simplifile.Eftype();
+    case "EINTR":
+      return new $simplifile.Eintr();
+    case "EINVAL":
+      return new $simplifile.Einval();
+    case "EIO":
+      return new $simplifile.Eio();
+    case "EISDIR":
+      return new $simplifile.Eisdir();
+    case "ELOOP":
+      return new $simplifile.Eloop();
+    case "EMFILE":
+      return new $simplifile.Emfile();
+    case "EMLINK":
+      return new $simplifile.Emlink();
+    case "EMULTIHOP":
+      return new $simplifile.Emultihop();
+    case "ENAMETOOLONG":
+      return new $simplifile.Enametoolong();
+    case "ENFILE":
+      return new $simplifile.Enfile();
+    case "ENOBUFS":
+      return new $simplifile.Enobufs();
+    case "ENODEV":
+      return new $simplifile.Enodev();
+    case "ENOLCK":
+      return new $simplifile.Enolck();
+    case "ENOLINK":
+      return new $simplifile.Enolink();
+    case "ENOENT":
+      return new $simplifile.Enoent();
+    case "ENOMEM":
+      return new $simplifile.Enomem();
+    case "ENOSPC":
+      return new $simplifile.Enospc();
+    case "ENOSR":
+      return new $simplifile.Enosr();
+    case "ENOSTR":
+      return new $simplifile.Enostr();
+    case "ENOSYS":
+      return new $simplifile.Enosys();
+    case "ENOBLK":
+      return new $simplifile.Enotblk();
+    case "ENOTDIR":
+      return new $simplifile.Enotdir();
+    case "ENOTSUP":
+      return new $simplifile.Enotsup();
+    case "ENXIO":
+      return new $simplifile.Enxio();
+    case "EOPNOTSUPP":
+      return new $simplifile.Eopnotsupp();
+    case "EOVERFLOW":
+      return new $simplifile.Eoverflow();
+    case "EPERM":
+      return new $simplifile.Eperm();
+    case "EPIPE":
+      return new $simplifile.Epipe();
+    case "ERANGE":
+      return new $simplifile.Erange();
+    case "EROFS":
+      return new $simplifile.Erofs();
+    case "ESPIPE":
+      return new $simplifile.Espipe();
+    case "ESRCH":
+      return new $simplifile.Esrch();
+    case "ESTALE":
+      return new $simplifile.Estale();
+    case "ETXTBSY":
+      return new $simplifile.Etxtbsy();
+    case "EXDEV":
+      return new $simplifile.Exdev();
+    case "NOTUTF8":
+      return new $simplifile.NotUtf8();
+    default:
+      return new $simplifile.Unknown(error_code);
+  }
+}