Small refactorings

Author: SebastianWendorf

java/src/main/resources/META-INF/jqassistant-plugin.xml

@@ -1,7 +1,9 @@
 <jqassistant-plugin xmlns="http://schema.jqassistant.org/plugin/v1.10"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     xsi:schemaLocation="http://schema.jqassistant.org/plugin/v1.10 https://schema.jqassistant.org/plugin/jqassistant-plugin-v1.8.xsd"
-                    name="jQAssistant Typescript Plugin" id="jqassistant.plugin.typescript">
+                    id="jqassistant.plugin.typescript"
+                    name="jQAssistant Typescript Plugin"
+                    version="${project.version}">
     <description>Provides a scanner for Typescript.</description>
     <model>
         <class>org.jqassistant.plugin.typescript.api.model.core.AccessorPropertyDescriptor</class>

typescript/src/core/processors/type.utils.ts

@@ -53,6 +53,7 @@ import { ModulePathUtils } from "../utils/modulepath.utils";
 import { DependencyResolutionProcessor } from "./dependency-resolution.processor";
 import { NodeUtils } from "../utils/node.utils";
 import path from "path";
+import { FileUtils } from "../utils/file.utils";
 
 /**
  * Returns the type for a given class property (with a non-computed name)
@@ -361,7 +362,7 @@ function parseType(processingContext: ProcessingContext, type: Type, node: Node,
             // normalize TypeChecker FQN and determine if type is part of the project
             const sourceFile = symbol?.valueDeclaration?.getSourceFile() ?? symbol?.declarations?.find((d) => !!d.getSourceFile())?.getSourceFile();
             const isStandardLibrary = !!sourceFile && globalContext.services.program.isSourceFileDefaultLibrary(sourceFile);
-            const relativeSrcPath = !!sourceFile ? path.relative(globalContext.projectInfo.rootPath, sourceFile.fileName).replace(/\\/g, "/") : undefined;
+            const relativeSrcPath = !!sourceFile ? FileUtils.normalizePath(path.relative(globalContext.projectInfo.rootPath, sourceFile.fileName)) : undefined;
             const isExternal = !!sourceFile && (globalContext.services.program.isSourceFileFromExternalLibrary(sourceFile) || relativeSrcPath!.startsWith("node_modules"));
 
             let normalizedFqn = new FQN("");

typescript/src/core/utils/modulepath.utils.ts

@@ -25,7 +25,7 @@ export class ModulePathUtils {
     static getPathType(path: string): PathType {
         if (p.isAbsolute(path)) {
             return "absolute";
-        } else if (path.startsWith(".") && !path.replace(/\\/g, "/").startsWith("./node_modules")) {
+        } else if (path.startsWith(".") && !FileUtils.normalizePath(path).startsWith("./node_modules")) {
             return "relative";
         } else {
             return "node";
@@ -47,10 +47,10 @@ export class ModulePathUtils {
         } else {
             let relPath;
             if (pathType === "absolute") {
-                relPath = p.relative(projectPath, path).replace(/\\/g, "/");
+                relPath = FileUtils.normalizePath(p.relative(projectPath, path));
             } else {
                 if (!originPath) throw new Error("originPath is required if path is relative");
-                relPath = p.relative(projectPath, p.resolve(projectPath, originPath.slice(0, originPath.lastIndexOf("/")), path)).replace(/\\/g, "/");
+                relPath = FileUtils.normalizePath(p.relative(projectPath, p.resolve(projectPath, originPath.slice(0, originPath.lastIndexOf("/")), path)));
             }
 
             if (!relPath.startsWith(".")) {
@@ -122,7 +122,7 @@ export class ModulePathUtils {
 
                 // normalize paths on Windows platforms
                 if(process.platform === "win32") {
-                    sourceFilePath = sourceFilePath.replace(/\\/g, "/");
+                    sourceFilePath = FileUtils.normalizePath(sourceFilePath);
                 }
 
                 // remove index.* filename from FQN path
@@ -135,7 +135,7 @@ export class ModulePathUtils {
         } else {
             let sourceFilePath = fs.realpathSync.native(sourceFilePathAbsolute);
             if(process.platform === "win32") {
-                sourceFilePath = sourceFilePath.replace(/\\/g, "/");
+                sourceFilePath = FileUtils.normalizePath(sourceFilePath);
             }
             return this.toFQN(sourceFilePath).globalFqn + "." + tcFQN;
         }
@@ -147,8 +147,8 @@ export class ModulePathUtils {
      */
     static toFQN(globalPath: string, localPath?: string): FQN {
         const indexSourceFileRegEx = /\/index\.\w+$/;
-        const basicGlobalFQN = '"' + (globalPath.replace(/\\/g, "/")).replace(indexSourceFileRegEx, "") + '"';
-        const basicLocalFQN = localPath ? '"' + (localPath.replace(/\\/g, "/")).replace(indexSourceFileRegEx, "") + '"' : "";
+        const basicGlobalFQN = '"' + (FileUtils.normalizePath(globalPath)).replace(indexSourceFileRegEx, "") + '"';
+        const basicLocalFQN = localPath ? '"' + (FileUtils.normalizePath(localPath)).replace(indexSourceFileRegEx, "") + '"' : "";
 
         return new FQN(
             basicGlobalFQN,

typescript/src/core/utils/node.utils.ts

@@ -30,7 +30,7 @@ export class NodeUtils {
 
         let currentPath = packagePath;
         while (currentPath !== projectRootPath && !path.relative(projectRootPath, currentPath).startsWith("..")) {
-            const allFiles = FileUtils.getAllFiles(currentPath).map((f) => f.replace(/\\/g, "/"));
+            const allFiles = FileUtils.getAllFiles(currentPath).map((f) => FileUtils.normalizePath(f));
             for (const file of allFiles) {
                 if (path.basename(file) === "package.json") {
                     const data = fs.readFileSync(file, "utf8");
@@ -68,14 +68,14 @@ export class NodeUtils {
             tsResolvedModule = module.resolvedModule?.resolvedFileName;
         } catch (e) {}
         if (tsResolvedModule) {
-            return tsResolvedModule.replace(/\\/g, "/");
+            return FileUtils.normalizePath(tsResolvedModule);
         } else {
             let jsResolvedModule: string | undefined;
             try {
                 jsResolvedModule = require.resolve(importPath, { paths: [projectPath] });
             } catch (e) {}
             if (jsResolvedModule) {
-                return jsResolvedModule.replace(/\\/g, "/");
+                return FileUtils.normalizePath(jsResolvedModule);
             } else {
                 throw new Error(`Could not resolve import: ${importPath}`);
             }

typescript/src/core/utils/project.utils.ts

@@ -78,7 +78,7 @@ export class ProjectUtils {
         if(tsConfig.projectReferences) {
             for (const ref of tsConfig.projectReferences) {
                 const subProjectInfos = this.getProjectInfo(ref.path);
-                subProjectPaths.push(...subProjectInfos.map(spi => spi.projectPath.replace(/\\/g, "/")));
+                subProjectPaths.push(...subProjectInfos.map(spi => FileUtils.normalizePath(spi.projectPath)));
                 result.push(...subProjectInfos);
             }
         }
@@ -90,10 +90,10 @@ export class ProjectUtils {
         }
 
         result.push({
-            rootPath: rootPath.replace(/\\/g, "/"),
-            projectPath: projectPath.replace(/\\/g, "/"),
+            rootPath: FileUtils.normalizePath(rootPath),
+            projectPath: FileUtils.normalizePath(projectPath),
             subProjectPaths: subProjectPaths,
-            sourceFilePaths: tsConfig.fileNames.map(fn => fn.replace(/\\/g, "/"))
+            sourceFilePaths: tsConfig.fileNames.map(fn => FileUtils.normalizePath(fn))
         });
 
         return result;

typescript/src/core/utils/traverser.utils.ts

@@ -8,6 +8,12 @@ import { TraverserContext } from "../traverser";
 
 /**
  * Tries to find an appropriate `Traverser` for the given node and calls its `traverse` method on the node.
+ *
+ * @param node child node of the node of the current processing context
+ * @param traverserContext `TraverserContext` containing the property name of provided child node
+ * @param parentNode/unusedProcessingContext current processing context
+ * @param processors processors provided to a traverser
+ * @param conceptMaps array of `ConceptMap`s to which extracted child concepts will be added
  * @returns the concepts generated for the node and/or its children or `undefined` if no `Traverser` could be found
  */
 export function runTraverserForNode(
@@ -38,6 +44,12 @@ export function runTraverserForNode(
 /**
  * Runs`runTraverserForNode` for the given nodes.
  * Also provides index information of the parent node property to the traversers.
+ *
+ * @param nodes child nodes of the node of the current processing context
+ * @param traverserContext `TraverserContext` containing the property name of provided child nodes
+ * @param processingContext current processing context
+ * @param processors processors provided to a traverser
+ * @param conceptMaps array of `ConceptMap`s to which extracted child concepts will be added
  */
 export function runTraverserForNodes(
     nodes: (Node | null)[],