Some refactoring. Added IdentifierNamesCacheStorage tests

src/interfaces/node-transformers/rename-identifiers-transformers/replacer/IThroughIdentifierReplacer.ts

@@ -1,11 +1,6 @@
 import * as ESTree from 'estree';
 
 export interface IThroughIdentifierReplacer {
-    /**
-     * @param {Identifier} identifierNode
-     */
-    store (identifierNode: ESTree.Identifier): void;
-
     /**
      * @param {Identifier} identifierNode
      * @returns {Identifier}

src/node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer.ts

@@ -108,30 +108,15 @@ export class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer
             return;
         }
 
-        const identifier: ESTree.Identifier = reference.identifier;
-
-        this.storeIdentifierName(identifier);
-        this.replaceIdentifierName(identifier, reference);
+        this.replaceIdentifierName(reference);
     }
 
     /**
-     * @param {Identifier} identifierNode
-     */
-    protected storeIdentifierName (
-        identifierNode: ESTree.Identifier
-    ): void {
-        this.throughIdentifierReplacer.store(identifierNode);
-    }
-
-    /**
-     * @param {Identifier} identifierNode
      * @param {Variable} reference
      */
-    protected replaceIdentifierName (
-        identifierNode: ESTree.Identifier,
-        reference: eslintScope.Reference
-    ): void {
-        const newIdentifier: ESTree.Identifier = this.throughIdentifierReplacer.replace(identifierNode);
+    protected replaceIdentifierName (reference: eslintScope.Reference): void {
+        const identifier: ESTree.Identifier = reference.identifier;
+        const newIdentifier: ESTree.Identifier = this.throughIdentifierReplacer.replace(identifier);
 
         // rename of identifier
         reference.identifier.name = newIdentifier.name;

src/node-transformers/rename-identifiers-transformers/replacer/IdentifierReplacer.ts

@@ -77,7 +77,9 @@ export class IdentifierReplacer implements IIdentifierReplacer {
         namesMap.set(identifierName, newIdentifierName);
 
         // Have to write all global identifier names to the identifier names cache storage
-        this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
+        if (this.options.identifierNamesCache) {
+            this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
+        }
     }
 
     /**

src/node-transformers/rename-identifiers-transformers/through-replacer/ThroughIdentifierReplacer.ts

@@ -34,37 +34,17 @@ export class ThroughIdentifierReplacer implements IThroughIdentifierReplacer {
         this.options = options;
     }
 
-    /**
-     * Store identifier node `name` of `through` identifiers as key in map with value from identifier names cache.
-     * Reserved name will be ignored.
-     *
-     * @param {Node} identifierNode
-     */
-    public store (identifierNode: ESTree.Identifier): void {
-        const identifierName: string = identifierNode.name;
-
-        if (this.isReservedName(identifierName)) {
-            return;
-        }
-
-        const newIdentifierName: string | null = this.identifierNamesCacheStorage.get(identifierName) ?? null;
-
-        if (!newIdentifierName) {
-            return;
-        }
-
-        this.identifierNamesCacheStorage.set(identifierName, newIdentifierName);
-    }
-
     /**
      * @param {Identifier} identifierNode
      * @returns {Identifier}
      */
     public replace (identifierNode: ESTree.Identifier): ESTree.Identifier {
-        const identifierName: string = this.identifierNamesCacheStorage.get(identifierNode.name)
-            ?? identifierNode.name;
+        const identifierName: string = identifierNode.name;
+        const newIdentifierName: string = this.options.identifierNamesCache && !this.isReservedName(identifierName)
+            ? this.identifierNamesCacheStorage.get(identifierName) ?? identifierName
+            : identifierName;
 
-        return NodeFactory.identifierNode(identifierName);
+        return NodeFactory.identifierNode(newIdentifierName);
     }
 
     /**

src/storages/identifier-names-cache/IdentifierNamesCacheStorage.ts

@@ -11,12 +11,7 @@ import { MapStorage } from '../MapStorage';
 
 @injectable()
 export class IdentifierNamesCacheStorage extends MapStorage <string, string> implements IIdentifierNamesCacheStorage {
-    /**
-     * @type {boolean}
-     */
-    private readonly shouldUseCache: boolean;
-
-    /**
+   /**
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      */
@@ -25,60 +20,20 @@ export class IdentifierNamesCacheStorage extends MapStorage <string, string> imp
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(randomGenerator, options);
-
-        this.shouldUseCache = !!options.identifierNamesCache;
     }
 
     @postConstruct()
     public override initialize (): void {
        super.initialize();
 
-       if (this.options.identifierNamesCache) {
-           this.storage = new Map(Object.entries(this.options.identifierNamesCache));
-       }
-    }
-
-    /**
-     * @param {string} key
-     * @returns {string | undefined}
-     */
-    public override get (key: string): string | undefined {
-        if (!this.shouldUseCache) {
-            return undefined;
-        }
-
-        return super.get(key);
-    }
-
-    /**
-     * @param {string} key
-     * @returns {boolean}
-     */
-    public override has (key: string): boolean {
-        if (!this.shouldUseCache) {
-            return false;
-        }
-
-        return super.has(key);
-    }
-
-    /**
-     * @param {string} key
-     * @param {string} value
-     */
-    public override set (key: string, value: string): void {
-        if (!this.shouldUseCache) {
-            return;
-        }
-
-        super.set(key, value);
+        this.storage = new Map(Object.entries(this.options.identifierNamesCache ?? {}));
     }
 
     /**
      * @returns {TIdentifierNamesCache}
      */
     public getCache (): TIdentifierNamesCache {
-        if (!this.shouldUseCache) {
+        if (!this.options.identifierNamesCache) {
             return null;
         }
 

test/index.spec.ts

@@ -36,6 +36,7 @@ import './unit-tests/source-code/ObfuscatedCode.spec';
 import './unit-tests/source-code/SourceCode.spec';
 import './unit-tests/storages/ArrayStorage.spec';
 import './unit-tests/storages/MapStorage.spec';
+import './unit-tests/storages/identifier-names-cache/IdentifierNamesCacheStorage.spec';
 import './unit-tests/storages/string-array-transformers/literal-nodes-cache/LiteralNodesCacheStorage.spec';
 import './unit-tests/storages/string-array-transformers/string-array/StringArrayStorage.spec';
 import './unit-tests/storages/string-array-transformers/visited-lexical-scope-nodes-stack/VisitedLexicalScopeNodesStackStorage.spec';

test/unit-tests/storages/identifier-names-cache/IdentifierNamesCacheStorage.spec.ts

@@ -0,0 +1,164 @@
+import 'reflect-metadata';
+
+import { assert } from 'chai';
+
+import { ServiceIdentifiers } from '../../../../src/container/ServiceIdentifiers';
+
+import { TDictionary } from '../../../../src/types/TDictionary';
+import { TIdentifierNamesCache } from '../../../../src/types/storages/TIdentifierNamesCache';
+
+import { IIdentifierNamesCacheStorage } from '../../../../src/interfaces/storages/identifier-names-cache/IIdentifierNamesCacheStorage';
+import { IInversifyContainerFacade } from '../../../../src/interfaces/container/IInversifyContainerFacade';
+import { IOptions } from '../../../../src/interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../../src/interfaces/utils/IRandomGenerator';
+
+import { DEFAULT_PRESET } from '../../../../src/options/presets/Default';
+
+import { IdentifierNamesCacheStorage } from '../../../../src/storages/identifier-names-cache/IdentifierNamesCacheStorage';
+import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
+
+/**
+ * @returns {IIdentifierNamesCacheStorage}
+ */
+const getStorageInstance = <V>(options: Partial<IOptions> = DEFAULT_PRESET): IIdentifierNamesCacheStorage => {
+    const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+    inversifyContainerFacade.load('', '', {});
+
+    const storage: IIdentifierNamesCacheStorage = new IdentifierNamesCacheStorage (
+        inversifyContainerFacade.get<IRandomGenerator>(ServiceIdentifiers.IRandomGenerator),
+        {
+            ...DEFAULT_PRESET,
+            ...options as IOptions
+        }
+    );
+
+    storage.initialize();
+
+    return storage;
+};
+
+describe('IdentifierNamesCacheStorage', () => {
+    const storageKey: string = 'foo';
+    const storageValue: string = 'bar';
+
+    let storage: IIdentifierNamesCacheStorage;
+
+    describe('initialize', () => {
+        describe('Variant #1: `identifierNamesCache` option values is object', () => {
+            const expectedDictionary: TDictionary<string> = {
+                [storageKey]: storageValue
+            };
+
+            let dictionary: TDictionary<string>;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: {
+                        [storageKey]: storageValue
+                    }
+                });
+
+                dictionary = storage.getStorageAsDictionary();
+            });
+
+            it('should initialize storage with `identifierNamesStorage` option object', () => {
+                assert.deepEqual(dictionary, expectedDictionary);
+            });
+        });
+
+        describe('Variant #2: `identifierNamesCache` option values is empty object', () => {
+            const expectedDictionary: TDictionary<string> = {};
+
+            let dictionary: TDictionary<string>;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: {}
+                });
+
+                dictionary = storage.getStorageAsDictionary();
+            });
+
+            it('should initialize storage with `identifierNamesStorage` option object', () => {
+                assert.deepEqual(dictionary, expectedDictionary);
+            });
+        });
+
+        describe('Variant #3: `identifierNamesCache` option values is `null`', () => {
+            const expectedDictionary: TDictionary<string> = {};
+
+            let dictionary: TDictionary<string>;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: null
+                });
+
+                dictionary = storage.getStorageAsDictionary();
+            });
+
+            it('should initialize storage with `identifierNamesStorage` option object', () => {
+                assert.deepEqual(dictionary, expectedDictionary);
+            });
+        });
+    });
+
+    describe('getCache', () => {
+        describe('Variant #1: `identifierNamesCache` option values is object', () => {
+            const expectedIdentifierNamesCache: TIdentifierNamesCache = {
+                [storageKey]: storageValue
+            };
+
+            let identifierNamesCache: TIdentifierNamesCache;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: {
+                        [storageKey]: storageValue
+                    }
+                });
+
+                identifierNamesCache = storage.getCache();
+            });
+
+            it('should return cache object', () => {
+                assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache);
+            });
+        });
+
+        describe('Variant #2: `identifierNamesCache` option values is empty object', () => {
+            const expectedIdentifierNamesCache: TIdentifierNamesCache = {};
+
+            let identifierNamesCache: TIdentifierNamesCache;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: {}
+                });
+
+                identifierNamesCache = storage.getCache();
+            });
+
+            it('should return empty cache object', () => {
+                assert.deepEqual(identifierNamesCache, expectedIdentifierNamesCache);
+            });
+        });
+
+        describe('Variant #3: `identifierNamesCache` option values is `null`', () => {
+            let identifierNamesCache: TIdentifierNamesCache;
+
+            before(() => {
+                storage = getStorageInstance({
+                    identifierNamesCache: null
+                });
+                storage.set(storageKey, storageValue);
+
+                identifierNamesCache = storage.getCache();
+            });
+
+            it('should return `null`', () => {
+                assert.isNull(identifierNamesCache);
+            });
+        });
+    });
+});