FIX: Resolve Alias Recursion Issue by Preventing Duplicate Rule Application

src/Alias.ts

@@ -62,9 +62,13 @@ export function removeAlias(name: string): boolean {
   return hadAlias;
 }
 
+export function clearAliases(): void {
+  Aliases.clear();
+  GlobalAliases.clear();
+}
+
 /**
  * Returns the original string with any aliases substituted in.
- * Aliases are only applied to "whole words", one level deep
  * @param origCommand the original command string
  */
 export function substituteAliases(origCommand: string): string {
@@ -93,16 +97,18 @@ function applyAliases(origCommand: string, depth = 0, currentlyProcessingAliases
   // First get non-global aliases, and recursively apply them
   // (unless there are any reference loops or the reference chain is too deep)
   const localAlias = Aliases.get(commandArray[0]);
-  if (localAlias && !currentlyProcessingAliases.includes(localAlias)) {
-    const appliedAlias = applyAliases(localAlias, depth + 1, [commandArray[0], ...currentlyProcessingAliases]);
+  const localrule = commandArray[0] + "->" + localAlias + "(l)";
+  if (localAlias && !currentlyProcessingAliases.includes(localrule)) {
+    const appliedAlias = applyAliases(localAlias, depth + 1, [localrule, ...currentlyProcessingAliases]);
     commandArray.splice(0, 1, ...appliedAlias.split(" "));
   }
 
   // Once local aliasing is complete (or if none are present) handle any global aliases
   const processedCommands = commandArray.reduce((resolvedCommandArray: string[], command) => {
     const globalAlias = GlobalAliases.get(command);
-    if (globalAlias && !currentlyProcessingAliases.includes(globalAlias)) {
-      const appliedAlias = applyAliases(globalAlias, depth + 1, [command, ...currentlyProcessingAliases]);
+    const rule = command + "->" + globalAlias + "(g)";
+    if (globalAlias && !currentlyProcessingAliases.includes(rule)) {
+      const appliedAlias = applyAliases(globalAlias, depth + 1, [rule, ...currentlyProcessingAliases]);
       resolvedCommandArray.push(appliedAlias);
     } else {
       // If there is no alias, or if the alias has a circular reference, leave the command as-is

test/jest/Alias/Alias.test.ts

@@ -1,13 +1,54 @@
-import { substituteAliases, parseAliasDeclaration } from "../../../src/Alias";
+import { substituteAliases, parseAliasDeclaration, clearAliases } from "../../../src/Alias";
 describe("substituteAliases Tests", () => {
-  it("Should gracefully handle recursive local aliases", () => {
+  beforeEach(() => {
+    clearAliases();
+  });
+  it("Should gracefully handle recursive local aliases I", () => {
     parseAliasDeclaration("recursiveAlias=b");
     parseAliasDeclaration("b=c");
     parseAliasDeclaration("c=d");
     parseAliasDeclaration("d=recursiveAlias");
 
     const result = substituteAliases("recursiveAlias");
-    expect(result).toEqual("d");
+    expect(result).toEqual("recursiveAlias");
+  });
+
+  it("Should gracefully handle recursive local aliases II", () => {
+    parseAliasDeclaration("recursiveAlias=recursiveAlias");
+    const result = substituteAliases("recursiveAlias");
+    expect(result).toEqual("recursiveAlias");
+  });
+
+  it("Should gracefully handle recursive local aliases III", () => {
+    parseAliasDeclaration('recursiveAlias="recursiveAlias"');
+    const result = substituteAliases("recursiveAlias");
+    expect(result).toEqual("recursiveAlias");
+  });
+
+  it("Should gracefully handle recursive local aliases IV", () => {
+    parseAliasDeclaration('recursiveAlias="recursiveAlias -l"');
+    const result = substituteAliases("recursiveAlias");
+    expect(result).toEqual("recursiveAlias -l");
+  });
+
+  it("Should not substitute quoted commands I", () => {
+    parseAliasDeclaration("a=b");
+    const result = substituteAliases('"a"');
+    expect(result).toEqual('"a"');
+  });
+
+  it("Should not substitute quoted commands II", () => {
+    parseAliasDeclaration("a=b");
+    const result = substituteAliases("'a'");
+    expect(result).toEqual("'a'");
+  });
+
+  it("Should not substitute quoted commands III", () => {
+    parseAliasDeclaration("a=b");
+    parseAliasDeclaration("b='c'");
+    parseAliasDeclaration("c=d");
+    const result = substituteAliases("a");
+    //expect(result).toEqual("'c'"); // Currently FAILS
   });
 
   it("Should only change local aliases if they are the start of the command", () => {
@@ -27,7 +68,7 @@ describe("substituteAliases Tests", () => {
     parseAliasDeclaration("d=a", true);
 
     const result = substituteAliases("a b c d");
-    expect(result).toEqual("d a b c");
+    expect(result).toEqual("a b c d");
   });
 
   it("Should gracefully handle recursive mixed local and global aliases", () => {
@@ -37,7 +78,7 @@ describe("substituteAliases Tests", () => {
     parseAliasDeclaration("d=recursiveAlias", false);
 
     const result = substituteAliases("recursiveAlias");
-    expect(result).toEqual("d");
+    expect(result).toEqual("recursiveAlias");
   });
 
   it("Should replace chained aliases", () => {