Replace all uses of getAbsolutePath with joinPaths as it is more correct and less confusing

Signed-off-by: Sebastian Malton <sebastian@malton.name>

src/common/app-paths/directory-for-binaries/directory-for-binaries.injectable.ts

@@ -4,16 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
-import getAbsolutePathInjectable from "../../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../path/join-paths.injectable";
 
 const directoryForBinariesInjectable = getInjectable({
   id: "directory-for-binaries",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
-    return getAbsolutePath(directoryForUserData, "binaries");
+    return joinPaths(directoryForUserData, "binaries");
   },
 });
 

src/common/app-paths/directory-for-kube-configs/directory-for-kube-configs.injectable.ts

@@ -4,19 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../directory-for-user-data/directory-for-user-data.injectable";
-import getAbsolutePathInjectable from "../../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../path/join-paths.injectable";
 
 const directoryForKubeConfigsInjectable = getInjectable({
   id: "directory-for-kube-configs",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
-    return getAbsolutePath(
-      directoryForUserData,
-      "kubeconfigs",
-    );
+    return joinPaths(directoryForUserData, "kubeconfigs");
   },
 });
 

src/common/app-paths/directory-for-kubectl-binaries/directory-for-kubectl-binaries.injectable.ts

@@ -4,17 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForBinariesInjectable from "../directory-for-binaries/directory-for-binaries.injectable";
-import getAbsolutePathInjectable from "../../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../path/join-paths.injectable";
 
 const directoryForKubectlBinariesInjectable = getInjectable({
   id: "directory-for-kubectl-binaries",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const directoryForBinaries = di.inject(directoryForBinariesInjectable);
 
-
-    return getAbsolutePath(directoryForBinaries, "kubectl");
+    return joinPaths(directoryForBinaries, "kubectl");
   },
 });
 

src/common/app-paths/get-custom-kube-config-directory/get-custom-kube-config-directory.injectable.ts

@@ -4,17 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForKubeConfigsInjectable from "../directory-for-kube-configs/directory-for-kube-configs.injectable";
-import getAbsolutePathInjectable from "../../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../path/join-paths.injectable";
 
 const getCustomKubeConfigDirectoryInjectable = getInjectable({
   id: "get-custom-kube-config-directory",
 
   instantiate: (di) => {
     const directoryForKubeConfigs = di.inject(directoryForKubeConfigsInjectable);
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
 
-    return (directoryName: string) =>
-      getAbsolutePath(directoryForKubeConfigs, directoryName);
+    return (directoryName: string) => joinPaths(directoryForKubeConfigs, directoryName);
   },
 });
 

src/common/directory-for-lens-local-storage/directory-for-lens-local-storage.injectable.ts

@@ -4,16 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import getAbsolutePathInjectable from "../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../path/join-paths.injectable";
 
 const directoryForLensLocalStorageInjectable = getInjectable({
   id: "directory-for-lens-local-storage",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
-    return getAbsolutePath(
+    return joinPaths(
       directoryForUserData,
       "lens-local-storage",
     );

src/common/vars/base-bundled-binaries-dir.injectable.ts

@@ -4,17 +4,17 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import bundledResourcesDirectoryInjectable from "./bundled-resources-dir.injectable";
-import getAbsolutePathInjectable from "../path/get-absolute-path.injectable";
 import normalizedPlatformArchitectureInjectable from "./normalized-platform-architecture.injectable";
+import joinPathsInjectable from "../path/join-paths.injectable";
 
 const baseBundledBinariesDirectoryInjectable = getInjectable({
   id: "base-bundled-binaries-directory",
   instantiate: (di) => {
     const bundledResourcesDirectory = di.inject(bundledResourcesDirectoryInjectable);
     const normalizedPlatformArchitecture = di.inject(normalizedPlatformArchitectureInjectable);
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
 
-    return getAbsolutePath(
+    return joinPaths(
       bundledResourcesDirectory,
       normalizedPlatformArchitecture,
     );

src/common/vars/bundled-resources-dir.injectable.ts

@@ -5,20 +5,20 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import isProductionInjectable from "./is-production.injectable";
 import normalizedPlatformInjectable from "./normalized-platform.injectable";
-import getAbsolutePathInjectable from "../path/get-absolute-path.injectable";
 import lensResourcesDirInjectable from "./lens-resources-dir.injectable";
+import joinPathsInjectable from "../path/join-paths.injectable";
 
 const bundledResourcesDirectoryInjectable = getInjectable({
   id: "bundled-resources-directory",
   instantiate: (di) => {
     const isProduction = di.inject(isProductionInjectable);
     const normalizedPlatform = di.inject(normalizedPlatformInjectable);
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const lensResourcesDir = di.inject(lensResourcesDirInjectable);
 
     return isProduction
       ? lensResourcesDir
-      : getAbsolutePath(lensResourcesDir, "binaries", "client", normalizedPlatform);
+      : joinPaths(lensResourcesDir, "binaries", "client", normalizedPlatform);
   },
 });
 

src/common/vars/static-files-directory.injectable.ts

@@ -3,17 +3,17 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import getAbsolutePathInjectable from "../path/get-absolute-path.injectable";
+import joinPathsInjectable from "../path/join-paths.injectable";
 import lensResourcesDirInjectable from "./lens-resources-dir.injectable";
 
 const staticFilesDirectoryInjectable = getInjectable({
   id: "static-files-directory",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const lensResourcesDir = di.inject(lensResourcesDirInjectable);
 
-    return getAbsolutePath(lensResourcesDir, "static");
+    return joinPaths(lensResourcesDir, "static");
   },
 });
 

src/extensions/extension-loader/file-system-provisioner-store/directory-for-extension-data.injectable.ts

@@ -4,16 +4,16 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import directoryForUserDataInjectable from "../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
-import getAbsolutePathInjectable from "../../../common/path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../../common/path/join-paths.injectable";
 
 const directoryForExtensionDataInjectable = getInjectable({
   id: "directory-for-extension-data",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const directoryForUserData = di.inject(directoryForUserDataInjectable);
 
-    return getAbsolutePath(directoryForUserData, "extension_data");
+    return joinPaths(directoryForUserData, "extension_data");
   },
 });
 

src/main/helm/helm-binary-path.injectable.ts

@@ -4,21 +4,21 @@
  */
 import { getInjectable } from "@ogre-tools/injectable";
 import { getBinaryName } from "../../common/vars";
-import getAbsolutePathInjectable from "../../common/path/get-absolute-path.injectable";
 import normalizedPlatformInjectable from "../../common/vars/normalized-platform.injectable";
 import baseBundledBinariesDirectoryInjectable from "../../common/vars/base-bundled-binaries-dir.injectable";
+import joinPathsInjectable from "../../common/path/join-paths.injectable";
 
 const helmBinaryPathInjectable = getInjectable({
   id: "helm-binary-path",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const normalizedPlatform = di.inject(normalizedPlatformInjectable);
     const baseBundledBinariesDirectory = di.inject(baseBundledBinariesDirectoryInjectable);
 
     const helmBinaryName = getBinaryName("helm", { forPlatform: normalizedPlatform });
 
-    return getAbsolutePath(baseBundledBinariesDirectory, helmBinaryName);
+    return joinPaths(baseBundledBinariesDirectory, helmBinaryName);
   },
 });
 

src/main/routes/static-file-route.injectable.ts

@@ -11,8 +11,6 @@ import path from "path";
 import isDevelopmentInjectable from "../../common/vars/is-development.injectable";
 import httpProxy from "http-proxy";
 import readFileBufferInjectable from "../../common/fs/read-file-buffer.injectable";
-import type { GetAbsolutePath } from "../../common/path/get-absolute-path.injectable";
-import getAbsolutePathInjectable from "../../common/path/get-absolute-path.injectable";
 import type { JoinPaths } from "../../common/path/join-paths.injectable";
 import joinPathsInjectable from "../../common/path/join-paths.injectable";
 import { webpackDevServerPort } from "../../../webpack/vars";
@@ -20,11 +18,13 @@ import type { LensApiRequest, RouteResponse } from "../router/route";
 import { route } from "../router/route";
 import staticFilesDirectoryInjectable from "../../common/vars/static-files-directory.injectable";
 import appNameInjectable from "../../common/vars/app-name.injectable";
+import type { GetAbsolutePath } from "../../common/path/get-absolute-path.injectable";
+import getAbsolutePathInjectable from "../../common/path/get-absolute-path.injectable";
 
 interface ProductionDependencies {
   readFileBuffer: (path: string) => Promise<Buffer>;
-  getAbsolutePath: GetAbsolutePath;
   joinPaths: JoinPaths;
+  getAbsolutePath: GetAbsolutePath;
   staticFilesDirectory: string;
   appName: string;
 }
@@ -98,8 +98,8 @@ const staticFileRouteInjectable = getRouteInjectable({
   instantiate: (di) => {
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const readFileBuffer = di.inject(readFileBufferInjectable);
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
     const joinPaths = di.inject(joinPathsInjectable);
+    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
     const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
     const appName = di.inject(appNameInjectable);
 
@@ -114,10 +114,10 @@ const staticFileRouteInjectable = getRouteInjectable({
         })
         : handleStaticFileInProduction({
           readFileBuffer,
-          getAbsolutePath,
           joinPaths,
           staticFilesDirectory,
           appName,
+          getAbsolutePath,
         }),
     );
   },

src/main/start-main-application/lens-window/splash-window/splash-window.injectable.ts

@@ -5,7 +5,7 @@
 import { getInjectable } from "@ogre-tools/injectable";
 import createLensWindowInjectable from "../application-window/create-lens-window.injectable";
 import staticFilesDirectoryInjectable from "../../../../common/vars/static-files-directory.injectable";
-import getAbsolutePathInjectable from "../../../../common/path/get-absolute-path.injectable";
+import joinPathsInjectable from "../../../../common/path/join-paths.injectable";
 
 const splashWindowInjectable = getInjectable({
   id: "splash-window",
@@ -13,8 +13,8 @@ const splashWindowInjectable = getInjectable({
   instantiate: (di) => {
     const createLensWindow = di.inject(createLensWindowInjectable);
     const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
-    const splashWindowFile = getAbsolutePath(staticFilesDirectory, "splash.html");
+    const joinPaths = di.inject(joinPathsInjectable);
+    const splashWindowFile = joinPaths(staticFilesDirectory, "splash.html");
 
     return createLensWindow({
       id: "splash",

src/main/tray/menu-icon/get-tray-icon-path.injectable.ts

@@ -3,34 +3,33 @@
  * Licensed under MIT License. See LICENSE in root directory for more information.
  */
 import { getInjectable } from "@ogre-tools/injectable";
-import getAbsolutePathInjectable from "../../../common/path/get-absolute-path.injectable";
 import staticFilesDirectoryInjectable from "../../../common/vars/static-files-directory.injectable";
 import isDevelopmentInjectable from "../../../common/vars/is-development.injectable";
 import isMacInjectable from "../../../common/vars/is-mac.injectable";
 import { camelCase, flow, upperFirst } from "lodash/fp";
+import joinPathsInjectable from "../../../common/path/join-paths.injectable";
 const upperCamelCase = flow(camelCase, upperFirst);
 
 const getTrayIconPathInjectable = getInjectable({
   id: "get-tray-icon-path",
 
   instantiate: (di) => {
-    const getAbsolutePath = di.inject(getAbsolutePathInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
     const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
     const isDevelopment = di.inject(isDevelopmentInjectable);
     const isMac = di.inject(isMacInjectable);
 
-    const baseIconDirectory = getAbsolutePath(
+    const baseIconDirectory = joinPaths(
       staticFilesDirectory,
       isDevelopment ? "../build/tray" : "icons", // copied within electron-builder extras
     );
 
     const fileSuffix = isMac ? "Template.png" : ".png";
 
-    return (name: string) =>
-      getAbsolutePath(
-        baseIconDirectory,
-        `trayIcon${upperCamelCase(name)}${fileSuffix}`,
-      );
+    return (name: string) => joinPaths(
+      baseIconDirectory,
+      `trayIcon${upperCamelCase(name)}${fileSuffix}`,
+    );
   },
 });
 

src/renderer/components/dock/create-resource/lens-templates.injectable.ts

@@ -8,44 +8,29 @@ import { hasCorrectExtension } from "./has-correct-extension";
 import readFileInjectable from "../../../../common/fs/read-file.injectable";
 import readDirInjectable from "../../../../common/fs/read-dir.injectable";
 import type { RawTemplates } from "./create-resource-templates.injectable";
-import type { GetAbsolutePath } from "../../../../common/path/get-absolute-path.injectable";
-import getAbsolutePathInjectable from "../../../../common/path/get-absolute-path.injectable";
 import staticFilesDirectoryInjectable from "../../../../common/vars/static-files-directory.injectable";
-
-interface Dependencies {
-  readDir: (dirPath: string) => Promise<string[]>;
-  readFile: (filePath: string) => Promise<string>;
-  getAbsolutePath: GetAbsolutePath;
-  staticFilesDirectory: string;
-}
-
-async function getTemplates({ readDir, readFile, getAbsolutePath, staticFilesDirectory }: Dependencies) {
-  const templatesFolder = getAbsolutePath(staticFilesDirectory, "../templates/create-resource");
-
-  /**
-   * Mapping between file names and their contents
-   */
-  const templates: [file: string, contents: string][] = [];
-
-  for (const dirEntry of await readDir(templatesFolder)) {
-    if (hasCorrectExtension(dirEntry)) {
-      templates.push([path.parse(dirEntry).name, await readFile(path.join(templatesFolder, dirEntry))]);
-    }
-  }
-
-  return templates;
-}
+import joinPathsInjectable from "../../../../common/path/join-paths.injectable";
 
 const lensCreateResourceTemplatesInjectable = getInjectable({
   id: "lens-create-resource-templates",
 
   instantiate: async (di): Promise<RawTemplates> => {
-    const templates = await getTemplates({
-      readFile: di.inject(readFileInjectable),
-      readDir: di.inject(readDirInjectable),
-      getAbsolutePath: di.inject(getAbsolutePathInjectable),
-      staticFilesDirectory: di.inject(staticFilesDirectoryInjectable),
-    });
+    const readFile = di.inject(readFileInjectable);
+    const readDir = di.inject(readDirInjectable);
+    const joinPaths = di.inject(joinPathsInjectable);
+    const staticFilesDirectory = di.inject(staticFilesDirectoryInjectable);
+
+    /**
+     * Mapping between file names and their contents
+     */
+    const templates: [file: string, contents: string][] = [];
+    const templatesFolder = joinPaths(staticFilesDirectory, "../templates/create-resource");
+
+    for (const dirEntry of await readDir(templatesFolder)) {
+      if (hasCorrectExtension(dirEntry)) {
+        templates.push([path.parse(dirEntry).name, await readFile(path.join(templatesFolder, dirEntry))]);
+      }
+    }
 
     return ["lens", templates];
   },

src/renderer/utils/create-storage/create-storage.injectable.ts

@@ -9,9 +9,9 @@ import readJsonFileInjectable from "../../../common/fs/read-json-file.injectable
 import writeJsonFileInjectable from "../../../common/fs/write-json-file.injectable";
 import { observable } from "mobx";
 import loggerInjectable from "../../../common/logger.injectable";
-import getAbsolutePathInjectable from "../../../common/path/get-absolute-path.injectable";
 import hostedClusterIdInjectable from "../../cluster-frame-context/hosted-cluster-id.injectable";
 import storageSaveDelayInjectable from "./storage-save-delay.injectable";
+import joinPathsInjectable from "../../../common/path/join-paths.injectable";
 
 const createStorageInjectable = getInjectable({
   id: "create-storage",
@@ -26,7 +26,7 @@ const createStorageInjectable = getInjectable({
     writeJsonFile: di.inject(writeJsonFileInjectable),
     logger: di.inject(loggerInjectable),
     directoryForLensLocalStorage: di.inject(directoryForLensLocalStorageInjectable),
-    getAbsolutePath: di.inject(getAbsolutePathInjectable),
+    joinPaths: di.inject(joinPathsInjectable),
     hostedClusterId: di.inject(hostedClusterIdInjectable),
     saveDelay: di.inject(storageSaveDelayInjectable),
   }),

src/renderer/utils/create-storage/create-storage.ts

@@ -8,10 +8,9 @@
 import { comparer, reaction, toJS, when } from "mobx";
 import type { StorageLayer } from "../storageHelper";
 import { StorageHelper } from "../storageHelper";
-import { isTestEnv } from "../../../common/vars";
 import type { JsonObject, JsonValue } from "type-fest";
 import type { Logger } from "../../../common/logger";
-import type { GetAbsolutePath } from "../../../common/path/get-absolute-path.injectable";
+import type { JoinPaths } from "../../../common/path/join-paths.injectable";
 
 interface Dependencies {
   storage: { initialized: boolean; loaded: boolean; data: Record<string, any> };
@@ -19,7 +18,7 @@ interface Dependencies {
   directoryForLensLocalStorage: string;
   readJsonFile: (filePath: string) => Promise<JsonValue>;
   writeJsonFile: (filePath: string, contentObject: JsonObject) => Promise<void>;
-  getAbsolutePath: GetAbsolutePath;
+  joinPaths: JoinPaths;
   hostedClusterId: string | undefined;
   saveDelay: number;
 }
@@ -31,7 +30,7 @@ export type CreateStorage = <T>(key: string, defaultValue: T) => StorageLayer<T>
  */
 export const createStorage = ({
   storage,
-  getAbsolutePath,
+  joinPaths,
   logger,
   directoryForLensLocalStorage,
   readJsonFile,
@@ -45,17 +44,14 @@ export const createStorage = ({
     storage.initialized = true;
 
     (async () => {
-      const filePath = getAbsolutePath(directoryForLensLocalStorage, `${hostedClusterId || "app"}.json`);
+      const filePath = joinPaths(directoryForLensLocalStorage, `${hostedClusterId || "app"}.json`);
 
       try {
         storage.data = (await readJsonFile(filePath)) as JsonObject;
       } catch {
         // do nothing
       } finally {
-        if (!isTestEnv) {
-          logger.info(`${logPrefix} loading finished for ${filePath}`);
-        }
-
+        logger.info(`${logPrefix} loading finished for ${filePath}`);
         storage.loaded = true;
       }