mirror of https://github.com/jkjoy/sunpeiwen.git
1301 lines
32 KiB
JavaScript
1301 lines
32 KiB
JavaScript
'use strict';
|
|
|
|
var assert = require('assert');
|
|
var TokenStream = require('token-stream');
|
|
var error = require('pug-error');
|
|
var inlineTags = require('./lib/inline-tags');
|
|
|
|
module.exports = parse;
|
|
module.exports.Parser = Parser;
|
|
function parse(tokens, options) {
|
|
var parser = new Parser(tokens, options);
|
|
var ast = parser.parse();
|
|
return JSON.parse(JSON.stringify(ast));
|
|
}
|
|
|
|
/**
|
|
* Initialize `Parser` with the given input `str` and `filename`.
|
|
*
|
|
* @param {String} str
|
|
* @param {String} filename
|
|
* @param {Object} options
|
|
* @api public
|
|
*/
|
|
|
|
function Parser(tokens, options) {
|
|
options = options || {};
|
|
if (!Array.isArray(tokens)) {
|
|
throw new Error(
|
|
'Expected tokens to be an Array but got "' + typeof tokens + '"'
|
|
);
|
|
}
|
|
if (typeof options !== 'object') {
|
|
throw new Error(
|
|
'Expected "options" to be an object but got "' + typeof options + '"'
|
|
);
|
|
}
|
|
this.tokens = new TokenStream(tokens);
|
|
this.filename = options.filename;
|
|
this.src = options.src;
|
|
this.inMixin = 0;
|
|
this.plugins = options.plugins || [];
|
|
}
|
|
|
|
/**
|
|
* Parser prototype.
|
|
*/
|
|
|
|
Parser.prototype = {
|
|
/**
|
|
* Save original constructor
|
|
*/
|
|
|
|
constructor: Parser,
|
|
|
|
error: function(code, message, token) {
|
|
var err = error(code, message, {
|
|
line: token.loc.start.line,
|
|
column: token.loc.start.column,
|
|
filename: this.filename,
|
|
src: this.src,
|
|
});
|
|
throw err;
|
|
},
|
|
|
|
/**
|
|
* Return the next token object.
|
|
*
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
advance: function() {
|
|
return this.tokens.advance();
|
|
},
|
|
|
|
/**
|
|
* Single token lookahead.
|
|
*
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
peek: function() {
|
|
return this.tokens.peek();
|
|
},
|
|
|
|
/**
|
|
* `n` token lookahead.
|
|
*
|
|
* @param {Number} n
|
|
* @return {Object}
|
|
* @api private
|
|
*/
|
|
|
|
lookahead: function(n) {
|
|
return this.tokens.lookahead(n);
|
|
},
|
|
|
|
/**
|
|
* Parse input returning a string of js for evaluation.
|
|
*
|
|
* @return {String}
|
|
* @api public
|
|
*/
|
|
|
|
parse: function() {
|
|
var block = this.emptyBlock(0);
|
|
|
|
while ('eos' != this.peek().type) {
|
|
if ('newline' == this.peek().type) {
|
|
this.advance();
|
|
} else if ('text-html' == this.peek().type) {
|
|
block.nodes = block.nodes.concat(this.parseTextHtml());
|
|
} else {
|
|
var expr = this.parseExpr();
|
|
if (expr) {
|
|
if (expr.type === 'Block') {
|
|
block.nodes = block.nodes.concat(expr.nodes);
|
|
} else {
|
|
block.nodes.push(expr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return block;
|
|
},
|
|
|
|
/**
|
|
* Expect the given type, or throw an exception.
|
|
*
|
|
* @param {String} type
|
|
* @api private
|
|
*/
|
|
|
|
expect: function(type) {
|
|
if (this.peek().type === type) {
|
|
return this.advance();
|
|
} else {
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'expected "' + type + '", but got "' + this.peek().type + '"',
|
|
this.peek()
|
|
);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Accept the given `type`.
|
|
*
|
|
* @param {String} type
|
|
* @api private
|
|
*/
|
|
|
|
accept: function(type) {
|
|
if (this.peek().type === type) {
|
|
return this.advance();
|
|
}
|
|
},
|
|
|
|
initBlock: function(line, nodes) {
|
|
/* istanbul ignore if */
|
|
if ((line | 0) !== line) throw new Error('`line` is not an integer');
|
|
/* istanbul ignore if */
|
|
if (!Array.isArray(nodes)) throw new Error('`nodes` is not an array');
|
|
return {
|
|
type: 'Block',
|
|
nodes: nodes,
|
|
line: line,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
emptyBlock: function(line) {
|
|
return this.initBlock(line, []);
|
|
},
|
|
|
|
runPlugin: function(context, tok) {
|
|
var rest = [this];
|
|
for (var i = 2; i < arguments.length; i++) {
|
|
rest.push(arguments[i]);
|
|
}
|
|
var pluginContext;
|
|
for (var i = 0; i < this.plugins.length; i++) {
|
|
var plugin = this.plugins[i];
|
|
if (plugin[context] && plugin[context][tok.type]) {
|
|
if (pluginContext)
|
|
throw new Error(
|
|
'Multiple plugin handlers found for context ' +
|
|
JSON.stringify(context) +
|
|
', token type ' +
|
|
JSON.stringify(tok.type)
|
|
);
|
|
pluginContext = plugin[context];
|
|
}
|
|
}
|
|
if (pluginContext)
|
|
return pluginContext[tok.type].apply(pluginContext, rest);
|
|
},
|
|
|
|
/**
|
|
* tag
|
|
* | doctype
|
|
* | mixin
|
|
* | include
|
|
* | filter
|
|
* | comment
|
|
* | text
|
|
* | text-html
|
|
* | dot
|
|
* | each
|
|
* | code
|
|
* | yield
|
|
* | id
|
|
* | class
|
|
* | interpolation
|
|
*/
|
|
|
|
parseExpr: function() {
|
|
switch (this.peek().type) {
|
|
case 'tag':
|
|
return this.parseTag();
|
|
case 'mixin':
|
|
return this.parseMixin();
|
|
case 'block':
|
|
return this.parseBlock();
|
|
case 'mixin-block':
|
|
return this.parseMixinBlock();
|
|
case 'case':
|
|
return this.parseCase();
|
|
case 'extends':
|
|
return this.parseExtends();
|
|
case 'include':
|
|
return this.parseInclude();
|
|
case 'doctype':
|
|
return this.parseDoctype();
|
|
case 'filter':
|
|
return this.parseFilter();
|
|
case 'comment':
|
|
return this.parseComment();
|
|
case 'text':
|
|
case 'interpolated-code':
|
|
case 'start-pug-interpolation':
|
|
return this.parseText({block: true});
|
|
case 'text-html':
|
|
return this.initBlock(this.peek().loc.start.line, this.parseTextHtml());
|
|
case 'dot':
|
|
return this.parseDot();
|
|
case 'each':
|
|
return this.parseEach();
|
|
case 'eachOf':
|
|
return this.parseEachOf();
|
|
case 'code':
|
|
return this.parseCode();
|
|
case 'blockcode':
|
|
return this.parseBlockCode();
|
|
case 'if':
|
|
return this.parseConditional();
|
|
case 'while':
|
|
return this.parseWhile();
|
|
case 'call':
|
|
return this.parseCall();
|
|
case 'interpolation':
|
|
return this.parseInterpolation();
|
|
case 'yield':
|
|
return this.parseYield();
|
|
case 'id':
|
|
case 'class':
|
|
if (!this.peek().loc.start) debugger;
|
|
this.tokens.defer({
|
|
type: 'tag',
|
|
val: 'div',
|
|
loc: this.peek().loc,
|
|
filename: this.filename,
|
|
});
|
|
return this.parseExpr();
|
|
default:
|
|
var pluginResult = this.runPlugin('expressionTokens', this.peek());
|
|
if (pluginResult) return pluginResult;
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'unexpected token "' + this.peek().type + '"',
|
|
this.peek()
|
|
);
|
|
}
|
|
},
|
|
|
|
parseDot: function() {
|
|
this.advance();
|
|
return this.parseTextBlock();
|
|
},
|
|
|
|
/**
|
|
* Text
|
|
*/
|
|
|
|
parseText: function(options) {
|
|
var tags = [];
|
|
var lineno = this.peek().loc.start.line;
|
|
var nextTok = this.peek();
|
|
loop: while (true) {
|
|
switch (nextTok.type) {
|
|
case 'text':
|
|
var tok = this.advance();
|
|
tags.push({
|
|
type: 'Text',
|
|
val: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
case 'interpolated-code':
|
|
var tok = this.advance();
|
|
tags.push({
|
|
type: 'Code',
|
|
val: tok.val,
|
|
buffer: tok.buffer,
|
|
mustEscape: tok.mustEscape !== false,
|
|
isInline: true,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
case 'newline':
|
|
if (!options || !options.block) break loop;
|
|
var tok = this.advance();
|
|
var nextType = this.peek().type;
|
|
if (nextType === 'text' || nextType === 'interpolated-code') {
|
|
tags.push({
|
|
type: 'Text',
|
|
val: '\n',
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
}
|
|
break;
|
|
case 'start-pug-interpolation':
|
|
this.advance();
|
|
tags.push(this.parseExpr());
|
|
this.expect('end-pug-interpolation');
|
|
break;
|
|
default:
|
|
var pluginResult = this.runPlugin('textTokens', nextTok, tags);
|
|
if (pluginResult) break;
|
|
break loop;
|
|
}
|
|
nextTok = this.peek();
|
|
}
|
|
if (tags.length === 1) return tags[0];
|
|
else return this.initBlock(lineno, tags);
|
|
},
|
|
|
|
parseTextHtml: function() {
|
|
var nodes = [];
|
|
var currentNode = null;
|
|
loop: while (true) {
|
|
switch (this.peek().type) {
|
|
case 'text-html':
|
|
var text = this.advance();
|
|
if (!currentNode) {
|
|
currentNode = {
|
|
type: 'Text',
|
|
val: text.val,
|
|
filename: this.filename,
|
|
line: text.loc.start.line,
|
|
column: text.loc.start.column,
|
|
isHtml: true,
|
|
};
|
|
nodes.push(currentNode);
|
|
} else {
|
|
currentNode.val += '\n' + text.val;
|
|
}
|
|
break;
|
|
case 'indent':
|
|
var block = this.block();
|
|
block.nodes.forEach(function(node) {
|
|
if (node.isHtml) {
|
|
if (!currentNode) {
|
|
currentNode = node;
|
|
nodes.push(currentNode);
|
|
} else {
|
|
currentNode.val += '\n' + node.val;
|
|
}
|
|
} else {
|
|
currentNode = null;
|
|
nodes.push(node);
|
|
}
|
|
});
|
|
break;
|
|
case 'code':
|
|
currentNode = null;
|
|
nodes.push(this.parseCode(true));
|
|
break;
|
|
case 'newline':
|
|
this.advance();
|
|
break;
|
|
default:
|
|
break loop;
|
|
}
|
|
}
|
|
return nodes;
|
|
},
|
|
|
|
/**
|
|
* ':' expr
|
|
* | block
|
|
*/
|
|
|
|
parseBlockExpansion: function() {
|
|
var tok = this.accept(':');
|
|
if (tok) {
|
|
var expr = this.parseExpr();
|
|
return expr.type === 'Block'
|
|
? expr
|
|
: this.initBlock(tok.loc.start.line, [expr]);
|
|
} else {
|
|
return this.block();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* case
|
|
*/
|
|
|
|
parseCase: function() {
|
|
var tok = this.expect('case');
|
|
var node = {
|
|
type: 'Case',
|
|
expr: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
var block = this.emptyBlock(tok.loc.start.line + 1);
|
|
this.expect('indent');
|
|
while ('outdent' != this.peek().type) {
|
|
switch (this.peek().type) {
|
|
case 'comment':
|
|
case 'newline':
|
|
this.advance();
|
|
break;
|
|
case 'when':
|
|
block.nodes.push(this.parseWhen());
|
|
break;
|
|
case 'default':
|
|
block.nodes.push(this.parseDefault());
|
|
break;
|
|
default:
|
|
var pluginResult = this.runPlugin('caseTokens', this.peek(), block);
|
|
if (pluginResult) break;
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'Unexpected token "' +
|
|
this.peek().type +
|
|
'", expected "when", "default" or "newline"',
|
|
this.peek()
|
|
);
|
|
}
|
|
}
|
|
this.expect('outdent');
|
|
|
|
node.block = block;
|
|
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* when
|
|
*/
|
|
|
|
parseWhen: function() {
|
|
var tok = this.expect('when');
|
|
if (this.peek().type !== 'newline') {
|
|
return {
|
|
type: 'When',
|
|
expr: tok.val,
|
|
block: this.parseBlockExpansion(),
|
|
debug: false,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
} else {
|
|
return {
|
|
type: 'When',
|
|
expr: tok.val,
|
|
debug: false,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
}
|
|
},
|
|
|
|
/**
|
|
* default
|
|
*/
|
|
|
|
parseDefault: function() {
|
|
var tok = this.expect('default');
|
|
return {
|
|
type: 'When',
|
|
expr: 'default',
|
|
block: this.parseBlockExpansion(),
|
|
debug: false,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* code
|
|
*/
|
|
|
|
parseCode: function(noBlock) {
|
|
var tok = this.expect('code');
|
|
assert(
|
|
typeof tok.mustEscape === 'boolean',
|
|
'Please update to the newest version of pug-lexer.'
|
|
);
|
|
var node = {
|
|
type: 'Code',
|
|
val: tok.val,
|
|
buffer: tok.buffer,
|
|
mustEscape: tok.mustEscape !== false,
|
|
isInline: !!noBlock,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
// todo: why is this here? It seems like a hacky workaround
|
|
if (node.val.match(/^ *else/)) node.debug = false;
|
|
|
|
if (noBlock) return node;
|
|
|
|
var block;
|
|
|
|
// handle block
|
|
block = 'indent' == this.peek().type;
|
|
if (block) {
|
|
if (tok.buffer) {
|
|
this.error(
|
|
'BLOCK_IN_BUFFERED_CODE',
|
|
'Buffered code cannot have a block attached to it',
|
|
this.peek()
|
|
);
|
|
}
|
|
node.block = this.block();
|
|
}
|
|
|
|
return node;
|
|
},
|
|
parseConditional: function() {
|
|
var tok = this.expect('if');
|
|
var node = {
|
|
type: 'Conditional',
|
|
test: tok.val,
|
|
consequent: this.emptyBlock(tok.loc.start.line),
|
|
alternate: null,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
// handle block
|
|
if ('indent' == this.peek().type) {
|
|
node.consequent = this.block();
|
|
}
|
|
|
|
var currentNode = node;
|
|
while (true) {
|
|
if (this.peek().type === 'newline') {
|
|
this.expect('newline');
|
|
} else if (this.peek().type === 'else-if') {
|
|
tok = this.expect('else-if');
|
|
currentNode = currentNode.alternate = {
|
|
type: 'Conditional',
|
|
test: tok.val,
|
|
consequent: this.emptyBlock(tok.loc.start.line),
|
|
alternate: null,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
if ('indent' == this.peek().type) {
|
|
currentNode.consequent = this.block();
|
|
}
|
|
} else if (this.peek().type === 'else') {
|
|
this.expect('else');
|
|
if (this.peek().type === 'indent') {
|
|
currentNode.alternate = this.block();
|
|
}
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return node;
|
|
},
|
|
parseWhile: function() {
|
|
var tok = this.expect('while');
|
|
var node = {
|
|
type: 'While',
|
|
test: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
// handle block
|
|
if ('indent' == this.peek().type) {
|
|
node.block = this.block();
|
|
} else {
|
|
node.block = this.emptyBlock(tok.loc.start.line);
|
|
}
|
|
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* block code
|
|
*/
|
|
|
|
parseBlockCode: function() {
|
|
var tok = this.expect('blockcode');
|
|
var line = tok.loc.start.line;
|
|
var column = tok.loc.start.column;
|
|
var body = this.peek();
|
|
var text = '';
|
|
if (body.type === 'start-pipeless-text') {
|
|
this.advance();
|
|
while (this.peek().type !== 'end-pipeless-text') {
|
|
tok = this.advance();
|
|
switch (tok.type) {
|
|
case 'text':
|
|
text += tok.val;
|
|
break;
|
|
case 'newline':
|
|
text += '\n';
|
|
break;
|
|
default:
|
|
var pluginResult = this.runPlugin('blockCodeTokens', tok, tok);
|
|
if (pluginResult) {
|
|
text += pluginResult;
|
|
break;
|
|
}
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'Unexpected token type: ' + tok.type,
|
|
tok
|
|
);
|
|
}
|
|
}
|
|
this.advance();
|
|
}
|
|
return {
|
|
type: 'Code',
|
|
val: text,
|
|
buffer: false,
|
|
mustEscape: false,
|
|
isInline: false,
|
|
line: line,
|
|
column: column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
/**
|
|
* comment
|
|
*/
|
|
|
|
parseComment: function() {
|
|
var tok = this.expect('comment');
|
|
var block;
|
|
if ((block = this.parseTextBlock())) {
|
|
return {
|
|
type: 'BlockComment',
|
|
val: tok.val,
|
|
block: block,
|
|
buffer: tok.buffer,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
} else {
|
|
return {
|
|
type: 'Comment',
|
|
val: tok.val,
|
|
buffer: tok.buffer,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
}
|
|
},
|
|
|
|
/**
|
|
* doctype
|
|
*/
|
|
|
|
parseDoctype: function() {
|
|
var tok = this.expect('doctype');
|
|
return {
|
|
type: 'Doctype',
|
|
val: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
parseIncludeFilter: function() {
|
|
var tok = this.expect('filter');
|
|
var attrs = [];
|
|
|
|
if (this.peek().type === 'start-attributes') {
|
|
attrs = this.attrs();
|
|
}
|
|
|
|
return {
|
|
type: 'IncludeFilter',
|
|
name: tok.val,
|
|
attrs: attrs,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* filter attrs? text-block
|
|
*/
|
|
|
|
parseFilter: function() {
|
|
var tok = this.expect('filter');
|
|
var block,
|
|
attrs = [];
|
|
|
|
if (this.peek().type === 'start-attributes') {
|
|
attrs = this.attrs();
|
|
}
|
|
|
|
if (this.peek().type === 'text') {
|
|
var textToken = this.advance();
|
|
block = this.initBlock(textToken.loc.start.line, [
|
|
{
|
|
type: 'Text',
|
|
val: textToken.val,
|
|
line: textToken.loc.start.line,
|
|
column: textToken.loc.start.column,
|
|
filename: this.filename,
|
|
},
|
|
]);
|
|
} else if (this.peek().type === 'filter') {
|
|
block = this.initBlock(tok.loc.start.line, [this.parseFilter()]);
|
|
} else {
|
|
block = this.parseTextBlock() || this.emptyBlock(tok.loc.start.line);
|
|
}
|
|
|
|
return {
|
|
type: 'Filter',
|
|
name: tok.val,
|
|
block: block,
|
|
attrs: attrs,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* each block
|
|
*/
|
|
|
|
parseEach: function() {
|
|
var tok = this.expect('each');
|
|
var node = {
|
|
type: 'Each',
|
|
obj: tok.code,
|
|
val: tok.val,
|
|
key: tok.key,
|
|
block: this.block(),
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
if (this.peek().type == 'else') {
|
|
this.advance();
|
|
node.alternate = this.block();
|
|
}
|
|
return node;
|
|
},
|
|
|
|
parseEachOf: function() {
|
|
var tok = this.expect('eachOf');
|
|
var node = {
|
|
type: 'EachOf',
|
|
obj: tok.code,
|
|
val: tok.val,
|
|
block: this.block(),
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
return node;
|
|
},
|
|
/**
|
|
* 'extends' name
|
|
*/
|
|
|
|
parseExtends: function() {
|
|
var tok = this.expect('extends');
|
|
var path = this.expect('path');
|
|
return {
|
|
type: 'Extends',
|
|
file: {
|
|
type: 'FileReference',
|
|
path: path.val.trim(),
|
|
line: path.loc.start.line,
|
|
column: path.loc.start.column,
|
|
filename: this.filename,
|
|
},
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* 'block' name block
|
|
*/
|
|
|
|
parseBlock: function() {
|
|
var tok = this.expect('block');
|
|
|
|
var node =
|
|
'indent' == this.peek().type
|
|
? this.block()
|
|
: this.emptyBlock(tok.loc.start.line);
|
|
node.type = 'NamedBlock';
|
|
node.name = tok.val.trim();
|
|
node.mode = tok.mode;
|
|
node.line = tok.loc.start.line;
|
|
node.column = tok.loc.start.column;
|
|
|
|
return node;
|
|
},
|
|
|
|
parseMixinBlock: function() {
|
|
var tok = this.expect('mixin-block');
|
|
if (!this.inMixin) {
|
|
this.error(
|
|
'BLOCK_OUTISDE_MIXIN',
|
|
'Anonymous blocks are not allowed unless they are part of a mixin.',
|
|
tok
|
|
);
|
|
}
|
|
return {
|
|
type: 'MixinBlock',
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
parseYield: function() {
|
|
var tok = this.expect('yield');
|
|
return {
|
|
type: 'YieldBlock',
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
},
|
|
|
|
/**
|
|
* include block?
|
|
*/
|
|
|
|
parseInclude: function() {
|
|
var tok = this.expect('include');
|
|
var node = {
|
|
type: 'Include',
|
|
file: {
|
|
type: 'FileReference',
|
|
filename: this.filename,
|
|
},
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
var filters = [];
|
|
while (this.peek().type === 'filter') {
|
|
filters.push(this.parseIncludeFilter());
|
|
}
|
|
var path = this.expect('path');
|
|
|
|
node.file.path = path.val.trim();
|
|
node.file.line = path.loc.start.line;
|
|
node.file.column = path.loc.start.column;
|
|
|
|
if (
|
|
(/\.jade$/.test(node.file.path) || /\.pug$/.test(node.file.path)) &&
|
|
!filters.length
|
|
) {
|
|
node.block =
|
|
'indent' == this.peek().type
|
|
? this.block()
|
|
: this.emptyBlock(tok.loc.start.line);
|
|
if (/\.jade$/.test(node.file.path)) {
|
|
console.warn(
|
|
this.filename +
|
|
', line ' +
|
|
tok.loc.start.line +
|
|
':\nThe .jade extension is deprecated, use .pug for "' +
|
|
node.file.path +
|
|
'".'
|
|
);
|
|
}
|
|
} else {
|
|
node.type = 'RawInclude';
|
|
node.filters = filters;
|
|
if (this.peek().type === 'indent') {
|
|
this.error(
|
|
'RAW_INCLUDE_BLOCK',
|
|
'Raw inclusion cannot contain a block',
|
|
this.peek()
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* call ident block
|
|
*/
|
|
|
|
parseCall: function() {
|
|
var tok = this.expect('call');
|
|
var name = tok.val;
|
|
var args = tok.args;
|
|
var mixin = {
|
|
type: 'Mixin',
|
|
name: name,
|
|
args: args,
|
|
block: this.emptyBlock(tok.loc.start.line),
|
|
call: true,
|
|
attrs: [],
|
|
attributeBlocks: [],
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
this.tag(mixin);
|
|
if (mixin.code) {
|
|
mixin.block.nodes.push(mixin.code);
|
|
delete mixin.code;
|
|
}
|
|
if (mixin.block.nodes.length === 0) mixin.block = null;
|
|
return mixin;
|
|
},
|
|
|
|
/**
|
|
* mixin block
|
|
*/
|
|
|
|
parseMixin: function() {
|
|
var tok = this.expect('mixin');
|
|
var name = tok.val;
|
|
var args = tok.args;
|
|
|
|
if ('indent' == this.peek().type) {
|
|
this.inMixin++;
|
|
var mixin = {
|
|
type: 'Mixin',
|
|
name: name,
|
|
args: args,
|
|
block: this.block(),
|
|
call: false,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
this.inMixin--;
|
|
return mixin;
|
|
} else {
|
|
this.error(
|
|
'MIXIN_WITHOUT_BODY',
|
|
'Mixin ' + name + ' declared without body',
|
|
tok
|
|
);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* indent (text | newline)* outdent
|
|
*/
|
|
|
|
parseTextBlock: function() {
|
|
var tok = this.accept('start-pipeless-text');
|
|
if (!tok) return;
|
|
var block = this.emptyBlock(tok.loc.start.line);
|
|
while (this.peek().type !== 'end-pipeless-text') {
|
|
var tok = this.advance();
|
|
switch (tok.type) {
|
|
case 'text':
|
|
block.nodes.push({
|
|
type: 'Text',
|
|
val: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
case 'newline':
|
|
block.nodes.push({
|
|
type: 'Text',
|
|
val: '\n',
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
case 'start-pug-interpolation':
|
|
block.nodes.push(this.parseExpr());
|
|
this.expect('end-pug-interpolation');
|
|
break;
|
|
case 'interpolated-code':
|
|
block.nodes.push({
|
|
type: 'Code',
|
|
val: tok.val,
|
|
buffer: tok.buffer,
|
|
mustEscape: tok.mustEscape !== false,
|
|
isInline: true,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
default:
|
|
var pluginResult = this.runPlugin('textBlockTokens', tok, block, tok);
|
|
if (pluginResult) break;
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'Unexpected token type: ' + tok.type,
|
|
tok
|
|
);
|
|
}
|
|
}
|
|
this.advance();
|
|
return block;
|
|
},
|
|
|
|
/**
|
|
* indent expr* outdent
|
|
*/
|
|
|
|
block: function() {
|
|
var tok = this.expect('indent');
|
|
var block = this.emptyBlock(tok.loc.start.line);
|
|
while ('outdent' != this.peek().type) {
|
|
if ('newline' == this.peek().type) {
|
|
this.advance();
|
|
} else if ('text-html' == this.peek().type) {
|
|
block.nodes = block.nodes.concat(this.parseTextHtml());
|
|
} else {
|
|
var expr = this.parseExpr();
|
|
if (expr.type === 'Block') {
|
|
block.nodes = block.nodes.concat(expr.nodes);
|
|
} else {
|
|
block.nodes.push(expr);
|
|
}
|
|
}
|
|
}
|
|
this.expect('outdent');
|
|
return block;
|
|
},
|
|
|
|
/**
|
|
* interpolation (attrs | class | id)* (text | code | ':')? newline* block?
|
|
*/
|
|
|
|
parseInterpolation: function() {
|
|
var tok = this.advance();
|
|
var tag = {
|
|
type: 'InterpolatedTag',
|
|
expr: tok.val,
|
|
selfClosing: false,
|
|
block: this.emptyBlock(tok.loc.start.line),
|
|
attrs: [],
|
|
attributeBlocks: [],
|
|
isInline: false,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
return this.tag(tag, {selfClosingAllowed: true});
|
|
},
|
|
|
|
/**
|
|
* tag (attrs | class | id)* (text | code | ':')? newline* block?
|
|
*/
|
|
|
|
parseTag: function() {
|
|
var tok = this.advance();
|
|
var tag = {
|
|
type: 'Tag',
|
|
name: tok.val,
|
|
selfClosing: false,
|
|
block: this.emptyBlock(tok.loc.start.line),
|
|
attrs: [],
|
|
attributeBlocks: [],
|
|
isInline: inlineTags.indexOf(tok.val) !== -1,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
};
|
|
|
|
return this.tag(tag, {selfClosingAllowed: true});
|
|
},
|
|
|
|
/**
|
|
* Parse tag.
|
|
*/
|
|
|
|
tag: function(tag, options) {
|
|
var seenAttrs = false;
|
|
var attributeNames = [];
|
|
var selfClosingAllowed = options && options.selfClosingAllowed;
|
|
// (attrs | class | id)*
|
|
out: while (true) {
|
|
switch (this.peek().type) {
|
|
case 'id':
|
|
case 'class':
|
|
var tok = this.advance();
|
|
if (tok.type === 'id') {
|
|
if (attributeNames.indexOf('id') !== -1) {
|
|
this.error(
|
|
'DUPLICATE_ID',
|
|
'Duplicate attribute "id" is not allowed.',
|
|
tok
|
|
);
|
|
}
|
|
attributeNames.push('id');
|
|
}
|
|
tag.attrs.push({
|
|
name: tok.type,
|
|
val: "'" + tok.val + "'",
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
mustEscape: false,
|
|
});
|
|
continue;
|
|
case 'start-attributes':
|
|
if (seenAttrs) {
|
|
console.warn(
|
|
this.filename +
|
|
', line ' +
|
|
this.peek().loc.start.line +
|
|
':\nYou should not have pug tags with multiple attributes.'
|
|
);
|
|
}
|
|
seenAttrs = true;
|
|
tag.attrs = tag.attrs.concat(this.attrs(attributeNames));
|
|
continue;
|
|
case '&attributes':
|
|
var tok = this.advance();
|
|
tag.attributeBlocks.push({
|
|
type: 'AttributeBlock',
|
|
val: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
});
|
|
break;
|
|
default:
|
|
var pluginResult = this.runPlugin(
|
|
'tagAttributeTokens',
|
|
this.peek(),
|
|
tag,
|
|
attributeNames
|
|
);
|
|
if (pluginResult) break;
|
|
break out;
|
|
}
|
|
}
|
|
|
|
// check immediate '.'
|
|
if ('dot' == this.peek().type) {
|
|
tag.textOnly = true;
|
|
this.advance();
|
|
}
|
|
|
|
// (text | code | ':')?
|
|
switch (this.peek().type) {
|
|
case 'text':
|
|
case 'interpolated-code':
|
|
var text = this.parseText();
|
|
if (text.type === 'Block') {
|
|
tag.block.nodes.push.apply(tag.block.nodes, text.nodes);
|
|
} else {
|
|
tag.block.nodes.push(text);
|
|
}
|
|
break;
|
|
case 'code':
|
|
tag.block.nodes.push(this.parseCode(true));
|
|
break;
|
|
case ':':
|
|
this.advance();
|
|
var expr = this.parseExpr();
|
|
tag.block =
|
|
expr.type === 'Block' ? expr : this.initBlock(tag.line, [expr]);
|
|
break;
|
|
case 'newline':
|
|
case 'indent':
|
|
case 'outdent':
|
|
case 'eos':
|
|
case 'start-pipeless-text':
|
|
case 'end-pug-interpolation':
|
|
break;
|
|
case 'slash':
|
|
if (selfClosingAllowed) {
|
|
this.advance();
|
|
tag.selfClosing = true;
|
|
break;
|
|
}
|
|
default:
|
|
var pluginResult = this.runPlugin(
|
|
'tagTokens',
|
|
this.peek(),
|
|
tag,
|
|
options
|
|
);
|
|
if (pluginResult) break;
|
|
this.error(
|
|
'INVALID_TOKEN',
|
|
'Unexpected token `' +
|
|
this.peek().type +
|
|
'` expected `text`, `interpolated-code`, `code`, `:`' +
|
|
(selfClosingAllowed ? ', `slash`' : '') +
|
|
', `newline` or `eos`',
|
|
this.peek()
|
|
);
|
|
}
|
|
|
|
// newline*
|
|
while ('newline' == this.peek().type) this.advance();
|
|
|
|
// block?
|
|
if (tag.textOnly) {
|
|
tag.block = this.parseTextBlock() || this.emptyBlock(tag.line);
|
|
} else if ('indent' == this.peek().type) {
|
|
var block = this.block();
|
|
for (var i = 0, len = block.nodes.length; i < len; ++i) {
|
|
tag.block.nodes.push(block.nodes[i]);
|
|
}
|
|
}
|
|
|
|
return tag;
|
|
},
|
|
|
|
attrs: function(attributeNames) {
|
|
this.expect('start-attributes');
|
|
|
|
var attrs = [];
|
|
var tok = this.advance();
|
|
while (tok.type === 'attribute') {
|
|
if (tok.name !== 'class' && attributeNames) {
|
|
if (attributeNames.indexOf(tok.name) !== -1) {
|
|
this.error(
|
|
'DUPLICATE_ATTRIBUTE',
|
|
'Duplicate attribute "' + tok.name + '" is not allowed.',
|
|
tok
|
|
);
|
|
}
|
|
attributeNames.push(tok.name);
|
|
}
|
|
attrs.push({
|
|
name: tok.name,
|
|
val: tok.val,
|
|
line: tok.loc.start.line,
|
|
column: tok.loc.start.column,
|
|
filename: this.filename,
|
|
mustEscape: tok.mustEscape !== false,
|
|
});
|
|
tok = this.advance();
|
|
}
|
|
this.tokens.defer(tok);
|
|
this.expect('end-attributes');
|
|
return attrs;
|
|
},
|
|
};
|