archive-gh-me/jsdoc
1
0
Fork 0
mirror of https://github.com/jsdoc/jsdoc.git synced 2025-12-08 19:46:11 +00:00
Code Issues Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
Jeff Williams 2015-02-26 16:05:22 -08:00
parent cc4ffc762e
commit a243719fb2
2 changed files with 113 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/jsdoc/src/astbuilder.js
View File

@ -53,7 +53,8 @@ var acceptsLeadingComments = (function() {
return accepts; return accepts;
})(); })();
var espreeOpts = { // exported so we can use them in tests
var parserOptions = exports.parserOptions = {
comment: true, comment: true,
loc: true, loc: true,
range: true, range: true,
@ -152,7 +153,7 @@ function parse(source, filename) {
var ast; var ast;
try { try {
ast = espree.parse(source, espreeOpts); ast = espree.parse(source, parserOptions);
} }
catch (e) { catch (e) {
jsdoc.util.logger.error('Unable to parse %s: %s', filename, e.message); jsdoc.util.logger.error('Unable to parse %s: %s', filename, e.message);

218
test/specs/jsdoc/src/astnode.js
View File

@ -1,77 +1,79 @@
'use strict'; 'use strict';
describe('jsdoc/src/astnode', function() { describe('jsdoc/src/astNode', function() {
var astnode = require('jsdoc/src/astnode'); var astBuilder = require('jsdoc/src/astbuilder');
var astNode = require('jsdoc/src/astnode');
var doop = require('jsdoc/util/doop'); var doop = require('jsdoc/util/doop');
var env = require('jsdoc/env'); var env = require('jsdoc/env');
var espree = require('espree'); var espree = require('espree');
var Syntax = require('jsdoc/src/syntax').Syntax; var Syntax = require('jsdoc/src/syntax').Syntax;
function parse(str) {
return espree.parse(str, astBuilder.parserOptions);
}
// create the AST nodes we'll be testing // create the AST nodes we'll be testing
var arrayExpression = espree.parse('[,]').body[0].expression; var arrayExpression = parse('[,]').body[0].expression;
var assignmentExpression = espree.parse('foo = 1;').body[0].expression; var assignmentExpression = parse('foo = 1;').body[0].expression;
var binaryExpression = espree.parse('foo & foo;').body[0].expression; var binaryExpression = parse('foo & foo;').body[0].expression;
var functionDeclaration1 = espree.parse('function foo() {}').body[0]; var functionDeclaration1 = parse('function foo() {}').body[0];
var functionDeclaration1a = espree.parse('function bar() {}').body[0]; var functionDeclaration1a = parse('function bar() {}').body[0];
var functionDeclaration2 = espree.parse('function foo(bar) {}').body[0]; var functionDeclaration2 = parse('function foo(bar) {}').body[0];
var functionDeclaration3 = espree.parse('function foo(bar, baz, qux) {}').body[0]; var functionDeclaration3 = parse('function foo(bar, baz, qux) {}').body[0];
var functionExpression1 = espree.parse('var foo = function() {};').body[0].declarations[0] var functionExpression1 = parse('var foo = function() {};').body[0].declarations[0].init;
.init; var functionExpression2 = parse('var foo = function(bar) {};').body[0].declarations[0].init;
var functionExpression2 = espree.parse('var foo = function(bar) {};').body[0].declarations[0] var identifier = parse('foo;').body[0].expression;
.init; var literal = parse('1;').body[0].expression;
var identifier = espree.parse('foo;').body[0].expression; var memberExpression = parse('foo.bar;').body[0].expression;
var literal = espree.parse('1;').body[0].expression; var memberExpressionComputed1 = parse('foo["bar"];').body[0].expression;
var memberExpression = espree.parse('foo.bar;').body[0].expression; var memberExpressionComputed2 = parse('foo[\'bar\'];').body[0].expression;
var memberExpressionComputed1 = espree.parse('foo["bar"];').body[0].expression; var propertyGet = parse('var foo = { get bar() {} };').body[0].declarations[0].init
var memberExpressionComputed2 = espree.parse('foo[\'bar\'];').body[0].expression;
var propertyGet = espree.parse('var foo = { get bar() {} };').body[0].declarations[0].init
.properties[0]; .properties[0];
var propertyInit = espree.parse('var foo = { bar: {} };').body[0].declarations[0].init var propertyInit = parse('var foo = { bar: {} };').body[0].declarations[0].init.properties[0];
var propertySet = parse('var foo = { set bar(a) {} };').body[0].declarations[0].init
.properties[0]; .properties[0];
var propertySet = espree.parse('var foo = { set bar(a) {} };').body[0].declarations[0].init var thisExpression = parse('this;').body[0].expression;
.properties[0]; var unaryExpression1 = parse('+1;').body[0].expression;
var thisExpression = espree.parse('this;').body[0].expression; var unaryExpression2 = parse('+foo;').body[0].expression;
var unaryExpression1 = espree.parse('+1;').body[0].expression; var variableDeclaration1 = parse('var foo = 1;').body[0];
var unaryExpression2 = espree.parse('+foo;').body[0].expression; var variableDeclaration2 = parse('var foo = 1, bar = 2;').body[0];
var variableDeclaration1 = espree.parse('var foo = 1;').body[0]; var variableDeclarator1 = parse('var foo = 1;').body[0].declarations[0];
var variableDeclaration2 = espree.parse('var foo = 1, bar = 2;').body[0]; var variableDeclarator2 = parse('var foo;').body[0].declarations[0];
var variableDeclarator1 = espree.parse('var foo = 1;').body[0].declarations[0];
var variableDeclarator2 = espree.parse('var foo;').body[0].declarations[0];
it('should exist', function() { it('should exist', function() {
expect(typeof astnode).toBe('object'); expect(typeof astNode).toBe('object');
}); });
it('should export an addNodeProperties method', function() { it('should export an addNodeProperties method', function() {
expect(typeof astnode.addNodeProperties).toBe('function'); expect(typeof astNode.addNodeProperties).toBe('function');
}); });
it('should export a getInfo method', function() { it('should export a getInfo method', function() {
expect(typeof astnode.getInfo).toBe('function'); expect(typeof astNode.getInfo).toBe('function');
}); });
it('should export a getParamNames method', function() { it('should export a getParamNames method', function() {
expect(typeof astnode.getParamNames).toBe('function'); expect(typeof astNode.getParamNames).toBe('function');
}); });
it('should export an isAccessor method', function() { it('should export an isAccessor method', function() {
expect(typeof astnode.isAccessor).toBe('function'); expect(typeof astNode.isAccessor).toBe('function');
}); });
it('should export an isAssignment method', function() { it('should export an isAssignment method', function() {
expect(typeof astnode.isAssignment).toBe('function'); expect(typeof astNode.isAssignment).toBe('function');
}); });
it('should export an isScope method', function() { it('should export an isScope method', function() {
expect(typeof astnode.isScope).toBe('function'); expect(typeof astNode.isScope).toBe('function');
}); });
it('should export a nodeToString method', function() { it('should export a nodeToString method', function() {
expect(typeof astnode.nodeToString).toBe('function'); expect(typeof astNode.nodeToString).toBe('function');
}); });
it('should export a nodeToValue method', function() { it('should export a nodeToValue method', function() {
expect(typeof astnode.nodeToValue).toBe('function'); expect(typeof astNode.nodeToValue).toBe('function');
}); });
describe('addNodeProperties', function() { describe('addNodeProperties', function() {
@ -86,22 +88,22 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return null for undefined input', function() { it('should return null for undefined input', function() {
expect( astnode.addNodeProperties() ).toBe(null); expect( astNode.addNodeProperties() ).toBe(null);
}); });
it('should return null if the input is not an object', function() { it('should return null if the input is not an object', function() {
expect( astnode.addNodeProperties('foo') ).toBe(null); expect( astNode.addNodeProperties('foo') ).toBe(null);
}); });
it('should preserve existing properties that are not "node properties"', function() { it('should preserve existing properties that are not "node properties"', function() {
var node = astnode.addNodeProperties({foo: 1}); var node = astNode.addNodeProperties({foo: 1});
expect(typeof node).toBe('object'); expect(typeof node).toBe('object');
expect(node.foo).toBe(1); expect(node.foo).toBe(1);
}); });
it('should add a non-enumerable nodeId if necessary', function() { it('should add a non-enumerable nodeId if necessary', function() {
var node = astnode.addNodeProperties({}); var node = astNode.addNodeProperties({});
var descriptor = Object.getOwnPropertyDescriptor(node, 'nodeId'); var descriptor = Object.getOwnPropertyDescriptor(node, 'nodeId');
expect(descriptor).toBeDefined(); expect(descriptor).toBeDefined();
@ -111,7 +113,7 @@ describe('jsdoc/src/astnode', function() {
it('should not overwrite an existing nodeId', function() { it('should not overwrite an existing nodeId', function() {
var nodeId = 'foo'; var nodeId = 'foo';
var node = astnode.addNodeProperties({nodeId: nodeId}); var node = astNode.addNodeProperties({nodeId: nodeId});
expect(node.nodeId).toBe(nodeId); expect(node.nodeId).toBe(nodeId);
}); });
@ -121,14 +123,14 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
descriptor = Object.getOwnPropertyDescriptor(node, 'nodeId'); descriptor = Object.getOwnPropertyDescriptor(node, 'nodeId');
expect(descriptor.enumerable).toBe(true); expect(descriptor.enumerable).toBe(true);
}); });
it('should add a non-enumerable, writable parent if necessary', function() { it('should add a non-enumerable, writable parent if necessary', function() {
var node = astnode.addNodeProperties({}); var node = astNode.addNodeProperties({});
var descriptor = Object.getOwnPropertyDescriptor(node, 'parent'); var descriptor = Object.getOwnPropertyDescriptor(node, 'parent');
expect(descriptor).toBeDefined(); expect(descriptor).toBeDefined();
@ -139,13 +141,13 @@ describe('jsdoc/src/astnode', function() {
it('should not overwrite an existing parent', function() { it('should not overwrite an existing parent', function() {
var parent = {}; var parent = {};
var node = astnode.addNodeProperties({parent: parent}); var node = astNode.addNodeProperties({parent: parent});
expect(node.parent).toBe(parent); expect(node.parent).toBe(parent);
}); });
it('should not overwrite a null parent', function() { it('should not overwrite a null parent', function() {
var node = astnode.addNodeProperties({parent: null}); var node = astNode.addNodeProperties({parent: null});
expect(node.parent).toBe(null); expect(node.parent).toBe(null);
}); });
@ -155,7 +157,7 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
descriptor = Object.getOwnPropertyDescriptor(node, 'parentId'); descriptor = Object.getOwnPropertyDescriptor(node, 'parentId');
expect(descriptor).toBeDefined(); expect(descriptor).toBeDefined();
@ -167,7 +169,7 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
expect(node.parentId).toBe(null); expect(node.parentId).toBe(null);
}); });
@ -178,15 +180,15 @@ describe('jsdoc/src/astnode', function() {
var parent; var parent;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
parent = astnode.addNodeProperties({}); parent = astNode.addNodeProperties({});
node.parent = parent; node.parent = parent;
expect(node.parentId).toBe(parent.nodeId); expect(node.parentId).toBe(parent.nodeId);
}); });
it('should add a non-enumerable, writable enclosingScope if necessary', function() { it('should add a non-enumerable, writable enclosingScope if necessary', function() {
var node = astnode.addNodeProperties({}); var node = astNode.addNodeProperties({});
var descriptor = Object.getOwnPropertyDescriptor(node, 'enclosingScope'); var descriptor = Object.getOwnPropertyDescriptor(node, 'enclosingScope');
expect(descriptor).toBeDefined(); expect(descriptor).toBeDefined();
@ -197,13 +199,13 @@ describe('jsdoc/src/astnode', function() {
it('should not overwrite an existing enclosingScope', function() { it('should not overwrite an existing enclosingScope', function() {
var enclosingScope = {}; var enclosingScope = {};
var node = astnode.addNodeProperties({enclosingScope: enclosingScope}); var node = astNode.addNodeProperties({enclosingScope: enclosingScope});
expect(node.enclosingScope).toBe(enclosingScope); expect(node.enclosingScope).toBe(enclosingScope);
}); });
it('should not overwrite a null enclosingScope', function() { it('should not overwrite a null enclosingScope', function() {
var node = astnode.addNodeProperties({enclosingScope: null}); var node = astNode.addNodeProperties({enclosingScope: null});
expect(node.enclosingScope).toBe(null); expect(node.enclosingScope).toBe(null);
}); });
@ -213,7 +215,7 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
descriptor = Object.getOwnPropertyDescriptor(node, 'enclosingScopeId'); descriptor = Object.getOwnPropertyDescriptor(node, 'enclosingScopeId');
expect(descriptor).toBeDefined(); expect(descriptor).toBeDefined();
@ -226,7 +228,7 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
expect(node.enclosingScopeId).toBe(null); expect(node.enclosingScopeId).toBe(null);
}); });
@ -238,8 +240,8 @@ describe('jsdoc/src/astnode', function() {
var node; var node;
env.opts.debug = true; env.opts.debug = true;
node = astnode.addNodeProperties({}); node = astNode.addNodeProperties({});
enclosingScope = astnode.addNodeProperties({}); enclosingScope = astNode.addNodeProperties({});
node.enclosingScope = enclosingScope; node.enclosingScope = enclosingScope;
expect(node.enclosingScopeId).toBe(enclosingScope.nodeId); expect(node.enclosingScopeId).toBe(enclosingScope.nodeId);
@ -249,14 +251,14 @@ describe('jsdoc/src/astnode', function() {
describe('getInfo', function() { describe('getInfo', function() {
it('should throw an error for undefined input', function() { it('should throw an error for undefined input', function() {
function noNode() { function noNode() {
astnode.getInfo(); astNode.getInfo();
} }
expect(noNode).toThrow(); expect(noNode).toThrow();
}); });
it('should return the correct info for an AssignmentExpression', function() { it('should return the correct info for an AssignmentExpression', function() {
var info = astnode.getInfo(assignmentExpression); var info = astNode.getInfo(assignmentExpression);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -270,7 +272,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a FunctionDeclaration', function() { it('should return the correct info for a FunctionDeclaration', function() {
var info = astnode.getInfo(functionDeclaration2); var info = astNode.getInfo(functionDeclaration2);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -286,7 +288,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a FunctionExpression', function() { it('should return the correct info for a FunctionExpression', function() {
var info = astnode.getInfo(functionExpression2); var info = astNode.getInfo(functionExpression2);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -302,7 +304,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a MemberExpression', function() { it('should return the correct info for a MemberExpression', function() {
var info = astnode.getInfo(memberExpression); var info = astNode.getInfo(memberExpression);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -314,7 +316,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a computed MemberExpression', function() { it('should return the correct info for a computed MemberExpression', function() {
var info = astnode.getInfo(memberExpressionComputed1); var info = astNode.getInfo(memberExpressionComputed1);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -326,7 +328,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a Property initializer', function() { it('should return the correct info for a Property initializer', function() {
var info = astnode.getInfo(propertyInit); var info = astNode.getInfo(propertyInit);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -338,7 +340,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a Property setter', function() { it('should return the correct info for a Property setter', function() {
var info = astnode.getInfo(propertySet); var info = astNode.getInfo(propertySet);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -354,7 +356,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a VariableDeclarator with a value', function() { it('should return the correct info for a VariableDeclarator with a value', function() {
var info = astnode.getInfo(variableDeclarator1); var info = astNode.getInfo(variableDeclarator1);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -367,7 +369,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for a VariableDeclarator with no value', function() { it('should return the correct info for a VariableDeclarator with no value', function() {
var info = astnode.getInfo(variableDeclarator2); var info = astNode.getInfo(variableDeclarator2);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -380,7 +382,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return the correct info for other node types', function() { it('should return the correct info for other node types', function() {
var info = astnode.getInfo(binaryExpression); var info = astNode.getInfo(binaryExpression);
expect(info).toBeDefined(); expect(info).toBeDefined();
@ -391,28 +393,28 @@ describe('jsdoc/src/astnode', function() {
describe('getParamNames', function() { describe('getParamNames', function() {
it('should return an empty array for undefined input', function() { it('should return an empty array for undefined input', function() {
var params = astnode.getParamNames(); var params = astNode.getParamNames();
expect( Array.isArray(params) ).toBe(true); expect( Array.isArray(params) ).toBe(true);
expect(params.length).toBe(0); expect(params.length).toBe(0);
}); });
it('should return an empty array if the input has no params property', function() { it('should return an empty array if the input has no params property', function() {
var params = astnode.getParamNames({}); var params = astNode.getParamNames({});
expect( Array.isArray(params) ).toBe(true); expect( Array.isArray(params) ).toBe(true);
expect(params.length).toBe(0); expect(params.length).toBe(0);
}); });
it('should return an empty array if the input has no params', function() { it('should return an empty array if the input has no params', function() {
var params = astnode.getParamNames(functionDeclaration1); var params = astNode.getParamNames(functionDeclaration1);
expect( Array.isArray(params) ).toBe(true); expect( Array.isArray(params) ).toBe(true);
expect(params.length).toBe(0); expect(params.length).toBe(0);
}); });
it('should return a single-item array if the input has a single param', function() { it('should return a single-item array if the input has a single param', function() {
var params = astnode.getParamNames(functionDeclaration2); var params = astNode.getParamNames(functionDeclaration2);
expect( Array.isArray(params) ).toBe(true); expect( Array.isArray(params) ).toBe(true);
expect(params.length).toBe(1); expect(params.length).toBe(1);
@ -420,7 +422,7 @@ describe('jsdoc/src/astnode', function() {
}); });
it('should return a multi-item array if the input has multiple params', function() { it('should return a multi-item array if the input has multiple params', function() {
var params = astnode.getParamNames(functionDeclaration3); var params = astNode.getParamNames(functionDeclaration3);
expect( Array.isArray(params) ).toBe(true); expect( Array.isArray(params) ).toBe(true);
expect(params.length).toBe(3); expect(params.length).toBe(3);
@ -432,149 +434,149 @@ describe('jsdoc/src/astnode', function() {
describe('isAccessor', function() { describe('isAccessor', function() {
it('should return false for undefined values', function() { it('should return false for undefined values', function() {
expect( astnode.isAccessor() ).toBe(false); expect( astNode.isAccessor() ).toBe(false);
}); });
it('should return false if the parameter is not an object', function() { it('should return false if the parameter is not an object', function() {
expect( astnode.isAccessor('foo') ).toBe(false); expect( astNode.isAccessor('foo') ).toBe(false);
}); });
it('should return false for non-Property nodes', function() { it('should return false for non-Property nodes', function() {
expect( astnode.isAccessor(binaryExpression) ).toBe(false); expect( astNode.isAccessor(binaryExpression) ).toBe(false);
}); });
it('should return false for Property nodes whose kind is "init"', function() { it('should return false for Property nodes whose kind is "init"', function() {
expect( astnode.isAccessor(propertyInit) ).toBe(false); expect( astNode.isAccessor(propertyInit) ).toBe(false);
}); });
it('should return true for Property nodes whose kind is "get"', function() { it('should return true for Property nodes whose kind is "get"', function() {
expect( astnode.isAccessor(propertyGet) ).toBe(true); expect( astNode.isAccessor(propertyGet) ).toBe(true);
}); });
it('should return true for Property nodes whose kind is "set"', function() { it('should return true for Property nodes whose kind is "set"', function() {
expect( astnode.isAccessor(propertySet) ).toBe(true); expect( astNode.isAccessor(propertySet) ).toBe(true);
}); });
}); });
describe('isAssignment', function() { describe('isAssignment', function() {
it('should return false for undefined values', function() { it('should return false for undefined values', function() {
expect( astnode.isAssignment() ).toBe(false); expect( astNode.isAssignment() ).toBe(false);
}); });
it('should return false if the parameter is not an object', function() { it('should return false if the parameter is not an object', function() {
expect( astnode.isAssignment('foo') ).toBe(false); expect( astNode.isAssignment('foo') ).toBe(false);
}); });
it('should return false for nodes that are not assignments', function() { it('should return false for nodes that are not assignments', function() {
expect( astnode.isAssignment(binaryExpression) ).toBe(false); expect( astNode.isAssignment(binaryExpression) ).toBe(false);
}); });
it('should return true for AssignmentExpression nodes', function() { it('should return true for AssignmentExpression nodes', function() {
expect( astnode.isAssignment(assignmentExpression) ).toBe(true); expect( astNode.isAssignment(assignmentExpression) ).toBe(true);
}); });
it('should return true for VariableDeclarator nodes', function() { it('should return true for VariableDeclarator nodes', function() {
expect( astnode.isAssignment(variableDeclarator1) ).toBe(true); expect( astNode.isAssignment(variableDeclarator1) ).toBe(true);
}); });
}); });
describe('isScope', function() { describe('isScope', function() {
it('should return false for undefined values', function() { it('should return false for undefined values', function() {
expect( astnode.isScope() ).toBe(false); expect( astNode.isScope() ).toBe(false);
}); });
it('should return false if the parameter is not an object', function() { it('should return false if the parameter is not an object', function() {
expect( astnode.isScope('foo') ).toBe(false); expect( astNode.isScope('foo') ).toBe(false);
}); });
it('should return true for CatchClause nodes', function() { it('should return true for CatchClause nodes', function() {
expect( astnode.isScope({type: Syntax.CatchClause}) ).toBe(true); expect( astNode.isScope({type: Syntax.CatchClause}) ).toBe(true);
}); });
it('should return true for FunctionDeclaration nodes', function() { it('should return true for FunctionDeclaration nodes', function() {
expect( astnode.isScope({type: Syntax.FunctionDeclaration}) ).toBe(true); expect( astNode.isScope({type: Syntax.FunctionDeclaration}) ).toBe(true);
}); });
it('should return true for FunctionExpression nodes', function() { it('should return true for FunctionExpression nodes', function() {
expect( astnode.isScope({type: Syntax.FunctionExpression}) ).toBe(true); expect( astNode.isScope({type: Syntax.FunctionExpression}) ).toBe(true);
}); });
it('should return false for other nodes', function() { it('should return false for other nodes', function() {
expect( astnode.isScope({type: Syntax.NameExpression}) ).toBe(false); expect( astNode.isScope({type: Syntax.NameExpression}) ).toBe(false);
}); });
}); });
describe('nodeToString', function() { describe('nodeToString', function() {
it('should be an alias to nodeToValue', function() { it('should be an alias to nodeToValue', function() {
expect(astnode.nodeToString).toBe(astnode.nodeToValue); expect(astNode.nodeToString).toBe(astNode.nodeToValue);
}); });
}); });
describe('nodeToValue', function() { describe('nodeToValue', function() {
it('should return `[null]` for the sparse array `[,]`', function() { it('should return `[null]` for the sparse array `[,]`', function() {
expect( astnode.nodeToValue(arrayExpression) ).toBe('[null]'); expect( astNode.nodeToValue(arrayExpression) ).toBe('[null]');
}); });
it('should return the variable name for assignment expressions', function() { it('should return the variable name for assignment expressions', function() {
expect( astnode.nodeToValue(assignmentExpression) ).toBe('foo'); expect( astNode.nodeToValue(assignmentExpression) ).toBe('foo');
}); });
it('should return "function" for function declarations', function() { it('should return "function" for function declarations', function() {
expect( astnode.nodeToValue(functionDeclaration1) ).toBe('function'); expect( astNode.nodeToValue(functionDeclaration1) ).toBe('function');
}); });
it('should return "function" for function expressions', function() { it('should return "function" for function expressions', function() {
expect( astnode.nodeToValue(functionExpression1) ).toBe('function'); expect( astNode.nodeToValue(functionExpression1) ).toBe('function');
}); });
it('should return the identifier name for identifiers', function() { it('should return the identifier name for identifiers', function() {
expect( astnode.nodeToValue(identifier) ).toBe('foo'); expect( astNode.nodeToValue(identifier) ).toBe('foo');
}); });
it('should return the literal value for literals', function() { it('should return the literal value for literals', function() {
expect( astnode.nodeToValue(literal) ).toBe(1); expect( astNode.nodeToValue(literal) ).toBe(1);
}); });
it('should return the object and property for noncomputed member expressions', function() { it('should return the object and property for noncomputed member expressions', function() {
expect( astnode.nodeToValue(memberExpression) ).toBe('foo.bar'); expect( astNode.nodeToValue(memberExpression) ).toBe('foo.bar');
}); });
it('should return the object and property, with a computed property that uses the same ' + it('should return the object and property, with a computed property that uses the same ' +
'quote character as the original source, for computed member expressions', function() { 'quote character as the original source, for computed member expressions', function() {
expect( astnode.nodeToValue(memberExpressionComputed1) ).toBe('foo["bar"]'); expect( astNode.nodeToValue(memberExpressionComputed1) ).toBe('foo["bar"]');
expect( astnode.nodeToValue(memberExpressionComputed2) ).toBe('foo[\'bar\']'); expect( astNode.nodeToValue(memberExpressionComputed2) ).toBe('foo[\'bar\']');
}); });
it('should return "this" for this expressions', function() { it('should return "this" for this expressions', function() {
expect( astnode.nodeToValue(thisExpression) ).toBe('this'); expect( astNode.nodeToValue(thisExpression) ).toBe('this');
}); });
it('should return the operator and nodeToValue value for prefix unary expressions', it('should return the operator and nodeToValue value for prefix unary expressions',
function() { function() {
expect( astnode.nodeToValue(unaryExpression1) ).toBe('+1'); expect( astNode.nodeToValue(unaryExpression1) ).toBe('+1');
expect( astnode.nodeToValue(unaryExpression2) ).toBe('+foo'); expect( astNode.nodeToValue(unaryExpression2) ).toBe('+foo');
}); });
it('should throw an error for postfix unary expressions', function() { it('should throw an error for postfix unary expressions', function() {
function postfixNodeToValue() { function postfixNodeToValue() {
// there's no valid source representation for this one, so we fake it // there's no valid source representation for this one, so we fake it
var unaryExpressionPostfix = (function() { var unaryExpressionPostfix = (function() {
var node = espree.parse('+1;').body[0].expression; var node = parse('+1;').body[0].expression;
node.prefix = false; node.prefix = false;
return node; return node;
})(); })();
return astnode.nodeToValue(unaryExpressionPostfix); return astNode.nodeToValue(unaryExpressionPostfix);
} }
expect(postfixNodeToValue).toThrow(); expect(postfixNodeToValue).toThrow();
}); });
it('should return the variable name for variable declarators', function() { it('should return the variable name for variable declarators', function() {
expect( astnode.nodeToValue(variableDeclarator1) ).toBe('foo'); expect( astNode.nodeToValue(variableDeclarator1) ).toBe('foo');
}); });
it('should return an empty string for all other nodes', function() { it('should return an empty string for all other nodes', function() {
expect( astnode.nodeToValue(binaryExpression) ).toBe(''); expect( astNode.nodeToValue(binaryExpression) ).toBe('');
}); });
}); });
}); });