miki-template 1.2.0 → 1.3.3

package/src/tags/extra.js

@@ -0,0 +1,154 @@
+/**
+ * Additional utility template tags: now, set, ifchanged.
+ */
+
+// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
+function resolveValue(token, context) {
+  if (token === undefined || token === null) return '';
+  if (typeof token !== 'string') return token;
+  if (token === '') return '';
+  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+    return token.slice(1, -1);
+  }
+  if (token === 'true' || token === 'True') return true;
+  if (token === 'false' || token === 'False') return false;
+  if (token === 'none' || token === 'None' || token === 'null') return null;
+  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
+  return context.get(token);
+}
+
+// --- {% now %} tag ---
+
+class NowNode {
+  constructor(formatExpr) {
+    this.formatExpr = formatExpr;
+  }
+
+  render(context) {
+    const fmt = resolveValue(this.formatExpr, context);
+    const now = new Date();
+    if (!fmt) return now.toISOString();
+    const dateFilter = require('../filters');
+    return dateFilter.getFilter('date')(now, fmt);
+  }
+}
+
+function parseNow(tagContent, _parser) {
+  const fmt = tagContent.slice(3).trim();
+  return new NowNode(fmt || '"Y-m-d H:i:s"');
+}
+
+// --- {% set %} tag ---
+
+class SetNode {
+  constructor(nameExpr, valueExpr, body) {
+    this.nameExpr = nameExpr;
+    this.valueExpr = valueExpr;
+    this.body = body || [];
+  }
+
+  render(context) {
+    const name = String(this.nameExpr);
+    const value = this.valueExpr !== undefined ? resolveValue(this.valueExpr, context) : '';
+    if (name) {
+      context.scopes[0][name] = value;
+    }
+    return this.body.map(n => n.render(context)).join('');
+  }
+}
+
+function parseSet(tagContent, parser) {
+  // {% set var = expr %}
+  // {% set var %}...{% endset %}
+  const trimmed = tagContent.slice(3).trim();
+
+  // Block form: {% set var %}...{% endset %}
+  if (!trimmed.includes('=')) {
+    const varName = trimmed.trim();
+    const body = parser.parse(['endset']);
+    const next = parser.peek();
+    if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endset') {
+      parser.advance();
+    }
+    return new SetNode(varName, undefined, body);
+  }
+
+  // Inline form: {% set var = expr %}
+  const eqIdx = trimmed.indexOf('=');
+  const nameExpr = trimmed.slice(0, eqIdx).trim();
+  const valueExpr = trimmed.slice(eqIdx + 1).trim();
+  return new SetNode(nameExpr, valueExpr, []);
+}
+
+// --- {% ifchanged %} tag ---
+
+class IfChangedNode {
+  constructor(conditionStr, body, elseBody) {
+    this.conditionStr = conditionStr;
+    this.body = body;
+    this.elseBody = elseBody;
+  }
+
+  render(context) {
+    const currentVal = this.conditionStr ? resolveValue(this.conditionStr, context) : undefined;
+
+    if (!context.ifChangedState) {
+      context.ifChangedState = new Map();
+    }
+
+    const lastVal = context.ifChangedState.get(this.conditionStr);
+
+    let changed = false;
+    if (lastVal === undefined) {
+      changed = true;
+    } else if (currentVal !== lastVal) {
+      changed = true;
+    }
+
+    if (changed) {
+      context.ifChangedState.set(this.conditionStr, currentVal);
+      return this.body.map(n => n.render(context)).join('');
+    }
+
+    if (this.elseBody) {
+      return this.elseBody.map(n => n.render(context)).join('');
+    }
+
+    return '';
+  }
+}
+
+function parseIfChanged(tagContent, parser) {
+  // {% ifchanged [value] %}
+  const conditionStr = tagContent.slice(9).trim();
+  const body = parser.parse(['else', 'endifchanged']);
+  let elseBody = null;
+
+  while (true) {
+    const next = parser.peek();
+    if (!next || next.type !== 'block') break;
+    const tagName = next.content.split(/\s+/)[0];
+    if (tagName === 'else') {
+      parser.advance();
+      elseBody = parser.parse(['endifchanged']);
+    } else if (tagName === 'endifchanged') {
+      parser.advance();
+      break;
+    } else {
+      break;
+    }
+  }
+
+  return new IfChangedNode(conditionStr, body, elseBody);
+}
+
+module.exports = {
+  NowNode,
+  SetNode,
+  IfChangedNode,
+  parsers: {
+    now: parseNow,
+    set: parseSet,
+    ifchanged: parseIfChanged
+  }
+};

package/src/tags/i18n.js

@@ -141,19 +141,57 @@ function parseLanguage(tagContent, parser) {
 }
 
 function parseBlockTrans(tagContent, parser) {
-  // Collect body until {% endblocktrans %}
-  const body = parser.parse(['blocktrans_internal_marker']); // placeholder
-  // Actually we need a different approach: scan raw body and parse it ourselves
-  // because blocktrans parses its own text content as a template.
-  // We'll rewind and use the lexer on the body tokens.
-  // For simplicity here, we re-parse the entire slice as a mini-template.
-  // The body tokens between {% blocktrans %} and {% endblocktrans %} are still
-  // available because parseUntil was called.
-  // For now, treat the body as a list of nodes that we'll re-render:
+  // Collect body until {% endblocktrans %}. The parser will stop at the
+  // first matching end tag it encounters in its untilTags list.
+  const body = parser.parse(['endblocktrans']);
+  // Consume the endblocktrans token if it's still pending.
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endblocktrans') {
+    parser.advance();
+  }
+
+  // Parse `with name=value` and `count` from the blocktrans tag content.
+  // Format: {% blocktrans with name1=var1 name2=var2 count n %}...{% endblocktrans %}
+  const withMappings = [];
+  const pluralMappings = [];
+  const afterTrans = tagContent.replace(/^blocktrans\s*/, '').trim();
+  // Split on "with" / "count" boundaries, keeping the keywords
+  const tokens = afterTrans.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+  let i = 0;
+  // Skip any leading context (e.g. "context")
+  if (tokens[i] === 'context') i += 2;
+  // Check for `with` or `count` after the main text
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (tok === 'with') {
+      i++;
+      // Read name=var pairs until we hit end or another keyword
+      while (i < tokens.length && tokens[i].indexOf('=') > 0) {
+        const pair = tokens[i];
+        const eq = pair.indexOf('=');
+        const name = pair.slice(0, eq);
+        let val = pair.slice(eq + 1);
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+          val = val.slice(1, -1);
+        }
+        withMappings.push({ name, valPath: val });
+        i++;
+      }
+    } else if (tok === 'count') {
+      i++;
+      // Next token is the count variable
+      if (i < tokens.length) {
+        pluralMappings.push({ name: 'count', valPath: tokens[i++] });
+      }
+    } else {
+      i++;
+    }
+  }
+
   return new BlockTransNode(
     extractTextAndVars(body),
-    extractWithMappings(body),
-    extractPluralMappings(body),
+    withMappings.length ? withMappings : extractWithMappings(body),
+    pluralMappings,
     body
   );
 }
@@ -186,18 +224,6 @@ function extractWithMappings(body) {
   return mappings;
 }
 
-function extractPluralMappings(body) {
-  // Look for a custom PluralNode (we mark it via a special tag)
-  // For now, treat WithNodes that have a count attribute as plural mappings.
-  const mappings = [];
-  for (const node of body) {
-    if (node.constructor.name === 'PluralMappingNode') {
-      mappings.push({ name: node.name, valPath: node.valPath });
-    }
-  }
-  return mappings;
-}
-
 class PluralMappingNode {
   constructor(name, valPath) {
     this.name = name;

package/src/tags/inheritance.js

@@ -3,12 +3,20 @@
  */
 const fs = require('fs');
 const path = require('path');
+const { Context } = require('../context');
 
-// Helper to resolve expression values
+// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
 function resolveValue(token, context) {
+  if (token === undefined || token === null) return '';
+  if (typeof token !== 'string') return token;
+  if (token === '') return '';
   if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
     return token.slice(1, -1);
   }
+  if (token === 'true' || token === 'True') return true;
+  if (token === 'false' || token === 'False') return false;
+  if (token === 'none' || token === 'None' || token === 'null') return null;
+  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
   return context.get(token);
 }
 
@@ -83,14 +91,25 @@ class BlockNode {
 }
 
 class IncludeNode {
-  constructor(templateNameExpr, extraMappings) {
+  constructor(templateNameExpr, extraMappings, partialName = null) {
     this.templateNameExpr = templateNameExpr;
     this.extraMappings = extraMappings; // Array of { name, valPath }
+    this.partialName = partialName;     // When set, render only this partial
   }
 
   render(context) {
-    const templateName = resolveValue(this.templateNameExpr, context);
-    if (!templateName) return '';
+    const rawName = resolveValue(this.templateNameExpr, context);
+    if (!rawName) return '';
+
+    // Django-style partial selector: "home.html#card" means render
+    // only the `card` partial defined inside `home.html`.
+    let templateName = rawName;
+    let partialName = this.partialName;
+    const hashIdx = rawName.indexOf('#');
+    if (hashIdx >= 0) {
+      templateName = rawName.slice(0, hashIdx);
+      partialName = rawName.slice(hashIdx + 1);
+    }
 
     let viewsDirs = ['.'];
     if (context.options && context.options.settings && context.options.settings.views) {
@@ -115,11 +134,9 @@ class IncludeNode {
         loaded = true;
         break;
       } catch (e) {
-        // Propagate traversal errors, otherwise try next directory
         if (e.message && e.message.startsWith('Include tag attempted path traversal')) {
           throw e;
         }
-        // continue searching other directories
       }
     }
 
@@ -127,7 +144,9 @@ class IncludeNode {
       throw new Error(`Template not found: '${templateName}' in directories ${JSON.stringify(viewsDirs)}`);
     }
 
-    // Parse and tokenize dynamically (uses lazy imports to break loops)
+    // Parse the included file. We use the same lexer/parser/registry
+    // as the outer compile, which means {% load %}, custom tags, and
+    // all partialdefs are registered when we parse the file.
     const { tokenize } = require('../lexer');
     const { Parser } = require('../parser');
     const { getTagRegistry } = require('./registry');
@@ -136,7 +155,46 @@ class IncludeNode {
     const parser = new Parser(tokens, getTagRegistry());
     const nodes = parser.parse();
 
-    // Set up include scope
+    // If a partial selector was specified, compile the file so its
+    // partialdefs register themselves, then render only the named
+    // partial using the current context.
+    if (partialName) {
+      // Use a fresh context so partials from the included file do NOT
+      // leak into the caller's partial registry. Only the requested
+      // partial is rendered, and it can reference other partials from
+      // the same included file via the temp context's registry.
+      const tempContext = new Context({}, context.options || {});
+      nodes.map(n => n.render(tempContext));
+      const partial = tempContext.getPartial(partialName);
+      if (!partial) {
+        throw new Error(`Partial '${partialName}' not found in template '${templateName}'`);
+      }
+      // Build a render context that carries the caller's state but
+      // only the included file's partial definitions.
+      const renderCtx = new Context({}, context.options || {});
+      renderCtx.scopes = context.scopes.slice();
+      renderCtx.blocks = context.blocks;
+      renderCtx.cycleStates = context.cycleStates;
+      renderCtx.autoescape = context.autoescape;
+      renderCtx.parentTemplate = context.parentTemplate;
+      renderCtx.blockRenderIndices = context.blockRenderIndices;
+      renderCtx.partialDefs = tempContext.partialDefs;
+      // Apply include's `with` extra mappings on top of caller's ctx
+      if (this.extraMappings && this.extraMappings.length > 0) {
+        const extraScope = {};
+        for (const m of this.extraMappings) {
+          extraScope[m.name] = resolveValue(m.valPath, context);
+        }
+        renderCtx.push(extraScope);
+        const out = partial.body.map(n => n.render(renderCtx)).join('');
+        renderCtx.pop();
+        return out;
+      }
+      return partial.body.map(n => n.render(renderCtx)).join('');
+    }
+
+    // Plain include (no partial selector): render the included body
+    // inside the caller's context, applying any `with` extra mappings.
     if (this.extraMappings && this.extraMappings.length > 0) {
       const extraScope = {};
       for (const mapping of this.extraMappings) {
@@ -152,9 +210,16 @@ class IncludeNode {
   }
 }
 
-// --- Tag Registry Parsers ---
-
-// --- Tag Registry Parsers ---
+module.exports = {
+  ExtendsNode,
+  BlockNode,
+  IncludeNode,
+  parsers: {
+    extends: parseExtends,
+    block: parseBlock,
+    include: parseInclude
+  }
+};
 
 function parseExtends(tagContent, _parser) {
   // tagContent: "extends 'base.html'"
@@ -185,25 +250,79 @@ function parseBlock(tagContent, parser) {
 }
 
 function parseInclude(tagContent, _parser) {
-  // tagContent: "include 'header.html'" or "include 'header.html' with val1=var1"
+  // tagContent: "include 'header.html'" or
+  //             "include 'header.html' with val1=var1 val2='literal'"
+  //             "include 'header.html#partial_name'"
   const content = tagContent.slice(8).trim();
-  
-  // Extract template expression
-  const parts = content.split(/\s+with\s+/);
-  const templateNameExpr = parts[0].trim();
-  
-  const extraMappings = [];
-  if (parts[1]) {
-    const pairRegex = /(\w+)=([^\s]+)/g;
-    let match;
-    while ((match = pairRegex.exec(parts[1])) !== null) {
-      extraMappings.push({ name: match[1], valPath: match[2] });
+
+  // Extract template expression (may be quoted)
+  const tmplMatch = content.match(/^(".*?"|'.*?'|\S+)/);
+  if (!tmplMatch) {
+    throw new Error('include tag requires a template name');
+  }
+  const templateNameExpr = tmplMatch[1];
+  const rest = content.slice(tmplMatch[0].length).trim();
+
+  // Optional `with k1=v1 k2='v2' k3=v3`
+  let extraMappings = [];
+  if (rest) {
+    const withMatch = rest.match(/^with\s+(.+)$/s);
+    if (withMatch) {
+      extraMappings = parseKeyValuePairs(withMatch[1]);
     }
   }
 
   return new IncludeNode(templateNameExpr, extraMappings);
 }
 
+/**
+ * Parse a whitespace-separated list of `key=value` pairs. Values may be
+ * quoted (single or double quotes) or bare identifiers. The
+ * control.js parseKeyValuePairs handles commas, so prefer that — but
+ * include's `with` historically used a whitespace separator. Support
+ * both for backwards compatibility.
+ */
+function parseKeyValuePairs(str) {
+  const pairs = [];
+  let i = 0;
+  while (i < str.length) {
+    while (i < str.length && /\s/.test(str[i])) i++;
+    if (i >= str.length) break;
+
+    // Read key
+    let key = '';
+    while (i < str.length && /[a-zA-Z0-9_]/.test(str[i])) {
+      key += str[i++];
+    }
+    if (!key) { i++; continue; }
+    while (i < str.length && /\s/.test(str[i])) i++;
+    if (str[i] !== '=') { i++; continue; }
+    i++; // consume '='
+    while (i < str.length && /\s/.test(str[i])) i++;
+
+    let val = '';
+    if (str[i] === '"' || str[i] === '\'') {
+      const quote = str[i++];
+      while (i < str.length && str[i] !== quote) {
+        if (str[i] === '\\' && i + 1 < str.length) i++;
+        val += str[i++];
+      }
+      if (str[i] === quote) i++;
+      // Preserve quotes so resolveValue can recognize the literal
+      val = quote + val + quote;
+    } else {
+      // Unquoted value: read until comma or whitespace
+      while (i < str.length && str[i] !== ',' && !/\s/.test(str[i])) {
+        val += str[i++];
+      }
+      // Consume trailing comma if present
+      if (str[i] === ',') i++;
+    }
+    pairs.push({ name: key, valPath: val });
+  }
+  return pairs;
+}
+
 module.exports = {
   ExtendsNode,
   BlockNode,

package/src/tags/util.js

@@ -2,12 +2,20 @@
  * Utility template tags: static, url, regroup, spaceless.
  */
 
-// Helper to resolve expression values
+// Helper to resolve expression values (literals, numbers, booleans, or context lookups)
 function resolveValue(token, context) {
-  if (!token) return '';
+  if (token === undefined || token === null) return '';
+  if (typeof token !== 'string') return token;
+  if (token === '') return '';
   if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
     return token.slice(1, -1);
   }
+  if (token === 'true' || token === 'True') return true;
+  if (token === 'false' || token === 'False') return false;
+  if (token === 'none' || token === 'None' || token === 'null') return null;
+  // Numeric literal (integer or float)
+  if (/^-?\d+(\.\d+)?$/.test(token)) return Number(token);
+  // Otherwise treat as a context variable lookup
   return context.get(token);
 }
 
@@ -18,7 +26,7 @@ class StaticNode {
 
   render(context) {
     const resolvedPath = resolveValue(this.pathExpr, context);
-    
+
     // Resolve static prefix
     let prefix = '/static/';
     if (context.options && context.options.staticUrl) {
@@ -29,29 +37,59 @@ class StaticNode {
 
     // Ensure double-slash doesn't occur and ends/starts correctly
     const base = prefix.endsWith('/') ? prefix : prefix + '/';
-    const relative = resolvedPath.startsWith('/') ? resolvedPath.slice(1) : resolvedPath;
-    
+    const relative = (typeof resolvedPath === 'string' && resolvedPath.startsWith('/'))
+      ? resolvedPath.slice(1)
+      : String(resolvedPath);
+
     return base + relative;
   }
 }
 
 class UrlNode {
-  constructor(routeNameExpr, argsExprs) {
+  constructor(routeNameExpr, positionalArgs, kwargs) {
     this.routeNameExpr = routeNameExpr;
-    this.argsExprs = argsExprs || [];
+    this.positionalArgs = positionalArgs || [];
+    // Each kwarg is { name, valueExpr } where valueExpr is the raw
+    // expression token (may be a number, a quoted string, or a var).
+    this.kwargs = kwargs || [];
   }
 
   render(context) {
     const routeName = resolveValue(this.routeNameExpr, context);
-    const resolvedArgs = this.argsExprs.map(arg => resolveValue(arg, context));
+    const resolvedPositional = this.positionalArgs.map(arg => resolveValue(arg, context));
+    const resolvedKwargs = {};
+    for (const kw of this.kwargs) {
+      resolvedKwargs[kw.name] = resolveValue(kw.valueExpr, context);
+    }
+    const hasKwargs = Object.keys(resolvedKwargs).length > 0;
 
-    // If an Express urlHelper is provided, use it
+    // If an Express urlHelper is provided, call it. We pass positional
+    // args spread, and (only when kwargs are present) a kwargs object
+    // as the last argument. This keeps the common `{{ url 'r' 42 }}`
+    // case with a `(name, ...args) => string` helper simple.
     if (context.options && typeof context.options.urlHelper === 'function') {
-      return context.options.urlHelper(routeName, ...resolvedArgs);
+      if (hasKwargs) {
+        return context.options.urlHelper(routeName, ...resolvedPositional, resolvedKwargs);
+      }
+      return context.options.urlHelper(routeName, ...resolvedPositional);
     }
 
-    // Fallback URL generator
-    return '/' + [routeName, ...resolvedArgs].filter(Boolean).join('/');
+    // Fallback URL builder: convert dotted route names into deep paths
+    // (e.g. "user.profile.posts.show" -> "/user/profile/posts/show")
+    // and append positional args. Kwargs are appended as query string.
+    const deepPath = String(routeName).split('.').map(seg => seg).join('/');
+    const parts = ['/' + deepPath, ...resolvedPositional
+      .filter(v => v !== '' && v !== null && v !== undefined)
+      .map(v => String(v))];
+    let url = parts.join('/');
+    if (hasKwargs) {
+      const qs = Object.keys(resolvedKwargs)
+        .filter(k => resolvedKwargs[k] !== undefined)
+        .map(k => `${encodeURIComponent(k)}=${encodeURIComponent(String(resolvedKwargs[k]))}`)
+        .join('&');
+      if (qs) url += '?' + qs;
+    }
+    return url;
   }
 }
 
@@ -118,9 +156,14 @@ class SpacelessNode {
 class CsrfTokenNode {
   render(context) {
     const token = context.get('csrf_token') || '';
-    const html = `<input type="hidden" name="csrfmiddlewaretoken" value="${token}">`;
-    const { markSafe } = require('../security');
-    return markSafe(html);
+    // Escape the token for safe interpolation into an HTML attribute.
+    // CSRF tokens are typically alphanumeric, but defending against
+    // malicious or malformed token values is required to prevent
+    // attribute injection (" onerror=... etc).
+    const { escapeHtml, markSafe } = require('../security');
+    return markSafe(
+      `<input type="hidden" name="csrfmiddlewaretoken" value="${escapeHtml(String(token), true)}">`
+    );
   }
 }
 
@@ -128,9 +171,9 @@ class CspNonceAttrNode {
   render(context) {
     const nonce = context.get('csp_nonce') || '';
     if (!nonce) return '';
-    const html = `nonce="${nonce}"`;
-    const { markSafe } = require('../security');
-    return markSafe(html);
+    // Escape the nonce for safe interpolation into an attribute value.
+    const { escapeHtml, markSafe } = require('../security');
+    return markSafe(`nonce="${escapeHtml(String(nonce), true)}"`);
   }
 }
 
@@ -143,17 +186,43 @@ function parseStatic(tagContent, _parser) {
 }
 
 function parseUrl(tagContent, _parser) {
-  // tagContent: "url 'route_name' arg1 arg2"
+  // tagContent examples:
+  //   "url 'route_name' arg1 arg2"
+  //   "url 'route.name' 34"
+  //   "url 'user.show' 34 email phone"
+  //   "url 'user.show' userId=34 tab='posts'"
+  //   "url 'user.show' 34 tab='posts'"
   const content = tagContent.slice(3).trim();
-  
-  // Extract route name and arguments
+
+  // Tokenize respecting quoted strings.
   const argRegex = /(".*?"|'.*?'|[^\s]+)/g;
   const matches = content.match(argRegex) || [];
-  
+
+  if (matches.length === 0) {
+    throw new Error('url tag requires a route name');
+  }
   const routeNameExpr = matches[0];
-  const argsExprs = matches.slice(1);
+  const positionalArgs = [];
+  const kwargs = [];
+
+  for (let i = 1; i < matches.length; i++) {
+    const tok = matches[i];
+    // Detect `key=value` pattern (not a quoted string)
+    const isQuoted = (tok.startsWith('"') && tok.endsWith('"')) ||
+                      (tok.startsWith('\'') && tok.endsWith('\''));
+    if (!isQuoted) {
+      const eq = tok.indexOf('=');
+      if (eq > 0) {
+        const name = tok.slice(0, eq);
+        const valueExpr = tok.slice(eq + 1);
+        kwargs.push({ name, valueExpr });
+        continue;
+      }
+    }
+    positionalArgs.push(tok);
+  }
 
-  return new UrlNode(routeNameExpr, argsExprs);
+  return new UrlNode(routeNameExpr, positionalArgs, kwargs);
 }
 
 function parseRegroup(tagContent, _parser) {
@@ -286,6 +355,15 @@ function parseLoad(tagContent, _parser) {
   if (parts.length === 0) {
     throw new Error('\'load\' tag requires at least one argument');
   }
+  // Pre-activate the library now so any tags it provides are available
+  // to the rest of the parser. The render-time activation in LoadNode
+  // is a no-op if the library is already active.
+  const { activateLibrary, hasLibrary } = require('../libraries');
+  for (const lib of parts) {
+    if (hasLibrary(lib)) {
+      activateLibrary(lib);
+    }
+  }
   return new LoadNode(parts);
 }