Implement {% for %} tag

Author: christophehenry

Cargo.lock

@@ -11,5 +11,5 @@ crate-type = ["cdylib"]
 pyo3 = { version = "0.28.0", features = ["num-bigint"] }
 regex = "1.11.2"
 oxc = { version = "0.98.0", features = ["full"] }
-dtl-lexer = { git = "https://github.com/LilyFirefly/django-rusty-templates", rev = "94bb0a45da6f388ea516ca2e3a7d71825e9b1068" }
+dtl-lexer = { git = "https://github.com/LilyFirefly/django-rusty-templates", rev = "c0a5c0fc66ce7bf3b0ae21cf31b57a20bfee5f5e" }
 num-bigint = "0.4.6"

Cargo.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "django-template-transpiler"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
@@ -18,10 +18,14 @@ python-source = "python"
 
 [tool.pytest.ini_options]
 DJANGO_SETTINGS_MODULE = "tests.settings"
+django_debug_mode = "true"
+addopts = ["--import-mode=importlib"]
+pythonpath = ["tests"]
+
 
 [dependency-groups]
 dev = [
-    "django",
+    "django>6",
     "maturin",
     "pytest",
     "pytest-django",

pyproject.toml

@@ -1,3 +1,9 @@
+/**
+ * @callback RenderFunction
+ * @param {Engine} engine
+ * @param {Context} context
+ */
+
 function todo() {
     throw new Error("Not implemented")
 }
@@ -6,33 +12,37 @@ const None = Symbol.for("None")
 const True = true
 const False = false
 
+const VarNotFound = ""
 
 class Context {
+    #entries = new Map()
+    /** @type {Map<string,any>|Context}*/
+    #parentContext = new Map(Object.entries({None, True, False}))
+
     constructor(dict, parentContext = undefined) {
-        this._entries = new Map(Object.entries(dict))
-
-        this.parentContext = (
-            parentContext instanceof Context
-                ? parentContext
-                : new Proxy(new Map(Object.entries({None, True, False})), {
-                    get(target, prop) {
-                        const value = target.get(prop)
-                        return value !== undefined ? value : ""
-                    }
-                })
-        )
-
-        return new Proxy(this, {
-            get(target, prop) {
-                const value = target._entries.get(prop)
-                return value !== undefined ? value : target.parentContext[prop]
-            }
-        })
+        this.#entries = new Map(Object.entries(dict))
+        if (parentContext instanceof Context) {
+            this.#parentContext = parentContext
+        }
     }
 
     extend(dict) {
         return new Context(dict, this)
     }
+
+    has(key) {
+        return this.#entries.has(key) || this.#parentContext.has(key)
+    }
+
+    get(key) {
+        if (this.#entries.has(key)) {
+            return this.#entries.get(key)
+        }
+        if (this.#parentContext.has(key)) {
+            return this.#parentContext.get(key)
+        }
+        return VarNotFound
+    }
 }
 
 
@@ -64,10 +74,6 @@ function escape(value) {
     return SafeString.isSafe(value) ? value : new Option(String(value)).innerHTML
 }
 
-function toNumber(value) {
-    return Number.isFinite(value) ? value : parseFloat(String(value))
-}
-
 function toInteger(value) {
     const result = parseInt(value, 10)
     if (!Number.isFinite(result)) {
@@ -77,7 +83,8 @@ function toInteger(value) {
 }
 
 class Filters {
-    constructor() {
+    constructor(engine) {
+        this.engine = engine
         return new Proxy(Object.freeze(this), {
             get(target, prop) {
                 const result = target[prop]
@@ -347,18 +354,93 @@ class Filters {
     }
 }
 
+
+class Tags {
+    #engine
+
+    constructor(engine) {
+        this.#engine = engine
+
+        return new Proxy(Object.freeze(this), {
+            get(target, prop, receiver) {
+                if (Reflect.has(target, prop)) {
+                    return Reflect.get(target, prop, receiver)
+                }
+                if (Reflect.has(target, `do_${prop}`)) {
+                    return Reflect.get(target, `do_${prop}`, receiver).bind(target)
+                }
+                throw new Error(`Unknown tag: ${prop}`)
+            }
+        })
+    }
+
+    /**
+     *
+     * @param params
+     * @param {Context} params.context
+     * @param {Iterable} params.iter
+     * @param {function(any): Object<string, any>} params.forloopVariables
+     * @param {boolean} params.reversed
+     * @param {RenderFunction} params.render
+     * @param {RenderFunction | null} params.emptyRender
+     * @returns {string}
+     */
+    do_for({context, iter, forloopVariables, render, emptyRender = null, reversed = false}) {
+        const parentloop = context.get("forloop") || None
+        const container = Array.from(iter)
+
+        function getContext(counter, value) {
+            return context.extend({
+                ...forloopVariables(value),
+                forloop: {
+                    get counter() {
+                        return counter + 1
+                    },
+                    get counter0() {
+                        return counter
+                    },
+                    get revcounter() {
+                        return container.length - counter
+                    },
+                    get revcounter0() {
+                        return container.length - counter - 1
+                    },
+                    get first() {
+                        return counter === 0
+                    },
+                    get last() {
+                        return counter === container.length - 1
+                    },
+                    get length() {
+                        return container.length
+                    },
+                    parentloop,
+                }
+            })
+        }
+
+        if (container.length === 0) {
+            return emptyRender?.call(null, this.#engine, context) ?? VarNotFound
+        }
+        const reducer = reversed ? container.reduceRight.bind(container) : container.reduce.bind(container)
+        return reducer((acc, value, idx) => acc + render(this.#engine, getContext(idx, value)), "")
+    }
+}
+
 const utils = Object.freeze({
     contains(first, second) {
         return Array.from(first).contains(second)
     },
     do_is(first, second) {
         return first === second
-    }
+    },
 })
 
 class Engine {
+    #tags = new Tags(this)
+    #filters = new Filters(this)
+
     constructor() {
-        this._filters = new Filters()
         this._ = utils
     }
 
@@ -371,25 +453,56 @@ class Engine {
     }
 
     /**
-     * @param {string} varName
-     * @param {any} literal
+     * @param {string[]|undefined} varNames
+     * @param {any|undefined} literal
      * @param {Context} context
-     * @param {Filters} filters
-     * @returns {string}
+     * @param {string[]} filters
+     * @returns {any}
      */
-    variable({varName, literal, context, filters}) {
-        let value = literal || context[varName]
+    variable({varNames = [], literal = undefined, context, filters}) {
+        if (literal !== undefined) {
+            return `${literal}`
+        }
+
+        let target = context
+        for (let varName of varNames) {
+            const orig = target
+            if (target instanceof Context || target instanceof Map) {
+                target = target.get(varName)
+            } else if ((target instanceof Set && target.has(varName)) || Object.hasOwn(target, varName)) {
+                target = target[varName]
+            } else {
+                target = VarNotFound
+            }
+
+            if (typeof target === "function") {
+                target = target.call(orig)
+            } else if (target === null || target === undefined) {
+                target = VarNotFound
+            }
+        }
+
         for (const {filterName, argument} of filters) {
-            value = escape(this._filters[filterName](value, argument))
+            target = this.#filters[filterName](target, argument)
         }
-        return value
+
+        return target
+    }
+
+    escape(value) {
+        return escape(`${value}`)
+    }
+
+    tag({tagName, args, context}) {
+        return this.#tags[tagName]({...args, context})
     }
 
     translate(value) {
         console.warn("Translation not implemented")
         return value
     }
 
+
 }
 
 export default Engine

python/django_template_transpiler/data/core.js

@@ -1,4 +1,5 @@
 mod parser;
+mod tag_for;
 mod tag_if;
 mod utils;
 mod variable;
@@ -23,3 +24,24 @@ pub mod django_template_transpiler {
         Ok(crate::transpile(raw_template))
     }
 }
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use crate::parser::Parser;
+    use dtl_lexer::types::TemplateString;
+    use oxc::allocator::Allocator;
+    use regex::Regex;
+
+    pub(crate) fn render_template(template: &str) -> String {
+        let allocator = Allocator::default();
+        Parser::new(&allocator, TemplateString(template)).render()
+    }
+
+    pub(crate) fn assert_template(expected: &str, template: &str) {
+        let process_regex = Regex::new(r"[\s\n]+").unwrap();
+        assert_eq!(
+            process_regex.replace_all(expected.trim(), " "),
+            process_regex.replace_all(render_template(template).trim(), " ")
+        );
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
+use crate::tag_for::ParseFor;
 use crate::tag_if::ParseIf;
 use crate::utils::{SimplerAstMethods, SomeWrap};
 use crate::variable::parse_variable;
@@ -72,10 +73,13 @@ impl<'t> Parser<'t> {
                     None,
                 ),
                 TokenType::Comment => continue,
-                TokenType::Variable => parse_variable(
-                    &self.ast_builder,
-                    self.template,
-                    (token.at.0 + START_TAG_LEN, token.at.1 - 2 * START_TAG_LEN),
+                TokenType::Variable => self.ast_builder.expression_call_simple(
+                    ["engine", "escape"],
+                    vec![parse_variable(
+                        &self.ast_builder,
+                        self.template,
+                        (token.at.0 + START_TAG_LEN, token.at.1 - 2 * START_TAG_LEN),
+                    )],
                 ),
                 TokenType::Tag => {
                     let tag =
@@ -121,8 +125,9 @@ impl<'t> Parser<'t> {
 
         match tag_name {
             "if" => self.parse_if(tag),
+            "for" => self.parse_for(tag),
             "autoescape" | "block" | "comment" | "csrf_token" | "cycle" | "debug" | "filter"
-            | "firstof" | "for" | "ifchanged" | "" | "load" | "lorem" | "now" | "partial"
+            | "firstof" | "ifchanged" | "" | "load" | "lorem" | "now" | "partial"
             | "partialdef" | "querystring" | "regroup" | "resetcycle" | "spaceless"
             | "templatetag" | "url" | "verbatim" | "widthratio" | "with" => {
                 todo!("{tag_name} not implemented yet")
@@ -177,23 +182,7 @@ impl<'t> Parser<'t> {
 
 #[cfg(test)]
 mod tests {
-    use crate::parser::Parser;
-    use dtl_lexer::types::TemplateString;
-    use oxc::allocator::Allocator;
-    use regex::Regex;
-
-    fn render_template(template: &str) -> String {
-        let allocator = Allocator::default();
-        Parser::new(&allocator, TemplateString(template)).render()
-    }
-
-    fn assert_template(expected: &str, template: &str) {
-        let process_regex = Regex::new(r"[\s\n]+").unwrap();
-        assert_eq!(
-            process_regex.replace_all(expected.trim(), " "),
-            process_regex.replace_all(render_template(template).trim(), " ")
-        );
-    }
+    use crate::tests::{assert_template, render_template};
 
     #[test]
     fn test_empty() {