@rhinostone/swig-jinja2 2.5.0

package/lib/tags/include.js

@@ -0,0 +1,154 @@
+/*!
+ * Jinja2 `{% include %}` tag.
+ *
+ * Jinja2 include syntax:
+ *
+ *   {% include "partial.html" %}
+ *   {% include "partial.html" with context %}      (the default)
+ *   {% include "partial.html" without context %}
+ *   {% include "partial.html" ignore missing %}
+ *   {% include "partial.html" ignore missing without context %}
+ *   {% include dynamicPath %}
+ *
+ * Path is lowered through `parser.parseExpr`, so STRING literals, VAR
+ * references, member access, inline-ifs, and any other Jinja2 expression
+ * all route through the same path.
+ *
+ * Three keyword markers are recognised via a depth-tracked scan over the
+ * lexed token stream, each a two-token VAR sequence at top-level depth:
+ * `with context`, `without context`, `ignore missing`. The default is
+ * `with context` — the included template sees the caller's locals. Unlike
+ * Twig, Jinja2's include has no explicit `with {dict}` context object;
+ * `without context` is lowered to an empty-object context so the backend's
+ * `Include` selector passes `{}` instead of `_ctx`.
+ *
+ * The tag emits an `IRInclude` node. The backend's `Include` branch owns
+ * the `_swig.compileFile(...)` + `resolveFrom` plumbing and the optional
+ * `try { ... } catch {}` wrapper that collapses missing-file errors to the
+ * empty string when `ignoreMissing` is set.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+var lexer = require('../lexer');
+
+exports.ends = false;
+exports.block = false;
+
+/**
+ * Strip WHITESPACE tokens from both ends of a slice range.
+ *
+ * @param  {object[]} tokens Token stream.
+ * @param  {number}   start  Inclusive start index.
+ * @param  {number}   end    Exclusive end index.
+ * @param  {object}   types  Lexer token-type enum.
+ * @return {object[]}        Trimmed slice.
+ * @private
+ */
+function sliceTrim(tokens, start, end, types) {
+  while (start < end && tokens[start].type === types.WHITESPACE) { start += 1; }
+  while (end > start && tokens[end - 1].type === types.WHITESPACE) { end -= 1; }
+  return tokens.slice(start, end);
+}
+
+/**
+ * Parse the `{% include %}` tag body — the path expression plus the
+ * optional `with context` / `without context` / `ignore missing` markers.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Jinja2 parser module (exposes `parseExpr`).
+ * @param  {object} types  Jinja2 lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — include has no body).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused — backend owns load).
+ * @param  {object} token  In-progress TagToken. `token.irExpr` gets the
+ *                         IRInclude node.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+
+  var depth = 0;
+  var keywordIdx = -1;
+  var withContext = false;
+  var withoutContext = false;
+  var ignoreMissing = false;
+  var i, tk, nextVar;
+
+  function nextVarAfter(idx) {
+    var j = idx + 1;
+    while (j < tokens.length && tokens[j].type === types.WHITESPACE) { j += 1; }
+    return j < tokens.length ? tokens[j] : null;
+  }
+  function markKeyword(idx) {
+    if (keywordIdx === -1) { keywordIdx = idx; }
+  }
+
+  for (i = 0; i < tokens.length; i += 1) {
+    tk = tokens[i];
+    if (tk.type === types.PARENOPEN || tk.type === types.BRACKETOPEN ||
+        tk.type === types.CURLYOPEN || tk.type === types.FUNCTION) {
+      depth += 1;
+      continue;
+    }
+    if (tk.type === types.PARENCLOSE || tk.type === types.BRACKETCLOSE ||
+        tk.type === types.CURLYCLOSE) {
+      depth -= 1;
+      continue;
+    }
+    if (depth !== 0 || tk.type !== types.VAR) { continue; }
+
+    if ((tk.match === 'with' || tk.match === 'without') && !withContext && !withoutContext) {
+      nextVar = nextVarAfter(i);
+      if (nextVar && nextVar.type === types.VAR && nextVar.match === 'context') {
+        if (tk.match === 'with') { withContext = true; } else { withoutContext = true; }
+        markKeyword(i);
+      }
+    } else if (tk.match === 'ignore' && !ignoreMissing) {
+      nextVar = nextVarAfter(i);
+      if (nextVar && nextVar.type === types.VAR && nextVar.match === 'missing') {
+        ignoreMissing = true;
+        markKeyword(i);
+      }
+    }
+  }
+
+  var pathEnd = keywordIdx === -1 ? tokens.length : keywordIdx;
+  var pathTokens = sliceTrim(tokens, 0, pathEnd, types);
+  if (!pathTokens.length) {
+    utils.throwError('Expected template path in "include" tag', line, opts.filename);
+  }
+  var pathExpr = parser.parseExpr(pathTokens);
+
+  var resolveFrom = (opts.filename || '').replace(/\\/g, '\\\\');
+
+  // `without context` -> empty-object context + isolated, so the backend's
+  // Include selector emits `{}` rather than `_ctx`. `with context` (and the
+  // default) leave context undefined + isolated false -> the selector emits
+  // `_ctx`. `withContext` is tracked only to mark the path end.
+  var ctxExpr;
+  if (withoutContext) {
+    ctxExpr = ir.objectLiteral([]);
+  }
+
+  token.irExpr = ir.include(pathExpr, ctxExpr, withoutContext, ignoreMissing, resolveFrom);
+  return true;
+};
+
+/**
+ * Return the pre-built IRInclude node. In async codegen mode, derive an
+ * IRIncludeDeferred from the same fields so the backend routes through the
+ * `_swig.getTemplate` + `await` path instead of the sync `_swig.compileFile`
+ * call.
+ *
+ * @return {object} IRInclude or IRIncludeDeferred node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  if (options && options.codegenMode === 'async') {
+    var i = token.irExpr;
+    return ir.includeDeferred(i.path, i.context, i.isolated, i.ignoreMissing, i.resolveFrom);
+  }
+  return token.irExpr;
+};

package/lib/tags/index.js

@@ -0,0 +1,32 @@
+/*!
+ * Jinja2 per-flavor tag registry.
+ *
+ * Each tag exports `{ parse, compile, ends, block }` with a Jinja2-tailored
+ * shape:
+ *
+ *   parse(str, line, parser, types, stack, opts, swig, token) → boolean
+ *
+ * The 8th `token` argument is the in-progress TagToken. Tag implementations
+ * call `parser.parseExpr(lexer.read(str), filters)` directly and attach the
+ * resulting IRExpr to `token.irExpr`, then return true. This avoids the
+ * native-swig `parser.on(types.X, fn)` callback indirection — Jinja2 tags
+ * own their own arg-parsing path.
+ */
+
+module.exports = {
+  'set': require('./set'),
+  'if': require('./if'),
+  'elif': require('./elif'),
+  'else': require('./else'),
+  'for': require('./for'),
+  'block': require('./block'),
+  'extends': require('./extends'),
+  'include': require('./include'),
+  'macro': require('./macro'),
+  'import': require('./import'),
+  'from': require('./from'),
+  'raw': require('./raw'),
+  'filter': require('./filter'),
+  'with': require('./with'),
+  'autoescape': require('./autoescape')
+};

package/lib/tags/macro.js

@@ -0,0 +1,174 @@
+/*!
+ * Jinja2 `{% macro %}` tag.
+ *
+ * Jinja2 macro syntax:
+ *
+ *   {% macro name() %}…{% endmacro %}
+ *   {% macro name(a, b, c) %}…{% endmacro %}
+ *   {% macro name(a, b='x', c=a) %}…{% endmacro %}   (parameter defaults)
+ *
+ * Defines a reusable function bound to `_ctx.<name>`. The backend emits the
+ * full IIFE (`_utils.extend` snapshot, shadow-delete of param names from
+ * `_ctx`, default-application, body, restore) — see backend.js Macro branch.
+ * The tag ships only semantic IR: name, params (`IRMacroParam[]`), body.
+ *
+ * A parameter default is any Jinja2 expression and is lowered via
+ * `parser.parseExpr`. Defaults are applied at the top of the macro body
+ * (before the `_ctx` shadow-delete), so a default may reference an earlier
+ * parameter or an incoming context variable. Keyword-style CALLING
+ * (`foo(a=1)`) is a non-goal.
+ *
+ * Param names and the macro name are bare identifiers — dotted paths
+ * (`foo.bar`) and CVE-2023-25345 prototype-chain names (`__proto__`,
+ * `constructor`, `prototype`) are rejected at parse time. Single-name
+ * binding slots reject any `.` in the match before the `_dangerousProps`
+ * check.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousProps;
+
+var lexer = require('../lexer');
+
+exports.ends = true;
+exports.block = true;
+
+/**
+ * Parse the `{% macro %}` tag body. Extracts the macro name and the
+ * optional comma-separated parameter list (each parameter optionally
+ * carrying a `= <default>` expression). Both name and params are validated
+ * against the bare-identifier rule and the CVE-2023-25345 `_dangerousProps`
+ * blocklist.
+ *
+ * Accepts both shapes:
+ *   `name` + FUNCTION/FUNCTIONEMPTY (idiomatic)
+ *   `name(a, b)` lexed as FUNCTION token whose `match` is the name
+ *
+ * Stashes `[name, IRMacroParam, IRMacroParam, ...]` on `token.args`. Compile
+ * lifts the name off the head and passes the remaining param objects
+ * straight to `ir.macro` — the backend handles the IIFE.
+ *
+ * @param  {string} str    Tag body.
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Jinja2 parser module (exposes `parseExpr`,
+ *                         used to lower parameter defaults).
+ * @param  {object} types  Jinja2 lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — parser.js manages push).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken. `token.args` gets the
+ *                         macro name + IRMacroParam objects.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  var pos = 0;
+
+  function peek() {
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    return pos < tokens.length ? tokens[pos] : null;
+  }
+  function consume() {
+    var t = peek();
+    if (t) { pos += 1; }
+    return t;
+  }
+
+  function checkName(name, role) {
+    if (name.indexOf('.') !== -1) {
+      utils.throwError(role + ' "' + name + '" must be a bare identifier in "macro" tag', line, opts.filename);
+    }
+    if (_dangerousProps.indexOf(name) !== -1) {
+      utils.throwError('Unsafe ' + role.toLowerCase() + ' "' + name + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+  }
+
+  var head = consume();
+  if (!head) {
+    utils.throwError('Expected macro name in "macro" tag', line, opts.filename);
+  }
+
+  var name;
+  var params = [];
+
+  if (head.type === types.FUNCTIONEMPTY) {
+    name = head.match;
+    checkName(name, 'Macro name');
+  } else if (head.type === types.FUNCTION) {
+    name = head.match;
+    checkName(name, 'Macro name');
+    var first = true;
+    while (true) {
+      var tk = peek();
+      if (!tk) {
+        utils.throwError('Unclosed parameter list in "macro" tag', line, opts.filename);
+      }
+      if (tk.type === types.PARENCLOSE) {
+        consume();
+        break;
+      }
+      if (!first) {
+        if (tk.type !== types.COMMA) {
+          utils.throwError('Expected "," between parameters in "macro" tag', line, opts.filename);
+        }
+        consume();
+      }
+      first = false;
+      var pTok = consume();
+      if (!pTok || pTok.type !== types.VAR) {
+        utils.throwError('Expected parameter name in "macro" tag', line, opts.filename);
+      }
+      checkName(pTok.match, 'Parameter');
+      var defaultExpr;
+      if (peek() && peek().type === types.ASSIGNMENT) {
+        if (peek().match !== '=') {
+          utils.throwError('Parameter default must use "=" in "macro" tag', line, opts.filename);
+        }
+        consume();
+        // Parse a single default expression from the cursor. parseExpr stops
+        // at the next COMMA / PARENCLOSE (neither is part of an expression);
+        // the out-param reports how many slice tokens it consumed so the
+        // local cursor can resume at the next parameter.
+        var posOut = {};
+        defaultExpr = parser.parseExpr(tokens.slice(pos), {}, posOut);
+        pos += posOut.pos;
+      }
+      params.push(ir.macroParam(pTok.match, defaultExpr));
+    }
+  } else if (head.type === types.VAR) {
+    name = head.match;
+    checkName(name, 'Macro name');
+  } else {
+    utils.throwError('Expected macro name in "macro" tag', line, opts.filename);
+  }
+
+  if (peek()) {
+    utils.throwError('Unexpected token "' + peek().match + '" after macro signature in "macro" tag', line, opts.filename);
+  }
+
+  token.args = [name].concat(params);
+  return true;
+};
+
+/**
+ * Emit an IRMacro node. The backend's `Macro` branch owns the
+ * `_ctx.<name> = function(...) { … }` IIFE, the `_utils.extend` snapshot,
+ * the default-application lines, and the shadow-delete of param names from
+ * `_ctx`.
+ *
+ * @param  {Function} compiler   Backend walker (recurses into `content`).
+ * @param  {Array}    args       `[name, IRMacroParam, ...]`.
+ * @param  {Array}    content    Child tokens between `{% macro %}` and
+ *                               `{% endmacro %}`.
+ * @param  {Array}    parents    Parent template chain (passed through).
+ * @param  {object}   options    Compile options (passed through).
+ * @param  {?string}  blockName  Enclosing block name (passed through).
+ * @return {object}   IRMacro node.
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName) {
+  var name = args[0];
+  var params = args.slice(1);
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.macro(name, params, [ir.legacyJS(bodyJS)]);
+};

package/lib/tags/raw.js

@@ -0,0 +1,51 @@
+/*!
+ * Jinja2 `{% raw %}…{% endraw %}` tag.
+ *
+ * Preserves arbitrary template-like content as literal output. Inside a
+ * raw block, `{{ … }}`, `{% … %}` (other than `{% endraw %}`), and
+ * `{# … #}` are NOT parsed — the splitter in `parser.js` flips an `inRaw`
+ * flag that bypasses the variable/tag/comment branches and wraps each
+ * chunk as `ir.text`, so the content array handed to this tag's compile
+ * is already a list of IRText nodes.
+ *
+ * Takes no arguments. Extra tokens after `raw` are rejected at parse time
+ * with a filename-aware throw.
+ */
+
+var utils = require('@rhinostone/swig-core/lib/utils');
+
+/**
+ * Reject any tokens after the `raw` keyword. The splitter owns all
+ * content-capture behaviour via its `inRaw` flag, so this handler only
+ * has to validate the tag's own argument list (which must be empty).
+ *
+ * @param  {string} str    Tag body (everything after `raw`).
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Jinja2 parser module (unused).
+ * @param  {object} types  Jinja2 lexer token-type enum (unused).
+ * @param  {Array}  stack  Open-tag stack (parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename`).
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts) {
+  var stripped = utils.strip(str || '');
+  if (stripped.length > 0) {
+    utils.throwError('Unexpected token "' + stripped + '" after "raw"', line, opts.filename);
+  }
+  return true;
+};
+
+/**
+ * Return the captured content array unchanged. Each item is already an
+ * IRText node (or another pre-built IR node that the backend will splice
+ * through), so the backend's emit loop can iterate and emit without any
+ * further wrapping.
+ *
+ * @return {Array} Content node list.
+ */
+exports.compile = function (compiler, args, content) {
+  return content;
+};
+
+exports.ends = true;
+exports.block = false;

package/lib/tags/set.js

@@ -0,0 +1,164 @@
+/*!
+ * Jinja2 `{% set %}` tag (assignment + body-capture forms).
+ *
+ * Jinja2 `set` has two forms:
+ *
+ *   Inline:  {% set <lhs> <op> <rhs> %}
+ *   Body:    {% set <lhs> %}…{% endset %}
+ *
+ *   lhs — a bare identifier or a pure-dot path (`foo`, `foo.bar.baz`).
+ *         Bracket LHS (`foo[bar]`) is rejected at parse time — the
+ *         bracket-lvalue contract is a cross-flavor design call and is
+ *         deferred.
+ *   op  — any valid JS assignment operator (`=`, `+=`, `-=`, `*=`, `/=`).
+ *         Inline form only.
+ *   rhs — any Jinja2 expression; parsed via `parser.parseExpr`.
+ *         Inline form only.
+ *
+ * Inline form emits an IRSet node on `token.irExpr`:
+ *
+ *   ir.set(ir.varRef(['foo', 'bar']), '=', <IRExpr value>)
+ *
+ * Body form captures the rendered content as a string via an IIFE and
+ * assigns it to the target. No dedicated IR factory — emits an IRLegacyJS
+ * fragment because the capture is a JS plumbing shape (IIFE over `_output`)
+ * that doesn't need its own IR surface.
+ *
+ * Static `exports.ends = true` is the default so the token's `ends` slot
+ * starts truthy — the body form keeps it, the inline form flips
+ * `token.ends = false` at parse time so the splitter does NOT push the
+ * inline-form token onto the open-tag stack.
+ *
+ * CVE-2023-25345 checkpoints apply twice — here on the LHS path segments,
+ * and again in the backend `checkDangerousSegment` walk — intentional
+ * defense-in-depth.
+ */
+
+var ir = require('@rhinostone/swig-core/lib/ir');
+var utils = require('@rhinostone/swig-core/lib/utils');
+var _dangerousProps = require('@rhinostone/swig-core/lib/security').dangerousProps;
+
+var lexer = require('../lexer');
+
+exports.ends = true;
+exports.block = true;
+
+/**
+ * Parse the `{% set %}` tag body and attach the appropriate IR to the
+ * token. Inline form sets `token.irExpr` and flips `token.ends = false`;
+ * body form leaves `token.ends = true` and stashes the target path on
+ * `token.args` for the compile step to pick up.
+ *
+ * @param  {string} str    Tag body (everything between `{%` and `%}`, tag name stripped).
+ * @param  {number} line   Source line of the opening `{%`.
+ * @param  {object} parser The Jinja2 parser module (exposes `parseExpr`).
+ * @param  {object} types  Jinja2 lexer token-type enum.
+ * @param  {Array}  stack  Open-tag stack (unused — parser.js manages the push).
+ * @param  {object} opts   Per-call options (honors `opts.filename` for filename-aware throws).
+ * @param  {object} swig   Swig instance (unused).
+ * @param  {object} token  In-progress TagToken.
+ * @return {boolean}       Always `true` on success. Throws otherwise.
+ */
+exports.parse = function (str, line, parser, types, stack, opts, swig, token) {
+  var tokens = lexer.read(utils.strip(str));
+  var pos = 0;
+
+  function peek() {
+    while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+    return pos < tokens.length ? tokens[pos] : null;
+  }
+  function consume() {
+    var t = peek();
+    if (t) { pos += 1; }
+    return t;
+  }
+
+  var lhsTok = consume();
+  if (!lhsTok || lhsTok.type !== types.VAR) {
+    utils.throwError('Expected variable name in "set" tag', line, opts.filename);
+  }
+
+  var path = lhsTok.match.split('.');
+  utils.each(path, function (segment) {
+    if (_dangerousProps.indexOf(segment) !== -1) {
+      utils.throwError('Unsafe assignment to "' + segment + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+  });
+
+  // DOTKEY tail — the Jinja2 lexer already folds dotted paths into the VAR
+  // match, but a defensive DOTKEY consumer here keeps this tag robust if a
+  // future lexer tightening splits `foo.bar` into VAR + DOTKEY.
+  while (peek() && peek().type === types.DOTKEY) {
+    var dk = consume();
+    if (_dangerousProps.indexOf(dk.match) !== -1) {
+      utils.throwError('Unsafe assignment to "' + dk.match + '" is not allowed (CVE-2023-25345)', line, opts.filename);
+    }
+    path.push(dk.match);
+  }
+
+  var next = peek();
+  if (next && next.type === types.BRACKETOPEN) {
+    utils.throwError('Bracket-notation assignment is not supported in "set" (use dot-path notation)', line, opts.filename);
+  }
+
+  if (!next) {
+    // Body-capture form — no more tokens after the LHS. Keep
+    // `token.ends = true` (the default) so the splitter pushes the token
+    // onto the open-tag stack and waits for a matching `{% endset %}`.
+    // Stash the path on `token.args` for the compile handler.
+    token.args = path;
+    return true;
+  }
+
+  // Inline form — flip `token.ends = false` so the splitter does NOT push
+  // the token onto the open-tag stack.
+  token.ends = false;
+
+  var opTok = consume();
+  if (opTok.type !== types.ASSIGNMENT) {
+    utils.throwError('Expected assignment operator in "set" tag', line, opts.filename);
+  }
+
+  while (pos < tokens.length && tokens[pos].type === types.WHITESPACE) { pos += 1; }
+
+  var rhsTokens = tokens.slice(pos);
+  if (!rhsTokens.length) {
+    utils.throwError('Expected expression after assignment in "set" tag', line, opts.filename);
+  }
+
+  var value = parser.parseExpr(rhsTokens);
+  token.irExpr = ir.set(ir.varRef(path), opTok.match, value);
+  return true;
+};
+
+/**
+ * Emit the IR for either the inline-assignment or body-capture form.
+ * Inline form returns the pre-built IRSet via `token.irExpr`. Body form
+ * compiles the captured content and wraps it in an IIFE assigned to the
+ * target.
+ *
+ * @param  {Function} compiler   Backend walker (recurses into `content`).
+ * @param  {Array}    args       Target path segments (body form only).
+ * @param  {Array}    content    Child tokens captured between `{% set %}`
+ *                               and `{% endset %}` (body form only).
+ * @param  {Array}    parents    Parent template chain (passed through).
+ * @param  {object}   options    Compile options (passed through).
+ * @param  {?string}  blockName  Enclosing block name (passed through).
+ * @param  {object}   token      The tag token. `token.irExpr` is set for
+ *                               inline form only.
+ * @return {object}   IRSet (inline) or IRLegacyJS (body).
+ */
+exports.compile = function (compiler, args, content, parents, options, blockName, token) {
+  if (token.irExpr) {
+    return token.irExpr;
+  }
+  var path = args;
+  var bodyJS = compiler(content, parents, options, blockName);
+  return ir.legacyJS(
+    '_ctx.' + path.join('.') + ' = (function () {\n' +
+    '  var _output = "";\n' +
+    bodyJS +
+    '  return _output;\n' +
+    '})();\n'
+  );
+};