"use strict";
exports.__esModule = true;
var _maxSafeInteger = require("babel-runtime/core-js/number/max-safe-integer");
var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);
var _stringify = require("babel-runtime/core-js/json/stringify");
var _stringify2 = _interopRequireDefault(_stringify);
var _getIterator2 = require("babel-runtime/core-js/get-iterator");
var _getIterator3 = _interopRequireDefault(_getIterator2);
exports.toComputedKey = toComputedKey;
exports.toSequenceExpression = toSequenceExpression;
exports.toKeyAlias = toKeyAlias;
exports.toIdentifier = toIdentifier;
exports.toBindingIdentifierName = toBindingIdentifierName;
exports.toStatement = toStatement;
exports.toExpression = toExpression;
exports.toBlock = toBlock;
exports.valueToNode = valueToNode;
var _isPlainObject = require("lodash/isPlainObject");
var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
var _isRegExp = require("lodash/isRegExp");
var _isRegExp2 = _interopRequireDefault(_isRegExp);
var _index = require("./index");
var t = _interopRequireWildcard(_index);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function toComputedKey(node) {
var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key || node.property;
if (!node.computed) {
if (t.isIdentifier(key)) key = t.stringLiteral(key.name);
}
return key;
}
function gatherSequenceExpressions(nodes, scope, declars) {
var exprs = [];
var ensureLastUndefined = true;
for (var _iterator = nodes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var node = _ref;
ensureLastUndefined = false;
if (t.isExpression(node)) {
exprs.push(node);
} else if (t.isExpressionStatement(node)) {
exprs.push(node.expression);
} else if (t.isVariableDeclaration(node)) {
if (node.kind !== "var") return;
for (var _iterator2 = node.declarations, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : (0, _getIterator3.default)(_iterator2);;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var declar = _ref2;
var bindings = t.getBindingIdentifiers(declar);
for (var key in bindings) {
declars.push({
kind: node.kind,
id: bindings[key]
});
}
if (declar.init) {
exprs.push(t.assignmentExpression("=", declar.id, declar.init));
}
}
ensureLastUndefined = true;
} else if (t.isIfStatement(node)) {
var consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
var alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
if (!consequent || !alternate) return;
exprs.push(t.conditionalExpression(node.test, consequent, alternate));
} else if (t.isBlockStatement(node)) {
var body = gatherSequenceExpressions(node.body, scope, declars);
if (!body) return;
exprs.push(body);
} else if (t.isEmptyStatement(node)) {
ensureLastUndefined = true;
} else {
return;
}
}
if (ensureLastUndefined) {
exprs.push(scope.buildUndefinedNode());
}
if (exprs.length === 1) {
return exprs[0];
} else {
return t.sequenceExpression(exprs);
}
}
function toSequenceExpression(nodes, scope) {
if (!nodes || !nodes.length) return;
var declars = [];
var result = gatherSequenceExpressions(nodes, scope, declars);
if (!result) return;
for (var _iterator3 = declars, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : (0, _getIterator3.default)(_iterator3);;) {
var _ref3;
if (_isArray3) {
if (_i3 >= _iterator3.length) break;
_ref3 = _iterator3[_i3++];
} else {
_i3 = _iterator3.next();
if (_i3.done) break;
_ref3 = _i3.value;
}
var declar = _ref3;
scope.push(declar);
}
return result;
}
function toKeyAlias(node) {
var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : node.key;
var alias = void 0;
if (node.kind === "method") {
return toKeyAlias.increment() + "";
} else if (t.isIdentifier(key)) {
alias = key.name;
} else if (t.isStringLiteral(key)) {
alias = (0, _stringify2.default)(key.value);
} else {
alias = (0, _stringify2.default)(t.removePropertiesDeep(t.cloneDeep(key)));
}
if (node.computed) {
alias = "[" + alias + "]";
}
if (node.static) {
alias = "static:" + alias;
}
return alias;
}
toKeyAlias.uid = 0;
toKeyAlias.increment = function () {
if (toKeyAlias.uid >= _maxSafeInteger2.default) {
return toKeyAlias.uid = 0;
} else {
return toKeyAlias.uid++;
}
};
function toIdentifier(name) {
name = name + "";
name = name.replace(/[^a-zA-Z0-9$_]/g, "-");
name = name.replace(/^[-0-9]+/, "");
name = name.replace(/[-\s]+(.)?/g, function (match, c) {
return c ? c.toUpperCase() : "";
});
if (!t.isValidIdentifier(name)) {
name = "_" + name;
}
return name || "_";
}
function toBindingIdentifierName(name) {
name = toIdentifier(name);
if (name === "eval" || name === "arguments") name = "_" + name;
return name;
}
function toStatement(node, ignore) {
if (t.isStatement(node)) {
return node;
}
var mustHaveId = false;
var newType = void 0;
if (t.isClass(node)) {
mustHaveId = true;
newType = "ClassDeclaration";
} else if (t.isFunction(node)) {
mustHaveId = true;
newType = "FunctionDeclaration";
} else if (t.isAssignmentExpression(node)) {
return t.expressionStatement(node);
}
if (mustHaveId && !node.id) {
newType = false;
}
if (!newType) {
if (ignore) {
return false;
} else {
throw new Error("cannot turn " + node.type + " to a statement");
}
}
node.type = newType;
return node;
}
function toExpression(node) {
if (t.isExpressionStatement(node)) {
node = node.expression;
}
if (t.isExpression(node)) {
return node;
}
if (t.isClass(node)) {
node.type = "ClassExpression";
} else if (t.isFunction(node)) {
node.type = "FunctionExpression";
}
if (!t.isExpression(node)) {
throw new Error("cannot turn " + node.type + " to an expression");
}
return node;
}
function toBlock(node, parent) {
if (t.isBlockStatement(node)) {
return node;
}
if (t.isEmptyStatement(node)) {
node = [];
}
if (!Array.isArray(node)) {
if (!t.isStatement(node)) {
if (t.isFunction(parent)) {
node = t.returnStatement(node);
} else {
node = t.expressionStatement(node);
}
}
node = [node];
}
return t.blockStatement(node);
}
function valueToNode(value) {
if (value === undefined) {
return t.identifier("undefined");
}
if (value === true || value === false) {
return t.booleanLiteral(value);
}
if (value === null) {
return t.nullLiteral();
}
if (typeof value === "string") {
return t.stringLiteral(value);
}
if (typeof value === "number") {
return t.numericLiteral(value);
}
if ((0, _isRegExp2.default)(value)) {
var pattern = value.source;
var flags = value.toString().match(/\/([a-z]+|)$/)[1];
return t.regExpLiteral(pattern, flags);
}
if (Array.isArray(value)) {
return t.arrayExpression(value.map(t.valueToNode));
}
if ((0, _isPlainObject2.default)(value)) {
var props = [];
for (var key in value) {
var nodeKey = void 0;
if (t.isValidIdentifier(key)) {
nodeKey = t.identifier(key);
} else {
nodeKey = t.stringLiteral(key);
}
props.push(t.objectProperty(nodeKey, t.valueToNode(value[key])));
}
return t.objectExpression(props);
}
throw new Error("don't know how to turn this value into a node");
}
# |
Change |
User |
Description |
Committed |
|
#1
|
23539 |
jenbottom |
Adding the basic code for ember test appk, created with 'ember new' command |
|
|