aliases!

Author: obfuscatedgenerated

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "ollieos",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "",
   "private": true,
   "main": "server.js",

package.json

@@ -27,6 +27,8 @@ export { default as touch } from "./touch";
 export { default as mkdir } from "./mkdir";
 export { default as mv } from "./mv";
 export { default as window } from "./window";
+export { default as alias } from "./alias";
+export { default as unalias } from "./unalias";
 
 // TODO: copy program
 // TODO: create an API for creating programs, mount any programs found in /bin/ (dont list in help)

src/programs/@ALL.ts

@@ -0,0 +1,56 @@
+import type { Program } from "../types";
+import {alias} from "./@ALL";
+
+export default {
+    name: "alias",
+    description: "Define or display aliases. (Use .ollierc to persist aliases)",
+    usage_suffix: "[name[=value] ...]",
+    arg_descriptions: {
+        name: "The name of the alias to define or display. If no arguments are given, all aliases are displayed. Multiple alias arguments can be provided.",
+        "name=value": "Defines an alias with the given name and value. End the value with a space to allow chaining."
+    },
+    main: async (data) => {
+        // extract from data to make code less verbose
+        const { term } = data;
+
+        // extract from ANSI to make code less verbose
+        const { STYLE, PREFABS } = term.ansi;
+
+        if (data.args.length === 0) {
+            // display all aliases
+            const aliases = term.list_aliases();
+            for (const [name, value] of aliases.entries()) {
+                term.writeln(`alias ${name}='${value}'`);
+            }
+
+            return 0;
+        }
+
+        for (const arg of data.args) {
+            if (arg.includes("=")) {
+                // define alias
+                const [name, ...value_parts] = arg.split("=");
+                const value = value_parts.join("=");
+
+                // remove surrounding quotes if present
+                let final_value = value;
+                if ((final_value.startsWith("'") && final_value.endsWith("'")) ||
+                    (final_value.startsWith('"') && final_value.endsWith('"'))) {
+                    final_value = final_value.slice(1, -1);
+                }
+
+                term.set_alias(name, final_value);
+            } else {
+                // display alias
+                const value = term.get_alias(arg);
+                if (value) {
+                    term.writeln(`alias ${arg}='${value}'`);
+                } else {
+                    term.writeln(`${PREFABS.error}alias: ${arg}: not found${STYLE.reset_all}`);
+                }
+            }
+        }
+
+        return 0;
+    }
+} as Program;

src/programs/alias.ts

@@ -110,7 +110,7 @@ export const add_subcommand = async (data: ProgramMainData, depended_by?: PkgAtV
                 // uninstall old version
                 term.writeln(`${FG.yellow}Uninstalling old ${pkg_name}@${pkg_version}...${STYLE.reset_all}`);
 
-                const remove_data = {term, args: ["remove", pkg_name], unsubbed_args: ["remove", pkg_name]};
+                const remove_data = {term, args: ["remove", pkg_name], unsubbed_args: ["remove", pkg_name], raw_parts: [...data.raw_parts, "remove", pkg_name]};
                 const remove_exit_code = await remove_subcommand(remove_data);
                 if (remove_exit_code !== 0) {
                     term.writeln(`${PREFABS.error}Failed to uninstall old version.${STYLE.reset_all}`);
@@ -134,7 +134,7 @@ export const add_subcommand = async (data: ProgramMainData, depended_by?: PkgAtV
             virtual_args.unshift("add");
 
             // we need to also pass the name of the dependent package to the virtual call to let the graph know
-            const virtual_data = {term, args: virtual_args, unsubbed_args: virtual_args};
+            const virtual_data = {term, args: virtual_args, unsubbed_args: virtual_args, raw_parts: [...data.raw_parts, ...virtual_args]};
             const virtual_exit_code = await add_subcommand(virtual_data, pkg_at_version as PkgAtVersion);
 
             if (virtual_exit_code !== 0) {

src/programs/pkg/add.ts

@@ -0,0 +1,31 @@
+import type { Program } from "../types";
+
+export default {
+    name: "unalias",
+    description: "Remove defined aliases.",
+    usage_suffix: "name [name ...]",
+    arg_descriptions: {
+        name: "The name of the alias to remove. Multiple alias names can be provided."
+    },
+    main: async (data) => {
+        // extract from data to make code less verbose
+        const { term } = data;
+
+        // extract from ANSI to make code less verbose
+        const { STYLE, PREFABS } = term.ansi;
+
+        if (data.args.length === 0) {
+            term.writeln(`${PREFABS.error}unalias: usage: unalias name [name ...]${STYLE.reset_all}`);
+            return 1;
+        }
+
+        for (const arg of data.args) {
+            const success = term.unset_alias(arg);
+            if (!success) {
+                term.writeln(`${PREFABS.error}unalias: ${arg}: not found${STYLE.reset_all}`);
+            }
+        }
+
+        return 0;
+    }
+} as Program;

src/programs/unalias.ts

@@ -115,6 +115,7 @@ export class WrappedTerminal extends Terminal {
     _is_handling_key_events = false;
 
     _vars: Map<string, string> = new Map();
+    _aliases: Map<string, string> = new Map();
 
     // TODO: this exporting is a bit lazy, but it works for now
 
@@ -163,8 +164,24 @@ export class WrappedTerminal extends Terminal {
         this._vars.set(name, value);
     }
 
-    unset_variable(name: string): void {
-        this._vars.delete(name);
+    unset_variable(name: string): boolean {
+        return this._vars.delete(name);
+    }
+
+    list_aliases(): Map<string, string> {
+        return this._aliases;
+    }
+
+    get_alias(name: string): string | undefined {
+        return this._aliases.get(name);
+    }
+
+    set_alias(name: string, value: string): void {
+        this._aliases.set(name, value);
+    }
+
+    unset_alias(name: string): boolean {
+        return this._aliases.delete(name);
     }
 
 
@@ -248,6 +265,39 @@ export class WrappedTerminal extends Terminal {
         // remove leading and trailing whitespace and split by spaces, unless contained in single or double quotes
         // TODO: use a proper stack based parser for readability and maintainability
         const sub = line.trim().split(/ +(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/);
+        const raw_parts = sub.slice();
+
+        // handle aliases
+        // for each part, check if it's an alias, and if so, replace it with the value
+        // if the value ends with a space, check the next part as well
+        for (let i = 0; i < sub.length; i++) {
+            const part = sub[i];
+            const alias_value = this.get_alias(part);
+
+            if (!alias_value) {
+                // not an alias, abort (alias only applies to the first word unless chaining)
+                break;
+            }
+
+            // split the alias value into parts
+            const alias_parts = alias_value.split(/ +(?=(?:(?:[^"']*["'][^"']*["'])*[^"']*$))/);
+
+            // if ends with a space, remove the trailing empty part
+            if (alias_value.endsWith(" ")) {
+                alias_parts.pop();
+            }
+
+            // remove the current part and insert the alias parts
+            sub.splice(i, 1, ...alias_parts);
+
+            // adjust the index to account for the new parts
+            i += alias_parts.length - 1;
+
+            // if the alias value ends with a space, check the next part as well
+            if (!alias_value.endsWith(" ")) {
+                break;
+            }
+        }
 
         const skip_variable_sub_idxs = [];
 
@@ -271,7 +321,6 @@ export class WrappedTerminal extends Terminal {
             }
         }
 
-
         // the first word is the command, the rest are arguments
         const command = sub[0];
 
@@ -344,6 +393,7 @@ export class WrappedTerminal extends Terminal {
             term: this,
             args,
             unsubbed_args,
+            raw_parts,
         }
 
         let old_title = "";

src/term_ctl.ts

@@ -4,6 +4,7 @@ export interface ProgramMainData {
     term: WrappedTerminal,
     args: string[],
     unsubbed_args: string[],
+    raw_parts: string[], // raw command parts, including program name and unparsed args
 }
 
 export type ProgramMain = (data: ProgramMainData) => Promise<number>;