Merge pull request #136 from IBM/feature/static_language_provider

Refactor language provider to static implementation

Author: worksofliam

cli/package-lock.json

@@ -68,7 +68,7 @@ export interface FileOptions {
  */
 
 export class Targets {
-	private languageProvider: TargetsLanguageProvider;
+	static LanguageProvider: TargetsLanguageProvider = new TargetsLanguageProvider();
 
 	/* pathCache and resolvedSearches are used for file resolving. */
 	private pathCache: { [path: string]: true | string[] } | undefined;
@@ -89,15 +89,14 @@ export class Targets {
 
 	constructor(private cwd: string, private fs: ReadFileSystem) {
 		this.logger = new Logger();
-		this.languageProvider = new TargetsLanguageProvider(this);
 	}
 
 	static get ignoredObjects() {
 		return ignoredObjects;
 	}
 
 	getSearchGlob(): string {
-		return this.languageProvider.getGlob();
+		return Targets.LanguageProvider.getGlob();
 	}
 
 	public getCwd() {
@@ -143,7 +142,7 @@ export class Targets {
 	}
 
 	private extCanBeProgram(ext: string): boolean {
-		return [`MODULE`, `PGM`].includes(this.languageProvider.getObjectType(ext));
+		return [`MODULE`, `PGM`].includes(Targets.LanguageProvider.getObjectType(ext));
 	}
 
 	public async resolvePathToObject(localPath: string, newText?: string) {
@@ -335,7 +334,7 @@ export class Targets {
 
 	// TODO: move this to language provider
 	getObjectType(relativePath: string, ext: string): ObjectType {
-		const objType = this.languageProvider.getObjectType(ext);
+		const objType = Targets.LanguageProvider.getObjectType(ext);
 
 		if (!objType) {
 			this.logger.fileLog(relativePath, {
@@ -389,7 +388,7 @@ export class Targets {
 					text: textMatch
 				};
 
-				await this.languageProvider.handleLanguage(filePath, content, options);
+				await Targets.LanguageProvider.handleLanguage(this, filePath, content, options);
 			} catch (e) {
 				this.logger.fileLog(relative, {
 					message: `Failed to parse file.`,

cli/src/targets/index.ts

@@ -1,7 +1,7 @@
 import { FileOptions, ObjectType, Targets } from ".";
 import { clExtensions, clleTargetCallback, clObjects } from "./languages/clle";
 import { ddsExtension, ddsObjects, ddsTargetCallback } from "./languages/dds";
-import { rpgExtensions, rpgleTargetParser, rpgObjects } from "./languages/rpgle";
+import { rpgleExtensions, rpgleObjects, rpgleTargetCallback } from "./languages/rpgle";
 import { sqlExtensions, sqlObjects, sqlTargetCallback } from "./languages/sql";
 import { binderExtensions, binderObjects, binderTargetCallback } from "./languages/binder";
 import { cmdExtensions, cmdObjects, cmdTargetCallback } from "./languages/cmd";
@@ -19,19 +19,14 @@ export class TargetsLanguageProvider {
   private languageTargets: LanguageGroup[] = [];
   private extensionMap: ExtensionMap = {};
 
-  constructor(private readonly targets: Targets) {
-    const rpgleTargets = new rpgleTargetParser(this.targets);
-
+  constructor() {
     this.registerLanguage(clExtensions, clleTargetCallback, clObjects);
     this.registerLanguage(sqlExtensions, sqlTargetCallback, sqlObjects);
     this.registerLanguage(ddsExtension, ddsTargetCallback, ddsObjects);
     this.registerLanguage(binderExtensions, binderTargetCallback, binderObjects);
     this.registerLanguage(cmdExtensions, cmdTargetCallback, cmdObjects);
     this.registerLanguage(noSourceObjects, noSourceTargetCallback, noSourceTargetObjects);
-
-    this.registerLanguage(rpgExtensions, (tazrgets, relativePath, content, options) => {
-      return rpgleTargets.rpgleTargetCallback(targets, relativePath, content, options);
-    }, rpgObjects);
+    this.registerLanguage(rpgleExtensions, rpgleTargetCallback, rpgleObjects);
   }
 
   public getExtensions() {
@@ -43,16 +38,11 @@ export class TargetsLanguageProvider {
     return `**/*.{${allExtensions.join(`,`)},${allExtensions.map(e => e.toUpperCase()).join(`,`)}}`;
   }
 
-  public static getStandardGlob() {
-    const allExtensions = [...clExtensions, ...sqlExtensions, ...ddsExtension, ...binderExtensions, ...cmdExtensions, ...rpgExtensions];
-    return `**/*.{${allExtensions.join(`,`)},${allExtensions.map(e => e.toUpperCase()).join(`,`)}}`;
-  }
-
-  public async handleLanguage(relativePath: string, content: string, options: FileOptions = {}) {
+  public async handleLanguage(targets: Targets, relativePath: string, content: string, options: FileOptions = {}) {
     const ext = relativePath.split('.').pop()?.toLowerCase();
     const language = this.languageTargets.find(lang => lang.extensions.includes(ext));
     if (ext && language) {
-      await language.callback(this.targets, relativePath, content, options);
+      await language.callback(targets, relativePath, content, options);
     }
   }