Absolute import path slashes normalized (#390)

hazzard993 · Perryvw · commit 9a23ce3252e8 · 2019-02-19T00:39:26.000+01:00
* Absolute import path slashes normalized

* Added require spec tests

* path logic no longer uses absolute paths

* Added errors and path conversion

* Added filename for compiler and more tests

* Removed FocusTest

* Added default root dir

* Fixed test

* Fixed paths for Linux and Windows machines

* .json paths are chopped

* json replacement first

* json path before windows
diff --git a/src/LuaTransformer.ts b/src/LuaTransformer.ts
@@ -3719,22 +3719,31 @@ export class LuaTransformer {
     }
 
     private getImportPath(relativePath: string): string {
-        // Calculate absolute path to import
-        const absolutePathToImport = this.getAbsoluteImportPath(relativePath);
-        if (this.options.rootDir) {
-            // Calculate path relative to project root
-            // and replace path.sep with dots (lua doesn't know paths)
-            const relativePathToRoot = this.pathToLuaRequirePath(
-                absolutePathToImport.replace(this.options.rootDir, "").slice(1)
-            );
-            return relativePathToRoot;
+        const rootDir = this.options.rootDir || path.resolve(".");
+        const absoluteImportPath = this.formatPathToLuaPath(this.getAbsoluteImportPath(relativePath));
+        const absoluteRootDirPath = this.formatPathToLuaPath(rootDir);
+        if (absoluteImportPath.includes(absoluteRootDirPath)) {
+            const relativePathToRoot = this.formatPathToLuaPath(
+                absoluteImportPath.replace(absoluteRootDirPath, "").slice(1));
+            return this.formatPathToLuaPath(relativePathToRoot);
+        } else {
+            throw TSTLErrors.UnresolvableRequirePath(undefined,
+                `Cannot create require path. Module does not exist within --rootDir`,
+                relativePath);
         }
-
-        return this.pathToLuaRequirePath(relativePath);
     }
 
-    private pathToLuaRequirePath(filePath: string): string {
-        return filePath.replace(/\.json$/, '').replace(new RegExp("\\\\|\/", "g"), ".");
+    private formatPathToLuaPath(filePath: string): string {
+        filePath = filePath.replace(/\.json$/, "");
+        if (process.platform === "win32") {
+            // Windows can use backslashes
+            filePath = filePath
+                .replace(/\.\\/g, "")
+                .replace(/\\/g, ".");
+        }
+        return filePath
+            .replace(/\.\//g, "")
+            .replace(/\//g, ".");
     }
 
     private shouldExportIdentifier(identifier: tstl.Identifier | tstl.Identifier[]): boolean {
diff --git a/src/TSTLErrors.ts b/src/TSTLErrors.ts
@@ -134,6 +134,13 @@ export class TSTLErrors {
             node);
     };
 
+    public static UnresolvableRequirePath = (node: ts.Node, reason: string, path?: string) => {
+        return new TranspileError(
+            `${reason}. ` +
+            `TypeScript path: ${path}.`,
+            node);
+    };
+
     public static ReferencedBeforeDeclaration = (node: ts.Identifier) => {
         return new TranspileError(
             `Identifier "${node.text}" was referenced before it was declared. The declaration ` +
diff --git a/test/src/util.ts b/test/src/util.ts
@@ -11,12 +11,16 @@ import {lauxlib, lua, lualib, to_jsstring, to_luastring } from "fengari";
 import * as fs from "fs";
 import { LuaTransformer } from "../../src/LuaTransformer";
 
-export function transpileString(str: string, options?: CompilerOptions, ignoreDiagnostics = true): string {
+export function transpileString(
+    str: string,
+    options?: CompilerOptions,
+    ignoreDiagnostics = true,
+    filePath = "file.ts"): string {
     if (options) {
         if (options.noHeader === undefined) {
             options.noHeader = true;
         }
-        return compilerTranspileString(str, options, ignoreDiagnostics);
+        return compilerTranspileString(str, options, ignoreDiagnostics, filePath);
     } else {
         return compilerTranspileString(
             str,
@@ -26,7 +30,8 @@ export function transpileString(str: string, options?: CompilerOptions, ignoreDi
                 target: ts.ScriptTarget.ES2015,
                 noHeader: true,
             },
-            ignoreDiagnostics
+            ignoreDiagnostics,
+            filePath
         );
     }
 }
diff --git a/test/unit/require.spec.ts b/test/unit/require.spec.ts
@@ -0,0 +1,35 @@
+import { Expect, FocusTest, Test, TestCase } from "alsatian";
+
+import * as util from "../src/util";
+import * as path from "path";
+import { CompilerOptions } from "../../src/CompilerOptions";
+
+export class RequireTests {
+
+    @TestCase("file.ts", "./folder/Module", "folder.Module", { rootDir: "." }, false)
+    @TestCase("src/file.ts", "./folder/Module", "src.folder.Module", { rootDir: "." }, false)
+    @TestCase("file.ts", "folder/Module", "folder.Module", { rootDir: ".", baseUrl: "." }, false)
+    @TestCase("src/file.ts", "./folder/Module", "folder.Module", { rootDir: "src" }, false)
+    @TestCase("src/file.ts", "./folder/Module", "folder.Module", { rootDir: "./src" }, false)
+    @TestCase("file.ts", "../Module", "", { rootDir: "./src" }, true)
+    @TestCase("src/dir/file.ts", "../Module", "Module", { rootDir: "./src" }, false)
+    @TestCase("src/dir/dir/file.ts", "../../dir/Module", "dir.Module", { rootDir: "./src" }, false)
+    @Test("require paths root from --baseUrl or --rootDir")
+    public testRequirePath(
+        filePath: string,
+        usedPath: string,
+        expectedPath: string,
+        options: CompilerOptions,
+        throwsError: boolean): void {
+        const regex = /require\("(.*?)"\)/;                 // This regex extracts `hello` from require("hello")
+        options.rootDir = path.resolve(options.rootDir);    // This happens automatically from the command line
+        if (throwsError) {
+            Expect(() => util.transpileString(`import * from "${usedPath}";`, options, true, filePath)).toThrow();
+        } else {
+            const lua = util.transpileString(`import * from "${usedPath}";`, options, true, filePath);
+            const match = regex.exec(lua);
+            Expect(match[1]).toBe(expectedPath);
+        }
+    }
+
+}
