\n')); } exports.nl2br = nl2br; function random(arr) { return arr[Math.floor(Math.random() * arr.length)]; } exports.random = random; /** * Construct select or reject filter * * @param {boolean} expectedTestResult * @returns {function(array, string, *): array} */ function getSelectOrReject(expectedTestResult) { function filter(arr, testName = 'truthy', secondArg) { const context = this; const test = context.env.getTest(testName); return lib.toArray(arr).filter(function examineTestResult(item) { return test.call(context, item, secondArg) === expectedTestResult; }); } return filter; } exports.reject = getSelectOrReject(false); function rejectattr(arr, attr) { return arr.filter((item) => !item[attr]); } exports.rejectattr = rejectattr; exports.select = getSelectOrReject(true); function selectattr(arr, attr) { return arr.filter((item) => !!item[attr]); } exports.selectattr = selectattr; function replace(str, old, new_, maxCount) { var originalStr = str; if (old instanceof RegExp) { return str.replace(old, new_); } if (typeof maxCount === 'undefined') { maxCount = -1; } let res = ''; // Output // Cast Numbers in the search term to string if (typeof old === 'number') { old = '' + old; } else if (typeof old !== 'string') { // If it is something other than number or string, // return the original string return str; } // Cast numbers in the replacement to string if (typeof str === 'number') { str = '' + str; } // If by now, we don't have a string, throw it back if (typeof str !== 'string' && !(str instanceof r.SafeString)) { return str; } // ShortCircuits if (old === '') { // Mimic the python behaviour: empty string is replaced // by replacement e.g. "abc"|replace("", ".") -> .a.b.c. res = new_ + str.split('').join(new_) + new_; return r.copySafeness(str, res); } let nextIndex = str.indexOf(old); // if # of replacements to perform is 0, or the string to does // not contain the old value, return the string if (maxCount === 0 || nextIndex === -1) { return str; } let pos = 0; let count = 0; // # of replacements made while (nextIndex > -1 && (maxCount === -1 || count < maxCount)) { // Grab the next chunk of src string and add it with the // replacement, to the result res += str.substring(pos, nextIndex) + new_; // Increment our pointer in the src string pos = nextIndex + old.length; count++; // See if there are any more replacements to be made nextIndex = str.indexOf(old, pos); } // We've either reached the end, or done the max # of // replacements, tack on any remaining string if (pos < str.length) { res += str.substring(pos); } return r.copySafeness(originalStr, res); } exports.replace = replace; function reverse(val) { var arr; if (lib.isString(val)) { arr = list(val); } else { // Copy it arr = lib.map(val, v => v); } arr.reverse(); if (lib.isString(val)) { return r.copySafeness(val, arr.join('')); } return arr; } exports.reverse = reverse; function round(val, precision, method) { precision = precision || 0; const factor = Math.pow(10, precision); let rounder; if (method === 'ceil') { rounder = Math.ceil; } else if (method === 'floor') { rounder = Math.floor; } else { rounder = Math.round; } return rounder(val * factor) / factor; } exports.round = round; function slice(arr, slices, fillWith) { const sliceLength = Math.floor(arr.length / slices); const extra = arr.length % slices; const res = []; let offset = 0; for (let i = 0; i < slices; i++) { const start = offset + (i * sliceLength); if (i < extra) { offset++; } const end = offset + ((i + 1) * sliceLength); const currSlice = arr.slice(start, end); if (fillWith && i >= extra) { currSlice.push(fillWith); } res.push(currSlice); } return res; } exports.slice = slice; function sum(arr, attr, start = 0) { if (attr) { arr = lib.map(arr, (v) => v[attr]); } return start + arr.reduce((a, b) => a + b, 0); } exports.sum = sum; exports.sort = r.makeMacro( ['value', 'reverse', 'case_sensitive', 'attribute'], [], function sortFilter(arr, reversed, caseSens, attr) { // Copy it let array = lib.map(arr, v => v); let getAttribute = lib.getAttrGetter(attr); array.sort((a, b) => { let x = (attr) ? getAttribute(a) : a; let y = (attr) ? getAttribute(b) : b; if ( this.env.opts.throwOnUndefined && attr && (x === undefined || y === undefined) ) { throw new TypeError(`sort: attribute "${attr}" resolved to undefined`); } if (!caseSens && lib.isString(x) && lib.isString(y)) { x = x.toLowerCase(); y = y.toLowerCase(); } if (x < y) { return reversed ? 1 : -1; } else if (x > y) { return reversed ? -1 : 1; } else { return 0; } }); return array; }); function string(obj) { return r.copySafeness(obj, obj); } exports.string = string; function striptags(input, preserveLinebreaks) { input = normalize(input, ''); let tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>|/gi; let trimmedInput = trim(input.replace(tags, '')); let res = ''; if (preserveLinebreaks) { res = trimmedInput .replace(/^ +| +$/gm, '') // remove leading and trailing spaces .replace(/ +/g, ' ') // squash adjacent spaces .replace(/(\r\n)/g, '\n') // normalize linebreaks (CRLF -> LF) .replace(/\n\n\n+/g, '\n\n'); // squash abnormal adjacent linebreaks } else { res = trimmedInput.replace(/\s+/gi, ' '); } return r.copySafeness(input, res); } exports.striptags = striptags; function title(str) { str = normalize(str, ''); let words = str.split(' ').map(word => capitalize(word)); return r.copySafeness(str, words.join(' ')); } exports.title = title; function trim(str) { return r.copySafeness(str, str.replace(/^\s*|\s*$/g, '')); } exports.trim = trim; function truncate(input, length, killwords, end) { var orig = input; input = normalize(input, ''); length = length || 255; if (input.length <= length) { return input; } if (killwords) { input = input.substring(0, length); } else { let idx = input.lastIndexOf(' ', length); if (idx === -1) { idx = length; } input = input.substring(0, idx); } input += (end !== undefined && end !== null) ? end : '...'; return r.copySafeness(orig, input); } exports.truncate = truncate; function upper(str) { str = normalize(str, ''); return str.toUpperCase(); } exports.upper = upper; function urlencode(obj) { var enc = encodeURIComponent; if (lib.isString(obj)) { return enc(obj); } else { let keyvals = (lib.isArray(obj)) ? obj : lib._entries(obj); return keyvals.map(([k, v]) => `${enc(k)}=${enc(v)}`).join('&'); } } exports.urlencode = urlencode; // For the jinja regexp, see // https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23 const puncRe = /^(?:\(|<|<)?(.*?)(?:\.|,|\)|\n|>)?$/; // from http://blog.gerv.net/2011/05/html5_email_address_regexp/ const emailRe = /^[\w.!#$%&'*+\-\/=?\^`{|}~]+@[a-z\d\-]+(\.[a-z\d\-]+)+$/i; const httpHttpsRe = /^https?:\/\/.*$/; const wwwRe = /^www\./; const tldRe = /\.(?:org|net|com)(?:\:|\/|$)/; function urlize(str, length, nofollow) { if (isNaN(length)) { length = Infinity; } const noFollowAttr = (nofollow === true ? ' rel="nofollow"' : ''); const words = str.split(/(\s+)/).filter((word) => { // If the word has no length, bail. This can happen for str with // trailing whitespace. return word && word.length; }).map((word) => { var matches = word.match(puncRe); var possibleUrl = (matches) ? matches[1] : word; var shortUrl = possibleUrl.substr(0, length); // url that starts with http or https if (httpHttpsRe.test(possibleUrl)) { return `${shortUrl}`; } // url that starts with www. if (wwwRe.test(possibleUrl)) { return `${shortUrl}`; } // an email address of the form username@domain.tld if (emailRe.test(possibleUrl)) { return `${possibleUrl}`; } // url that ends in .com, .org or .net that is not an email address if (tldRe.test(possibleUrl)) { return `${shortUrl}`; } return word; }); return words.join(''); } exports.urlize = urlize; function wordcount(str) { str = normalize(str, ''); const words = (str) ? str.match(/\w+/g) : null; return (words) ? words.length : null; } exports.wordcount = wordcount; function float(val, def) { var res = parseFloat(val); return (isNaN(res)) ? def : res; } exports.float = float; const intFilter = r.makeMacro( ['value', 'default', 'base'], [], function doInt(value, defaultValue, base = 10) { var res = parseInt(value, base); return (isNaN(res)) ? defaultValue : res; } ); exports.int = intFilter; // Aliases exports.d = exports.default; exports.e = exports.escape; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/globals.js 000664 000000 000000 00000002475 14012546311 024473 0 ustar 00root root 000000 000000 'use strict'; function cycler(items) { var index = -1; return { current: null, reset() { index = -1; this.current = null; }, next() { index++; if (index >= items.length) { index = 0; } this.current = items[index]; return this.current; }, }; } function joiner(sep) { sep = sep || ','; let first = true; return () => { const val = first ? '' : sep; first = false; return val; }; } // Making this a function instead so it returns a new object // each time it's called. That way, if something like an environment // uses it, they will each have their own copy. function globals() { return { range(start, stop, step) { if (typeof stop === 'undefined') { stop = start; start = 0; step = 1; } else if (!step) { step = 1; } const arr = []; if (step > 0) { for (let i = start; i < stop; i += step) { arr.push(i); } } else { for (let i = start; i > stop; i += step) { // eslint-disable-line for-direction arr.push(i); } } return arr; }, cycler() { return cycler(Array.prototype.slice.call(arguments)); }, joiner(sep) { return joiner(sep); } }; } module.exports = globals; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/jinja-compat.js 000664 000000 000000 00000017636 14012546311 025431 0 ustar 00root root 000000 000000 function installCompat() { 'use strict'; /* eslint-disable camelcase */ // This must be called like `nunjucks.installCompat` so that `this` // references the nunjucks instance var runtime = this.runtime; var lib = this.lib; // Handle slim case where these 'modules' are excluded from the built source var Compiler = this.compiler.Compiler; var Parser = this.parser.Parser; var nodes = this.nodes; var lexer = this.lexer; var orig_contextOrFrameLookup = runtime.contextOrFrameLookup; var orig_memberLookup = runtime.memberLookup; var orig_Compiler_assertType; var orig_Parser_parseAggregate; if (Compiler) { orig_Compiler_assertType = Compiler.prototype.assertType; } if (Parser) { orig_Parser_parseAggregate = Parser.prototype.parseAggregate; } function uninstall() { runtime.contextOrFrameLookup = orig_contextOrFrameLookup; runtime.memberLookup = orig_memberLookup; if (Compiler) { Compiler.prototype.assertType = orig_Compiler_assertType; } if (Parser) { Parser.prototype.parseAggregate = orig_Parser_parseAggregate; } } runtime.contextOrFrameLookup = function contextOrFrameLookup(context, frame, key) { var val = orig_contextOrFrameLookup.apply(this, arguments); if (val !== undefined) { return val; } switch (key) { case 'True': return true; case 'False': return false; case 'None': return null; default: return undefined; } }; function getTokensState(tokens) { return { index: tokens.index, lineno: tokens.lineno, colno: tokens.colno }; } if (process.env.BUILD_TYPE !== 'SLIM' && nodes && Compiler && Parser) { // i.e., not slim mode const Slice = nodes.Node.extend('Slice', { fields: ['start', 'stop', 'step'], init(lineno, colno, start, stop, step) { start = start || new nodes.Literal(lineno, colno, null); stop = stop || new nodes.Literal(lineno, colno, null); step = step || new nodes.Literal(lineno, colno, 1); this.parent(lineno, colno, start, stop, step); } }); Compiler.prototype.assertType = function assertType(node) { if (node instanceof Slice) { return; } orig_Compiler_assertType.apply(this, arguments); }; Compiler.prototype.compileSlice = function compileSlice(node, frame) { this._emit('('); this._compileExpression(node.start, frame); this._emit('),('); this._compileExpression(node.stop, frame); this._emit('),('); this._compileExpression(node.step, frame); this._emit(')'); }; Parser.prototype.parseAggregate = function parseAggregate() { var origState = getTokensState(this.tokens); // Set back one accounting for opening bracket/parens origState.colno--; origState.index--; try { return orig_Parser_parseAggregate.apply(this); } catch (e) { const errState = getTokensState(this.tokens); const rethrow = () => { lib._assign(this.tokens, errState); return e; }; // Reset to state before original parseAggregate called lib._assign(this.tokens, origState); this.peeked = false; const tok = this.peekToken(); if (tok.type !== lexer.TOKEN_LEFT_BRACKET) { throw rethrow(); } else { this.nextToken(); } const node = new Slice(tok.lineno, tok.colno); // If we don't encounter a colon while parsing, this is not a slice, // so re-raise the original exception. let isSlice = false; for (let i = 0; i <= node.fields.length; i++) { if (this.skip(lexer.TOKEN_RIGHT_BRACKET)) { break; } if (i === node.fields.length) { if (isSlice) { this.fail('parseSlice: too many slice components', tok.lineno, tok.colno); } else { break; } } if (this.skip(lexer.TOKEN_COLON)) { isSlice = true; } else { const field = node.fields[i]; node[field] = this.parseExpression(); isSlice = this.skip(lexer.TOKEN_COLON) || isSlice; } } if (!isSlice) { throw rethrow(); } return new nodes.Array(tok.lineno, tok.colno, [node]); } }; } function sliceLookup(obj, start, stop, step) { obj = obj || []; if (start === null) { start = (step < 0) ? (obj.length - 1) : 0; } if (stop === null) { stop = (step < 0) ? -1 : obj.length; } else if (stop < 0) { stop += obj.length; } if (start < 0) { start += obj.length; } const results = []; for (let i = start; ; i += step) { if (i < 0 || i > obj.length) { break; } if (step > 0 && i >= stop) { break; } if (step < 0 && i <= stop) { break; } results.push(runtime.memberLookup(obj, i)); } return results; } function hasOwnProp(obj, key) { return Object.prototype.hasOwnProperty.call(obj, key); } const ARRAY_MEMBERS = { pop(index) { if (index === undefined) { return this.pop(); } if (index >= this.length || index < 0) { throw new Error('KeyError'); } return this.splice(index, 1); }, append(element) { return this.push(element); }, remove(element) { for (let i = 0; i < this.length; i++) { if (this[i] === element) { return this.splice(i, 1); } } throw new Error('ValueError'); }, count(element) { var count = 0; for (let i = 0; i < this.length; i++) { if (this[i] === element) { count++; } } return count; }, index(element) { var i; if ((i = this.indexOf(element)) === -1) { throw new Error('ValueError'); } return i; }, find(element) { return this.indexOf(element); }, insert(index, elem) { return this.splice(index, 0, elem); } }; const OBJECT_MEMBERS = { items() { return lib._entries(this); }, values() { return lib._values(this); }, keys() { return lib.keys(this); }, get(key, def) { var output = this[key]; if (output === undefined) { output = def; } return output; }, has_key(key) { return hasOwnProp(this, key); }, pop(key, def) { var output = this[key]; if (output === undefined && def !== undefined) { output = def; } else if (output === undefined) { throw new Error('KeyError'); } else { delete this[key]; } return output; }, popitem() { const keys = lib.keys(this); if (!keys.length) { throw new Error('KeyError'); } const k = keys[0]; const val = this[k]; delete this[k]; return [k, val]; }, setdefault(key, def = null) { if (!(key in this)) { this[key] = def; } return this[key]; }, update(kwargs) { lib._assign(this, kwargs); return null; // Always returns None } }; OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items; OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values; OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys; runtime.memberLookup = function memberLookup(obj, val, autoescape) { if (arguments.length === 4) { return sliceLookup.apply(this, arguments); } obj = obj || {}; // If the object is an object, return any of the methods that Python would // otherwise provide. if (lib.isArray(obj) && hasOwnProp(ARRAY_MEMBERS, val)) { return ARRAY_MEMBERS[val].bind(obj); } if (lib.isObject(obj) && hasOwnProp(OBJECT_MEMBERS, val)) { return OBJECT_MEMBERS[val].bind(obj); } return orig_memberLookup.apply(this, arguments); }; return uninstall; } module.exports = installCompat; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/lexer.js 000664 000000 000000 00000036145 14012546311 024170 0 ustar 00root root 000000 000000 'use strict'; const lib = require('./lib'); let whitespaceChars = ' \n\t\r\u00A0'; let delimChars = '()[]{}%*-+~/#,:|.<>=!'; let intChars = '0123456789'; let BLOCK_START = '{%'; let BLOCK_END = '%}'; let VARIABLE_START = '{{'; let VARIABLE_END = '}}'; let COMMENT_START = '{#'; let COMMENT_END = '#}'; let TOKEN_STRING = 'string'; let TOKEN_WHITESPACE = 'whitespace'; let TOKEN_DATA = 'data'; let TOKEN_BLOCK_START = 'block-start'; let TOKEN_BLOCK_END = 'block-end'; let TOKEN_VARIABLE_START = 'variable-start'; let TOKEN_VARIABLE_END = 'variable-end'; let TOKEN_COMMENT = 'comment'; let TOKEN_LEFT_PAREN = 'left-paren'; let TOKEN_RIGHT_PAREN = 'right-paren'; let TOKEN_LEFT_BRACKET = 'left-bracket'; let TOKEN_RIGHT_BRACKET = 'right-bracket'; let TOKEN_LEFT_CURLY = 'left-curly'; let TOKEN_RIGHT_CURLY = 'right-curly'; let TOKEN_OPERATOR = 'operator'; let TOKEN_COMMA = 'comma'; let TOKEN_COLON = 'colon'; let TOKEN_TILDE = 'tilde'; let TOKEN_PIPE = 'pipe'; let TOKEN_INT = 'int'; let TOKEN_FLOAT = 'float'; let TOKEN_BOOLEAN = 'boolean'; let TOKEN_NONE = 'none'; let TOKEN_SYMBOL = 'symbol'; let TOKEN_SPECIAL = 'special'; let TOKEN_REGEX = 'regex'; function token(type, value, lineno, colno) { return { type: type, value: value, lineno: lineno, colno: colno }; } class Tokenizer { constructor(str, opts) { this.str = str; this.index = 0; this.len = str.length; this.lineno = 0; this.colno = 0; this.in_code = false; opts = opts || {}; let tags = opts.tags || {}; this.tags = { BLOCK_START: tags.blockStart || BLOCK_START, BLOCK_END: tags.blockEnd || BLOCK_END, VARIABLE_START: tags.variableStart || VARIABLE_START, VARIABLE_END: tags.variableEnd || VARIABLE_END, COMMENT_START: tags.commentStart || COMMENT_START, COMMENT_END: tags.commentEnd || COMMENT_END }; this.trimBlocks = !!opts.trimBlocks; this.lstripBlocks = !!opts.lstripBlocks; } nextToken() { let lineno = this.lineno; let colno = this.colno; let tok; if (this.in_code) { // Otherwise, if we are in a block parse it as code let cur = this.current(); if (this.isFinished()) { // We have nothing else to parse return null; } else if (cur === '"' || cur === '\'') { // We've hit a string return token(TOKEN_STRING, this._parseString(cur), lineno, colno); } else if ((tok = this._extract(whitespaceChars))) { // We hit some whitespace return token(TOKEN_WHITESPACE, tok, lineno, colno); } else if ((tok = this._extractString(this.tags.BLOCK_END)) || (tok = this._extractString('-' + this.tags.BLOCK_END))) { // Special check for the block end tag // // It is a requirement that start and end tags are composed of // delimiter characters (%{}[] etc), and our code always // breaks on delimiters so we can assume the token parsing // doesn't consume these elsewhere this.in_code = false; if (this.trimBlocks) { cur = this.current(); if (cur === '\n') { // Skip newline this.forward(); } else if (cur === '\r') { // Skip CRLF newline this.forward(); cur = this.current(); if (cur === '\n') { this.forward(); } else { // Was not a CRLF, so go back this.back(); } } } return token(TOKEN_BLOCK_END, tok, lineno, colno); } else if ((tok = this._extractString(this.tags.VARIABLE_END)) || (tok = this._extractString('-' + this.tags.VARIABLE_END))) { // Special check for variable end tag (see above) this.in_code = false; return token(TOKEN_VARIABLE_END, tok, lineno, colno); } else if (cur === 'r' && this.str.charAt(this.index + 1) === '/') { // Skip past 'r/'. this.forwardN(2); // Extract until the end of the regex -- / ends it, \/ does not. let regexBody = ''; while (!this.isFinished()) { if (this.current() === '/' && this.previous() !== '\\') { this.forward(); break; } else { regexBody += this.current(); this.forward(); } } // Check for flags. // The possible flags are according to https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/RegExp) let POSSIBLE_FLAGS = ['g', 'i', 'm', 'y']; let regexFlags = ''; while (!this.isFinished()) { let isCurrentAFlag = POSSIBLE_FLAGS.indexOf(this.current()) !== -1; if (isCurrentAFlag) { regexFlags += this.current(); this.forward(); } else { break; } } return token(TOKEN_REGEX, { body: regexBody, flags: regexFlags }, lineno, colno); } else if (delimChars.indexOf(cur) !== -1) { // We've hit a delimiter (a special char like a bracket) this.forward(); let complexOps = ['==', '===', '!=', '!==', '<=', '>=', '//', '**']; let curComplex = cur + this.current(); let type; if (lib.indexOf(complexOps, curComplex) !== -1) { this.forward(); cur = curComplex; // See if this is a strict equality/inequality comparator if (lib.indexOf(complexOps, curComplex + this.current()) !== -1) { cur = curComplex + this.current(); this.forward(); } } switch (cur) { case '(': type = TOKEN_LEFT_PAREN; break; case ')': type = TOKEN_RIGHT_PAREN; break; case '[': type = TOKEN_LEFT_BRACKET; break; case ']': type = TOKEN_RIGHT_BRACKET; break; case '{': type = TOKEN_LEFT_CURLY; break; case '}': type = TOKEN_RIGHT_CURLY; break; case ',': type = TOKEN_COMMA; break; case ':': type = TOKEN_COLON; break; case '~': type = TOKEN_TILDE; break; case '|': type = TOKEN_PIPE; break; default: type = TOKEN_OPERATOR; } return token(type, cur, lineno, colno); } else { // We are not at whitespace or a delimiter, so extract the // text and parse it tok = this._extractUntil(whitespaceChars + delimChars); if (tok.match(/^[-+]?[0-9]+$/)) { if (this.current() === '.') { this.forward(); let dec = this._extract(intChars); return token(TOKEN_FLOAT, tok + '.' + dec, lineno, colno); } else { return token(TOKEN_INT, tok, lineno, colno); } } else if (tok.match(/^(true|false)$/)) { return token(TOKEN_BOOLEAN, tok, lineno, colno); } else if (tok === 'none') { return token(TOKEN_NONE, tok, lineno, colno); /* * Added to make the test `null is null` evaluate truthily. * Otherwise, Nunjucks will look up null in the context and * return `undefined`, which is not what we want. This *may* have * consequences is someone is using null in their templates as a * variable. */ } else if (tok === 'null') { return token(TOKEN_NONE, tok, lineno, colno); } else if (tok) { return token(TOKEN_SYMBOL, tok, lineno, colno); } else { throw new Error('Unexpected value while parsing: ' + tok); } } } else { // Parse out the template text, breaking on tag // delimiters because we need to look for block/variable start // tags (don't use the full delimChars for optimization) let beginChars = (this.tags.BLOCK_START.charAt(0) + this.tags.VARIABLE_START.charAt(0) + this.tags.COMMENT_START.charAt(0) + this.tags.COMMENT_END.charAt(0)); if (this.isFinished()) { return null; } else if ((tok = this._extractString(this.tags.BLOCK_START + '-')) || (tok = this._extractString(this.tags.BLOCK_START))) { this.in_code = true; return token(TOKEN_BLOCK_START, tok, lineno, colno); } else if ((tok = this._extractString(this.tags.VARIABLE_START + '-')) || (tok = this._extractString(this.tags.VARIABLE_START))) { this.in_code = true; return token(TOKEN_VARIABLE_START, tok, lineno, colno); } else { tok = ''; let data; let inComment = false; if (this._matches(this.tags.COMMENT_START)) { inComment = true; tok = this._extractString(this.tags.COMMENT_START); } // Continually consume text, breaking on the tag delimiter // characters and checking to see if it's a start tag. // // We could hit the end of the template in the middle of // our looping, so check for the null return value from // _extractUntil while ((data = this._extractUntil(beginChars)) !== null) { tok += data; if ((this._matches(this.tags.BLOCK_START) || this._matches(this.tags.VARIABLE_START) || this._matches(this.tags.COMMENT_START)) && !inComment) { if (this.lstripBlocks && this._matches(this.tags.BLOCK_START) && this.colno > 0 && this.colno <= tok.length) { let lastLine = tok.slice(-this.colno); if (/^\s+$/.test(lastLine)) { // Remove block leading whitespace from beginning of the string tok = tok.slice(0, -this.colno); if (!tok.length) { // All data removed, collapse to avoid unnecessary nodes // by returning next token (block start) return this.nextToken(); } } } // If it is a start tag, stop looping break; } else if (this._matches(this.tags.COMMENT_END)) { if (!inComment) { throw new Error('unexpected end of comment'); } tok += this._extractString(this.tags.COMMENT_END); break; } else { // It does not match any tag, so add the character and // carry on tok += this.current(); this.forward(); } } if (data === null && inComment) { throw new Error('expected end of comment, got end of file'); } return token(inComment ? TOKEN_COMMENT : TOKEN_DATA, tok, lineno, colno); } } } _parseString(delimiter) { this.forward(); let str = ''; while (!this.isFinished() && this.current() !== delimiter) { let cur = this.current(); if (cur === '\\') { this.forward(); switch (this.current()) { case 'n': str += '\n'; break; case 't': str += '\t'; break; case 'r': str += '\r'; break; default: str += this.current(); } this.forward(); } else { str += cur; this.forward(); } } this.forward(); return str; } _matches(str) { if (this.index + str.length > this.len) { return null; } let m = this.str.slice(this.index, this.index + str.length); return m === str; } _extractString(str) { if (this._matches(str)) { this.forwardN(str.length); return str; } return null; } _extractUntil(charString) { // Extract all non-matching chars, with the default matching set // to everything return this._extractMatching(true, charString || ''); } _extract(charString) { // Extract all matching chars (no default, so charString must be // explicit) return this._extractMatching(false, charString); } _extractMatching(breakOnMatch, charString) { // Pull out characters until a breaking char is hit. // If breakOnMatch is false, a non-matching char stops it. // If breakOnMatch is true, a matching char stops it. if (this.isFinished()) { return null; } let first = charString.indexOf(this.current()); // Only proceed if the first character doesn't meet our condition if ((breakOnMatch && first === -1) || (!breakOnMatch && first !== -1)) { let t = this.current(); this.forward(); // And pull out all the chars one at a time until we hit a // breaking char let idx = charString.indexOf(this.current()); while (((breakOnMatch && idx === -1) || (!breakOnMatch && idx !== -1)) && !this.isFinished()) { t += this.current(); this.forward(); idx = charString.indexOf(this.current()); } return t; } return ''; } _extractRegex(regex) { let matches = this.currentStr().match(regex); if (!matches) { return null; } // Move forward whatever was matched this.forwardN(matches[0].length); return matches; } isFinished() { return this.index >= this.len; } forwardN(n) { for (let i = 0; i < n; i++) { this.forward(); } } forward() { this.index++; if (this.previous() === '\n') { this.lineno++; this.colno = 0; } else { this.colno++; } } backN(n) { for (let i = 0; i < n; i++) { this.back(); } } back() { this.index--; if (this.current() === '\n') { this.lineno--; let idx = this.src.lastIndexOf('\n', this.index - 1); if (idx === -1) { this.colno = this.index; } else { this.colno = this.index - idx; } } else { this.colno--; } } // current returns current character current() { if (!this.isFinished()) { return this.str.charAt(this.index); } return ''; } // currentStr returns what's left of the unparsed string currentStr() { if (!this.isFinished()) { return this.str.substr(this.index); } return ''; } previous() { return this.str.charAt(this.index - 1); } } module.exports = { lex(src, opts) { return new Tokenizer(src, opts); }, TOKEN_STRING: TOKEN_STRING, TOKEN_WHITESPACE: TOKEN_WHITESPACE, TOKEN_DATA: TOKEN_DATA, TOKEN_BLOCK_START: TOKEN_BLOCK_START, TOKEN_BLOCK_END: TOKEN_BLOCK_END, TOKEN_VARIABLE_START: TOKEN_VARIABLE_START, TOKEN_VARIABLE_END: TOKEN_VARIABLE_END, TOKEN_COMMENT: TOKEN_COMMENT, TOKEN_LEFT_PAREN: TOKEN_LEFT_PAREN, TOKEN_RIGHT_PAREN: TOKEN_RIGHT_PAREN, TOKEN_LEFT_BRACKET: TOKEN_LEFT_BRACKET, TOKEN_RIGHT_BRACKET: TOKEN_RIGHT_BRACKET, TOKEN_LEFT_CURLY: TOKEN_LEFT_CURLY, TOKEN_RIGHT_CURLY: TOKEN_RIGHT_CURLY, TOKEN_OPERATOR: TOKEN_OPERATOR, TOKEN_COMMA: TOKEN_COMMA, TOKEN_COLON: TOKEN_COLON, TOKEN_TILDE: TOKEN_TILDE, TOKEN_PIPE: TOKEN_PIPE, TOKEN_INT: TOKEN_INT, TOKEN_FLOAT: TOKEN_FLOAT, TOKEN_BOOLEAN: TOKEN_BOOLEAN, TOKEN_NONE: TOKEN_NONE, TOKEN_SYMBOL: TOKEN_SYMBOL, TOKEN_SPECIAL: TOKEN_SPECIAL, TOKEN_REGEX: TOKEN_REGEX }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/lib.js 000664 000000 000000 00000017056 14012546311 023617 0 ustar 00root root 000000 000000 'use strict'; var ArrayProto = Array.prototype; var ObjProto = Object.prototype; var escapeMap = { '&': '&', '"': '"', '\'': ''', '<': '<', '>': '>' }; var escapeRegex = /[&"'<>]/g; var exports = module.exports = {}; function hasOwnProp(obj, k) { return ObjProto.hasOwnProperty.call(obj, k); } exports.hasOwnProp = hasOwnProp; function lookupEscape(ch) { return escapeMap[ch]; } function _prettifyError(path, withInternals, err) { if (!err.Update) { // not one of ours, cast it err = new exports.TemplateError(err); } err.Update(path); // Unless they marked the dev flag, show them a trace from here if (!withInternals) { const old = err; err = new Error(old.message); err.name = old.name; } return err; } exports._prettifyError = _prettifyError; function TemplateError(message, lineno, colno) { var err; var cause; if (message instanceof Error) { cause = message; message = `${cause.name}: ${cause.message}`; } if (Object.setPrototypeOf) { err = new Error(message); Object.setPrototypeOf(err, TemplateError.prototype); } else { err = this; Object.defineProperty(err, 'message', { enumerable: false, writable: true, value: message, }); } Object.defineProperty(err, 'name', { value: 'Template render error', }); if (Error.captureStackTrace) { Error.captureStackTrace(err, this.constructor); } let getStack; if (cause) { const stackDescriptor = Object.getOwnPropertyDescriptor(cause, 'stack'); getStack = stackDescriptor && (stackDescriptor.get || (() => stackDescriptor.value)); if (!getStack) { getStack = () => cause.stack; } } else { const stack = (new Error(message)).stack; getStack = (() => stack); } Object.defineProperty(err, 'stack', { get: () => getStack.call(err), }); Object.defineProperty(err, 'cause', { value: cause }); err.lineno = lineno; err.colno = colno; err.firstUpdate = true; err.Update = function Update(path) { let msg = '(' + (path || 'unknown path') + ')'; // only show lineno + colno next to path of template // where error occurred if (this.firstUpdate) { if (this.lineno && this.colno) { msg += ` [Line ${this.lineno}, Column ${this.colno}]`; } else if (this.lineno) { msg += ` [Line ${this.lineno}]`; } } msg += '\n '; if (this.firstUpdate) { msg += ' '; } this.message = msg + (this.message || ''); this.firstUpdate = false; return this; }; return err; } if (Object.setPrototypeOf) { Object.setPrototypeOf(TemplateError.prototype, Error.prototype); } else { TemplateError.prototype = Object.create(Error.prototype, { constructor: { value: TemplateError, }, }); } exports.TemplateError = TemplateError; function escape(val) { return val.replace(escapeRegex, lookupEscape); } exports.escape = escape; function isFunction(obj) { return ObjProto.toString.call(obj) === '[object Function]'; } exports.isFunction = isFunction; function isArray(obj) { return ObjProto.toString.call(obj) === '[object Array]'; } exports.isArray = isArray; function isString(obj) { return ObjProto.toString.call(obj) === '[object String]'; } exports.isString = isString; function isObject(obj) { return ObjProto.toString.call(obj) === '[object Object]'; } exports.isObject = isObject; /** * @param {string|number} attr * @returns {(string|number)[]} * @private */ function _prepareAttributeParts(attr) { if (!attr) { return []; } if (typeof attr === 'string') { return attr.split('.'); } return [attr]; } /** * @param {string} attribute Attribute value. Dots allowed. * @returns {function(Object): *} */ function getAttrGetter(attribute) { const parts = _prepareAttributeParts(attribute); return function attrGetter(item) { let _item = item; for (let i = 0; i < parts.length; i++) { const part = parts[i]; // If item is not an object, and we still got parts to handle, it means // that something goes wrong. Just roll out to undefined in that case. if (hasOwnProp(_item, part)) { _item = _item[part]; } else { return undefined; } } return _item; }; } exports.getAttrGetter = getAttrGetter; function groupBy(obj, val, throwOnUndefined) { const result = {}; const iterator = isFunction(val) ? val : getAttrGetter(val); for (let i = 0; i < obj.length; i++) { const value = obj[i]; const key = iterator(value, i); if (key === undefined && throwOnUndefined === true) { throw new TypeError(`groupby: attribute "${val}" resolved to undefined`); } (result[key] || (result[key] = [])).push(value); } return result; } exports.groupBy = groupBy; function toArray(obj) { return Array.prototype.slice.call(obj); } exports.toArray = toArray; function without(array) { const result = []; if (!array) { return result; } const length = array.length; const contains = toArray(arguments).slice(1); let index = -1; while (++index < length) { if (indexOf(contains, array[index]) === -1) { result.push(array[index]); } } return result; } exports.without = without; function repeat(char_, n) { var str = ''; for (let i = 0; i < n; i++) { str += char_; } return str; } exports.repeat = repeat; function each(obj, func, context) { if (obj == null) { return; } if (ArrayProto.forEach && obj.forEach === ArrayProto.forEach) { obj.forEach(func, context); } else if (obj.length === +obj.length) { for (let i = 0, l = obj.length; i < l; i++) { func.call(context, obj[i], i, obj); } } } exports.each = each; function map(obj, func) { var results = []; if (obj == null) { return results; } if (ArrayProto.map && obj.map === ArrayProto.map) { return obj.map(func); } for (let i = 0; i < obj.length; i++) { results[results.length] = func(obj[i], i); } if (obj.length === +obj.length) { results.length = obj.length; } return results; } exports.map = map; function asyncIter(arr, iter, cb) { let i = -1; function next() { i++; if (i < arr.length) { iter(arr[i], i, next, cb); } else { cb(); } } next(); } exports.asyncIter = asyncIter; function asyncFor(obj, iter, cb) { const keys = keys_(obj || {}); const len = keys.length; let i = -1; function next() { i++; const k = keys[i]; if (i < len) { iter(k, obj[k], i, len, next); } else { cb(); } } next(); } exports.asyncFor = asyncFor; function indexOf(arr, searchElement, fromIndex) { return Array.prototype.indexOf.call(arr || [], searchElement, fromIndex); } exports.indexOf = indexOf; function keys_(obj) { /* eslint-disable no-restricted-syntax */ const arr = []; for (let k in obj) { if (hasOwnProp(obj, k)) { arr.push(k); } } return arr; } exports.keys = keys_; function _entries(obj) { return keys_(obj).map((k) => [k, obj[k]]); } exports._entries = _entries; function _values(obj) { return keys_(obj).map((k) => obj[k]); } exports._values = _values; function extend(obj1, obj2) { obj1 = obj1 || {}; keys_(obj2).forEach(k => { obj1[k] = obj2[k]; }); return obj1; } exports._assign = exports.extend = extend; function inOperator(key, val) { if (isArray(val) || isString(val)) { return val.indexOf(key) !== -1; } else if (isObject(val)) { return key in val; } throw new Error('Cannot use "in" operator to search for "' + key + '" in unexpected types.'); } exports.inOperator = inOperator; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/loader.js 000664 000000 000000 00000000503 14012546311 024304 0 ustar 00root root 000000 000000 'use strict'; const path = require('path'); const {EmitterObj} = require('./object'); module.exports = class Loader extends EmitterObj { resolve(from, to) { return path.resolve(path.dirname(from), to); } isRelative(filename) { return (filename.indexOf('./') === 0 || filename.indexOf('../') === 0); } }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/loaders.js 000664 000000 000000 00000000211 14012546311 024463 0 ustar 00root root 000000 000000 // This file will automatically be rewired to web-loader.js when // building for the browser module.exports = require('./node-loaders'); nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/node-loaders.js 000664 000000 000000 00000007351 14012546311 025422 0 ustar 00root root 000000 000000 /* eslint-disable no-console */ 'use strict'; const fs = require('fs'); const path = require('path'); const Loader = require('./loader'); const {PrecompiledLoader} = require('./precompiled-loader.js'); let chokidar; class FileSystemLoader extends Loader { constructor(searchPaths, opts) { super(); if (typeof opts === 'boolean') { console.log( '[nunjucks] Warning: you passed a boolean as the second ' + 'argument to FileSystemLoader, but it now takes an options ' + 'object. See http://mozilla.github.io/nunjucks/api.html#filesystemloader' ); } opts = opts || {}; this.pathsToNames = {}; this.noCache = !!opts.noCache; if (searchPaths) { searchPaths = Array.isArray(searchPaths) ? searchPaths : [searchPaths]; // For windows, convert to forward slashes this.searchPaths = searchPaths.map(path.normalize); } else { this.searchPaths = ['.']; } if (opts.watch) { // Watch all the templates in the paths and fire an event when // they change try { chokidar = require('chokidar'); // eslint-disable-line global-require } catch (e) { throw new Error('watch requires chokidar to be installed'); } const paths = this.searchPaths.filter(fs.existsSync); const watcher = chokidar.watch(paths); watcher.on('all', (event, fullname) => { fullname = path.resolve(fullname); if (event === 'change' && fullname in this.pathsToNames) { this.emit('update', this.pathsToNames[fullname], fullname); } }); watcher.on('error', (error) => { console.log('Watcher error: ' + error); }); } } getSource(name) { var fullpath = null; var paths = this.searchPaths; for (let i = 0; i < paths.length; i++) { const basePath = path.resolve(paths[i]); const p = path.resolve(paths[i], name); // Only allow the current directory and anything // underneath it to be searched if (p.indexOf(basePath) === 0 && fs.existsSync(p)) { fullpath = p; break; } } if (!fullpath) { return null; } this.pathsToNames[fullpath] = name; const source = { src: fs.readFileSync(fullpath, 'utf-8'), path: fullpath, noCache: this.noCache }; this.emit('load', name, source); return source; } } class NodeResolveLoader extends Loader { constructor(opts) { super(); opts = opts || {}; this.pathsToNames = {}; this.noCache = !!opts.noCache; if (opts.watch) { try { chokidar = require('chokidar'); // eslint-disable-line global-require } catch (e) { throw new Error('watch requires chokidar to be installed'); } this.watcher = chokidar.watch(); this.watcher.on('change', (fullname) => { this.emit('update', this.pathsToNames[fullname], fullname); }); this.watcher.on('error', (error) => { console.log('Watcher error: ' + error); }); this.on('load', (name, source) => { this.watcher.add(source.path); }); } } getSource(name) { // Don't allow file-system traversal if ((/^\.?\.?(\/|\\)/).test(name)) { return null; } if ((/^[A-Z]:/).test(name)) { return null; } let fullpath; try { fullpath = require.resolve(name); } catch (e) { return null; } this.pathsToNames[fullpath] = name; const source = { src: fs.readFileSync(fullpath, 'utf-8'), path: fullpath, noCache: this.noCache, }; this.emit('load', name, source); return source; } } module.exports = { FileSystemLoader: FileSystemLoader, PrecompiledLoader: PrecompiledLoader, NodeResolveLoader: NodeResolveLoader, }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/nodes.js 000664 000000 000000 00000016305 14012546311 024155 0 ustar 00root root 000000 000000 'use strict'; const {Obj} = require('./object'); function traverseAndCheck(obj, type, results) { if (obj instanceof type) { results.push(obj); } if (obj instanceof Node) { obj.findAll(type, results); } } class Node extends Obj { init(lineno, colno, ...args) { this.lineno = lineno; this.colno = colno; this.fields.forEach((field, i) => { // The first two args are line/col numbers, so offset by 2 var val = arguments[i + 2]; // Fields should never be undefined, but null. It makes // testing easier to normalize values. if (val === undefined) { val = null; } this[field] = val; }); } findAll(type, results) { results = results || []; if (this instanceof NodeList) { this.children.forEach(child => traverseAndCheck(child, type, results)); } else { this.fields.forEach(field => traverseAndCheck(this[field], type, results)); } return results; } iterFields(func) { this.fields.forEach((field) => { func(this[field], field); }); } } // Abstract nodes class Value extends Node { get typename() { return 'Value'; } get fields() { return ['value']; } } // Concrete nodes class NodeList extends Node { get typename() { return 'NodeList'; } get fields() { return ['children']; } init(lineno, colno, nodes) { super.init(lineno, colno, nodes || []); } addChild(node) { this.children.push(node); } } const Root = NodeList.extend('Root'); const Literal = Value.extend('Literal'); const Symbol = Value.extend('Symbol'); const Group = NodeList.extend('Group'); const ArrayNode = NodeList.extend('Array'); const Pair = Node.extend('Pair', { fields: ['key', 'value'] }); const Dict = NodeList.extend('Dict'); const LookupVal = Node.extend('LookupVal', { fields: ['target', 'val'] }); const If = Node.extend('If', { fields: ['cond', 'body', 'else_'] }); const IfAsync = If.extend('IfAsync'); const InlineIf = Node.extend('InlineIf', { fields: ['cond', 'body', 'else_'] }); const For = Node.extend('For', { fields: ['arr', 'name', 'body', 'else_'] }); const AsyncEach = For.extend('AsyncEach'); const AsyncAll = For.extend('AsyncAll'); const Macro = Node.extend('Macro', { fields: ['name', 'args', 'body'] }); const Caller = Macro.extend('Caller'); const Import = Node.extend('Import', { fields: ['template', 'target', 'withContext'] }); class FromImport extends Node { get typename() { return 'FromImport'; } get fields() { return ['template', 'names', 'withContext']; } init(lineno, colno, template, names, withContext) { super.init(lineno, colno, template, names || new NodeList(), withContext); } } const FunCall = Node.extend('FunCall', { fields: ['name', 'args'] }); const Filter = FunCall.extend('Filter'); const FilterAsync = Filter.extend('FilterAsync', { fields: ['name', 'args', 'symbol'] }); const KeywordArgs = Dict.extend('KeywordArgs'); const Block = Node.extend('Block', { fields: ['name', 'body'] }); const Super = Node.extend('Super', { fields: ['blockName', 'symbol'] }); const TemplateRef = Node.extend('TemplateRef', { fields: ['template'] }); const Extends = TemplateRef.extend('Extends'); const Include = Node.extend('Include', { fields: ['template', 'ignoreMissing'] }); const Set = Node.extend('Set', { fields: ['targets', 'value'] }); const Switch = Node.extend('Switch', { fields: ['expr', 'cases', 'default'] }); const Case = Node.extend('Case', { fields: ['cond', 'body'] }); const Output = NodeList.extend('Output'); const Capture = Node.extend('Capture', { fields: ['body'] }); const TemplateData = Literal.extend('TemplateData'); const UnaryOp = Node.extend('UnaryOp', { fields: ['target'] }); const BinOp = Node.extend('BinOp', { fields: ['left', 'right'] }); const In = BinOp.extend('In'); const Is = BinOp.extend('Is'); const Or = BinOp.extend('Or'); const And = BinOp.extend('And'); const Not = UnaryOp.extend('Not'); const Add = BinOp.extend('Add'); const Concat = BinOp.extend('Concat'); const Sub = BinOp.extend('Sub'); const Mul = BinOp.extend('Mul'); const Div = BinOp.extend('Div'); const FloorDiv = BinOp.extend('FloorDiv'); const Mod = BinOp.extend('Mod'); const Pow = BinOp.extend('Pow'); const Neg = UnaryOp.extend('Neg'); const Pos = UnaryOp.extend('Pos'); const Compare = Node.extend('Compare', { fields: ['expr', 'ops'] }); const CompareOperand = Node.extend('CompareOperand', { fields: ['expr', 'type'] }); const CallExtension = Node.extend('CallExtension', { init(ext, prop, args, contentArgs) { this.parent(); this.extName = ext.__name || ext; this.prop = prop; this.args = args || new NodeList(); this.contentArgs = contentArgs || []; this.autoescape = ext.autoescape; }, fields: ['extName', 'prop', 'args', 'contentArgs'] }); const CallExtensionAsync = CallExtension.extend('CallExtensionAsync'); // This is hacky, but this is just a debugging function anyway function print(str, indent, inline) { var lines = str.split('\n'); lines.forEach((line, i) => { if (line && ((inline && i > 0) || !inline)) { process.stdout.write((' ').repeat(indent)); } const nl = (i === lines.length - 1) ? '' : '\n'; process.stdout.write(`${line}${nl}`); }); } // Print the AST in a nicely formatted tree format for debuggin function printNodes(node, indent) { indent = indent || 0; print(node.typename + ': ', indent); if (node instanceof NodeList) { print('\n'); node.children.forEach((n) => { printNodes(n, indent + 2); }); } else if (node instanceof CallExtension) { print(`${node.extName}.${node.prop}\n`); if (node.args) { printNodes(node.args, indent + 2); } if (node.contentArgs) { node.contentArgs.forEach((n) => { printNodes(n, indent + 2); }); } } else { let nodes = []; let props = null; node.iterFields((val, fieldName) => { if (val instanceof Node) { nodes.push([fieldName, val]); } else { props = props || {}; props[fieldName] = val; } }); if (props) { print(JSON.stringify(props, null, 2) + '\n', null, true); } else { print('\n'); } nodes.forEach(([fieldName, n]) => { print(`[${fieldName}] =>`, indent + 2); printNodes(n, indent + 4); }); } } module.exports = { Node: Node, Root: Root, NodeList: NodeList, Value: Value, Literal: Literal, Symbol: Symbol, Group: Group, Array: ArrayNode, Pair: Pair, Dict: Dict, Output: Output, Capture: Capture, TemplateData: TemplateData, If: If, IfAsync: IfAsync, InlineIf: InlineIf, For: For, AsyncEach: AsyncEach, AsyncAll: AsyncAll, Macro: Macro, Caller: Caller, Import: Import, FromImport: FromImport, FunCall: FunCall, Filter: Filter, FilterAsync: FilterAsync, KeywordArgs: KeywordArgs, Block: Block, Super: Super, Extends: Extends, Include: Include, Set: Set, Switch: Switch, Case: Case, LookupVal: LookupVal, BinOp: BinOp, In: In, Is: Is, Or: Or, And: And, Not: Not, Add: Add, Concat: Concat, Sub: Sub, Mul: Mul, Div: Div, FloorDiv: FloorDiv, Mod: Mod, Pow: Pow, Neg: Neg, Pos: Pos, Compare: Compare, CompareOperand: CompareOperand, CallExtension: CallExtension, CallExtensionAsync: CallExtensionAsync, printNodes: printNodes }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/object.js 000664 000000 000000 00000003166 14012546311 024314 0 ustar 00root root 000000 000000 'use strict'; // A simple class system, more documentation to come const EventEmitter = require('events'); const lib = require('./lib'); function parentWrap(parent, prop) { if (typeof parent !== 'function' || typeof prop !== 'function') { return prop; } return function wrap() { // Save the current parent method const tmp = this.parent; // Set parent to the previous method, call, and restore this.parent = parent; const res = prop.apply(this, arguments); this.parent = tmp; return res; }; } function extendClass(cls, name, props) { props = props || {}; lib.keys(props).forEach(k => { props[k] = parentWrap(cls.prototype[k], props[k]); }); class subclass extends cls { get typename() { return name; } } lib._assign(subclass.prototype, props); return subclass; } class Obj { constructor(...args) { // Unfortunately necessary for backwards compatibility this.init(...args); } init() {} get typename() { return this.constructor.name; } static extend(name, props) { if (typeof name === 'object') { props = name; name = 'anonymous'; } return extendClass(this, name, props); } } class EmitterObj extends EventEmitter { constructor(...args) { super(); // Unfortunately necessary for backwards compatibility this.init(...args); } init() {} get typename() { return this.constructor.name; } static extend(name, props) { if (typeof name === 'object') { props = name; name = 'anonymous'; } return extendClass(this, name, props); } } module.exports = { Obj, EmitterObj }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/parser.js 000664 000000 000000 00000104253 14012546311 024341 0 ustar 00root root 000000 000000 'use strict'; var lexer = require('./lexer'); var nodes = require('./nodes'); var Obj = require('./object').Obj; var lib = require('./lib'); class Parser extends Obj { init(tokens) { this.tokens = tokens; this.peeked = null; this.breakOnBlocks = null; this.dropLeadingWhitespace = false; this.extensions = []; } nextToken(withWhitespace) { var tok; if (this.peeked) { if (!withWhitespace && this.peeked.type === lexer.TOKEN_WHITESPACE) { this.peeked = null; } else { tok = this.peeked; this.peeked = null; return tok; } } tok = this.tokens.nextToken(); if (!withWhitespace) { while (tok && tok.type === lexer.TOKEN_WHITESPACE) { tok = this.tokens.nextToken(); } } return tok; } peekToken() { this.peeked = this.peeked || this.nextToken(); return this.peeked; } pushToken(tok) { if (this.peeked) { throw new Error('pushToken: can only push one token on between reads'); } this.peeked = tok; } error(msg, lineno, colno) { if (lineno === undefined || colno === undefined) { const tok = this.peekToken() || {}; lineno = tok.lineno; colno = tok.colno; } if (lineno !== undefined) { lineno += 1; } if (colno !== undefined) { colno += 1; } return new lib.TemplateError(msg, lineno, colno); } fail(msg, lineno, colno) { throw this.error(msg, lineno, colno); } skip(type) { var tok = this.nextToken(); if (!tok || tok.type !== type) { this.pushToken(tok); return false; } return true; } expect(type) { var tok = this.nextToken(); if (tok.type !== type) { this.fail('expected ' + type + ', got ' + tok.type, tok.lineno, tok.colno); } return tok; } skipValue(type, val) { var tok = this.nextToken(); if (!tok || tok.type !== type || tok.value !== val) { this.pushToken(tok); return false; } return true; } skipSymbol(val) { return this.skipValue(lexer.TOKEN_SYMBOL, val); } advanceAfterBlockEnd(name) { var tok; if (!name) { tok = this.peekToken(); if (!tok) { this.fail('unexpected end of file'); } if (tok.type !== lexer.TOKEN_SYMBOL) { this.fail('advanceAfterBlockEnd: expected symbol token or ' + 'explicit name to be passed'); } name = this.nextToken().value; } tok = this.nextToken(); if (tok && tok.type === lexer.TOKEN_BLOCK_END) { if (tok.value.charAt(0) === '-') { this.dropLeadingWhitespace = true; } } else { this.fail('expected block end in ' + name + ' statement'); } return tok; } advanceAfterVariableEnd() { var tok = this.nextToken(); if (tok && tok.type === lexer.TOKEN_VARIABLE_END) { this.dropLeadingWhitespace = tok.value.charAt( tok.value.length - this.tokens.tags.VARIABLE_END.length - 1 ) === '-'; } else { this.pushToken(tok); this.fail('expected variable end'); } } parseFor() { var forTok = this.peekToken(); var node; var endBlock; if (this.skipSymbol('for')) { node = new nodes.For(forTok.lineno, forTok.colno); endBlock = 'endfor'; } else if (this.skipSymbol('asyncEach')) { node = new nodes.AsyncEach(forTok.lineno, forTok.colno); endBlock = 'endeach'; } else if (this.skipSymbol('asyncAll')) { node = new nodes.AsyncAll(forTok.lineno, forTok.colno); endBlock = 'endall'; } else { this.fail('parseFor: expected for{Async}', forTok.lineno, forTok.colno); } node.name = this.parsePrimary(); if (!(node.name instanceof nodes.Symbol)) { this.fail('parseFor: variable name expected for loop'); } const type = this.peekToken().type; if (type === lexer.TOKEN_COMMA) { // key/value iteration const key = node.name; node.name = new nodes.Array(key.lineno, key.colno); node.name.addChild(key); while (this.skip(lexer.TOKEN_COMMA)) { const prim = this.parsePrimary(); node.name.addChild(prim); } } if (!this.skipSymbol('in')) { this.fail('parseFor: expected "in" keyword for loop', forTok.lineno, forTok.colno); } node.arr = this.parseExpression(); this.advanceAfterBlockEnd(forTok.value); node.body = this.parseUntilBlocks(endBlock, 'else'); if (this.skipSymbol('else')) { this.advanceAfterBlockEnd('else'); node.else_ = this.parseUntilBlocks(endBlock); } this.advanceAfterBlockEnd(); return node; } parseMacro() { const macroTok = this.peekToken(); if (!this.skipSymbol('macro')) { this.fail('expected macro'); } const name = this.parsePrimary(true); const args = this.parseSignature(); const node = new nodes.Macro(macroTok.lineno, macroTok.colno, name, args); this.advanceAfterBlockEnd(macroTok.value); node.body = this.parseUntilBlocks('endmacro'); this.advanceAfterBlockEnd(); return node; } parseCall() { // a call block is parsed as a normal FunCall, but with an added // 'caller' kwarg which is a Caller node. var callTok = this.peekToken(); if (!this.skipSymbol('call')) { this.fail('expected call'); } const callerArgs = this.parseSignature(true) || new nodes.NodeList(); const macroCall = this.parsePrimary(); this.advanceAfterBlockEnd(callTok.value); const body = this.parseUntilBlocks('endcall'); this.advanceAfterBlockEnd(); const callerName = new nodes.Symbol(callTok.lineno, callTok.colno, 'caller'); const callerNode = new nodes.Caller(callTok.lineno, callTok.colno, callerName, callerArgs, body); // add the additional caller kwarg, adding kwargs if necessary const args = macroCall.args.children; if (!(args[args.length - 1] instanceof nodes.KeywordArgs)) { args.push(new nodes.KeywordArgs()); } const kwargs = args[args.length - 1]; kwargs.addChild(new nodes.Pair(callTok.lineno, callTok.colno, callerName, callerNode)); return new nodes.Output(callTok.lineno, callTok.colno, [macroCall]); } parseWithContext() { var tok = this.peekToken(); var withContext = null; if (this.skipSymbol('with')) { withContext = true; } else if (this.skipSymbol('without')) { withContext = false; } if (withContext !== null) { if (!this.skipSymbol('context')) { this.fail('parseFrom: expected context after with/without', tok.lineno, tok.colno); } } return withContext; } parseImport() { var importTok = this.peekToken(); if (!this.skipSymbol('import')) { this.fail('parseImport: expected import', importTok.lineno, importTok.colno); } const template = this.parseExpression(); if (!this.skipSymbol('as')) { this.fail('parseImport: expected "as" keyword', importTok.lineno, importTok.colno); } const target = this.parseExpression(); const withContext = this.parseWithContext(); const node = new nodes.Import(importTok.lineno, importTok.colno, template, target, withContext); this.advanceAfterBlockEnd(importTok.value); return node; } parseFrom() { const fromTok = this.peekToken(); if (!this.skipSymbol('from')) { this.fail('parseFrom: expected from'); } const template = this.parseExpression(); if (!this.skipSymbol('import')) { this.fail('parseFrom: expected import', fromTok.lineno, fromTok.colno); } const names = new nodes.NodeList(); let withContext; while (1) { // eslint-disable-line no-constant-condition const nextTok = this.peekToken(); if (nextTok.type === lexer.TOKEN_BLOCK_END) { if (!names.children.length) { this.fail('parseFrom: Expected at least one import name', fromTok.lineno, fromTok.colno); } // Since we are manually advancing past the block end, // need to keep track of whitespace control (normally // this is done in `advanceAfterBlockEnd` if (nextTok.value.charAt(0) === '-') { this.dropLeadingWhitespace = true; } this.nextToken(); break; } if (names.children.length > 0 && !this.skip(lexer.TOKEN_COMMA)) { this.fail('parseFrom: expected comma', fromTok.lineno, fromTok.colno); } const name = this.parsePrimary(); if (name.value.charAt(0) === '_') { this.fail('parseFrom: names starting with an underscore cannot be imported', name.lineno, name.colno); } if (this.skipSymbol('as')) { const alias = this.parsePrimary(); names.addChild(new nodes.Pair(name.lineno, name.colno, name, alias)); } else { names.addChild(name); } withContext = this.parseWithContext(); } return new nodes.FromImport(fromTok.lineno, fromTok.colno, template, names, withContext); } parseBlock() { const tag = this.peekToken(); if (!this.skipSymbol('block')) { this.fail('parseBlock: expected block', tag.lineno, tag.colno); } const node = new nodes.Block(tag.lineno, tag.colno); node.name = this.parsePrimary(); if (!(node.name instanceof nodes.Symbol)) { this.fail('parseBlock: variable name expected', tag.lineno, tag.colno); } this.advanceAfterBlockEnd(tag.value); node.body = this.parseUntilBlocks('endblock'); this.skipSymbol('endblock'); this.skipSymbol(node.name.value); const tok = this.peekToken(); if (!tok) { this.fail('parseBlock: expected endblock, got end of file'); } this.advanceAfterBlockEnd(tok.value); return node; } parseExtends() { const tagName = 'extends'; const tag = this.peekToken(); if (!this.skipSymbol(tagName)) { this.fail('parseTemplateRef: expected ' + tagName); } const node = new nodes.Extends(tag.lineno, tag.colno); node.template = this.parseExpression(); this.advanceAfterBlockEnd(tag.value); return node; } parseInclude() { const tagName = 'include'; const tag = this.peekToken(); if (!this.skipSymbol(tagName)) { this.fail('parseInclude: expected ' + tagName); } const node = new nodes.Include(tag.lineno, tag.colno); node.template = this.parseExpression(); if (this.skipSymbol('ignore') && this.skipSymbol('missing')) { node.ignoreMissing = true; } this.advanceAfterBlockEnd(tag.value); return node; } parseIf() { const tag = this.peekToken(); let node; if (this.skipSymbol('if') || this.skipSymbol('elif') || this.skipSymbol('elseif')) { node = new nodes.If(tag.lineno, tag.colno); } else if (this.skipSymbol('ifAsync')) { node = new nodes.IfAsync(tag.lineno, tag.colno); } else { this.fail('parseIf: expected if, elif, or elseif', tag.lineno, tag.colno); } node.cond = this.parseExpression(); this.advanceAfterBlockEnd(tag.value); node.body = this.parseUntilBlocks('elif', 'elseif', 'else', 'endif'); const tok = this.peekToken(); switch (tok && tok.value) { case 'elseif': case 'elif': node.else_ = this.parseIf(); break; case 'else': this.advanceAfterBlockEnd(); node.else_ = this.parseUntilBlocks('endif'); this.advanceAfterBlockEnd(); break; case 'endif': node.else_ = null; this.advanceAfterBlockEnd(); break; default: this.fail('parseIf: expected elif, else, or endif, got end of file'); } return node; } parseSet() { const tag = this.peekToken(); if (!this.skipSymbol('set')) { this.fail('parseSet: expected set', tag.lineno, tag.colno); } const node = new nodes.Set(tag.lineno, tag.colno, []); let target; while ((target = this.parsePrimary())) { node.targets.push(target); if (!this.skip(lexer.TOKEN_COMMA)) { break; } } if (!this.skipValue(lexer.TOKEN_OPERATOR, '=')) { if (!this.skip(lexer.TOKEN_BLOCK_END)) { this.fail('parseSet: expected = or block end in set tag', tag.lineno, tag.colno); } else { node.body = new nodes.Capture( tag.lineno, tag.colno, this.parseUntilBlocks('endset') ); node.value = null; this.advanceAfterBlockEnd(); } } else { node.value = this.parseExpression(); this.advanceAfterBlockEnd(tag.value); } return node; } parseSwitch() { /* * Store the tag names in variables in case someone ever wants to * customize this. */ const switchStart = 'switch'; const switchEnd = 'endswitch'; const caseStart = 'case'; const caseDefault = 'default'; // Get the switch tag. const tag = this.peekToken(); // fail early if we get some unexpected tag. if ( !this.skipSymbol(switchStart) && !this.skipSymbol(caseStart) && !this.skipSymbol(caseDefault) ) { this.fail('parseSwitch: expected "switch," "case" or "default"', tag.lineno, tag.colno); } // parse the switch expression const expr = this.parseExpression(); // advance until a start of a case, a default case or an endswitch. this.advanceAfterBlockEnd(switchStart); this.parseUntilBlocks(caseStart, caseDefault, switchEnd); // this is the first case. it could also be an endswitch, we'll check. let tok = this.peekToken(); // create new variables for our cases and default case. const cases = []; let defaultCase; // while we're dealing with new cases nodes... do { // skip the start symbol and get the case expression this.skipSymbol(caseStart); const cond = this.parseExpression(); this.advanceAfterBlockEnd(switchStart); // get the body of the case node and add it to the array of cases. const body = this.parseUntilBlocks(caseStart, caseDefault, switchEnd); cases.push(new nodes.Case(tok.line, tok.col, cond, body)); // get our next case tok = this.peekToken(); } while (tok && tok.value === caseStart); // we either have a default case or a switch end. switch (tok.value) { case caseDefault: this.advanceAfterBlockEnd(); defaultCase = this.parseUntilBlocks(switchEnd); this.advanceAfterBlockEnd(); break; case switchEnd: this.advanceAfterBlockEnd(); break; default: // otherwise bail because EOF this.fail('parseSwitch: expected "case," "default" or "endswitch," got EOF.'); } // and return the switch node. return new nodes.Switch(tag.lineno, tag.colno, expr, cases, defaultCase); } parseStatement() { var tok = this.peekToken(); var node; if (tok.type !== lexer.TOKEN_SYMBOL) { this.fail('tag name expected', tok.lineno, tok.colno); } if (this.breakOnBlocks && lib.indexOf(this.breakOnBlocks, tok.value) !== -1) { return null; } switch (tok.value) { case 'raw': return this.parseRaw(); case 'verbatim': return this.parseRaw('verbatim'); case 'if': case 'ifAsync': return this.parseIf(); case 'for': case 'asyncEach': case 'asyncAll': return this.parseFor(); case 'block': return this.parseBlock(); case 'extends': return this.parseExtends(); case 'include': return this.parseInclude(); case 'set': return this.parseSet(); case 'macro': return this.parseMacro(); case 'call': return this.parseCall(); case 'import': return this.parseImport(); case 'from': return this.parseFrom(); case 'filter': return this.parseFilterStatement(); case 'switch': return this.parseSwitch(); default: if (this.extensions.length) { for (let i = 0; i < this.extensions.length; i++) { const ext = this.extensions[i]; if (lib.indexOf(ext.tags || [], tok.value) !== -1) { return ext.parse(this, nodes, lexer); } } } this.fail('unknown block tag: ' + tok.value, tok.lineno, tok.colno); } return node; } parseRaw(tagName) { tagName = tagName || 'raw'; const endTagName = 'end' + tagName; // Look for upcoming raw blocks (ignore all other kinds of blocks) const rawBlockRegex = new RegExp('([\\s\\S]*?){%\\s*(' + tagName + '|' + endTagName + ')\\s*(?=%})%}'); let rawLevel = 1; let str = ''; let matches = null; // Skip opening raw token // Keep this token to track line and column numbers const begun = this.advanceAfterBlockEnd(); // Exit when there's nothing to match // or when we've found the matching "endraw" block while ((matches = this.tokens._extractRegex(rawBlockRegex)) && rawLevel > 0) { const all = matches[0]; const pre = matches[1]; const blockName = matches[2]; // Adjust rawlevel if (blockName === tagName) { rawLevel += 1; } else if (blockName === endTagName) { rawLevel -= 1; } // Add to str if (rawLevel === 0) { // We want to exclude the last "endraw" str += pre; // Move tokenizer to beginning of endraw block this.tokens.backN(all.length - pre.length); } else { str += all; } } return new nodes.Output( begun.lineno, begun.colno, [new nodes.TemplateData(begun.lineno, begun.colno, str)] ); } parsePostfix(node) { let lookup; let tok = this.peekToken(); while (tok) { if (tok.type === lexer.TOKEN_LEFT_PAREN) { // Function call node = new nodes.FunCall(tok.lineno, tok.colno, node, this.parseSignature()); } else if (tok.type === lexer.TOKEN_LEFT_BRACKET) { // Reference lookup = this.parseAggregate(); if (lookup.children.length > 1) { this.fail('invalid index'); } node = new nodes.LookupVal(tok.lineno, tok.colno, node, lookup.children[0]); } else if (tok.type === lexer.TOKEN_OPERATOR && tok.value === '.') { // Reference this.nextToken(); const val = this.nextToken(); if (val.type !== lexer.TOKEN_SYMBOL) { this.fail('expected name as lookup value, got ' + val.value, val.lineno, val.colno); } // Make a literal string because it's not a variable // reference lookup = new nodes.Literal(val.lineno, val.colno, val.value); node = new nodes.LookupVal(tok.lineno, tok.colno, node, lookup); } else { break; } tok = this.peekToken(); } return node; } parseExpression() { var node = this.parseInlineIf(); return node; } parseInlineIf() { let node = this.parseOr(); if (this.skipSymbol('if')) { const condNode = this.parseOr(); const bodyNode = node; node = new nodes.InlineIf(node.lineno, node.colno); node.body = bodyNode; node.cond = condNode; if (this.skipSymbol('else')) { node.else_ = this.parseOr(); } else { node.else_ = null; } } return node; } parseOr() { let node = this.parseAnd(); while (this.skipSymbol('or')) { const node2 = this.parseAnd(); node = new nodes.Or(node.lineno, node.colno, node, node2); } return node; } parseAnd() { let node = this.parseNot(); while (this.skipSymbol('and')) { const node2 = this.parseNot(); node = new nodes.And(node.lineno, node.colno, node, node2); } return node; } parseNot() { const tok = this.peekToken(); if (this.skipSymbol('not')) { return new nodes.Not(tok.lineno, tok.colno, this.parseNot()); } return this.parseIn(); } parseIn() { let node = this.parseIs(); while (1) { // eslint-disable-line no-constant-condition // check if the next token is 'not' const tok = this.nextToken(); if (!tok) { break; } const invert = tok.type === lexer.TOKEN_SYMBOL && tok.value === 'not'; // if it wasn't 'not', put it back if (!invert) { this.pushToken(tok); } if (this.skipSymbol('in')) { const node2 = this.parseIs(); node = new nodes.In(node.lineno, node.colno, node, node2); if (invert) { node = new nodes.Not(node.lineno, node.colno, node); } } else { // if we'd found a 'not' but this wasn't an 'in', put back the 'not' if (invert) { this.pushToken(tok); } break; } } return node; } // I put this right after "in" in the operator precedence stack. That can // obviously be changed to be closer to Jinja. parseIs() { let node = this.parseCompare(); // look for an is if (this.skipSymbol('is')) { // look for a not const not = this.skipSymbol('not'); // get the next node const node2 = this.parseCompare(); // create an Is node using the next node and the info from our Is node. node = new nodes.Is(node.lineno, node.colno, node, node2); // if we have a Not, create a Not node from our Is node. if (not) { node = new nodes.Not(node.lineno, node.colno, node); } } // return the node. return node; } parseCompare() { const compareOps = ['==', '===', '!=', '!==', '<', '>', '<=', '>=']; const expr = this.parseConcat(); const ops = []; while (1) { // eslint-disable-line no-constant-condition const tok = this.nextToken(); if (!tok) { break; } else if (compareOps.indexOf(tok.value) !== -1) { ops.push(new nodes.CompareOperand(tok.lineno, tok.colno, this.parseConcat(), tok.value)); } else { this.pushToken(tok); break; } } if (ops.length) { return new nodes.Compare(ops[0].lineno, ops[0].colno, expr, ops); } else { return expr; } } // finds the '~' for string concatenation parseConcat() { let node = this.parseAdd(); while (this.skipValue(lexer.TOKEN_TILDE, '~')) { const node2 = this.parseAdd(); node = new nodes.Concat(node.lineno, node.colno, node, node2); } return node; } parseAdd() { let node = this.parseSub(); while (this.skipValue(lexer.TOKEN_OPERATOR, '+')) { const node2 = this.parseSub(); node = new nodes.Add(node.lineno, node.colno, node, node2); } return node; } parseSub() { let node = this.parseMul(); while (this.skipValue(lexer.TOKEN_OPERATOR, '-')) { const node2 = this.parseMul(); node = new nodes.Sub(node.lineno, node.colno, node, node2); } return node; } parseMul() { let node = this.parseDiv(); while (this.skipValue(lexer.TOKEN_OPERATOR, '*')) { const node2 = this.parseDiv(); node = new nodes.Mul(node.lineno, node.colno, node, node2); } return node; } parseDiv() { let node = this.parseFloorDiv(); while (this.skipValue(lexer.TOKEN_OPERATOR, '/')) { const node2 = this.parseFloorDiv(); node = new nodes.Div(node.lineno, node.colno, node, node2); } return node; } parseFloorDiv() { let node = this.parseMod(); while (this.skipValue(lexer.TOKEN_OPERATOR, '//')) { const node2 = this.parseMod(); node = new nodes.FloorDiv(node.lineno, node.colno, node, node2); } return node; } parseMod() { let node = this.parsePow(); while (this.skipValue(lexer.TOKEN_OPERATOR, '%')) { const node2 = this.parsePow(); node = new nodes.Mod(node.lineno, node.colno, node, node2); } return node; } parsePow() { let node = this.parseUnary(); while (this.skipValue(lexer.TOKEN_OPERATOR, '**')) { const node2 = this.parseUnary(); node = new nodes.Pow(node.lineno, node.colno, node, node2); } return node; } parseUnary(noFilters) { const tok = this.peekToken(); let node; if (this.skipValue(lexer.TOKEN_OPERATOR, '-')) { node = new nodes.Neg(tok.lineno, tok.colno, this.parseUnary(true)); } else if (this.skipValue(lexer.TOKEN_OPERATOR, '+')) { node = new nodes.Pos(tok.lineno, tok.colno, this.parseUnary(true)); } else { node = this.parsePrimary(); } if (!noFilters) { node = this.parseFilter(node); } return node; } parsePrimary(noPostfix) { const tok = this.nextToken(); let val; let node = null; if (!tok) { this.fail('expected expression, got end of file'); } else if (tok.type === lexer.TOKEN_STRING) { val = tok.value; } else if (tok.type === lexer.TOKEN_INT) { val = parseInt(tok.value, 10); } else if (tok.type === lexer.TOKEN_FLOAT) { val = parseFloat(tok.value); } else if (tok.type === lexer.TOKEN_BOOLEAN) { if (tok.value === 'true') { val = true; } else if (tok.value === 'false') { val = false; } else { this.fail('invalid boolean: ' + tok.value, tok.lineno, tok.colno); } } else if (tok.type === lexer.TOKEN_NONE) { val = null; } else if (tok.type === lexer.TOKEN_REGEX) { val = new RegExp(tok.value.body, tok.value.flags); } if (val !== undefined) { node = new nodes.Literal(tok.lineno, tok.colno, val); } else if (tok.type === lexer.TOKEN_SYMBOL) { node = new nodes.Symbol(tok.lineno, tok.colno, tok.value); } else { // See if it's an aggregate type, we need to push the // current delimiter token back on this.pushToken(tok); node = this.parseAggregate(); } if (!noPostfix) { node = this.parsePostfix(node); } if (node) { return node; } else { throw this.error(`unexpected token: ${tok.value}`, tok.lineno, tok.colno); } } parseFilterName() { const tok = this.expect(lexer.TOKEN_SYMBOL); let name = tok.value; while (this.skipValue(lexer.TOKEN_OPERATOR, '.')) { name += '.' + this.expect(lexer.TOKEN_SYMBOL).value; } return new nodes.Symbol(tok.lineno, tok.colno, name); } parseFilterArgs(node) { if (this.peekToken().type === lexer.TOKEN_LEFT_PAREN) { // Get a FunCall node and add the parameters to the // filter const call = this.parsePostfix(node); return call.args.children; } return []; } parseFilter(node) { while (this.skip(lexer.TOKEN_PIPE)) { const name = this.parseFilterName(); node = new nodes.Filter( name.lineno, name.colno, name, new nodes.NodeList( name.lineno, name.colno, [node].concat(this.parseFilterArgs(node)) ) ); } return node; } parseFilterStatement() { var filterTok = this.peekToken(); if (!this.skipSymbol('filter')) { this.fail('parseFilterStatement: expected filter'); } const name = this.parseFilterName(); const args = this.parseFilterArgs(name); this.advanceAfterBlockEnd(filterTok.value); const body = new nodes.Capture( name.lineno, name.colno, this.parseUntilBlocks('endfilter') ); this.advanceAfterBlockEnd(); const node = new nodes.Filter( name.lineno, name.colno, name, new nodes.NodeList( name.lineno, name.colno, [body].concat(args) ) ); return new nodes.Output( name.lineno, name.colno, [node] ); } parseAggregate() { var tok = this.nextToken(); var node; switch (tok.type) { case lexer.TOKEN_LEFT_PAREN: node = new nodes.Group(tok.lineno, tok.colno); break; case lexer.TOKEN_LEFT_BRACKET: node = new nodes.Array(tok.lineno, tok.colno); break; case lexer.TOKEN_LEFT_CURLY: node = new nodes.Dict(tok.lineno, tok.colno); break; default: return null; } while (1) { // eslint-disable-line no-constant-condition const type = this.peekToken().type; if (type === lexer.TOKEN_RIGHT_PAREN || type === lexer.TOKEN_RIGHT_BRACKET || type === lexer.TOKEN_RIGHT_CURLY) { this.nextToken(); break; } if (node.children.length > 0) { if (!this.skip(lexer.TOKEN_COMMA)) { this.fail('parseAggregate: expected comma after expression', tok.lineno, tok.colno); } } if (node instanceof nodes.Dict) { // TODO: check for errors const key = this.parsePrimary(); // We expect a key/value pair for dicts, separated by a // colon if (!this.skip(lexer.TOKEN_COLON)) { this.fail('parseAggregate: expected colon after dict key', tok.lineno, tok.colno); } // TODO: check for errors const value = this.parseExpression(); node.addChild(new nodes.Pair(key.lineno, key.colno, key, value)); } else { // TODO: check for errors const expr = this.parseExpression(); node.addChild(expr); } } return node; } parseSignature(tolerant, noParens) { let tok = this.peekToken(); if (!noParens && tok.type !== lexer.TOKEN_LEFT_PAREN) { if (tolerant) { return null; } else { this.fail('expected arguments', tok.lineno, tok.colno); } } if (tok.type === lexer.TOKEN_LEFT_PAREN) { tok = this.nextToken(); } const args = new nodes.NodeList(tok.lineno, tok.colno); const kwargs = new nodes.KeywordArgs(tok.lineno, tok.colno); let checkComma = false; while (1) { // eslint-disable-line no-constant-condition tok = this.peekToken(); if (!noParens && tok.type === lexer.TOKEN_RIGHT_PAREN) { this.nextToken(); break; } else if (noParens && tok.type === lexer.TOKEN_BLOCK_END) { break; } if (checkComma && !this.skip(lexer.TOKEN_COMMA)) { this.fail('parseSignature: expected comma after expression', tok.lineno, tok.colno); } else { const arg = this.parseExpression(); if (this.skipValue(lexer.TOKEN_OPERATOR, '=')) { kwargs.addChild( new nodes.Pair(arg.lineno, arg.colno, arg, this.parseExpression()) ); } else { args.addChild(arg); } } checkComma = true; } if (kwargs.children.length) { args.addChild(kwargs); } return args; } parseUntilBlocks(...blockNames) { const prev = this.breakOnBlocks; this.breakOnBlocks = blockNames; const ret = this.parse(); this.breakOnBlocks = prev; return ret; } parseNodes() { let tok; const buf = []; while ((tok = this.nextToken())) { if (tok.type === lexer.TOKEN_DATA) { let data = tok.value; const nextToken = this.peekToken(); const nextVal = nextToken && nextToken.value; // If the last token has "-" we need to trim the // leading whitespace of the data. This is marked with // the `dropLeadingWhitespace` variable. if (this.dropLeadingWhitespace) { // TODO: this could be optimized (don't use regex) data = data.replace(/^\s*/, ''); this.dropLeadingWhitespace = false; } // Same for the succeeding block start token if (nextToken && ((nextToken.type === lexer.TOKEN_BLOCK_START && nextVal.charAt(nextVal.length - 1) === '-') || (nextToken.type === lexer.TOKEN_VARIABLE_START && nextVal.charAt(this.tokens.tags.VARIABLE_START.length) === '-') || (nextToken.type === lexer.TOKEN_COMMENT && nextVal.charAt(this.tokens.tags.COMMENT_START.length) === '-'))) { // TODO: this could be optimized (don't use regex) data = data.replace(/\s*$/, ''); } buf.push(new nodes.Output(tok.lineno, tok.colno, [new nodes.TemplateData(tok.lineno, tok.colno, data)])); } else if (tok.type === lexer.TOKEN_BLOCK_START) { this.dropLeadingWhitespace = false; const n = this.parseStatement(); if (!n) { break; } buf.push(n); } else if (tok.type === lexer.TOKEN_VARIABLE_START) { const e = this.parseExpression(); this.dropLeadingWhitespace = false; this.advanceAfterVariableEnd(); buf.push(new nodes.Output(tok.lineno, tok.colno, [e])); } else if (tok.type === lexer.TOKEN_COMMENT) { this.dropLeadingWhitespace = tok.value.charAt( tok.value.length - this.tokens.tags.COMMENT_END.length - 1 ) === '-'; } else { // Ignore comments, otherwise this should be an error this.fail('Unexpected token at top-level: ' + tok.type, tok.lineno, tok.colno); } } return buf; } parse() { return new nodes.NodeList(0, 0, this.parseNodes()); } parseAsRoot() { return new nodes.Root(0, 0, this.parseNodes()); } } // var util = require('util'); // var l = lexer.lex('{%- if x -%}\n hello {% endif %}'); // var t; // while((t = l.nextToken())) { // console.log(util.inspect(t)); // } // var p = new Parser(lexer.lex('hello {% filter title %}' + // 'Hello madam how are you' + // '{% endfilter %}')); // var n = p.parseAsRoot(); // nodes.printNodes(n); module.exports = { parse(src, extensions, opts) { var p = new Parser(lexer.lex(src, opts)); if (extensions !== undefined) { p.extensions = extensions; } return p.parseAsRoot(); }, Parser: Parser }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/precompile-global.js 000664 000000 000000 00000001153 14012546311 026435 0 ustar 00root root 000000 000000 'use strict'; function precompileGlobal(templates, opts) { var out = ''; opts = opts || {}; for (let i = 0; i < templates.length; i++) { const name = JSON.stringify(templates[i].name); const template = templates[i].template; out += '(function() {' + '(window.nunjucksPrecompiled = window.nunjucksPrecompiled || {})' + '[' + name + '] = (function() {\n' + template + '\n})();\n'; if (opts.asFunction) { out += 'return function(ctx, cb) { return nunjucks.render(' + name + ', ctx, cb); }\n'; } out += '})();\n'; } return out; } module.exports = precompileGlobal; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/precompile.js 000664 000000 000000 00000007211 14012546311 025200 0 ustar 00root root 000000 000000 'use strict'; const fs = require('fs'); const path = require('path'); const {_prettifyError} = require('./lib'); const compiler = require('./compiler'); const {Environment} = require('./environment'); const precompileGlobal = require('./precompile-global'); function match(filename, patterns) { if (!Array.isArray(patterns)) { return false; } return patterns.some((pattern) => filename.match(pattern)); } function precompileString(str, opts) { opts = opts || {}; opts.isString = true; const env = opts.env || new Environment([]); const wrapper = opts.wrapper || precompileGlobal; if (!opts.name) { throw new Error('the "name" option is required when compiling a string'); } return wrapper([_precompile(str, opts.name, env)], opts); } function precompile(input, opts) { // The following options are available: // // * name: name of the template (auto-generated when compiling a directory) // * isString: input is a string, not a file path // * asFunction: generate a callable function // * force: keep compiling on error // * env: the Environment to use (gets extensions and async filters from it) // * include: which file/folders to include (folders are auto-included, files are auto-excluded) // * exclude: which file/folders to exclude (folders are auto-included, files are auto-excluded) // * wrapper: function(templates, opts) {...} // Customize the output format to store the compiled template. // By default, templates are stored in a global variable used by the runtime. // A custom loader will be necessary to load your custom wrapper. opts = opts || {}; const env = opts.env || new Environment([]); const wrapper = opts.wrapper || precompileGlobal; if (opts.isString) { return precompileString(input, opts); } const pathStats = fs.existsSync(input) && fs.statSync(input); const precompiled = []; const templates = []; function addTemplates(dir) { fs.readdirSync(dir).forEach((file) => { const filepath = path.join(dir, file); let subpath = filepath.substr(path.join(input, '/').length); const stat = fs.statSync(filepath); if (stat && stat.isDirectory()) { subpath += '/'; if (!match(subpath, opts.exclude)) { addTemplates(filepath); } } else if (match(subpath, opts.include)) { templates.push(filepath); } }); } if (pathStats.isFile()) { precompiled.push(_precompile( fs.readFileSync(input, 'utf-8'), opts.name || input, env )); } else if (pathStats.isDirectory()) { addTemplates(input); for (let i = 0; i < templates.length; i++) { const name = templates[i].replace(path.join(input, '/'), ''); try { precompiled.push(_precompile( fs.readFileSync(templates[i], 'utf-8'), name, env )); } catch (e) { if (opts.force) { // Don't stop generating the output if we're // forcing compilation. console.error(e); // eslint-disable-line no-console } else { throw e; } } } } return wrapper(precompiled, opts); } function _precompile(str, name, env) { env = env || new Environment([]); const asyncFilters = env.asyncFilters; const extensions = env.extensionsList; let template; name = name.replace(/\\/g, '/'); try { template = compiler.compile(str, asyncFilters, extensions, name, env.opts); } catch (err) { throw _prettifyError(name, false, err); } return { name: name, template: template }; } module.exports = { precompile: precompile, precompileString: precompileString }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/precompiled-loader.js 000664 000000 000000 00000000727 14012546311 026615 0 ustar 00root root 000000 000000 'use strict'; const Loader = require('./loader'); class PrecompiledLoader extends Loader { constructor(compiledTemplates) { super(); this.precompiled = compiledTemplates || {}; } getSource(name) { if (this.precompiled[name]) { return { src: { type: 'code', obj: this.precompiled[name] }, path: name }; } return null; } } module.exports = { PrecompiledLoader: PrecompiledLoader, }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/runtime.js 000664 000000 000000 00000020432 14012546311 024524 0 ustar 00root root 000000 000000 'use strict'; var lib = require('./lib'); var arrayFrom = Array.from; var supportsIterators = ( typeof Symbol === 'function' && Symbol.iterator && typeof arrayFrom === 'function' ); // Frames keep track of scoping both at compile-time and run-time so // we know how to access variables. Block tags can introduce special // variables, for example. class Frame { constructor(parent, isolateWrites) { this.variables = Object.create(null); this.parent = parent; this.topLevel = false; // if this is true, writes (set) should never propagate upwards past // this frame to its parent (though reads may). this.isolateWrites = isolateWrites; } set(name, val, resolveUp) { // Allow variables with dots by automatically creating the // nested structure var parts = name.split('.'); var obj = this.variables; var frame = this; if (resolveUp) { if ((frame = this.resolve(parts[0], true))) { frame.set(name, val); return; } } for (let i = 0; i < parts.length - 1; i++) { const id = parts[i]; if (!obj[id]) { obj[id] = {}; } obj = obj[id]; } obj[parts[parts.length - 1]] = val; } get(name) { var val = this.variables[name]; if (val !== undefined) { return val; } return null; } lookup(name) { var p = this.parent; var val = this.variables[name]; if (val !== undefined) { return val; } return p && p.lookup(name); } resolve(name, forWrite) { var p = (forWrite && this.isolateWrites) ? undefined : this.parent; var val = this.variables[name]; if (val !== undefined) { return this; } return p && p.resolve(name); } push(isolateWrites) { return new Frame(this, isolateWrites); } pop() { return this.parent; } } function makeMacro(argNames, kwargNames, func) { return function macro(...macroArgs) { var argCount = numArgs(macroArgs); var args; var kwargs = getKeywordArgs(macroArgs); if (argCount > argNames.length) { args = macroArgs.slice(0, argNames.length); // Positional arguments that should be passed in as // keyword arguments (essentially default values) macroArgs.slice(args.length, argCount).forEach((val, i) => { if (i < kwargNames.length) { kwargs[kwargNames[i]] = val; } }); args.push(kwargs); } else if (argCount < argNames.length) { args = macroArgs.slice(0, argCount); for (let i = argCount; i < argNames.length; i++) { const arg = argNames[i]; // Keyword arguments that should be passed as // positional arguments, i.e. the caller explicitly // used the name of a positional arg args.push(kwargs[arg]); delete kwargs[arg]; } args.push(kwargs); } else { args = macroArgs; } return func.apply(this, args); }; } function makeKeywordArgs(obj) { obj.__keywords = true; return obj; } function isKeywordArgs(obj) { return obj && Object.prototype.hasOwnProperty.call(obj, '__keywords'); } function getKeywordArgs(args) { var len = args.length; if (len) { const lastArg = args[len - 1]; if (isKeywordArgs(lastArg)) { return lastArg; } } return {}; } function numArgs(args) { var len = args.length; if (len === 0) { return 0; } const lastArg = args[len - 1]; if (isKeywordArgs(lastArg)) { return len - 1; } else { return len; } } // A SafeString object indicates that the string should not be // autoescaped. This happens magically because autoescaping only // occurs on primitive string objects. function SafeString(val) { if (typeof val !== 'string') { return val; } this.val = val; this.length = val.length; } SafeString.prototype = Object.create(String.prototype, { length: { writable: true, configurable: true, value: 0 } }); SafeString.prototype.valueOf = function valueOf() { return this.val; }; SafeString.prototype.toString = function toString() { return this.val; }; function copySafeness(dest, target) { if (dest instanceof SafeString) { return new SafeString(target); } return target.toString(); } function markSafe(val) { var type = typeof val; if (type === 'string') { return new SafeString(val); } else if (type !== 'function') { return val; } else { return function wrapSafe(args) { var ret = val.apply(this, arguments); if (typeof ret === 'string') { return new SafeString(ret); } return ret; }; } } function suppressValue(val, autoescape) { val = (val !== undefined && val !== null) ? val : ''; if (autoescape && !(val instanceof SafeString)) { val = lib.escape(val.toString()); } return val; } function ensureDefined(val, lineno, colno) { if (val === null || val === undefined) { throw new lib.TemplateError( 'attempted to output null or undefined value', lineno + 1, colno + 1 ); } return val; } function memberLookup(obj, val) { if (obj === undefined || obj === null) { return undefined; } if (typeof obj[val] === 'function') { return (...args) => obj[val].apply(obj, args); } return obj[val]; } function callWrap(obj, name, context, args) { if (!obj) { throw new Error('Unable to call `' + name + '`, which is undefined or falsey'); } else if (typeof obj !== 'function') { throw new Error('Unable to call `' + name + '`, which is not a function'); } return obj.apply(context, args); } function contextOrFrameLookup(context, frame, name) { var val = frame.lookup(name); return (val !== undefined) ? val : context.lookup(name); } function handleError(error, lineno, colno) { if (error.lineno) { return error; } else { return new lib.TemplateError(error, lineno, colno); } } function asyncEach(arr, dimen, iter, cb) { if (lib.isArray(arr)) { const len = arr.length; lib.asyncIter(arr, function iterCallback(item, i, next) { switch (dimen) { case 1: iter(item, i, len, next); break; case 2: iter(item[0], item[1], i, len, next); break; case 3: iter(item[0], item[1], item[2], i, len, next); break; default: item.push(i, len, next); iter.apply(this, item); } }, cb); } else { lib.asyncFor(arr, function iterCallback(key, val, i, len, next) { iter(key, val, i, len, next); }, cb); } } function asyncAll(arr, dimen, func, cb) { var finished = 0; var len; var outputArr; function done(i, output) { finished++; outputArr[i] = output; if (finished === len) { cb(null, outputArr.join('')); } } if (lib.isArray(arr)) { len = arr.length; outputArr = new Array(len); if (len === 0) { cb(null, ''); } else { for (let i = 0; i < arr.length; i++) { const item = arr[i]; switch (dimen) { case 1: func(item, i, len, done); break; case 2: func(item[0], item[1], i, len, done); break; case 3: func(item[0], item[1], item[2], i, len, done); break; default: item.push(i, len, done); func.apply(this, item); } } } } else { const keys = lib.keys(arr || {}); len = keys.length; outputArr = new Array(len); if (len === 0) { cb(null, ''); } else { for (let i = 0; i < keys.length; i++) { const k = keys[i]; func(k, arr[k], i, len, done); } } } } function fromIterator(arr) { if (typeof arr !== 'object' || arr === null || lib.isArray(arr)) { return arr; } else if (supportsIterators && Symbol.iterator in arr) { return arrayFrom(arr); } else { return arr; } } module.exports = { Frame: Frame, makeMacro: makeMacro, makeKeywordArgs: makeKeywordArgs, numArgs: numArgs, suppressValue: suppressValue, ensureDefined: ensureDefined, memberLookup: memberLookup, contextOrFrameLookup: contextOrFrameLookup, callWrap: callWrap, handleError: handleError, isArray: lib.isArray, keys: lib.keys, SafeString: SafeString, copySafeness: copySafeness, markSafe: markSafe, asyncEach: asyncEach, asyncAll: asyncAll, inOperator: lib.inOperator, fromIterator: fromIterator }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/tests.js 000664 000000 000000 00000013213 14012546311 024202 0 ustar 00root root 000000 000000 'use strict'; var SafeString = require('./runtime').SafeString; /** * Returns `true` if the object is a function, otherwise `false`. * @param { any } value * @returns { boolean } */ function callable(value) { return typeof value === 'function'; } exports.callable = callable; /** * Returns `true` if the object is strictly not `undefined`. * @param { any } value * @returns { boolean } */ function defined(value) { return value !== undefined; } exports.defined = defined; /** * Returns `true` if the operand (one) is divisble by the test's argument * (two). * @param { number } one * @param { number } two * @returns { boolean } */ function divisibleby(one, two) { return (one % two) === 0; } exports.divisibleby = divisibleby; /** * Returns true if the string has been escaped (i.e., is a SafeString). * @param { any } value * @returns { boolean } */ function escaped(value) { return value instanceof SafeString; } exports.escaped = escaped; /** * Returns `true` if the arguments are strictly equal. * @param { any } one * @param { any } two */ function equalto(one, two) { return one === two; } exports.equalto = equalto; // Aliases exports.eq = exports.equalto; exports.sameas = exports.equalto; /** * Returns `true` if the value is evenly divisible by 2. * @param { number } value * @returns { boolean } */ function even(value) { return value % 2 === 0; } exports.even = even; /** * Returns `true` if the value is falsy - if I recall correctly, '', 0, false, * undefined, NaN or null. I don't know if we should stick to the default JS * behavior or attempt to replicate what Python believes should be falsy (i.e., * empty arrays, empty dicts, not 0...). * @param { any } value * @returns { boolean } */ function falsy(value) { return !value; } exports.falsy = falsy; /** * Returns `true` if the operand (one) is greater or equal to the test's * argument (two). * @param { number } one * @param { number } two * @returns { boolean } */ function ge(one, two) { return one >= two; } exports.ge = ge; /** * Returns `true` if the operand (one) is greater than the test's argument * (two). * @param { number } one * @param { number } two * @returns { boolean } */ function greaterthan(one, two) { return one > two; } exports.greaterthan = greaterthan; // alias exports.gt = exports.greaterthan; /** * Returns `true` if the operand (one) is less than or equal to the test's * argument (two). * @param { number } one * @param { number } two * @returns { boolean } */ function le(one, two) { return one <= two; } exports.le = le; /** * Returns `true` if the operand (one) is less than the test's passed argument * (two). * @param { number } one * @param { number } two * @returns { boolean } */ function lessthan(one, two) { return one < two; } exports.lessthan = lessthan; // alias exports.lt = exports.lessthan; /** * Returns `true` if the string is lowercased. * @param { string } value * @returns { boolean } */ function lower(value) { return value.toLowerCase() === value; } exports.lower = lower; /** * Returns `true` if the operand (one) is less than or equal to the test's * argument (two). * @param { number } one * @param { number } two * @returns { boolean } */ function ne(one, two) { return one !== two; } exports.ne = ne; /** * Returns true if the value is strictly equal to `null`. * @param { any } * @returns { boolean } */ function nullTest(value) { return value === null; } exports.null = nullTest; /** * Returns true if value is a number. * @param { any } * @returns { boolean } */ function number(value) { return typeof value === 'number'; } exports.number = number; /** * Returns `true` if the value is *not* evenly divisible by 2. * @param { number } value * @returns { boolean } */ function odd(value) { return value % 2 === 1; } exports.odd = odd; /** * Returns `true` if the value is a string, `false` if not. * @param { any } value * @returns { boolean } */ function string(value) { return typeof value === 'string'; } exports.string = string; /** * Returns `true` if the value is not in the list of things considered falsy: * '', null, undefined, 0, NaN and false. * @param { any } value * @returns { boolean } */ function truthy(value) { return !!value; } exports.truthy = truthy; /** * Returns `true` if the value is undefined. * @param { any } value * @returns { boolean } */ function undefinedTest(value) { return value === undefined; } exports.undefined = undefinedTest; /** * Returns `true` if the string is uppercased. * @param { string } value * @returns { boolean } */ function upper(value) { return value.toUpperCase() === value; } exports.upper = upper; /** * If ES6 features are available, returns `true` if the value implements the * `Symbol.iterator` method. If not, it's a string or Array. * * Could potentially cause issues if a browser exists that has Set and Map but * not Symbol. * * @param { any } value * @returns { boolean } */ function iterable(value) { if (typeof Symbol !== 'undefined') { return !!value[Symbol.iterator]; } else { return Array.isArray(value) || typeof value === 'string'; } } exports.iterable = iterable; /** * If ES6 features are available, returns `true` if the value is an object hash * or an ES6 Map. Otherwise just return if it's an object hash. * @param { any } value * @returns { boolean } */ function mapping(value) { // only maps and object hashes var bool = value !== null && value !== undefined && typeof value === 'object' && !Array.isArray(value); if (Set) { return bool && !(value instanceof Set); } else { return bool; } } exports.mapping = mapping; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/transformer.js 000664 000000 000000 00000012324 14012546311 025404 0 ustar 00root root 000000 000000 'use strict'; var nodes = require('./nodes'); var lib = require('./lib'); var sym = 0; function gensym() { return 'hole_' + sym++; } // copy-on-write version of map function mapCOW(arr, func) { var res = null; for (let i = 0; i < arr.length; i++) { const item = func(arr[i]); if (item !== arr[i]) { if (!res) { res = arr.slice(); } res[i] = item; } } return res || arr; } function walk(ast, func, depthFirst) { if (!(ast instanceof nodes.Node)) { return ast; } if (!depthFirst) { const astT = func(ast); if (astT && astT !== ast) { return astT; } } if (ast instanceof nodes.NodeList) { const children = mapCOW(ast.children, (node) => walk(node, func, depthFirst)); if (children !== ast.children) { ast = new nodes[ast.typename](ast.lineno, ast.colno, children); } } else if (ast instanceof nodes.CallExtension) { const args = walk(ast.args, func, depthFirst); const contentArgs = mapCOW(ast.contentArgs, (node) => walk(node, func, depthFirst)); if (args !== ast.args || contentArgs !== ast.contentArgs) { ast = new nodes[ast.typename](ast.extName, ast.prop, args, contentArgs); } } else { const props = ast.fields.map((field) => ast[field]); const propsT = mapCOW(props, (prop) => walk(prop, func, depthFirst)); if (propsT !== props) { ast = new nodes[ast.typename](ast.lineno, ast.colno); propsT.forEach((prop, i) => { ast[ast.fields[i]] = prop; }); } } return depthFirst ? (func(ast) || ast) : ast; } function depthWalk(ast, func) { return walk(ast, func, true); } function _liftFilters(node, asyncFilters, prop) { var children = []; var walked = depthWalk(prop ? node[prop] : node, (descNode) => { let symbol; if (descNode instanceof nodes.Block) { return descNode; } else if ((descNode instanceof nodes.Filter && lib.indexOf(asyncFilters, descNode.name.value) !== -1) || descNode instanceof nodes.CallExtensionAsync) { symbol = new nodes.Symbol(descNode.lineno, descNode.colno, gensym()); children.push(new nodes.FilterAsync(descNode.lineno, descNode.colno, descNode.name, descNode.args, symbol)); } return symbol; }); if (prop) { node[prop] = walked; } else { node = walked; } if (children.length) { children.push(node); return new nodes.NodeList( node.lineno, node.colno, children ); } else { return node; } } function liftFilters(ast, asyncFilters) { return depthWalk(ast, (node) => { if (node instanceof nodes.Output) { return _liftFilters(node, asyncFilters); } else if (node instanceof nodes.Set) { return _liftFilters(node, asyncFilters, 'value'); } else if (node instanceof nodes.For) { return _liftFilters(node, asyncFilters, 'arr'); } else if (node instanceof nodes.If) { return _liftFilters(node, asyncFilters, 'cond'); } else if (node instanceof nodes.CallExtension) { return _liftFilters(node, asyncFilters, 'args'); } else { return undefined; } }); } function liftSuper(ast) { return walk(ast, (blockNode) => { if (!(blockNode instanceof nodes.Block)) { return; } let hasSuper = false; const symbol = gensym(); blockNode.body = walk(blockNode.body, (node) => { // eslint-disable-line consistent-return if (node instanceof nodes.FunCall && node.name.value === 'super') { hasSuper = true; return new nodes.Symbol(node.lineno, node.colno, symbol); } }); if (hasSuper) { blockNode.body.children.unshift(new nodes.Super( 0, 0, blockNode.name, new nodes.Symbol(0, 0, symbol) )); } }); } function convertStatements(ast) { return depthWalk(ast, (node) => { if (!(node instanceof nodes.If) && !(node instanceof nodes.For)) { return undefined; } let async = false; walk(node, (child) => { if (child instanceof nodes.FilterAsync || child instanceof nodes.IfAsync || child instanceof nodes.AsyncEach || child instanceof nodes.AsyncAll || child instanceof nodes.CallExtensionAsync) { async = true; // Stop iterating by returning the node return child; } return undefined; }); if (async) { if (node instanceof nodes.If) { return new nodes.IfAsync( node.lineno, node.colno, node.cond, node.body, node.else_ ); } else if (node instanceof nodes.For && !(node instanceof nodes.AsyncAll)) { return new nodes.AsyncEach( node.lineno, node.colno, node.arr, node.name, node.body, node.else_ ); } } return undefined; }); } function cps(ast, asyncFilters) { return convertStatements(liftSuper(liftFilters(ast, asyncFilters))); } function transform(ast, asyncFilters) { return cps(ast, asyncFilters || []); } // var parser = require('./parser'); // var src = 'hello {% foo %}{% endfoo %} end'; // var ast = transform(parser.parse(src, [new FooExtension()]), ['bar']); // nodes.printNodes(ast); module.exports = { transform: transform }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/nunjucks/src/web-loaders.js 000664 000000 000000 00000004671 14012546311 025254 0 ustar 00root root 000000 000000 'use strict'; const Loader = require('./loader'); const {PrecompiledLoader} = require('./precompiled-loader.js'); class WebLoader extends Loader { constructor(baseURL, opts) { super(); this.baseURL = baseURL || '.'; opts = opts || {}; // By default, the cache is turned off because there's no way // to "watch" templates over HTTP, so they are re-downloaded // and compiled each time. (Remember, PRECOMPILE YOUR // TEMPLATES in production!) this.useCache = !!opts.useCache; // We default `async` to false so that the simple synchronous // API can be used when you aren't doing anything async in // your templates (which is most of the time). This performs a // sync ajax request, but that's ok because it should *only* // happen in development. PRECOMPILE YOUR TEMPLATES. this.async = !!opts.async; } resolve(from, to) { throw new Error('relative templates not support in the browser yet'); } getSource(name, cb) { var useCache = this.useCache; var result; this.fetch(this.baseURL + '/' + name, (err, src) => { if (err) { if (cb) { cb(err.content); } else if (err.status === 404) { result = null; } else { throw err.content; } } else { result = { src: src, path: name, noCache: !useCache }; this.emit('load', name, result); if (cb) { cb(null, result); } } }); // if this WebLoader isn't running asynchronously, the // fetch above would actually run sync and we'll have a // result here return result; } fetch(url, cb) { // Only in the browser please if (typeof window === 'undefined') { throw new Error('WebLoader can only by used in a browser'); } const ajax = new XMLHttpRequest(); let loading = true; ajax.onreadystatechange = () => { if (ajax.readyState === 4 && loading) { loading = false; if (ajax.status === 0 || ajax.status === 200) { cb(null, ajax.responseText); } else { cb({ status: ajax.status, content: ajax.responseText }); } } }; url += (url.indexOf('?') === -1 ? '?' : '&') + 's=' + (new Date().getTime()); ajax.open('GET', url, this.async); ajax.send(); } } module.exports = { WebLoader: WebLoader, PrecompiledLoader: PrecompiledLoader }; nunjucks-fd500902d7c88672470c87170796de52fc0f791a/package.json 000664 000000 000000 00000006102 14012546311 022340 0 ustar 00root root 000000 000000 { "name": "nunjucks", "description": "A powerful templating engine with inheritance, asynchronous control, and more (jinja2 inspired)", "version": "3.2.3", "author": "James Long
' + body() + '
');
var ajax = new XMLHttpRequest();
ajax.onreadystatechange = function() {
if (ajax.readyState == 4) {
if (ajax.status == 200) {
document.getElementById(id).innerHTML = ajax.responseText;
} else {
document.getElementById(id).innerHTML = errorBody();
}
}
};
ajax.open('GET', url, true);
ajax.send();
return ret;
};
}
nunjucks-fd500902d7c88672470c87170796de52fc0f791a/samples/express/main.js 000664 000000 000000 00000001270 14012546311 024472 0 ustar 00root root 000000 000000 /* eslint-disable func-names */
'use strict';
var path = require('path');
var nunjucks = require('../..');
var express = require('express');
var app = express();
nunjucks.configure(path.join(__dirname, 'views'), {
autoescape: true,
express: app,
watch: true
});
// app
app.use(express.static(__dirname));
app.use(function(req, res, next) {
res.locals.user = 'hello';
next();
});
app.get('/', function(req, res) {
res.render('index.html', {
username: 'James Long copyright'
});
});
app.get('/about', function(req, res) {
res.render('about.html');
});
app.listen(4000, function() {
console.log('Express server running on http://localhost:4000');
});
nunjucks-fd500902d7c88672470c87170796de52fc0f791a/samples/express/pre.js 000664 000000 000000 00000001314 14012546311 024333 0 ustar 00root root 000000 000000 #!/usr/bin/env node
'use strict';
var precompileString = require('../..').precompileString;
var fs = require('fs');
var path = require('path');
var out = 'window.baseTmpl = ' +
precompileString(
fs.readFileSync(path.join(__dirname, 'views/base.html'), 'utf-8'), {
name: 'base.html',
asFunction: true
});
out += 'window.aboutTmpl = ' +
precompileString(
fs.readFileSync(path.join(__dirname, 'views/about.html'), 'utf-8'), {
name: 'about.html',
asFunction: true
});
fs.writeFileSync(path.join(__dirname, 'js/templates.js'), out, 'utf-8');
fs.writeFileSync(path.join(__dirname, 'js/nunjucks.js'),
fs.readFileSync(path.join(__dirname, '../../browser/nunjucks.js'), 'utf-8'),
'utf-8');
nunjucks-fd500902d7c88672470c87170796de52fc0f791a/samples/express/views/ 000775 000000 000000 00000000000 14012546311 024345 5 ustar 00root root 000000 000000 nunjucks-fd500902d7c88672470c87170796de52fc0f791a/samples/express/views/about.html 000664 000000 000000 00000000264 14012546311 026347 0 ustar 00root root 000000 000000 {% extends "base.html" %}
{% block content %}
This is just the about page
{% endblock %}
{% block footer %}
{{ super() }}
You really should read this!
{{ poop }}
{% endblock %}
nunjucks-fd500902d7c88672470c87170796de52fc0f791a/samples/express/views/base.html 000664 000000 000000 00000001010 14012546311 026135 0 ustar 00root root 000000 000000
Tests do not indicate performance. They are much slower because a
new environment is created for every single template and is
recompiled from scratch, and you can see there are
quite
a
lot
of
tests.
nunjucks-fd500902d7c88672470c87170796de52fc0f791a/tests/browser/slim.html 000664 000000 000000 00000003523 14012546311 024535 0 ustar 00root root 000000 000000
{{ foo() }}
',
'{% endblock %}',
].join('\n');
var env = new Environment(new Loader('tests/templates'));
var tmpl = new Template(tmplStr, env, 'user-error.njk');
function foo() {
throw new Error('ERROR');
}
tmpl.render({foo: foo}, function(err, res) {
expect(res).to.be(undefined);
expect(err.toString()).to.be([
'Template render error: (user-error.njk) [Line 1, Column 11]',
' Error: ERROR',
].join('\n'));
done();
});
});
}
it('should throw exceptions from included templates when called synchronously', function() {
function templateRender() {
render('{% include "broken-import.njk" %}', {str: 'abc'});
}
expect(templateRender).to.throwException(/template not found: doesnotexist/);
});
it('should pass errors from included templates to callback when async', function(done) {
render(
'{% include "broken-import.njk" %}',
{str: 'abc'},
{noThrow: true},
function(err, res) {
expect(err).to.match(/template not found: doesnotexist/);
expect(res).to.be(undefined);
done();
});
});
it('should compile string concatenations with tilde', function(done) {
equal('{{ 4 ~ \'hello\' }}', '4hello');
equal('{{ 4 ~ 5 }}', '45');
equal('{{ \'a\' ~ \'b\' ~ 5 }}', 'ab5');
finish(done);
});
it('should compile macros', function(done) {
equal(
'{% macro foo() %}This is a macro{% endmacro %}' +
'{{ foo() }}',
'This is a macro');
finish(done);
});
it('should compile macros with optional args', function(done) {
equal(
'{% macro foo(x, y) %}{{ y }}{% endmacro %}' +
'{{ foo(1) }}',
'');
finish(done);
});
it('should compile macros with args that can be passed to filters', function(done) {
equal(
'{% macro foo(x) %}{{ x|title }}{% endmacro %}' +
'{{ foo("foo") }}',
'Foo');
finish(done);
});
it('should compile macros with positional args', function(done) {
equal(
'{% macro foo(x, y) %}{{ y }}{% endmacro %}' +
'{{ foo(1, 2) }}',
'2');
finish(done);
});
it('should compile macros with arg defaults', function(done) {
equal(
'{% macro foo(x, y, z=5) %}{{ y }}{% endmacro %}' +
'{{ foo(1, 2) }}',
'2');
equal(
'{% macro foo(x, y, z=5) %}{{ z }}{% endmacro %}' +
'{{ foo(1, 2) }}',
'5');
finish(done);
});
it('should compile macros with keyword args', function(done) {
equal(
'{% macro foo(x, y, z=5) %}{{ y }}{% endmacro %}' +
'{{ foo(1, y=2) }}',
'2');
finish(done);
});
it('should compile macros with only keyword args', function(done) {
equal(
'{% macro foo(x, y, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{{ foo(x=1, y=2) }}',
'125');
finish(done);
});
it('should compile macros with keyword args overriding defaults', function(done) {
equal(
'{% macro foo(x, y, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{{ foo(x=1, y=2, z=3) }}',
'123');
finish(done);
});
it('should compile macros with out-of-order keyword args', function(done) {
equal(
'{% macro foo(x, y=2, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{{ foo(1, z=3) }}',
'123');
finish(done);
});
it('should compile macros', function(done) {
equal(
'{% macro foo(x, y=2, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{{ foo(1) }}',
'125');
finish(done);
});
it('should compile macros with multiple overridden arg defaults', function(done) {
equal(
'{% macro foo(x, y=2, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{{ foo(1, 10, 20) }}',
'11020');
finish(done);
});
it('should compile macro calls inside blocks', function(done) {
equal(
'{% extends "base.njk" %}' +
'{% macro foo(x, y=2, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{% block block1 %}' +
'{{ foo(1) }}' +
'{% endblock %}',
'Foo125BazFizzle');
finish(done);
});
it('should compile macros defined in one block and called in another', function(done) {
equal(
'{% block bar %}' +
'{% macro foo(x, y=2, z=5) %}{{ x }}{{ y }}{{ z }}' +
'{% endmacro %}' +
'{% endblock %}' +
'{% block baz %}' +
'{{ foo(1) }}' +
'{% endblock %}',
'125');
finish(done);
});
it('should compile macros that include other templates', function(done) {
equal(
'{% macro foo() %}{% include "include.njk" %}{% endmacro %}' +
'{{ foo() }}',
{
name: 'james'
},
'FooInclude james');
finish(done);
});
it('should compile macros that set vars', function(done) {
equal(
'{% macro foo() %}{% set x = "foo"%}{{ x }}{% endmacro %}' +
'{% set x = "bar" %}' +
'{{ x }}' +
'{{ foo() }}' +
'{{ x }}',
'barfoobar');
finish(done);
});
it('should not leak variables set in macro to calling scope', function(done) {
equal(
'{% macro setFoo() %}' +
'{% set x = "foo" %}' +
'{{ x }}' +
'{% endmacro %}' +
'{% macro display() %}' +
'{% set x = "bar" %}' +
'{{ setFoo() }}' +
'{{ x }}' +
'{% endmacro %}' +
'{{ display() }}',
'foobar');
finish(done);
});
it('should not leak variables set in nested scope within macro out to calling scope', function(done) {
equal(
'{% macro setFoo() %}' +
'{% for y in [1] %}{% set x = "foo" %}{{ x }}{% endfor %}' +
'{% endmacro %}' +
'{% macro display() %}' +
'{% set x = "bar" %}' +
'{{ setFoo() }}' +
'{{ x }}' +
'{% endmacro %}' +
'{{ display() }}',
'foobar');
finish(done);
});
it('should compile macros without leaking set to calling scope', function(done) {
// This test checks that the issue #577 is resolved.
// If the bug is not fixed, and set variables leak into the
// caller scope, there will be too many "foo"s here ("foofoofoo"),
// because each recursive call will append a "foo" to the
// variable x in its caller's scope, instead of just its own.
equal(
'{% macro foo(topLevel, prefix="") %}' +
'{% if topLevel %}' +
'{% set x = "" %}' +
'{% for i in [1,2] %}' +
'{{ foo(false, x) }}' +
'{% endfor %}' +
'{% else %}' +
'{% set x = prefix + "foo" %}' +
'{{ x }}' +
'{% endif %}' +
'{% endmacro %}' +
'{{ foo(true) }}',
'foofoo');
finish(done);
});
it('should compile macros that cannot see variables in caller scope', function(done) {
equal(
'{% macro one(var) %}{{ two() }}{% endmacro %}' +
'{% macro two() %}{{ var }}{% endmacro %}' +
'{{ one("foo") }}',
'');
finish(done);
});
it('should compile call blocks', function(done) {
equal(
'{% macro wrap(el) %}' +
'<{{ el }}>{{ caller() }}' +
'{% endmacro %}' +
'{% call wrap("div") %}Hello{% endcall %}',
'Hello
');
finish(done);
});
it('should compile call blocks with args', function(done) {
equal(
'{% macro list(items) %}' +
'- {% for i in items %}' +
'
- {{ caller(i) }} ' + '{% endfor %}
- a
- b
foo
'] }, { autoescape: true }, '<p>foo</p>'); equal( '{{ foo }}', { foo: { toString: function() { return 'foo
'; } } }, { autoescape: true }, '<p>foo</p>'); equal('{{ foo | safe }}', { foo: null }, { autoescape: true }, ''); equal( '{{ foo | safe }}', { foo: 'foo
' }, { autoescape: true }, 'foo
'); equal( '{{ foo | safe }}', { foo: ['foo
'] }, { autoescape: true }, 'foo
'); equal( '{{ foo | safe }}', { foo: { toString: function() { return 'foo
'; } } }, { autoescape: true }, 'foo
'); finish(done); }); it('should not autoescape safe strings', function(done) { equal( '{{ foo|safe }}', { foo: '"\'<>&' }, { autoescape: true }, '"\'<>&'); finish(done); }); it('should not autoescape macros', function(done) { render( '{% macro foo(x, y) %}{{ x }} and {{ y }}{% endmacro %}' + '{{ foo("<>&", "<>") }}', null, { autoescape: true }, function(err, res) { expect(res).to.be('<>& and <>'); } ); render( '{% macro foo(x, y) %}{{ x|safe }} and {{ y }}{% endmacro %}' + '{{ foo("<>&", "<>") }}', null, { autoescape: true }, function(err, res) { expect(res).to.be('<>& and <>'); } ); finish(done); }); it('should not autoescape super()', function(done) { render( '{% extends "base3.njk" %}' + '{% block block1 %}{{ super() }}{% endblock %}', null, { autoescape: true }, function(err, res) { expect(res).to.be('Foo'); } ); finish(done); }); it('should not autoescape when extension set false', function(done) { function TestExtension() { // jshint validthis: true this.tags = ['test']; this.autoescape = false; this.parse = function(parser, nodes) { var tok = parser.nextToken(); var args = parser.parseSignature(null, true); parser.advanceAfterBlockEnd(tok.value); return new nodes.CallExtension(this, 'run', args, null); }; this.run = function() { // Reverse the string return 'Foo'; }; } render( '{% test "123456" %}', null, { extensions: { TestExtension: new TestExtension() }, autoescape: true }, function(err, res) { expect(res).to.be('Foo'); } ); finish(done); }); it('should pass context as this to filters', function(done) { render( '{{ foo | hallo }}', { foo: 1, bar: 2 }, { filters: { hallo: function(foo) { return foo + this.lookup('bar'); } } }, function(err, res) { expect(res).to.be('3'); } ); finish(done); }); it('should render regexs', function(done) { equal('{{ r/name [0-9] \\// }}', '/name [0-9] \\//'); equal('{{ r/x/gi }}', '/x/gi'); finish(done); }); it('should throw an error when {% call %} is passed an object that is not a function', function(done) { render( '{% call foo() %}{% endcall %}', {foo: 'bar'}, {noThrow: true}, function(err, res) { expect(res).to.be(undefined); expect(err).to.match(/Unable to call `\w+`, which is not a function/); }); finish(done); }); it('should throw an error when including a file that calls an undefined macro', function(done) { render( '{% include "undefined-macro.njk" %}', {}, { noThrow: true }, function(err, res) { expect(res).to.be(undefined); expect(err).to.match(/Unable to call `\w+`, which is undefined or falsey/); } ); finish(done); }); it('should throw an error when including a file that calls an undefined macro even inside {% if %} tag', function(done) { render( '{% if true %}{% include "undefined-macro.njk" %}{% endif %}', {}, { noThrow: true }, function(err, res) { expect(res).to.be(undefined); expect(err).to.match(/Unable to call `\w+`, which is undefined or falsey/); } ); finish(done); }); it('should throw an error when including a file that imports macro that calls an undefined macro', function(done) { render( '{% include "import-macro-call-undefined-macro.njk" %}', { list: [1, 2, 3] }, { noThrow: true }, function(err, res) { expect(res).to.be(undefined); expect(err).to.match(/Unable to call `\w+`, which is undefined or falsey/); } ); finish(done); }); it('should control whitespaces correctly', function(done) { equal( '{% if true -%}{{"hello"}} {{"world"}}{% endif %}', 'hello world'); equal( '{% if true -%}{% if true %} {{"hello"}} {{"world"}}' + '{% endif %}{% endif %}', ' hello world'); equal( '{% if true -%}{# comment #} {{"hello"}}{% endif %}', ' hello'); finish(done); }); it('should control expression whitespaces correctly', function(done) { equal( 'Well, {{- \' hello, \' -}} my friend', 'Well, hello, my friend' ); equal(' {{ 2 + 2 }} ', ' 4 '); equal(' {{-2 + 2 }} ', '4 '); equal(' {{ -2 + 2 }} ', ' 0 '); equal(' {{ 2 + 2 -}} ', ' 4'); finish(done); }); it('should get right value when macro parameter conflict with global macro name', function(done) { render( '{# macro1 and macro2 definition #}' + '{% macro macro1() %}' + '{% endmacro %}' + '' + '{% macro macro2(macro1="default") %}' + '{{macro1}}' + '{% endmacro %}' + '' + '{# calling macro2 #}' + '{{macro2("this should be outputted") }}', {}, {}, function(err, res) { expect(res.trim()).to.eql('this should be outputted'); }); finish(done); }); it('should get right value when macro include macro', function(done) { render( '{# macro1 and macro2 definition #}' + '{% macro macro1() %} foo' + '{% endmacro %}' + '' + '{% macro macro2(text="default") %}' + '{{macro1()}}' + '{% endmacro %}' + '' + '{# calling macro2 #}' + '{{macro2("this should not be outputted") }}', {}, {}, function(err, res) { expect(res.trim()).to.eql('foo'); }); finish(done); }); it('should allow access to outer scope in call blocks', function(done) { render( '{% macro inside() %}' + '{{ caller() }}' + '{% endmacro %}' + '{% macro outside(var) %}' + '{{ var }}\n' + '{% call inside() %}' + '{{ var }}' + '{% endcall %}' + '{% endmacro %}' + '{{ outside("foobar") }}', {}, {}, function(err, res) { expect(res.trim()).to.eql('foobar\nfoobar'); }); finish(done); }); it('should not leak scope from call blocks to parent', function(done) { render( '{% set var = "expected" %}' + '{% macro inside() %}' + '{% set var = "incorrect-value" %}' + '{{ caller() }}' + '{% endmacro %}' + '{% macro outside() %}' + '{% call inside() %}' + '{% endcall %}' + '{% endmacro %}' + '{{ outside() }}' + '{{ var }}', {}, {}, function(err, res) { expect(res.trim()).to.eql('expected'); }); finish(done); }); if (!isSlim) { it('should import template objects', function(done) { var tmpl = new Template('{% macro foo() %}Inside a macro{% endmacro %}' + '{% set bar = "BAZ" %}'); equal( '{% import tmpl as imp %}' + '{{ imp.foo() }} {{ imp.bar }}', { tmpl: tmpl }, 'Inside a macro BAZ'); equal( '{% from tmpl import foo as baz, bar %}' + '{{ bar }} {{ baz() }}', { tmpl: tmpl }, 'BAZ Inside a macro'); finish(done); }); it('should inherit template objects', function(done) { var tmpl = new Template('Foo{% block block1 %}Bar{% endblock %}' + '{% block block2 %}Baz{% endblock %}Whizzle'); equal('hola {% extends tmpl %} fizzle mumble', { tmpl: tmpl }, 'FooBarBazWhizzle'); equal( '{% extends tmpl %}' + '{% block block1 %}BAR{% endblock %}' + '{% block block2 %}BAZ{% endblock %}', { tmpl: tmpl }, 'FooBARBAZWhizzle'); finish(done); }); it('should include template objects', function(done) { var tmpl = new Template('FooInclude {{ name }}'); equal('hello world {% include tmpl %}', { name: 'thedude', tmpl: tmpl }, 'hello world FooInclude thedude'); finish(done); }); it('should throw an error when invalid expression whitespaces are used', function(done) { render( ' {{ 2 + 2- }}', {}, { noThrow: true }, function(err, res) { expect(res).to.be(undefined); expect(err).to.match(/unexpected token: }}/); } ); finish(done); }); } }); describe('the filter tag', function() { it('should apply the title filter to the body', function(done) { equal('{% filter title %}may the force be with you{% endfilter %}', 'May The Force Be With You'); finish(done); }); it('should apply the replace filter to the body', function(done) { equal('{% filter replace("force", "forth") %}may the force be with you{% endfilter %}', 'may the forth be with you'); finish(done); }); it('should work with variables in the body', function(done) { equal('{% set foo = "force" %}{% filter replace("force", "forth") %}may the {{ foo }} be with you{% endfilter %}', 'may the forth be with you'); finish(done); }); it('should work with blocks in the body', function(done) { equal( '{% extends "filter-block.html" %}' + '{% block block1 %}force{% endblock %}', 'may the forth be with you\n'); finish(done); }); }); }()); nunjucks-fd500902d7c88672470c87170796de52fc0f791a/tests/core.js 000664 000000 000000 00000003615 14012546311 022510 0 ustar 00root root 000000 000000 (function() { 'use strict'; var expect, nunjucks, fs, os, path; if (typeof require !== 'undefined') { expect = require('expect.js'); nunjucks = require('../nunjucks/index'); fs = require('fs-extra'); path = require('path'); os = require('os'); } else { expect = window.expect; nunjucks = window.nunjucks; } function rmdir(dirPath) { fs.emptyDirSync(dirPath); fs.rmdirSync(dirPath); } describe('nunjucks.configure', function() { var tempdir; before(function() { if (fs && path && os) { try { tempdir = fs.mkdtempSync(path.join(os.tmpdir(), 'templates')); fs.emptyDirSync(tempdir); } catch (e) { rmdir(tempdir); throw e; } } }); after(function() { nunjucks.reset(); if (typeof tempdir !== 'undefined') { rmdir(tempdir); } }); it('should cache templates by default', function() { if (typeof fs === 'undefined') { this.skip(); return; } nunjucks.configure(tempdir); fs.writeFileSync(tempdir + '/test.html', '{{ name }}', 'utf-8'); expect(nunjucks.render('test.html', {name: 'foo'})).to.be('foo'); fs.writeFileSync(tempdir + '/test.html', '{{ name }}-changed', 'utf-8'); expect(nunjucks.render('test.html', {name: 'foo'})).to.be('foo'); }); it('should not cache templates with {noCache: true}', function() { if (typeof fs === 'undefined') { this.skip(); return; } nunjucks.configure(tempdir, {noCache: true}); fs.writeFileSync(tempdir + '/test.html', '{{ name }}', 'utf-8'); expect(nunjucks.render('test.html', {name: 'foo'})).to.be('foo'); fs.writeFileSync(tempdir + '/test.html', '{{ name }}-changed', 'utf-8'); expect(nunjucks.render('test.html', {name: 'foo'})).to.be('foo-changed'); }); }); }()); nunjucks-fd500902d7c88672470c87170796de52fc0f791a/tests/express.js 000664 000000 000000 00000002113 14012546311 023241 0 ustar 00root root 000000 000000 'use strict'; var path = require('path'); var express = require('express'); var expect = require('expect.js'); var request = require('supertest'); var nunjucks = require('../nunjucks/index'); var VIEWS = path.join(__dirname, '../samples/express/views'); describe('express', function() { var app; var env; beforeEach(function() { app = express(); env = new nunjucks.Environment(new nunjucks.FileSystemLoader(VIEWS)); env.express(app); }); it('should have reference to nunjucks env', function() { expect(app.settings.nunjucksEnv).to.be(env); }); it('should render a view with extension', function(done) { app.get('/', function(req, res) { res.render('about.html'); }); request(app) .get('/') .expect(/This is just the about page/) .end(done); }); it('should render a view without extension', function(done) { app.get('/', function(req, res) { res.render('about'); }); app.set('view engine', 'html'); request(app) .get('/') .expect(/This is just the about page/) .end(done); }); }); nunjucks-fd500902d7c88672470c87170796de52fc0f791a/tests/filters.js 000664 000000 000000 00000077712 14012546311 023241 0 ustar 00root root 000000 000000 (function() { 'use strict'; var expect; var util; var lib; var r; var render; var equal; var finish; if (typeof require !== 'undefined') { expect = require('expect.js'); util = require('./util'); lib = require('../nunjucks/src/lib'); r = require('../nunjucks/src/runtime'); } else { expect = window.expect; util = window.util; lib = nunjucks.lib; r = nunjucks.runtime; } render = util.render; equal = util.equal; finish = util.finish; describe('filter', function() { it('abs', function(done) { equal('{{ -3|abs }}', '3'); equal('{{ -3.456|abs }}', '3.456'); finish(done); }); it('batch', function(done) { equal( [ '{% for a in [1,2,3,4,5,6]|batch(2) %}', '-{% for b in a %}', '{{ b }}', '{% endfor %}-', '{% endfor %}'].join(''), '-12--34--56-'); finish(done); }); it('capitalize', function(done) { equal('{{ "foo" | capitalize }}', 'Foo'); equal('{{ str | capitalize }}', { str: r.markSafe('foo') }, 'Foo'); equal('{{ undefined | capitalize }}', ''); equal('{{ null | capitalize }}', ''); equal('{{ nothing | capitalize }}', ''); finish(done); }); it('center', function(done) { equal('{{ "fooo" | center }}', lib.repeat(' ', 38) + 'fooo' + lib.repeat(' ', 38)); equal('{{ str | center }}', {str: r.markSafe('fooo')}, lib.repeat(' ', 38) + 'fooo' + lib.repeat(' ', 38)); equal('{{ undefined | center }}', lib.repeat(' ', 40) + '' + lib.repeat(' ', 40)); equal('{{ null | center }}', lib.repeat(' ', 40) + '' + lib.repeat(' ', 40)); equal('{{ nothing | center }}', lib.repeat(' ', 40) + '' + lib.repeat(' ', 40)); equal('{{ "foo" | center }}', lib.repeat(' ', 38) + 'foo' + lib.repeat(' ', 39)); finish(done); }); it('default', function(done) { equal('{{ undefined | default("foo") }}', 'foo'); equal('{{ bar | default("foo") }}', { bar: null }, ''); equal('{{ false | default("foo") }}', 'false'); equal('{{ false | default("foo", true) }}', 'foo'); equal('{{ bar | default("foo") }}', 'foo'); equal('{{ "bar" | default("foo") }}', 'bar'); finish(done); }); it('dump', function() { equal('{{ [\'a\', 1, {b: true}] | dump }}', '["a",1,{"b":true}]'); equal('{{ [\'a\', 1, {b: true}] | dump(2) }}', '[\n "a",\n 1,\n {\n "b": true\n }\n]'); equal('{{ [\'a\', 1, {b: true}] | dump(4) }}', '[\n "a",\n 1,\n {\n "b": true\n }\n]'); equal('{{ [\'a\', 1, {b: true}] | dump(\'\t\') }}', '[\n\t"a",\n\t1,\n\t{\n\t\t"b": true\n\t}\n]'); }); it('escape', function() { equal( '{{ "" | escape }}', {}, { autoescape: false }, '<html>'); }); it('escape skip safe', function() { equal('{{ "" | safe | escape }}', {}, { autoescape: false }, ''); }); it('should not double escape strings', function() { equal('{{ "" | escape | escape }}', {}, { autoescape: false }, '<html>'); }); it('should not double escape with autoescape on', function() { equal('{% set val = "" | escape %}{{ val }}', {}, { autoescape: true }, '<html>'); }); it('should work with non-string values', function() { equal( '{{ foo | escape }}', { foo: [''] }, { autoescape: false }, '<html>'); equal( '{{ foo | escape }}', { foo: { toString: function() { return ''; } } }, { autoescape: false }, '<html>'); equal('{{ foo | escape }}', { foo: null }, { autoescape: false }, ''); }); it('should not escape safe strings with autoescape on', function() { equal( '{{ "" | safe | escape }}', {}, { autoescape: true }, ''); equal( '{% set val = "" | safe | e %}{{ val }}', {}, { autoescape: true }, ''); }); it('should keep strings escaped after they have been escaped', function() { equal( '{% set val = "" | e | safe %}{{ val }}', {}, { autoescape: false }, '<html>'); }); it('dictsort', function(done) { // no real foolproof way to test that a js obj has been transformed // from unsorted -> sorted, as its enumeration ordering is undefined // and might fluke being sorted originally .. lets just init with some jumbled // keys // no params - should be case insensitive, by key equal( '{% for item in items | dictsort %}' + '{{ item[0] }}{% endfor %}', { items: { e: 1, d: 2, c: 3, a: 4, f: 5, b: 6 } }, 'abcdef'); // case sensitive = true equal( '{% for item in items | dictsort(true) %}{{ item[0] }},{% endfor %}', { items: { ABC: 6, ABc: 5, Abc: 1, abc: 2 } }, 'ABC,ABc,Abc,abc,'); // use values for sort equal( '{% for item in items | dictsort(false, "value") %}{{ item[0] }}{% endfor %}', { items: { a: 6, b: 5, c: 1, d: 2 } }, 'cdba'); finish(done); }); it('first', function(done) { equal('{{ [1,2,3] | first }}', '1'); finish(done); }); it('float', function() { equal('{{ "3.5" | float }}', '3.5'); equal('{{ "0" | float }}', '0'); }); it('forceescape', function(done) { equal('{{ str | forceescape }}', { str: r.markSafe('')}, '<html>'); equal('{{ "" | safe | forceescape }}', '<html>'); finish(done); }); it('int', function() { equal('{{ "3.5" | int }}', '3'); equal('{{ "0" | int }}', '0'); equal('{{ "foobar" | int("42") }}', '42'); equal('{{ "0x4d32" | int(base=16) }}', '19762'); equal('{{ "011" | int(base=8) }}', '9'); }); it('int (default value)', function() { equal('{{ "bob" | int("cat") }}', 'cat'); }); it('float (default value)', function() { equal('{{ "bob" | float("cat") }}', 'cat'); }); it('groupby', function(done) { const namesContext = { items: [{ name: 'james', type: 'green' }, { name: 'john', type: 'blue' }, { name: 'jim', type: 'blue' }, { name: 'jessie', type: 'green' }] }; equal( '{% for type, items in items | groupby("type") %}' + ':{{ type }}:' + '{% for item in items %}' + '{{ item.name }}' + '{% endfor %}' + '{% endfor %}', namesContext, ':green:jamesjessie:blue:johnjim'); equal( '{% for type, items in items | groupby("type") %}' + ':{{ type }}:' + '{% for item in items %}' + '{{ item.name }}' + '{% endfor %}' + '{% endfor %}', { items: [{ name: 'james', type: 'green' }, { name: 'john', type: 'blue' }, { name: 'jim', type: 'blue' }, { name: 'jessie', color: 'green' }] }, ':green:james:blue:johnjim:undefined:jessie'); equal( '{% for year, posts in posts | groupby("date.year") %}' + ':{{ year }}:' + '{% for post in posts %}' + '{{ post.title }}' + '{% endfor %}' + '{% endfor %}', { posts: [ { date: { year: 2019 }, title: 'Post 1' }, { date: { year: 2018 }, title: 'Post 2' }, { date: { year: 2019 }, title: 'Post 3' } ] }, ':2018:Post 2:2019:Post 1Post 3'); equal( '{% for year, posts in posts | groupby("date.year") %}' + ':{{ year }}:' + '{% for post in posts %}' + '{{ post.title }}' + '{% endfor %}' + '{% endfor %}', { posts: [ { date: { year: 2019 }, title: 'Post 1' }, { date: { year: 2018 }, title: 'Post 2' }, { meta: { month: 2 }, title: 'Post 3' } ] }, ':2018:Post 2:2019:Post 1:undefined:Post 3'); equal( '{% for type, items in items | groupby({}) %}' + ':{{ type }}:' + '{% for item in items %}' + '{{ item.name }}' + '{% endfor %}' + '{% endfor %}', namesContext, ':undefined:jamesjohnjimjessie' ); const undefinedTemplate = ( '{% for type, items in items | groupby("a.b.c") %}' + ':{{ type }}:' + '{% for item in items %}' + '{{ item.name }}' + '{% endfor %}' + '{% endfor %}' ); equal( undefinedTemplate, namesContext, ':undefined:jamesjohnjimjessie' ); expect(function() { render( undefinedTemplate, namesContext, { throwOnUndefined: true } ); }).to.throwError(/groupby: attribute "a\.b\.c" resolved to undefined/); finish(done); }); it('indent', function(done) { equal('{{ "one\ntwo\nthree" | indent }}', 'one\n two\n three'); equal('{{ "one\ntwo\nthree" | indent(2) }}', 'one\n two\n three'); equal('{{ "one\ntwo\nthree" | indent(2, true) }}', ' one\n two\n three'); equal('{{ str | indent }}', { str: r.markSafe('one\ntwo\nthree') }, 'one\n two\n three'); equal('{{ "" | indent }}', ''); equal('{{ undefined | indent }}', ''); equal('{{ undefined | indent(2) }}', ''); equal('{{ undefined | indent(2, true) }}', ''); equal('{{ null | indent }}', ''); equal('{{ null | indent(2) }}', ''); equal('{{ null | indent(2, true) }}', ''); equal('{{ nothing | indent }}', ''); equal('{{ nothing | indent(2) }}', ''); equal('{{ nothing | indent(2, true) }}', ''); finish(done); }); it('join', function(done) { equal('{{ items | join }}', { items: [1, 2, 3] }, '123'); equal('{{ items | join(",") }}', { items: ['foo', 'bar', 'bear'] }, 'foo,bar,bear'); equal('{{ items | join(",", "name") }}', { items: [{ name: 'foo' }, { name: 'bar' }, { name: 'bear' }] }, 'foo,bar,bear'); finish(done); }); it('last', function(done) { equal('{{ [1,2,3] | last }}', '3'); finish(done); }); describe('the length filter', function suite() { it('should return length of a list literal', function test() { equal('{{ [1,2,3] | length }}', '3'); }); it('should output 0 for a missing context variable', function test() { equal('{{ blah|length }}', '0'); }); it('should output string length for string variables', function test() { equal('{{ str | length }}', { str: 'blah' }, '4'); }); it('should output string length for a SafeString variable', function test() { equal('{{ str | length }}', { str: r.markSafe('\nbar'); equal('{{ str | nl2br }}', { str: r.markSafe('foo\nbar') }, 'foo
\nbar'); equal('{{ str | nl2br }}', { str: r.markSafe('foo\n\nbar') }, 'foo
\n
\nbar'); equal('{{ "foo\nbar" | nl2br }}', 'foo<br />\nbar'); finish(done); }); it('random', function(done) { var i; for (i = 0; i < 100; i++) { render('{{ [1,2,3,4,5,6,7,8,9] | random }}', function(err, res) { var val = parseInt(res, 10); expect(val).to.be.within(1, 9); }); } finish(done); }); it('reject', function(done) { var context = { numbers: [0, 1, 2, 3, 4, 5] }; equal('{{ numbers | reject("odd") | join }}', context, '024'); equal('{{ numbers | reject("even") | join }}', context, '135'); equal('{{ numbers | reject("divisibleby", 3) | join }}', context, '1245'); equal('{{ numbers | reject() | join }}', context, '0'); finish(done); }); it('rejectattr', function(done) { var foods = [{ tasty: true }, { tasty: false }, { tasty: true }]; equal('{{ foods | rejectattr("tasty") | length }}', { foods: foods }, '1'); finish(done); }); it('select', function(done) { var context = { numbers: [0, 1, 2, 3, 4, 5] }; equal('{{ numbers | select("odd") | join }}', context, '135'); equal('{{ numbers | select("even") | join }}', context, '024'); equal('{{ numbers | select("divisibleby", 3) | join }}', context, '03'); equal('{{ numbers | select() | join }}', context, '12345'); finish(done); }); it('selectattr', function(done) { var foods = [{ tasty: true }, { tasty: false }, { tasty: true }]; equal('{{ foods | selectattr("tasty") | length }}', { foods: foods }, '2'); finish(done); }); it('replace', function(done) { equal('{{ 123456 | replace("4", ".") }}', '123.56'); equal('{{ 123456 | replace("4", ".") }}', '123.56'); equal('{{ 12345.6 | replace("4", ".") }}', '123.5.6'); equal('{{ 12345.6 | replace(4, ".") }}', '123.5.6'); equal('{{ 12345.6 | replace("4", "7") }}', '12375.6'); equal('{{ 12345.6 | replace(4, 7) }}', '12375.6'); equal('{{ 123450.6 | replace(0, 7) }}', '123457.6'); equal('{{ "aaabbbccc" | replace("", ".") }}', '.a.a.a.b.b.b.c.c.c.'); equal('{{ "aaabbbccc" | replace(null, ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace(undefined, ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace({}, ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace(true, ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace(false, ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace(["wrong"], ".") }}', 'aaabbbccc'); equal('{{ "aaabbbccc" | replace("a", "x") }}', 'xxxbbbccc'); equal('{{ "aaabbbccc" | replace("a", "x", 2) }}', 'xxabbbccc'); equal('{{ "aaabbbbbccc" | replace("b", "y", 4) }}', 'aaayyyybccc'); equal('{{ "aaabbbbbccc" | replace("", "") }}', 'aaabbbbbccc'); equal('{{ "aaabbbbbccc" | replace("b", "") }}', 'aaaccc'); equal('{{ "aaabbbbbccc" | replace("b", "", 4) }}', 'aaabccc'); equal('{{ "aaabbbbbccc" | replace("ab", "y", 4) }}', 'aaybbbbccc'); equal('{{ "aaabbbbbccc" | replace("b", "y", 4) }}', 'aaayyyybccc'); equal('{{ "aaabbbbbccc" | replace("d", "y", 4) }}', 'aaabbbbbccc'); equal('{{ "aaabbcccbbb" | replace("b", "y", 4) }}', 'aaayycccyyb'); // Bad initial inputs equal('{{ undefined | replace("b", "y", 4) }}', ''); equal('{{ null | replace("b", "y", 4) }}', ''); equal('{{ {} | replace("b", "y", 4) }}', '[object Object]'); // End up with the object passed out of replace, then toString called on it equal('{{ [] | replace("b", "y", 4) }}', ''); equal('{{ true | replace("rue", "afafasf", 4) }}', 'true'); equal('{{ false | replace("rue", "afafasf", 4) }}', 'false'); // Will result in an infinite loop if unbounded otherwise test will pass equal('{{ "
an \n example link
\nto a webpage
' + '' }, 'an example link to a webpage'); equal('{{ undefined | striptags }}', ''); equal('{{ null | striptags }}', ''); equal('{{ nothing | striptags }}', ''); equal('{{ html | striptags(true) }}', { html: '\n row1\nrow2 \n row3\n
\n\n' +
' HEADER \n\n- \n
- option 1 \n
- option 2 \n