miki-template 1.2.0

package/src/tags/i18n.js

@@ -0,0 +1,230 @@
+/**
+ * i18n template tags: trans, blocktrans, language.
+ */
+const i18n = require('../i18n');
+
+/**
+ * {% trans "translation key" %}
+ * {% trans "Hello, %s!" name %}
+ * Optional context: {% trans context "key" %}
+ */
+class TransNode {
+  constructor(key, args) {
+    this.key = key;
+    this.args = args; // { name: 'userName', ... }
+  }
+
+  render(context) {
+    const params = {};
+    if (this.args) {
+      for (const [k, v] of Object.entries(this.args)) {
+        params[k] = context.get(v);
+      }
+    }
+    // For unquoted keys: if the key is a variable name, resolve it
+    let key = this.key;
+    if (!key.startsWith('"') && !key.startsWith('\'') && !key.includes(' ')) {
+      const resolved = context.get(key);
+      if (typeof resolved === 'string' && resolved.length > 0) {
+        key = resolved;
+      }
+    } else {
+      key = key.slice(1, -1);
+    }
+    return i18n.lookup(key, params);
+  }
+}
+
+class LanguageNode {
+  constructor(lang, body) {
+    this.lang = lang;
+    this.body = body;
+  }
+
+  render(context) {
+    // Strip quotes
+    const lang = this.lang.startsWith('"') || this.lang.startsWith('\'')
+      ? this.lang.slice(1, -1)
+      : (context.get(this.lang) || this.lang);
+    const previous = i18n.getLanguage();
+    i18n.setLanguage(lang);
+    try {
+      return this.body.map(n => n.render(context)).join('');
+    } finally {
+      i18n.setLanguage(previous);
+    }
+  }
+}
+
+/**
+ * {% blocktrans %}...{% endblocktrans %}
+ * Supports {% with name=value %}, {% plural count %}, {% endblocktrans %}
+ * Inner text may contain {% with %} and {% plural %} tags.
+ */
+class BlockTransNode {
+  constructor(textParts, withMappings, pluralMappings, body) {
+    // textParts: array of raw string segments between variable interpolations
+    // e.g. "Hello, " + [name] + "!"  => ['Hello, ', { type: 'var', name: 'name' }, '!']
+    this.textParts = textParts;
+    this.withMappings = withMappings || [];
+    this.pluralMappings = pluralMappings || [];
+    this.body = body; // for nested tags (unused currently)
+  }
+
+  render(context) {
+    // 1. Apply {% with %} mappings to a local scope
+    const localParams = {};
+    for (const m of this.withMappings) {
+      localParams[m.name] = context.get(m.valPath);
+    }
+    // 2. Apply {% plural count %} mappings
+    for (const m of this.pluralMappings) {
+      localParams[m.name] = context.get(m.valPath);
+    }
+
+    // 3. Reassemble the full text
+    let fullText = '';
+    for (const part of this.textParts) {
+      if (typeof part === 'string') {
+        fullText += part;
+      } else if (part.type === 'var') {
+        const val = localParams[part.name] !== undefined
+          ? localParams[part.name]
+          : context.get(part.name);
+        fullText += String(val);
+      }
+    }
+
+    // 4. Look up translation
+    const count = Object.values(localParams).find(v => typeof v === 'number');
+    return i18n.lookup(fullText, localParams, count);
+  }
+}
+
+// --- Parsers ---
+
+function parseTrans(tagContent, _parser) {
+  // {% trans "key" %}
+  // {% trans "Hello %s" name=user.name %}
+  // {% trans context "key" %}
+  const trimmed = tagContent.slice(5).trim(); // strip "trans"
+  const tokens = trimmed.match(/(?:"[^"]*"|'[^']*'|\S+)/g) || [];
+
+  let keyIdx = 0;
+  if (tokens[0] && tokens[0] === 'context') {
+    keyIdx = 2;
+  }
+  const key = tokens[keyIdx] || '';
+  const args = {};
+  for (let i = keyIdx + 1; i < tokens.length; i++) {
+    const eq = tokens[i].indexOf('=');
+    if (eq > 0) {
+      const name = tokens[i].slice(0, eq);
+      let val = tokens[i].slice(eq + 1);
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith('\'') && val.endsWith('\''))) {
+        val = val.slice(1, -1);
+      }
+      args[name] = val;
+    }
+  }
+  return new TransNode(key, Object.keys(args).length ? args : null);
+}
+
+function parseLanguage(tagContent, parser) {
+  const lang = tagContent.slice(9).trim(); // strip "language"
+  const body = parser.parse(['endlanguage']);
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endlanguage') {
+    parser.advance();
+  }
+  return new LanguageNode(lang, body);
+}
+
+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:
+  return new BlockTransNode(
+    extractTextAndVars(body),
+    extractWithMappings(body),
+    extractPluralMappings(body),
+    body
+  );
+}
+
+/** Extract raw text + {% with %}-bound variable references from a body. */
+function extractTextAndVars(body) {
+  const parts = [];
+  for (const node of body) {
+    if (node.constructor.name === 'TextNode') {
+      parts.push(node.content);
+    } else if (node.constructor.name === 'VariableNode') {
+      // Top-level var: bind it to the parsed varPath so it can be filled
+      parts.push({ type: 'var', name: node.varPath });
+    } else {
+      parts.push('');
+    }
+  }
+  return parts;
+}
+
+function extractWithMappings(body) {
+  const mappings = [];
+  for (const node of body) {
+    if (node.constructor.name === 'WithNode' && node.mappings) {
+      for (const m of node.mappings) {
+        mappings.push({ name: m.name, valPath: m.valPath });
+      }
+    }
+  }
+  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;
+    this.valPath = valPath;
+  }
+  render() { return ''; }
+}
+
+function parsePlural(tagContent, _parser) {
+  // {% plural count %}
+  const rest = tagContent.slice(6).trim();
+  const eq = rest.indexOf('=');
+  if (eq > 0) {
+    return new PluralMappingNode(rest.slice(0, eq).trim(), rest.slice(eq + 1).trim());
+  }
+  return new PluralMappingNode('count', rest);
+}
+
+module.exports = {
+  TransNode,
+  LanguageNode,
+  BlockTransNode,
+  PluralMappingNode,
+  parsers: {
+    trans: parseTrans,
+    language: parseLanguage,
+    blocktrans: parseBlockTrans,
+    plural: parsePlural
+  }
+};

package/src/tags/inheritance.js

@@ -0,0 +1,216 @@
+/**
+ * Inheritance template tags: extends, block, include.
+ */
+const fs = require('fs');
+const path = require('path');
+
+// Helper to resolve expression values
+function resolveValue(token, context) {
+  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+    return token.slice(1, -1);
+  }
+  return context.get(token);
+}
+
+class ExtendsNode {
+  constructor(parentTemplateExpr) {
+    this.parentTemplateExpr = parentTemplateExpr;
+  }
+
+  render(context) {
+    const parentName = resolveValue(this.parentTemplateExpr, context);
+    if (!parentName) return '';
+    context.parentTemplate = parentName;
+    return '';
+  }
+}
+
+class BlockNode {
+  constructor(name, body) {
+    this.name = name;
+    this.body = body;
+  }
+
+  render(context) {
+    const blockStack = context.blocks[this.name];
+    if (!blockStack || blockStack.length === 0) {
+      // If block is not overridden, render its default body
+      return this.body.map(n => n.render(context)).join('');
+    }
+
+    if (!context.blockRenderIndices) {
+      context.blockRenderIndices = {};
+    }
+
+    const currentIndex = context.blockRenderIndices[this.name] !== undefined 
+      ? context.blockRenderIndices[this.name] 
+      : -1;
+
+    if (currentIndex === -1) {
+      // Direct rendering entrypoint: start at the child-most block (index 0)
+      context.blockRenderIndices[this.name] = 0;
+      
+      let superVal = '';
+      if (blockStack.length > 1) {
+        context.blockRenderIndices[this.name] = 1;
+        superVal = blockStack[1].render(context);
+      }
+      
+      context.push({ block: { super: superVal } });
+      context.blockRenderIndices[this.name] = 0;
+      const result = blockStack[0].body.map(n => n.render(context)).join('');
+      context.pop();
+      
+      context.blockRenderIndices[this.name] = -1;
+      return result;
+    } else {
+      // Rendering a parent/super block in the inheritance stack
+      const nextIndex = currentIndex + 1;
+      let superVal = '';
+      if (nextIndex < blockStack.length) {
+        context.blockRenderIndices[this.name] = nextIndex;
+        superVal = blockStack[nextIndex].render(context);
+      }
+      
+      context.push({ block: { super: superVal } });
+      context.blockRenderIndices[this.name] = currentIndex;
+      const result = blockStack[currentIndex].body.map(n => n.render(context)).join('');
+      context.pop();
+      
+      return result;
+    }
+  }
+}
+
+class IncludeNode {
+  constructor(templateNameExpr, extraMappings) {
+    this.templateNameExpr = templateNameExpr;
+    this.extraMappings = extraMappings; // Array of { name, valPath }
+  }
+
+  render(context) {
+    const templateName = resolveValue(this.templateNameExpr, context);
+    if (!templateName) return '';
+
+    let viewsDirs = ['.'];
+    if (context.options && context.options.settings && context.options.settings.views) {
+      const views = context.options.settings.views;
+      viewsDirs = Array.isArray(views) ? views : [views];
+    } else if (context.options && context.options.views) {
+      const views = context.options.views;
+      viewsDirs = Array.isArray(views) ? views : [views];
+    }
+
+    let fileContent = '';
+    let loaded = false;
+    for (const dir of viewsDirs) {
+      try {
+        const fullPath = path.resolve(dir, templateName);
+        // Security check: ensure the resolved path is within the allowed view directory
+        const relative = path.relative(path.resolve(dir), fullPath);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+          throw new Error(`Include tag attempted path traversal outside allowed views: '${templateName}'`);
+        }
+        fileContent = fs.readFileSync(fullPath, 'utf8');
+        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
+      }
+    }
+
+    if (!loaded) {
+      throw new Error(`Template not found: '${templateName}' in directories ${JSON.stringify(viewsDirs)}`);
+    }
+
+    // Parse and tokenize dynamically (uses lazy imports to break loops)
+    const { tokenize } = require('../lexer');
+    const { Parser } = require('../parser');
+    const { getTagRegistry } = require('./registry');
+
+    const tokens = tokenize(fileContent);
+    const parser = new Parser(tokens, getTagRegistry());
+    const nodes = parser.parse();
+
+    // Set up include scope
+    if (this.extraMappings && this.extraMappings.length > 0) {
+      const extraScope = {};
+      for (const mapping of this.extraMappings) {
+        extraScope[mapping.name] = resolveValue(mapping.valPath, context);
+      }
+      context.push(extraScope);
+      const res = nodes.map(n => n.render(context)).join('');
+      context.pop();
+      return res;
+    }
+
+    return nodes.map(n => n.render(context)).join('');
+  }
+}
+
+// --- Tag Registry Parsers ---
+
+// --- Tag Registry Parsers ---
+
+function parseExtends(tagContent, _parser) {
+  // tagContent: "extends 'base.html'"
+  const parentTemplateExpr = tagContent.slice(8).trim();
+  return new ExtendsNode(parentTemplateExpr);
+}
+
+function parseBlock(tagContent, parser) {
+  // tagContent: "block content"
+  const name = tagContent.slice(6).trim();
+  const body = parser.parse(['endblock']);
+  
+  const next = parser.peek();
+  if (next && next.type === 'block' && next.content.split(/\s+/)[0] === 'endblock') {
+    parser.advance(); // Consume endblock
+  }
+
+  const blockNode = new BlockNode(name, body);
+
+  // Register the block stack on the parser so we track overriding chain
+  parser.blocks = parser.blocks || {};
+  if (!parser.blocks[name]) {
+    parser.blocks[name] = [];
+  }
+  parser.blocks[name].push(blockNode);
+
+  return blockNode;
+}
+
+function parseInclude(tagContent, _parser) {
+  // tagContent: "include 'header.html'" or "include 'header.html' with val1=var1"
+  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] });
+    }
+  }
+
+  return new IncludeNode(templateNameExpr, extraMappings);
+}
+
+module.exports = {
+  ExtendsNode,
+  BlockNode,
+  IncludeNode,
+  parsers: {
+    extends: parseExtends,
+    block: parseBlock,
+    include: parseInclude
+  }
+};

package/src/tags/registry.js

@@ -0,0 +1,18 @@
+/**
+ * Central tag registry for template tags.
+ */
+
+const tagRegistry = {};
+
+function registerTag(name, parserFn) {
+  tagRegistry[name] = parserFn;
+}
+
+function getTagRegistry() {
+  return tagRegistry;
+}
+
+module.exports = {
+  registerTag,
+  getTagRegistry
+};