NodeUtils refactoring

dist/index.js

@@ -260,18 +260,22 @@ module.exports =
 	        value: function getBlockScopeOfNode(node) {
 	            var depth = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];
 	
-	            if (!node.parentNode) {
+	            var parentNode = node.parentNode;
+	            if (!parentNode) {
 	                throw new ReferenceError('`parentNode` property of given node is `undefined`');
 	            }
-	            if (!Utils_1.Utils.arrayContains(NodeUtils.nodesWithBlockScope, node.parentNode.type)) {
-	                return NodeUtils.getBlockScopeOfNode(node.parentNode, depth);
-	            } else if (depth > 0) {
-	                return NodeUtils.getBlockScopeOfNode(node.parentNode, --depth);
+	            if (Nodes_1.Nodes.isBlockStatementNode(parentNode)) {
+	                if (!Utils_1.Utils.arrayContains(NodeUtils.nodesWithBlockScope, parentNode['parentNode'].type)) {
+	                    return NodeUtils.getBlockScopeOfNode(parentNode, depth);
+	                } else if (depth > 0) {
+	                    return NodeUtils.getBlockScopeOfNode(parentNode, --depth);
+	                }
+	                return parentNode;
 	            }
-	            if (Nodes_1.Nodes.isProgramNode(node) || Nodes_1.Nodes.isBlockStatementNode(node)) {
-	                return node;
+	            if (Nodes_1.Nodes.isProgramNode(parentNode)) {
+	                return parentNode;
 	            }
-	            return NodeUtils.getBlockScopeOfNode(node.parentNode);
+	            return NodeUtils.getBlockScopeOfNode(parentNode);
 	        }
 	    }, {
 	        key: "insertNodeAtIndex",

src/NodeUtils.ts

@@ -69,21 +69,27 @@ export class NodeUtils {
      * @returns {INode}
      */
     public static getBlockScopeOfNode (node: INode, depth: number = 0): TNodeWithBlockStatement {
-        if (!node.parentNode) {
+        let parentNode: INode = node.parentNode;
+
+        if (!parentNode) {
             throw new ReferenceError('`parentNode` property of given node is `undefined`');
         }
 
-        if (!Utils.arrayContains(NodeUtils.nodesWithBlockScope, node.parentNode.type)) {
-            return NodeUtils.getBlockScopeOfNode(node.parentNode, depth);
-        } else if (depth > 0) {
-            return NodeUtils.getBlockScopeOfNode(node.parentNode, --depth);
+        if (Nodes.isBlockStatementNode(parentNode)) {
+            if (!Utils.arrayContains(NodeUtils.nodesWithBlockScope, parentNode['parentNode'].type)) {
+                return NodeUtils.getBlockScopeOfNode(parentNode, depth);
+            } else if (depth > 0) {
+                return NodeUtils.getBlockScopeOfNode(parentNode, --depth);
+            }
+
+            return parentNode;
         }
 
-        if (Nodes.isProgramNode(node) || Nodes.isBlockStatementNode(node)) {
-            return node;
+        if (Nodes.isProgramNode(parentNode)) {
+            return parentNode;
         }
 
-        return NodeUtils.getBlockScopeOfNode(node.parentNode);
+        return NodeUtils.getBlockScopeOfNode(parentNode);
     }
 
     /**

test/NodeUtils.spec.ts

@@ -156,15 +156,21 @@ describe('NodeUtils', () => {
             functionDeclarationNode['parentNode'] = programNode;
             blockStatementNode['parentNode'] = functionDeclarationNode;
             identifierNode['parentNode'] = blockStatementNode;
-            literalNode['parentNode'] = blockStatementNode;
         });
 
         it('should return block-scope node for given node', () => {
             assert.deepEqual(NodeUtils.getBlockScopeOfNode(identifierNode), blockStatementNode);
             assert.deepEqual(NodeUtils.getBlockScopeOfNode(identifierNode, 1), programNode);
             assert.deepEqual(NodeUtils.getBlockScopeOfNode(functionDeclarationNode), programNode);
+            assert.deepEqual(NodeUtils.getBlockScopeOfNode(blockStatementNode), programNode);
             assert.deepEqual(NodeUtils.getBlockScopeOfNode(programNode), programNode);
         });
+
+        it('should throw a `ReferenceError` if node has no `parentNode` property', () => {
+            assert.throws(function () {
+                return NodeUtils.getBlockScopeOfNode(literalNode);
+            }, ReferenceError);
+        });
     });
 
     describe('insertNodeAtIndex (blockScopeBody: INode[], node: INode, index: number): void', () => {
@@ -214,8 +220,6 @@ describe('NodeUtils', () => {
             ]);
 
             NodeUtils.parentize(blockStatementNode);
-
-            console.log(blockStatementNode);
         });
 
         it('should parentize given AST-tree', () => {