Fix usage of template origins in {% extends %} tags

Author: LilyFirefly

src/loaders.rs

@@ -22,6 +22,15 @@ pub struct Origin {
     pub loader: Option<usize>,
 }
 
+impl Origin {
+    pub fn as_name(&self) -> &str {
+        match &self.template_name {
+            Some(name) => name,
+            None => &self.name,
+        }
+    }
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LoaderError {
     pub tried: Vec<(String, String)>,
@@ -122,7 +131,14 @@ fn get_template(
             ))));
         }
         return Ok(
-            match Template::new(py, &contents, path, template_name, engine) {
+            match Template::new(
+                py,
+                &contents,
+                path,
+                template_name,
+                engine,
+                Some(this_origin.clone()),
+            ) {
                 Ok(template) => Ok((template, this_origin)),
                 Err(error) => Err(error),
             },
@@ -325,6 +341,7 @@ impl LocMemLoader {
                     PathBuf::from(template_name),
                     template_name,
                     engine,
+                    Some(this_origin.clone()),
                 ) {
                     Ok(template) => Ok((template, this_origin)),
                     Err(error) => Err(error),

src/parse.rs

@@ -2077,7 +2077,7 @@ impl<'t, 'py> Parser<'t, 'py> {
         let template_name = match parse_extends_template_token(token, self)? {
             IncludeTemplateName::Text(Text { at }) => {
                 let template_path = self.template.content(at);
-                let origin_name = self.origin.as_ref().map(|origin| origin.name.as_str());
+                let origin_name = self.origin.as_ref().map(|origin| origin.as_name());
                 match construct_relative_path(template_path, origin_name, at)
                     .map_err(ParseError::from)?
                 {
@@ -2160,7 +2160,7 @@ impl<'t, 'py> Parser<'t, 'py> {
         let template_name = match parse_include_template_token(template_token, self)? {
             IncludeTemplateName::Text(Text { at }) => {
                 let template_path = self.template.content(at);
-                let origin_name = self.origin.as_ref().map(|origin| origin.name.as_str());
+                let origin_name = self.origin.as_ref().map(|origin| origin.as_name());
                 match construct_relative_path(template_path, origin_name, at)? {
                     Some(path) => IncludeTemplateName::Relative(RelativePath {
                         path: path.into_owned(),
@@ -2214,7 +2214,7 @@ impl<'t, 'py> Parser<'t, 'py> {
                 return Err(ParseError::MissingKeywordArgument { at: with_at.into() });
             }
         }
-        let origin = self.origin.as_ref().map(|origin| origin.name.clone());
+        let origin = self.origin.as_ref().map(|origin| origin.as_name().to_string());
         let include = Include {
             template_name,
             origin,

src/render/tags.rs

@@ -26,8 +26,7 @@ use crate::parse::{
 };
 use crate::path::construct_relative_path;
 use crate::template::django_rusty_templates::{
-    NoReverseMatch, Template, TemplateDoesNotExist, TemplateSyntaxError, WithSourceCode,
-    get_template,
+    NoReverseMatch, Template, TemplateDoesNotExist, TemplateSyntaxError, get_template,
 };
 use crate::types::Variable;
 use crate::utils::PyResultMethods;
@@ -1102,39 +1101,6 @@ impl Extends {
         }
     }
 
-    fn get_template_from_string<'t, 'py>(
-        &self,
-        content: &Bound<'py, PyString>,
-        template: TemplateString<'t>,
-        context: &mut Context,
-    ) -> Result<Template, PyErr> {
-        let py = content.py();
-        let template_path = content
-            .extract()
-            .expect("PyString should be compatible with Cow<str>");
-        let origin_name = match &self.origin {
-            Some(origin) => origin.template_name.as_deref(),
-            None => None,
-        };
-        let relative_path =
-            construct_relative_path(template_path, origin_name, template_at(&self.template_name));
-        let template_path =
-            match relative_path {
-                Err(error) => {
-                    return Err(TemplateDoesNotExist::with_source_code(
-                        error.into(),
-                        template.to_string(),
-                    ));
-                }
-                Ok(Some(_)) => {
-                    return Err(TemplateDoesNotExist::new_err((template_path.to_string(),))
-                        .annotate(py, template_at(&self.template_name), "here", template));
-                }
-                Ok(None) => template_path.to_string(),
-            };
-        self.load_template(py, template_path, template, context)
-    }
-
     fn get_template<'t, 'py>(
         &self,
         template_name: Content<'t, 'py>,
@@ -1150,13 +1116,19 @@ impl Extends {
                 if let Ok(parent) = content.extract::<Template>() {
                     Ok(parent)
                 } else if let Ok(content) = content.cast::<PyString>() {
-                    self.get_template_from_string(content, template, context)
+                    let template_path = content
+                        .extract()
+                        .expect("PyString should be compatible with Cow<str>");
+                    self.load_template(py, template_path, template, context)
                 } else {
                     let promise = PROMISE.import(py, "django.utils.functional", "Promise")?;
                     let path_like = PATH_LIKE.import(py, "os", "PathLike")?;
                     if content.is_instance(promise)? || content.is_instance(path_like)? {
                         let content = content.str()?;
-                        self.get_template_from_string(&content, template, context)
+                        let template_path = content
+                            .extract()
+                            .expect("PyString should be compatible with Cow<str>");
+                        self.load_template(py, template_path, template, context)
                     } else {
                         return Err(invalid_template_name(
                             py,

src/template.rs

@@ -521,11 +521,15 @@ pub mod django_rusty_templates {
             filename: PathBuf,
             template_name: &str,
             engine: Arc<Engine>,
+            origin: Option<Origin>,
         ) -> PyResult<Self> {
-            let origin = Origin {
-                name: template_name.to_string(),
-                template_name: None,
-                loader: None,
+            let origin = match origin {
+                Some(origin) => origin,
+                None => Origin {
+                    name: template_name.to_string(),
+                    template_name: None,
+                    loader: None,
+                },
             };
             let mut parser =
                 Parser::new(py, TemplateString(template), engine.clone(), Some(origin));
@@ -740,8 +744,15 @@ mod tests {
             let engine = Arc::new(Engine::empty());
             let template_string = std::fs::read_to_string(&filename).unwrap();
             let error = temp_env::with_var("NO_COLOR", Some("1"), || {
-                Template::new(py, &template_string, filename, "parse_error.txt", engine)
-                    .unwrap_err()
+                Template::new(
+                    py,
+                    &template_string,
+                    filename,
+                    "parse_error.txt",
+                    engine,
+                    None,
+                )
+                .unwrap_err()
             });
 
             let error_string = format!("{error}");

tests/tags/test_extends.py

@@ -158,6 +158,15 @@ def test_extends_content_outside_blocks(assert_render):
     )
 
 
+def test_extends_relative_template_variable_parent(assert_render):
+    template = "{% extends 'extends_extends_variable.txt' %}"
+    assert_render(
+        template=template,
+        context={"parent": "./basic.txt", "user": "Lily"},
+        expected="Hello Lily!\n",
+    )
+
+
 def test_extends_after_variable(assert_parse_error):
     template = "{{ variable }} {% extends 'base.txt' %}{% block body %}Some content{% endblock body %}"
     django_message = snapshot(
@@ -553,8 +562,7 @@ def test_extends_variable_relative_path(assert_render_error):
     template = "{% extends 'nested/extends_variable.txt' %}"
     django_message = snapshot("../base.txt")
     rusty_message = snapshot("""\
-  × The relative path '../base.txt' cannot be evaluated due to an unknown
-  │ template origin.
+  × ../base.txt
    ╭─[1:12]
  1 │ {% extends parent %}
    ·            ───┬──
@@ -575,8 +583,7 @@ def test_extends_variable_relative_path_deep(assert_render_error):
     template = "{% extends 'nested/extends_variable.txt' %}"
     django_message = snapshot("../../missing.txt")
     rusty_message = snapshot("""\
-  × The relative path '../../missing.txt' cannot be evaluated due to an
-  │ unknown template origin.
+  × ../../missing.txt
    ╭─[1:12]
  1 │ {% extends parent %}
    ·            ───┬──

tests/templates/extends_extends_variable.txt

@@ -0,0 +1 @@
+{% extends "extends_variable.txt" %}

tests/templates/extends_variable.txt

@@ -0,0 +1 @@
+{% extends parent %}