chore: Add more tests and fix some issues with transformation.

.npmignore

@@ -10,7 +10,6 @@
 /dist/tests
 /coverage
 /setup
-/temp
 *.js.map
 *.v12.suo
 *.csproj

src/tests/mainTests.ts

@@ -1,12 +1,34 @@
-import * as assert from "assert";
-import { replaceInText } from "./../main";
-import { runTestOnAllMethods } from "./testMethods";
+import { runTestOnAllMethods } from "./testMethods";
 
 runTestOnAllMethods(doTestsForMethod);
 
-function doTestsForMethod(runTest: (text: string, expected: string) => void) {
-    describe("arrays", () => {
-        describe("nameof", () => {
+function doTestsForMethod(runTest: (text: string, expected: string) => void, runThrowsTest: (text: string) => void) {
+    describe("nameof", () => {
+        describe("argument", () => {
+            it("should get the result of an identifier", () => {
+                runTest(`nameof(myObj);`, `"myObj";`);
+            });
+
+            it("should get the result of a property access expression", () => {
+                runTest(`nameof(myObj.prop);`, `"prop";`);
+            });
+
+            it("should get the result of a property access expression with null assertion operators", () => {
+                runTest(`nameof(myObj!.prop!);`, `"prop";`);
+            });
+        });
+
+        describe("type parameter", () => {
+            it("should get the result of an identifier", () => {
+                runTest(`nameof<Test>();`, `"Test";`);
+            });
+
+            it("should get the result of a fully qualified name", () => {
+                runTest(`nameof<This.Is.A.Test>();`, `"Test";`);
+            });
+        });
+
+        describe("arrays", () => {
             it("should include the brackets", () => {
                 runTest(`nameof(anyProp[0]);`, `"anyProp[0]";`);
             });
@@ -24,43 +46,133 @@ function doTestsForMethod(runTest: (text: string, expected: string) => void) {
             });
         });
 
-        describe("nameof.full", () => {
-            it("should include the brackets", () => {
-                runTest(`nameof.full(anyProp[0].myProp);`, `"anyProp[0].myProp";`);
+        describe("with function", () => {
+            it("should get the last string", () => {
+                runTest(`nameof<MyInterface>(i => i.prop1.prop2);`, `"prop2";`);
+            });
+
+            it("should throw when the function doesn't have a period", () => {
+                runThrowsTest(`nameof<MyInterface>(i => i);`);
             });
         });
     });
 
-    describe("nameof with function", () => {
-        it("should get the last string", () => {
-            runTest(`nameof<MyInterface>(i => i.prop1.prop2);`, `"prop2";`);
-        });
+    describe("nameof.full", () => {
+        describe("argument", () => {
+            it("should include everything when no count arg is provided", () => {
+                runTest(`nameof.full(obj.prop.other);`, `"obj.prop.other";`);
+            });
 
-        it("should throw when the function doesn't have a period", () => {
-            assert.throws(() => {
-                replaceInText(`nameof<MyInterface>(i => i);`);
+            it("should not include null assertion operators", () => {
+                runTest(`nameof.full(obj!.prop!.other!);`, `"obj.prop.other";`);
+            });
+
+            it("should not include null assertion operators when also using element access expressions", () => {
+                runTest(`nameof.full(obj!.prop![0].other!);`, `"obj.prop[0].other";`);
+            });
+
+            it("should allow using a period index", () => {
+                runTest("nameof.full(MyTest.Test.This, 1);", `"Test.This";`);
+            });
+
+            it("should allow using a period index of 0", () => {
+                runTest("nameof.full(MyTest.Test.This, 0);", `"MyTest.Test.This";`);
+            });
+
+            it("should allow using a period index up to its max value", () => {
+                runTest("nameof.full(MyTest.Test.This, 2);", `"This";`);
+            });
+
+            it("should allow using a negative period index", () => {
+                runTest("nameof.full(MyTest.Test.This, -1);", `"This";`);
+            });
+
+            it("should allow using a negative period index to its max value", () => {
+                runTest("nameof.full(MyTest.Test.This, -3);", `"MyTest.Test.This";`);
+            });
+
+            it("should throw when the periodIndex is not a number literal", () => {
+                runThrowsTest("nameof.full(MyTest.Test, 'test')");
             });
-        });
-    });
 
-    describe("nameof.full with function", () => {
-        it("should get the text", () => {
-            runTest(`nameof.full<MyInterface>(i => i.prop1.prop2);`, `"prop1.prop2";`);
+            it("should throw when the periodIndex is greater than the number of periods", () => {
+                runThrowsTest("nameof.full(MyTest.Test, 2)");
+            });
+
+            it("should throw when the absolute value of the negative periodIndex is greater than the number of periods + 1", () => {
+                runThrowsTest("nameof.full(MyTest.Test, -3)");
+            });
         });
 
-        it("should get the when using a function", () => {
-            runTest(`nameof.full<MyInterface>(function(i) { return i.prop1.prop2; });`, `"prop1.prop2";`);
+        describe("type parameter", () => {
+            it("should include everything when no count arg is provided", () => {
+                runTest(`nameof.full<Some.Test.Name>();`, `"Some.Test.Name";`);
+            });
+
+            it("should allow using a period index", () => {
+                runTest("nameof.full<MyTest.Test.This>(1);", `"Test.This";`);
+            });
+
+            it("should allow using a period index of 0", () => {
+                runTest("nameof.full<MyTest.Test.This>(0);", `"MyTest.Test.This";`);
+            });
+
+            it("should allow using a period index up to its max value", () => {
+                runTest("nameof.full<MyTest.Test.This>(2);", `"This";`);
+            });
+
+            it("should allow using a negative period index", () => {
+                runTest("nameof.full<MyTest.Test.This>(-1);", `"This";`);
+            });
+
+            it("should allow using a negative period index to its max value", () => {
+                runTest("nameof.full<MyTest.Test.This>(-3);", `"MyTest.Test.This";`);
+            });
+
+            it("should throw when the periodIndex is not a number literal", () => {
+                runThrowsTest("nameof.full<MyTest.Test>('test')");
+            });
+
+            it("should throw when the periodIndex is greater than the number of periods", () => {
+                runThrowsTest("nameof.full<MyTest.Test>(2)");
+            });
+
+            it("should throw when the absolute value of the negative periodIndex is greater than the number of periods + 1", () => {
+                runThrowsTest("nameof.full<MyTest.Test>(-3)");
+            });
         });
 
-        it("should get the text when providing a period", () => {
-            runTest(`nameof.full<MyInterface>(i => i.prop1.prop2, 0);`, `"prop1.prop2";`);
-            runTest(`nameof.full<MyInterface>(i => i.prop1.prop2, 1);`, `"prop2";`);
-            runTest(`nameof.full<MyInterface>(i => i.prop1.prop2.prop3, -1);`, `"prop3";`);
+        describe("arrays", () => {
+            it("should include the brackets", () => {
+                runTest(`nameof.full(anyProp[0].myProp);`, `"anyProp[0].myProp";`);
+            });
         });
 
-        it("should throw when the function doesn't have a period", () => {
-            assert.throws(() => {
-                replaceInText(`nameof.full<MyInterface>(i => i);`);
+        describe("with function", () => {
+            it("should get the text", () => {
+                runTest(`nameof.full<MyInterface>(i => i.prop1.prop2);`, `"prop1.prop2";`);
+            });
+
+            it("should get the text without the null assertion operator", () => {
+                runTest(`nameof.full<MyInterface>(i => i.prop1!.prop2!);`, `"prop1.prop2";`);
+            });
+
+            it("should get the text when there's a trailing comma with whitespace", () => {
+                runTest("nameof.full<IState>(state => state.field.dates, );", `"field.dates";`);
+            });
+
+            it("should get the text when using a function", () => {
+                runTest(`nameof.full<MyInterface>(function(i) { return i.prop1.prop2; });`, `"prop1.prop2";`);
+            });
+
+            it("should get the text when providing a period", () => {
+                runTest(`nameof.full<MyInterface>(i => i.prop1.prop2, 0);`, `"prop1.prop2";`);
+                runTest(`nameof.full<MyInterface>(i => i.prop1.prop2, 1);`, `"prop2";`);
+                runTest(`nameof.full<MyInterface>(i => i.prop1.prop2.prop3, -1);`, `"prop3";`);
+            });
+
+            it("should throw when the function doesn't have a period", () => {
+                runThrowsTest(`nameof.full<MyInterface>(i => i);`);
             });
         });
     });

src/tests/testMethods/replaceInTextTestMethod.ts

@@ -6,3 +6,7 @@ export function runTest(text: string, expected: string) {
     const result = replaceInText(text);
     assert.equal(result.fileText || text, expected);
 }
+
+export function runThrowTest(text: string) {
+    assert.throws(() => replaceInText(text));
+}

src/tests/testMethods/runTestOnAllMethods.ts

@@ -1,12 +1,15 @@
-import { runTest as runTest1 } from "./replaceInTextTestMethod";
-import { runTest as runTest2 } from "./transformationTestMethod";
+import * as replaceInTextTestMethod from "./replaceInTextTestMethod";
+import * as transformationTestMethod from "./transformationTestMethod";
 
-const testMethods = [{ name: "replaceInText", runTest: runTest1 }, { name: "transformation", runTest: runTest2 }];
+const testMethods = [
+    { name: "replaceInText", ...replaceInTextTestMethod },
+    { name: "transformation", ...transformationTestMethod }
+];
 
-export function runTestOnAllMethods(runTest: (method: (text: string, expected: string) => void) => void) {
+export function runTestOnAllMethods(runTest: (method: (text: string, expected: string) => void, throwTestMethod: (text: string) => void) => void) {
     for (const testMethod of testMethods) {
         describe(testMethod.name, () => {
-            runTest(testMethod.runTest);
+            runTest(testMethod.runTest, testMethod.runThrowTest);
         });
     }
 }

src/tests/testMethods/transformationTestMethod.ts

@@ -4,6 +4,15 @@ import * as ts from "typescript";
 import { transformerFactory } from "../../transformation";
 
 export function runTest(text: string, expected: string) {
+    const results = run(text);
+    assert.equal(results[0].fileText.trim(), expected.trim());
+}
+
+export function runThrowTest(text: string) {
+    assert.throws(() => run(text));
+}
+
+function run(text: string) {
     const results: { fileName: string; fileText: string; }[] = [];
     const compilerOptions: ts.CompilerOptions = {
         strictNullChecks: true,
@@ -32,6 +41,5 @@ export function runTest(text: string, expected: string) {
     };
     const program = ts.createProgram(["/file.ts"], compilerOptions, host);
     program.emit(undefined, (fileName, fileText) => results.push({ fileName, fileText }), undefined, false, transformers);
-
-    assert.equal(results[0].fileText.trim(), expected.trim());
+    return results;
 }

src/text/replaceCallExpressionReplacesInText.ts

@@ -7,7 +7,7 @@ export function replaceCallExpressionReplacesInText(callExpressionReplaces: Repl
         const text = getReplaceInfoText(currentReplace, periodIndexArgIndex);
         const newText = (currentReplace.showFull
             ? `"${getFullText(text, getPeriodIndexArgText(currentReplace, periodIndexArgIndex))}"`
-            : `"${text.substring(text.lastIndexOf(".") + 1)}"`).replace(/ /g, "");
+            : `"${text.substring(text.lastIndexOf(".") + 1)}"`).replace(/ /g, "").replace(/!/g, "");
         const offset = newText.length - (currentReplace.end - currentReplace.pos);
 
         data = data.substring(0, currentReplace.pos) + newText + data.substring(currentReplace.end);