Move code generation into askama_derive

12 files changed, 22 insertions, 111 deletions

diff --git a/askama_shared/src/config.rs b/askama_derive/src/config.rs
index 01f81a2..01f81a2 100644
--- a/askama_shared/src/config.rs
+++ b/askama_derive/src/config.rs
diff --git a/askama_shared/src/generator.rs b/askama_derive/src/generator.rs
index ea95bd3..39a5380 100644
--- a/askama_shared/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -2,9 +2,9 @@ use crate::config::{get_template_source, read_config_file, Config, WhitespaceHan
 use crate::heritage::{Context, Heritage};
 use crate::input::{Print, Source, TemplateInput};
 use crate::parser::{parse, Cond, CondTest, Expr, Loop, Node, Target, When, Whitespace, Ws};
-use crate::{filters, CompileError};
+use crate::CompileError;
 
-use proc_macro2::TokenStream;
+use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
 
 use std::collections::HashMap;
@@ -12,9 +12,8 @@ use std::path::{Path, PathBuf};
 use std::{cmp, hash, mem, str};
 
 /// The actual implementation for askama_derive::Template
-#[doc(hidden)]
-pub fn derive_template(input: TokenStream) -> TokenStream {
-    let ast: syn::DeriveInput = syn::parse2(input).unwrap();
+pub(crate) fn derive_template(input: TokenStream) -> TokenStream {
+    let ast: syn::DeriveInput = syn::parse(input).unwrap();
     match build_template(&ast) {
         Ok(source) => source.parse().unwrap(),
         Err(e) => e.into_compile_error(),
@@ -302,19 +301,19 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         self.impl_template(ctx, &mut buf)?;
         self.impl_display(&mut buf)?;
 
-        #[cfg(feature = "actix-web")]
+        #[cfg(feature = "with-actix-web")]
         self.impl_actix_web_responder(&mut buf)?;
-        #[cfg(feature = "axum")]
+        #[cfg(feature = "with-axum")]
         self.impl_axum_into_response(&mut buf)?;
-        #[cfg(feature = "gotham")]
+        #[cfg(feature = "with-gotham")]
         self.impl_gotham_into_response(&mut buf)?;
-        #[cfg(feature = "mendes")]
+        #[cfg(feature = "with-mendes")]
         self.impl_mendes_responder(&mut buf)?;
-        #[cfg(feature = "rocket")]
+        #[cfg(feature = "with-rocket")]
         self.impl_rocket_responder(&mut buf)?;
-        #[cfg(feature = "tide")]
+        #[cfg(feature = "with-tide")]
         self.impl_tide_integrations(&mut buf)?;
-        #[cfg(feature = "warp")]
+        #[cfg(feature = "with-warp")]
         self.impl_warp_reply(&mut buf)?;
 
         Ok(buf.buf)
@@ -405,7 +404,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement Actix-web's `Responder`.
-    #[cfg(feature = "actix-web")]
+    #[cfg(feature = "with-actix-web")]
     fn impl_actix_web_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         self.write_header(buf, "::askama_actix::actix_web::Responder", None)?;
         buf.writeln("type Body = ::askama_actix::actix_web::body::BoxBody;")?;
@@ -420,7 +419,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement Axum's `IntoResponse`.
-    #[cfg(feature = "axum")]
+    #[cfg(feature = "with-axum")]
     fn impl_axum_into_response(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         self.write_header(buf, "::askama_axum::IntoResponse", None)?;
         buf.writeln("#[inline]")?;
@@ -435,7 +434,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement gotham's `IntoResponse`.
-    #[cfg(feature = "gotham")]
+    #[cfg(feature = "with-gotham")]
     fn impl_gotham_into_response(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         self.write_header(buf, "::askama_gotham::IntoResponse", None)?;
         buf.writeln("#[inline]")?;
@@ -450,7 +449,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement mendes' `Responder`.
-    #[cfg(feature = "mendes")]
+    #[cfg(feature = "with-mendes")]
     fn impl_mendes_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         let param = syn::parse_str("A: ::mendes::Application").unwrap();
 
@@ -500,7 +499,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement Rocket's `Responder`.
-    #[cfg(feature = "rocket")]
+    #[cfg(feature = "with-rocket")]
     fn impl_rocket_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         let lifetime = syn::Lifetime::new("'askama", proc_macro2::Span::call_site());
         let param = syn::GenericParam::Lifetime(syn::LifetimeDef::new(lifetime));
@@ -523,7 +522,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         Ok(())
     }
 
-    #[cfg(feature = "tide")]
+    #[cfg(feature = "with-tide")]
     fn impl_tide_integrations(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         let ext = self.input.extension().unwrap_or("txt");
 
@@ -549,7 +548,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         buf.writeln("}\n}")
     }
 
-    #[cfg(feature = "warp")]
+    #[cfg(feature = "with-warp")]
     fn impl_warp_reply(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         self.write_header(buf, "::askama_warp::warp::reply::Reply", None)?;
         buf.writeln("#[inline]")?;
@@ -1381,11 +1380,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             name = "json";
         }
 
-        #[cfg(not(feature = "json"))]
+        #[cfg(not(feature = "serde-json"))]
         if name == "json" {
             return Err("the `json` filter requires the `serde-json` feature to be enabled".into());
         }
-        #[cfg(not(feature = "yaml"))]
+        #[cfg(not(feature = "serde-yaml"))]
         if name == "yaml" {
             return Err("the `yaml` filter requires the `serde-yaml` feature to be enabled".into());
         }
@@ -1396,7 +1395,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 "::askama::filters::{}({}, ",
                 name, self.input.escaper
             ));
-        } else if filters::BUILT_IN_FILTERS.contains(&name) {
+        } else if crate::BUILT_IN_FILTERS.contains(&name) {
             buf.write(&format!("::askama::filters::{}(", name));
         } else {
             buf.write(&format!("filters::{}(", name));
diff --git a/askama_shared/src/heritage.rs b/askama_derive/src/heritage.rs
index 52c14a2..52c14a2 100644
--- a/askama_shared/src/heritage.rs
+++ b/askama_derive/src/heritage.rs
diff --git a/askama_shared/src/input.rs b/askama_derive/src/input.rs
index 1f367fd..c09f3d0 100644
--- a/askama_shared/src/input.rs
+++ b/askama_derive/src/input.rs
@@ -181,8 +181,7 @@ impl Default for Print {
     }
 }
 
-#[doc(hidden)]
-pub fn extension_to_mime_type(ext: &str) -> Mime {
+pub(crate) fn extension_to_mime_type(ext: &str) -> Mime {
     let basic_type = mime_guess::from_ext(ext).first_or_octet_stream();
     for (simple, utf_8) in &TEXT_TYPES {
         if &basic_type == simple {
diff --git a/askama_shared/src/parser.rs b/askama_derive/src/parser.rs
index efcad73..efcad73 100644
--- a/askama_shared/src/parser.rs
+++ b/askama_derive/src/parser.rs
diff --git a/askama_shared/templates/a.html b/askama_derive/templates/a.html
index 257cc56..257cc56 100644
--- a/askama_shared/templates/a.html
+++ b/askama_derive/templates/a.html
diff --git a/askama_shared/templates/b.html b/askama_derive/templates/b.html
index 5716ca5..5716ca5 100644
--- a/askama_shared/templates/b.html
+++ b/askama_derive/templates/b.html
diff --git a/askama_shared/templates/sub/b.html b/askama_derive/templates/sub/b.html
index 5716ca5..5716ca5 100644
--- a/askama_shared/templates/sub/b.html
+++ b/askama_derive/templates/sub/b.html
diff --git a/askama_shared/templates/sub/c.html b/askama_derive/templates/sub/c.html
index 7601807..7601807 100644
--- a/askama_shared/templates/sub/c.html
+++ b/askama_derive/templates/sub/c.html
diff --git a/askama_shared/templates/sub/sub1/d.html b/askama_derive/templates/sub/sub1/d.html
index fa11a6a..fa11a6a 100644
--- a/askama_shared/templates/sub/sub1/d.html
+++ b/askama_derive/templates/sub/sub1/d.html
diff --git a/askama_shared/src/filters/mod.rs b/askama_shared/src/filters/mod.rs
index 6437ce0..1782602 100644
--- a/askama_shared/src/filters/mod.rs
+++ b/askama_shared/src/filters/mod.rs
@@ -43,42 +43,6 @@ const URLENCODE_STRICT_SET: &AsciiSet = &NON_ALPHANUMERIC
 // Same as URLENCODE_STRICT_SET, but preserves forward slashes for encoding paths
 const URLENCODE_SET: &AsciiSet = &URLENCODE_STRICT_SET.remove(b'/');
 
-// This is used by the code generator to decide whether a named filter is part of
-// Askama or should refer to a local `filters` module. It should contain all the
-// filters shipped with Askama, even the optional ones (since optional inclusion
-// in the const vector based on features seems impossible right now).
-pub const BUILT_IN_FILTERS: &[&str] = &[
-    "abs",
-    "capitalize",
-    "center",
-    "e",
-    "escape",
-    "filesizeformat",
-    "fmt",
-    "format",
-    "indent",
-    "into_f64",
-    "into_isize",
-    "join",
-    "linebreaks",
-    "linebreaksbr",
-    "paragraphbreaks",
-    "lower",
-    "lowercase",
-    "safe",
-    "trim",
-    "truncate",
-    "upper",
-    "uppercase",
-    "urlencode",
-    "urlencode_strict",
-    "wordcount",
-    // optional features, reserve the names anyway:
-    "json",
-    "markdown",
-    "yaml",
-];
-
 /// Marks a string (or other `Display` type) as safe
 ///
 /// Use this is you want to allow markup in an expression, or if you know
diff --git a/askama_shared/src/lib.rs b/askama_shared/src/lib.rs
index a3ee4c1..cb26406 100644
--- a/askama_shared/src/lib.rs
+++ b/askama_shared/src/lib.rs
@@ -3,23 +3,14 @@
 #![deny(elided_lifetimes_in_paths)]
 #![deny(unreachable_pub)]
 
-use std::borrow::Cow;
 use std::fmt;
 
-pub use crate::generator::derive_template;
-pub use crate::input::extension_to_mime_type;
 pub use askama_escape::MarkupDisplay;
-use proc_macro2::{Span, TokenStream};
 
-mod config;
 mod error;
 pub use crate::error::{Error, Result};
 pub mod filters;
-mod generator;
 pub mod helpers;
-mod heritage;
-mod input;
-mod parser;
 
 /// Main `Template` trait; implementations are generally derived
 ///
@@ -107,48 +98,6 @@ impl fmt::Display for dyn DynTemplate {
     }
 }
 
-#[derive(Debug, Clone)]
-struct CompileError {
-    msg: Cow<'static, str>,
-    span: Span,
-}
-
-impl CompileError {
-    fn new<S: Into<Cow<'static, str>>>(s: S, span: Span) -> Self {
-        Self {
-            msg: s.into(),
-            span,
-        }
-    }
-
-    fn into_compile_error(self) -> TokenStream {
-        syn::Error::new(self.span, self.msg).to_compile_error()
-    }
-}
-
-impl std::error::Error for CompileError {}
-
-impl fmt::Display for CompileError {
-    #[inline]
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.write_str(&self.msg)
-    }
-}
-
-impl From<&'static str> for CompileError {
-    #[inline]
-    fn from(s: &'static str) -> Self {
-        Self::new(s, Span::call_site())
-    }
-}
-
-impl From<String> for CompileError {
-    #[inline]
-    fn from(s: String) -> Self {
-        Self::new(s, Span::call_site())
-    }
-}
-
 #[cfg(test)]
 #[allow(clippy::blacklisted_name)]
 mod tests {