ember-legacy-class-transform
Version:
The default blueprint for ember-cli addons.
279 lines (270 loc) • 40.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.HandlebarsNodeVisitors = undefined;
var _builders = require("../builders");
var _builders2 = _interopRequireDefault(_builders);
var _utils = require("../utils");
var _parser = require("../parser");
var _syntaxError = require("../errors/syntax-error");
var _syntaxError2 = _interopRequireDefault(_syntaxError);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
class HandlebarsNodeVisitors extends _parser.Parser {
Program(program) {
let body = [];
let node = _builders2.default.program(body, program.blockParams, program.loc);
let i,
l = program.body.length;
this.elementStack.push(node);
if (l === 0) {
return this.elementStack.pop();
}
for (i = 0; i < l; i++) {
this.acceptNode(program.body[i]);
}
// Ensure that that the element stack is balanced properly.
let poppedNode = this.elementStack.pop();
if (poppedNode !== node) {
let elementNode = poppedNode;
throw new _syntaxError2.default("Unclosed element `" + elementNode.tag + "` (on line " + elementNode.loc.start.line + ").", elementNode.loc);
}
return node;
}
BlockStatement(block) {
if (this.tokenizer['state'] === 'comment') {
this.appendToCommentData(this.sourceForNode(block));
return;
}
if (this.tokenizer['state'] !== 'comment' && this.tokenizer['state'] !== 'data' && this.tokenizer['state'] !== 'beforeData') {
throw new _syntaxError2.default("A block may only be used inside an HTML element or another block.", block.loc);
}
let { path, params, hash } = acceptCallNodes(this, block);
let program = this.Program(block.program);
let inverse = block.inverse ? this.Program(block.inverse) : null;
let node = _builders2.default.block(path, params, hash, program, inverse, block.loc);
let parentProgram = this.currentElement();
(0, _utils.appendChild)(parentProgram, node);
}
MustacheStatement(rawMustache) {
let { tokenizer } = this;
if (tokenizer['state'] === 'comment') {
this.appendToCommentData(this.sourceForNode(rawMustache));
return;
}
let mustache;
let { escaped, loc } = rawMustache;
if (rawMustache.path.type.match(/Literal$/)) {
mustache = {
type: 'MustacheStatement',
path: this.acceptNode(rawMustache.path),
params: [],
hash: _builders2.default.hash(),
escaped,
loc
};
} else {
let { path, params, hash } = acceptCallNodes(this, rawMustache);
mustache = _builders2.default.mustache(path, params, hash, !escaped, loc);
}
switch (tokenizer.state) {
// Tag helpers
case "tagName":
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
case "beforeAttributeName":
addElementModifier(this.currentStartTag, mustache);
break;
case "attributeName":
case "afterAttributeName":
this.beginAttributeValue(false);
this.finishAttributeValue();
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
case "afterAttributeValueQuoted":
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
// Attribute values
case "beforeAttributeValue":
appendDynamicAttributeValuePart(this.currentAttribute, mustache);
tokenizer.state = 'attributeValueUnquoted';
break;
case "attributeValueDoubleQuoted":
case "attributeValueSingleQuoted":
case "attributeValueUnquoted":
appendDynamicAttributeValuePart(this.currentAttribute, mustache);
break;
// TODO: Only append child when the tokenizer state makes
// sense to do so, otherwise throw an error.
default:
(0, _utils.appendChild)(this.currentElement(), mustache);
}
return mustache;
}
ContentStatement(content) {
updateTokenizerLocation(this.tokenizer, content);
this.tokenizer.tokenizePart(content.value);
this.tokenizer.flushData();
}
CommentStatement(rawComment) {
let { tokenizer } = this;
if (tokenizer.state === 'comment') {
this.appendToCommentData(this.sourceForNode(rawComment));
return null;
}
let { value, loc } = rawComment;
let comment = _builders2.default.mustacheComment(value, loc);
switch (tokenizer.state) {
case "beforeAttributeName":
this.currentStartTag.comments.push(comment);
break;
case 'beforeData':
case 'data':
(0, _utils.appendChild)(this.currentElement(), comment);
break;
default:
throw new _syntaxError2.default(`Using a Handlebars comment when in the \`${tokenizer.state}\` state is not supported: "${comment.value}" on line ${loc.start.line}:${loc.start.column}`, rawComment.loc);
}
return comment;
}
PartialStatement(partial) {
let { loc } = partial;
throw new _syntaxError2.default(`Handlebars partials are not supported: "${this.sourceForNode(partial, partial.name)}" at L${loc.start.line}:C${loc.start.column}`, partial.loc);
}
PartialBlockStatement(partialBlock) {
let { loc } = partialBlock;
throw new _syntaxError2.default(`Handlebars partial blocks are not supported: "${this.sourceForNode(partialBlock, partialBlock.name)}" at L${loc.start.line}:C${loc.start.column}`, partialBlock.loc);
}
Decorator(decorator) {
let { loc } = decorator;
throw new _syntaxError2.default(`Handlebars decorators are not supported: "${this.sourceForNode(decorator, decorator.path)}" at L${loc.start.line}:C${loc.start.column}`, decorator.loc);
}
DecoratorBlock(decoratorBlock) {
let { loc } = decoratorBlock;
throw new _syntaxError2.default(`Handlebars decorator blocks are not supported: "${this.sourceForNode(decoratorBlock, decoratorBlock.path)}" at L${loc.start.line}:C${loc.start.column}`, decoratorBlock.loc);
}
SubExpression(sexpr) {
let { path, params, hash } = acceptCallNodes(this, sexpr);
return _builders2.default.sexpr(path, params, hash, sexpr.loc);
}
PathExpression(path) {
let { original, loc } = path;
let parts;
if (original.indexOf('/') !== -1) {
if (original.slice(0, 2) === './') {
throw new _syntaxError2.default(`Using "./" is not supported in Glimmer and unnecessary: "${path.original}" on line ${loc.start.line}.`, path.loc);
}
if (original.slice(0, 3) === '../') {
throw new _syntaxError2.default(`Changing context using "../" is not supported in Glimmer: "${path.original}" on line ${loc.start.line}.`, path.loc);
}
if (original.indexOf('.') !== -1) {
throw new _syntaxError2.default(`Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: "${path.original}" on line ${loc.start.line}.`, path.loc);
}
parts = [path.parts.join('/')];
} else {
parts = path.parts;
}
let thisHead = false;
// This is to fix a bug in the Handlebars AST where the path expressions in
// `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)
// are simply turned into `{{foo}}`. The fix is to push it back onto the
// parts array and let the runtime see the difference. However, we cannot
// simply use the string `this` as it means literally the property called
// "this" in the current context (it can be expressed in the syntax as
// `{{[this]}}`, where the square bracket are generally for this kind of
// escaping – such as `{{foo.["bar.baz"]}}` would mean lookup a property
// named literally "bar.baz" on `this.foo`). By convention, we use `null`
// for this purpose.
if (original.match(/^this(\..+)?$/)) {
thisHead = true;
}
return {
type: 'PathExpression',
original: path.original,
this: thisHead,
parts,
data: path.data,
loc: path.loc
};
}
Hash(hash) {
let pairs = [];
for (let i = 0; i < hash.pairs.length; i++) {
let pair = hash.pairs[i];
pairs.push(_builders2.default.pair(pair.key, this.acceptNode(pair.value), pair.loc));
}
return _builders2.default.hash(pairs, hash.loc);
}
StringLiteral(string) {
return _builders2.default.literal('StringLiteral', string.value, string.loc);
}
BooleanLiteral(boolean) {
return _builders2.default.literal('BooleanLiteral', boolean.value, boolean.loc);
}
NumberLiteral(number) {
return _builders2.default.literal('NumberLiteral', number.value, number.loc);
}
UndefinedLiteral(undef) {
return _builders2.default.literal('UndefinedLiteral', undefined, undef.loc);
}
NullLiteral(nul) {
return _builders2.default.literal('NullLiteral', null, nul.loc);
}
}
exports.HandlebarsNodeVisitors = HandlebarsNodeVisitors;
function calculateRightStrippedOffsets(original, value) {
if (value === '') {
// if it is empty, just return the count of newlines
// in original
return {
lines: original.split("\n").length - 1,
columns: 0
};
}
// otherwise, return the number of newlines prior to
// `value`
let difference = original.split(value)[0];
let lines = difference.split(/\n/);
let lineCount = lines.length - 1;
return {
lines: lineCount,
columns: lines[lineCount].length
};
}
function updateTokenizerLocation(tokenizer, content) {
let line = content.loc.start.line;
let column = content.loc.start.column;
let offsets = calculateRightStrippedOffsets(content.original, content.value);
line = line + offsets.lines;
if (offsets.lines) {
column = offsets.columns;
} else {
column = column + offsets.columns;
}
tokenizer.line = line;
tokenizer.column = column;
}
function acceptCallNodes(compiler, node) {
let path = compiler.PathExpression(node.path);
let params = node.params ? node.params.map(e => compiler.acceptNode(e)) : [];
let hash = node.hash ? compiler.Hash(node.hash) : _builders2.default.hash();
return { path, params, hash };
}
function addElementModifier(element, mustache) {
let { path, params, hash, loc } = mustache;
if ((0, _utils.isLiteral)(path)) {
let modifier = `{{${(0, _utils.printLiteral)(path)}}}`;
let tag = `<${element.name} ... ${modifier} ...`;
throw new _syntaxError2.default(`In ${tag}, ${modifier} is not a valid modifier: "${path.original}" on line ${loc && loc.start.line}.`, mustache.loc);
}
let modifier = _builders2.default.elementModifier(path, params, hash, loc);
element.modifiers.push(modifier);
}
function appendDynamicAttributeValuePart(attribute, part) {
attribute.isDynamic = true;
attribute.parts.push(part);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["lib/parser/handlebars-node-visitors.js"],"names":["HandlebarsNodeVisitors","Program","program","body","node","blockParams","loc","i","l","length","elementStack","push","pop","acceptNode","poppedNode","elementNode","tag","start","line","BlockStatement","block","tokenizer","appendToCommentData","sourceForNode","path","params","hash","acceptCallNodes","inverse","parentProgram","currentElement","MustacheStatement","rawMustache","mustache","escaped","type","match","state","addElementModifier","currentStartTag","beginAttributeValue","finishAttributeValue","appendDynamicAttributeValuePart","currentAttribute","ContentStatement","content","updateTokenizerLocation","tokenizePart","value","flushData","CommentStatement","rawComment","comment","mustacheComment","comments","column","PartialStatement","partial","name","PartialBlockStatement","partialBlock","Decorator","decorator","DecoratorBlock","decoratorBlock","SubExpression","sexpr","PathExpression","original","parts","indexOf","slice","join","thisHead","this","data","Hash","pairs","pair","key","StringLiteral","string","literal","BooleanLiteral","boolean","NumberLiteral","number","UndefinedLiteral","undef","undefined","NullLiteral","nul","calculateRightStrippedOffsets","lines","split","columns","difference","lineCount","offsets","compiler","map","e","element","modifier","elementModifier","modifiers","attribute","part","isDynamic"],"mappings":"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","file":"lib/parser/handlebars-node-visitors.js","sourcesContent":["import b from \"../builders\";\nimport { appendChild, isLiteral, printLiteral } from \"../utils\";\nimport { Parser } from '../parser';\nimport SyntaxError from '../errors/syntax-error';\nexport class HandlebarsNodeVisitors extends Parser {\n    Program(program) {\n        let body = [];\n        let node = b.program(body, program.blockParams, program.loc);\n        let i,\n            l = program.body.length;\n        this.elementStack.push(node);\n        if (l === 0) {\n            return this.elementStack.pop();\n        }\n        for (i = 0; i < l; i++) {\n            this.acceptNode(program.body[i]);\n        }\n        // Ensure that that the element stack is balanced properly.\n        let poppedNode = this.elementStack.pop();\n        if (poppedNode !== node) {\n            let elementNode = poppedNode;\n            throw new SyntaxError(\"Unclosed element `\" + elementNode.tag + \"` (on line \" + elementNode.loc.start.line + \").\", elementNode.loc);\n        }\n        return node;\n    }\n    BlockStatement(block) {\n        if (this.tokenizer['state'] === 'comment') {\n            this.appendToCommentData(this.sourceForNode(block));\n            return;\n        }\n        if (this.tokenizer['state'] !== 'comment' && this.tokenizer['state'] !== 'data' && this.tokenizer['state'] !== 'beforeData') {\n            throw new SyntaxError(\"A block may only be used inside an HTML element or another block.\", block.loc);\n        }\n        let { path, params, hash } = acceptCallNodes(this, block);\n        let program = this.Program(block.program);\n        let inverse = block.inverse ? this.Program(block.inverse) : null;\n        let node = b.block(path, params, hash, program, inverse, block.loc);\n        let parentProgram = this.currentElement();\n        appendChild(parentProgram, node);\n    }\n    MustacheStatement(rawMustache) {\n        let { tokenizer } = this;\n        if (tokenizer['state'] === 'comment') {\n            this.appendToCommentData(this.sourceForNode(rawMustache));\n            return;\n        }\n        let mustache;\n        let { escaped, loc } = rawMustache;\n        if (rawMustache.path.type.match(/Literal$/)) {\n            mustache = {\n                type: 'MustacheStatement',\n                path: this.acceptNode(rawMustache.path),\n                params: [],\n                hash: b.hash(),\n                escaped,\n                loc\n            };\n        } else {\n            let { path, params, hash } = acceptCallNodes(this, rawMustache);\n            mustache = b.mustache(path, params, hash, !escaped, loc);\n        }\n        switch (tokenizer.state) {\n            // Tag helpers\n            case \"tagName\":\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            case \"beforeAttributeName\":\n                addElementModifier(this.currentStartTag, mustache);\n                break;\n            case \"attributeName\":\n            case \"afterAttributeName\":\n                this.beginAttributeValue(false);\n                this.finishAttributeValue();\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            case \"afterAttributeValueQuoted\":\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            // Attribute values\n            case \"beforeAttributeValue\":\n                appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n                tokenizer.state = 'attributeValueUnquoted';\n                break;\n            case \"attributeValueDoubleQuoted\":\n            case \"attributeValueSingleQuoted\":\n            case \"attributeValueUnquoted\":\n                appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n                break;\n            // TODO: Only append child when the tokenizer state makes\n            // sense to do so, otherwise throw an error.\n            default:\n                appendChild(this.currentElement(), mustache);\n        }\n        return mustache;\n    }\n    ContentStatement(content) {\n        updateTokenizerLocation(this.tokenizer, content);\n        this.tokenizer.tokenizePart(content.value);\n        this.tokenizer.flushData();\n    }\n    CommentStatement(rawComment) {\n        let { tokenizer } = this;\n        if (tokenizer.state === 'comment') {\n            this.appendToCommentData(this.sourceForNode(rawComment));\n            return null;\n        }\n        let { value, loc } = rawComment;\n        let comment = b.mustacheComment(value, loc);\n        switch (tokenizer.state) {\n            case \"beforeAttributeName\":\n                this.currentStartTag.comments.push(comment);\n                break;\n            case 'beforeData':\n            case 'data':\n                appendChild(this.currentElement(), comment);\n                break;\n            default:\n                throw new SyntaxError(`Using a Handlebars comment when in the \\`${tokenizer.state}\\` state is not supported: \"${comment.value}\" on line ${loc.start.line}:${loc.start.column}`, rawComment.loc);\n        }\n        return comment;\n    }\n    PartialStatement(partial) {\n        let { loc } = partial;\n        throw new SyntaxError(`Handlebars partials are not supported: \"${this.sourceForNode(partial, partial.name)}\" at L${loc.start.line}:C${loc.start.column}`, partial.loc);\n    }\n    PartialBlockStatement(partialBlock) {\n        let { loc } = partialBlock;\n        throw new SyntaxError(`Handlebars partial blocks are not supported: \"${this.sourceForNode(partialBlock, partialBlock.name)}\" at L${loc.start.line}:C${loc.start.column}`, partialBlock.loc);\n    }\n    Decorator(decorator) {\n        let { loc } = decorator;\n        throw new SyntaxError(`Handlebars decorators are not supported: \"${this.sourceForNode(decorator, decorator.path)}\" at L${loc.start.line}:C${loc.start.column}`, decorator.loc);\n    }\n    DecoratorBlock(decoratorBlock) {\n        let { loc } = decoratorBlock;\n        throw new SyntaxError(`Handlebars decorator blocks are not supported: \"${this.sourceForNode(decoratorBlock, decoratorBlock.path)}\" at L${loc.start.line}:C${loc.start.column}`, decoratorBlock.loc);\n    }\n    SubExpression(sexpr) {\n        let { path, params, hash } = acceptCallNodes(this, sexpr);\n        return b.sexpr(path, params, hash, sexpr.loc);\n    }\n    PathExpression(path) {\n        let { original, loc } = path;\n        let parts;\n        if (original.indexOf('/') !== -1) {\n            if (original.slice(0, 2) === './') {\n                throw new SyntaxError(`Using \"./\" is not supported in Glimmer and unnecessary: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            if (original.slice(0, 3) === '../') {\n                throw new SyntaxError(`Changing context using \"../\" is not supported in Glimmer: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            if (original.indexOf('.') !== -1) {\n                throw new SyntaxError(`Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            parts = [path.parts.join('/')];\n        } else {\n            parts = path.parts;\n        }\n        let thisHead = false;\n        // This is to fix a bug in the Handlebars AST where the path expressions in\n        // `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)\n        // are simply turned into `{{foo}}`. The fix is to push it back onto the\n        // parts array and let the runtime see the difference. However, we cannot\n        // simply use the string `this` as it means literally the property called\n        // \"this\" in the current context (it can be expressed in the syntax as\n        // `{{[this]}}`, where the square bracket are generally for this kind of\n        // escaping – such as `{{foo.[\"bar.baz\"]}}` would mean lookup a property\n        // named literally \"bar.baz\" on `this.foo`). By convention, we use `null`\n        // for this purpose.\n        if (original.match(/^this(\\..+)?$/)) {\n            thisHead = true;\n        }\n        return {\n            type: 'PathExpression',\n            original: path.original,\n            this: thisHead,\n            parts,\n            data: path.data,\n            loc: path.loc\n        };\n    }\n    Hash(hash) {\n        let pairs = [];\n        for (let i = 0; i < hash.pairs.length; i++) {\n            let pair = hash.pairs[i];\n            pairs.push(b.pair(pair.key, this.acceptNode(pair.value), pair.loc));\n        }\n        return b.hash(pairs, hash.loc);\n    }\n    StringLiteral(string) {\n        return b.literal('StringLiteral', string.value, string.loc);\n    }\n    BooleanLiteral(boolean) {\n        return b.literal('BooleanLiteral', boolean.value, boolean.loc);\n    }\n    NumberLiteral(number) {\n        return b.literal('NumberLiteral', number.value, number.loc);\n    }\n    UndefinedLiteral(undef) {\n        return b.literal('UndefinedLiteral', undefined, undef.loc);\n    }\n    NullLiteral(nul) {\n        return b.literal('NullLiteral', null, nul.loc);\n    }\n}\nfunction calculateRightStrippedOffsets(original, value) {\n    if (value === '') {\n        // if it is empty, just return the count of newlines\n        // in original\n        return {\n            lines: original.split(\"\\n\").length - 1,\n            columns: 0\n        };\n    }\n    // otherwise, return the number of newlines prior to\n    // `value`\n    let difference = original.split(value)[0];\n    let lines = difference.split(/\\n/);\n    let lineCount = lines.length - 1;\n    return {\n        lines: lineCount,\n        columns: lines[lineCount].length\n    };\n}\nfunction updateTokenizerLocation(tokenizer, content) {\n    let line = content.loc.start.line;\n    let column = content.loc.start.column;\n    let offsets = calculateRightStrippedOffsets(content.original, content.value);\n    line = line + offsets.lines;\n    if (offsets.lines) {\n        column = offsets.columns;\n    } else {\n        column = column + offsets.columns;\n    }\n    tokenizer.line = line;\n    tokenizer.column = column;\n}\nfunction acceptCallNodes(compiler, node) {\n    let path = compiler.PathExpression(node.path);\n    let params = node.params ? node.params.map(e => compiler.acceptNode(e)) : [];\n    let hash = node.hash ? compiler.Hash(node.hash) : b.hash();\n    return { path, params, hash };\n}\nfunction addElementModifier(element, mustache) {\n    let { path, params, hash, loc } = mustache;\n    if (isLiteral(path)) {\n        let modifier = `{{${printLiteral(path)}}}`;\n        let tag = `<${element.name} ... ${modifier} ...`;\n        throw new SyntaxError(`In ${tag}, ${modifier} is not a valid modifier: \"${path.original}\" on line ${loc && loc.start.line}.`, mustache.loc);\n    }\n    let modifier = b.elementModifier(path, params, hash, loc);\n    element.modifiers.push(modifier);\n}\nfunction appendDynamicAttributeValuePart(attribute, part) {\n    attribute.isDynamic = true;\n    attribute.parts.push(part);\n}"]}