Implement a cache for loc file parsing.

iclanton · iclanton · commit 2e0bdffed518 · 2020-02-04T14:47:03.000-08:00
diff --git a/webpack/localization-plugin/src/TypingsGenerator.ts b/webpack/localization-plugin/src/TypingsGenerator.ts
@@ -3,7 +3,6 @@
 
 import {
   FileSystem,
-  JsonFile,
   Terminal,
   ConsoleTerminalProvider,
   Path
@@ -14,13 +13,7 @@ import { EOL } from 'os';
 import * as chokidar from 'chokidar';
 
 import { ILocFile } from './interfaces';
-import { ResxReader } from './utilities/ResxReader';
-import { Constants } from './utilities/Constants';
-import {
-  Logging,
-  ILoggingFunctions,
-  ILoggerOptions
-} from './utilities/Logging';
+import { ILoggerOptions } from './utilities/Logging';
 import { LocFileParser } from './utilities/LocFileParser';
 
 /**
@@ -41,7 +34,6 @@ export interface ITypingsGeneratorOptions {
  */
 export class TypingsGenerator {
   private _options: ITypingsGeneratorOptions;
-  private _loggingFunctions: ILoggingFunctions;
   private _loggingOptions: ILoggerOptions;
 
   public constructor(options: ITypingsGeneratorOptions) {
@@ -74,7 +66,6 @@ export class TypingsGenerator {
       writeError: this._options.terminal.writeErrorLine.bind(this._options.terminal),
       writeWarning: this._options.terminal.writeWarningLine.bind(this._options.terminal)
     };
-    this._loggingFunctions = Logging.getLoggingFunctions(this._loggingOptions);
   }
 
   public generateTypings(): void {
@@ -84,42 +75,22 @@ export class TypingsGenerator {
       return path.resolve(this._options.srcFolder, fileToIgnore);
     }));
 
-    const locJsonFilePaths: string[] = glob.sync(
-      path.join('**', '*.loc.json'),
-      {
-        root: this._options.srcFolder,
-        absolute: true
-      }
-    );
-
-    for (let locJsonFilePath of locJsonFilePaths) {
-      locJsonFilePath = path.resolve(locJsonFilePath);
-
-      if (filesToIgnore.has(locJsonFilePath)) {
-        continue;
-      }
-
-      const locFileData: ILocFile = JsonFile.loadAndValidate(locJsonFilePath, Constants.LOC_JSON_SCHEMA);
-      this._generateTypingsForLocFile(locJsonFilePath, locFileData);
-    }
-
-    const resxFiles: string[] = glob.sync(
-      path.join('**', '*.resx'),
+    const locFilePaths: string[] = glob.sync(
+      path.join('**', '*+(.resx|.loc.json)'),
       {
         root: this._options.srcFolder,
         absolute: true
       }
     );
 
-    for (let resxFilePath of resxFiles) {
-      resxFilePath = path.resolve(resxFilePath);
+    for (let locFilePath of locFilePaths) {
+      locFilePath = path.resolve(locFilePath);
 
-      if (filesToIgnore.has(resxFilePath)) {
+      if (filesToIgnore.has(locFilePath)) {
         continue;
       }
 
-      const locFileData: ILocFile = ResxReader.readResxFileAsLocFile({ ...this._loggingFunctions, resxFilePath });
-      this._generateTypingsForLocFile(resxFilePath, locFileData);
+      this._parseFileAndGenerateTypings(locFilePath);
     }
   }
 
diff --git a/webpack/localization-plugin/src/utilities/LocFileParser.ts b/webpack/localization-plugin/src/utilities/LocFileParser.ts
@@ -18,9 +18,15 @@ export interface IParseLocFileOptions {
   content: string;
 }
 
+interface IParseCacheEntry {
+  content: string;
+  parsedFile: ILocFile;
+}
+
+const parseCache: Map<string, IParseCacheEntry> = new Map<string, IParseCacheEntry>();
+
 export class LocFileParser {
   public static parseLocFileFromLoader(content: string, loaderContext: loader.LoaderContext): ILocFile {
-    debugger;
     return LocFileParser.parseLocFile({
       filePath: loaderContext.resourcePath,
       loggerOptions: { writeError: loaderContext.emitError, writeWarning: loaderContext.emitWarning },
@@ -29,23 +35,32 @@ export class LocFileParser {
   }
 
   public static parseLocFile(options: IParseLocFileOptions): ILocFile {
+    if (parseCache.has(options.filePath)) {
+      const entry: IParseCacheEntry = parseCache.get(options.filePath)!;
+      if (entry.content === options.content) {
+        return entry.parsedFile;
+      }
+    }
+
+    let parsedFile: ILocFile;
     if (/\.resx$/i.test(options.filePath)) {
-      return ResxReader.readResxAsLocFile(
+      parsedFile = ResxReader.readResxAsLocFile(
         options.content,
         {
           ...Logging.getLoggingFunctions(options.loggerOptions),
           resxFilePath: options.filePath
         }
       );
     } else {
-      const locJsonFileData: ILocFile = jju.parse(options.content);
+      parsedFile = jju.parse(options.content);
       try {
-        Constants.LOC_JSON_SCHEMA.validateObject(locJsonFileData, options.filePath);
+        Constants.LOC_JSON_SCHEMA.validateObject(parsedFile, options.filePath);
       } catch (e) {
         options.loggerOptions.writeError(`The loc file is invalid. Error: ${e}`);
       }
-
-      return locJsonFileData;
     }
+
+    parseCache.set(options.filePath, { content: options.content, parsedFile });
+    return parsedFile;
   }
 }
