From 467f4ade19fa34983de7e6f6d81c6b4d5ff140fe Mon Sep 17 00:00:00 2001
From: Dirkjan Ochtman <dirkjan@ochtman.nl>
Date: Thu, 10 Jan 2019 17:19:28 +0100
Subject: Specify a trait that handles the output format's escaping

---
 askama_derive/src/input.rs | 48 +++++++++++++++-------------------------------
 1 file changed, 15 insertions(+), 33 deletions(-)

(limited to 'askama_derive/src/input.rs')

diff --git a/askama_derive/src/input.rs b/askama_derive/src/input.rs
index c23d30f..b584298 100644
--- a/askama_derive/src/input.rs
+++ b/askama_derive/src/input.rs
@@ -15,7 +15,7 @@ pub struct TemplateInput<'a> {
     pub syntax: &'a Syntax<'a>,
     pub source: Source,
     pub print: Print,
-    pub escaping: EscapeMode,
+    pub escaping: &'a str,
     pub ext: Option<String>,
     pub parent: Option<&'a syn::Type>,
     pub path: PathBuf,
@@ -91,7 +91,7 @@ impl<'a> TemplateInput<'a> {
                         }
                         "escape" => {
                             if let syn::Lit::Str(ref s) = pair.lit {
-                                escaping = Some(s.value().into());
+                                escaping = Some(s.value());
                             } else {
                                 panic!("escape value must be string literal");
                             }
@@ -165,12 +165,24 @@ impl<'a> TemplateInput<'a> {
             },
         );
 
+        let escaping = escaping.unwrap_or_else(|| {
+            path.extension()
+                .map(|s| s.to_str().unwrap())
+                .unwrap_or("none")
+                .to_string()
+        });
+        let escaping = match escaping.as_str() {
+            "html" | "htm" | "xml" => "::askama::Html",
+            "txt" | "none" => "::askama::Text",
+            val => panic!("unknown value '{}' for escape mode", val),
+        };
+
         TemplateInput {
             ast,
             config,
             source,
             print,
-            escaping: escaping.unwrap_or_else(|| EscapeMode::from_path(&path)),
+            escaping,
             ext,
             parent,
             path,
@@ -184,34 +196,6 @@ pub enum Source {
     Source(String),
 }
 
-#[derive(PartialEq)]
-pub enum EscapeMode {
-    Html,
-    None,
-}
-
-impl From<String> for EscapeMode {
-    fn from(s: String) -> EscapeMode {
-        use self::EscapeMode::*;
-        match s.as_ref() {
-            "html" => Html,
-            "none" => None,
-            v => panic!("invalid value for escape option: {}", v),
-        }
-    }
-}
-
-impl EscapeMode {
-    fn from_path(path: &PathBuf) -> EscapeMode {
-        let extension = path.extension().map(|s| s.to_str().unwrap()).unwrap_or("");
-        if HTML_EXTENSIONS.contains(&extension) {
-            EscapeMode::Html
-        } else {
-            EscapeMode::None
-        }
-    }
-}
-
 #[derive(PartialEq)]
 pub enum Print {
     All,
@@ -232,5 +216,3 @@ impl From<String> for Print {
         }
     }
 }
-
-const HTML_EXTENSIONS: [&str; 3] = ["html", "htm", "xml"];
-- 
cgit