Moved logic from ParentificationTransformer to NodeUtils.parentizeNode method

src/interfaces/node-transformers/ITransformersRunner.d.ts

@@ -8,5 +8,5 @@ export interface ITransformersRunner {
      * @param {NodeTransformer[]} nodeTransformers
      * @returns {T}
      */
-    transform <T extends ESTree.Program> (astTree: T, nodeTransformers: NodeTransformer[]): T;
+    transform <T extends ESTree.Node = ESTree.Program> (astTree: T, nodeTransformers: NodeTransformer[]): T;
 }

src/node-transformers/preparing-transformers/ParentificationTransformer.ts

@@ -8,6 +8,7 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeUtils } from '../../node/NodeUtils';
 
 /**
  * Adds `parentNode` properties to each node
@@ -42,9 +43,6 @@ export class ParentificationTransformer extends AbstractNodeTransformer {
      * @returns {Node}
      */
     public transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node {
-        node.parentNode = parentNode || node;
-        node.obfuscatedNode = false;
-
-        return node;
+        return NodeUtils.parentizeNode(node, parentNode);
     }
 }

src/node/NodeUtils.ts

@@ -200,17 +200,26 @@ export class NodeUtils {
      * @param {T} astTree
      * @returns {T}
      */
-    public static parentize <T extends ESTree.Node = ESTree.Program> (astTree: T): T {
+    public static parentize <T extends ESTree.Node = ESTree.Node> (astTree: T): T {
         estraverse.traverse(astTree, {
-            enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                node.parentNode = parentNode || node;
-                node.obfuscatedNode = false;
-            }
+            enter: NodeUtils.parentizeNode
         });
 
         return astTree;
     }
 
+    /**
+     * @param {T} node
+     * @param {Node} parentNode
+     * @returns {T}
+     */
+    public static parentizeNode <T extends ESTree.Node = ESTree.Node> (node: T, parentNode: ESTree.Node): T {
+        node.parentNode = parentNode || node;
+        node.obfuscatedNode = false;
+
+        return node;
+    }
+
     /**
      * @param {NodeGuards} astTree
      * @param {string} nodeType

test/index.spec.ts

@@ -17,7 +17,6 @@ import './unit-tests/logger/Logger.spec';
 import './unit-tests/node/node-appender/NodeAppender.spec';
 import './unit-tests/node/node-utils/NodeUtils.spec';
 import './unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec';
-import './unit-tests/node-transformers/preparing-transformers/ParentificationTransformer.spec';
 import './unit-tests/obfuscation-result/ObfuscationResult.spec';
 import './unit-tests/options/OptionsNormalizer.spec';
 import './unit-tests/options/ValidationErrorsFormatter.spec';

test/unit-tests/node-transformers/preparing-transformers/ParentificationTransformer.spec.ts

@@ -1,66 +0,0 @@
-import 'reflect-metadata';
-
-import { assert } from 'chai';
-
-import * as ESTree from 'estree';
-
-import { ServiceIdentifiers } from '../../../../src/container/ServiceIdentifiers';
-import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
-
-import { IInversifyContainerFacade } from '../../../../src/interfaces/container/IInversifyContainerFacade';
-import { INodeTransformer } from '../../../../src/interfaces/node-transformers/INodeTransformer';
-
-import { NodeTransformer } from '../../../../src/enums/node-transformers/NodeTransformer';
-import { Nodes } from '../../../../src/node/Nodes';
-import { NodeUtils } from '../../../../src/node/NodeUtils';
-
-describe('ParentificationTransformer', () => {
-    describe('transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node', () => {
-        let inversifyContainerFacade: IInversifyContainerFacade,
-            parentificationTransformer: INodeTransformer;
-
-        before(() => {
-            inversifyContainerFacade = new InversifyContainerFacade();
-            inversifyContainerFacade.load('', {});
-
-            parentificationTransformer = inversifyContainerFacade
-                .getNamed(ServiceIdentifiers.INodeTransformer, NodeTransformer.ParentificationTransformer);
-        });
-
-        describe('variant #1: node with parent node', () => {
-            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
-            const breakStatement: ESTree.BreakStatement = Nodes.getBreakStatement(identifier);
-
-            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
-
-            let result: ESTree.Identifier;
-
-            before(() => {
-                expectedResult.parentNode = breakStatement;
-
-                result = <ESTree.Identifier>parentificationTransformer.transformNode(identifier, breakStatement);
-            });
-
-            it('should parentize given node', () => {
-                assert.deepEqual(result, expectedResult);
-            });
-        });
-
-        describe('variant #2: node without parent node', () => {
-            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('Foo');
-            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
-
-            let result: ESTree.Identifier;
-
-            before(() => {
-                expectedResult.parentNode = expectedResult;
-
-                result = <ESTree.Identifier>parentificationTransformer.transformNode(identifier, <any>null);
-            });
-
-            it('should parentize given node', () => {
-                assert.deepEqual(result, expectedResult);
-            });
-        });
-    });
-});

test/unit-tests/node/node-utils/NodeUtils.spec.ts

@@ -493,7 +493,7 @@ describe('NodeUtils', () => {
             );
         });
 
-        describe('parentize AST-tree with `ProgramNode` as root node', () => {
+        describe('variant #1: parentize AST-tree with `ProgramNode` as root node', () => {
             beforeEach(() => {
                 programNode = Nodes.getProgramNode([
                     ifStatementNode
@@ -523,7 +523,7 @@ describe('NodeUtils', () => {
             });
         });
 
-        describe('parentize AST-tree', () => {
+        describe('variant #2: parentize AST-tree', () => {
             beforeEach(() => {
                 ifStatementNode = NodeUtils.parentize(ifStatementNode);
             });
@@ -545,4 +545,42 @@ describe('NodeUtils', () => {
             });
         });
     });
+
+    describe('parentizeNode <T extends ESTree.Node = ESTree.Program> (node: T, parentNode: ESTree.Node): T', () => {
+        describe('variant #1: node with parent node', () => {
+            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('foo');
+            const breakStatement: ESTree.BreakStatement = Nodes.getBreakStatement(identifier);
+
+            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
+
+            let result: ESTree.Identifier;
+
+            before(() => {
+                expectedResult.parentNode = breakStatement;
+
+                result = NodeUtils.parentizeNode(identifier, breakStatement);
+            });
+
+            it('should parentize given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+
+        describe('variant #2: node without parent node', () => {
+            const identifier: ESTree.Identifier = Nodes.getIdentifierNode('Foo');
+            const expectedResult: ESTree.Identifier = NodeUtils.clone(identifier);
+
+            let result: ESTree.Identifier;
+
+            before(() => {
+                expectedResult.parentNode = expectedResult;
+
+                result = NodeUtils.parentizeNode(identifier, <any>null);
+            });
+
+            it('should parentize given node', () => {
+                assert.deepEqual(result, expectedResult);
+            });
+        });
+    });
 });