Merge askama_derive into askama

Cargo.toml

@@ -8,7 +8,6 @@ members = [
     "askama_escape",
     "askama_mendes",
     "askama_rocket",
-    "askama_shared",
     "askama_tide",
     "askama_warp",
     "testing",
@@ -18,6 +17,5 @@ default-members = [
     "askama",
     "askama_derive",
     "askama_escape",
-    "askama_shared",
     "testing",
 ]

askama/Cargo.toml

@@ -17,20 +17,20 @@ maintenance = { status = "actively-developed" }
 
 [features]
 default = ["config", "humansize", "num-traits", "urlencode"]
-config = ["askama_derive/config", "askama_shared/config"]
-humansize = ["askama_derive/humansize", "askama_shared/humansize"]
-markdown = ["askama_derive/markdown", "askama_shared/markdown"]
-urlencode = ["askama_derive/urlencode", "askama_shared/percent-encoding"]
-serde-json = ["askama_derive/serde-json", "askama_shared/json"]
-serde-yaml = ["askama_derive/serde-yaml", "askama_shared/yaml"]
-num-traits = ["askama_derive/num-traits", "askama_shared/num-traits"]
-with-actix-web = ["askama_derive/with-actix-web", "askama_shared/actix-web"]
-with-axum = ["askama_derive/with-axum", "askama_shared/axum"]
-with-gotham = ["askama_derive/with-gotham", "askama_shared/gotham"]
-with-mendes = ["askama_derive/with-mendes", "askama_shared/mendes"]
-with-rocket = ["askama_derive/with-rocket", "askama_shared/rocket"]
-with-tide = ["askama_derive/with-tide", "askama_shared/tide"]
-with-warp = ["askama_derive/with-warp", "askama_shared/warp"]
+config = ["askama_derive/config"]
+humansize = ["askama_derive/humansize", "dep_humansize"]
+markdown = ["askama_derive/markdown", "comrak"]
+num-traits = ["askama_derive/num-traits", "dep_num_traits"]
+serde-json = ["askama_derive/serde-json", "askama_escape/json", "serde", "serde_json"]
+serde-yaml = ["askama_derive/serde-yaml", "serde", "serde_yaml"]
+urlencode = ["askama_derive/urlencode", "percent-encoding"]
+with-actix-web = ["askama_derive/with-actix-web"]
+with-axum = ["askama_derive/with-axum"]
+with-gotham = ["askama_derive/with-gotham"]
+with-mendes = ["askama_derive/with-mendes"]
+with-rocket = ["askama_derive/with-rocket"]
+with-tide = ["askama_derive/with-tide"]
+with-warp = ["askama_derive/with-warp"]
 
 # deprecated
 mime = []
@@ -39,7 +39,13 @@ mime_guess = []
 [dependencies]
 askama_derive = { version = "0.12.0", path = "../askama_derive" }
 askama_escape = { version = "0.10.3", path = "../askama_escape" }
-askama_shared = { version = "0.13.0", path = "../askama_shared", default-features = false }
+comrak = { version = "0.13", optional = true, default-features = false }
+dep_humansize = { package = "humansize", version = "1.1.0", optional = true }
+dep_num_traits = { package = "num-traits", version = "0.2.6", optional = true }
+percent-encoding = { version = "2.1.0", optional = true }
+serde = { version = "1.0", optional = true, features = ["derive"] }
+serde_json = { version = "1.0", optional = true }
+serde_yaml = { version = "0.8", optional = true }
 
 [package.metadata.docs.rs]
 features = ["config", "humansize", "num-traits", "serde-json", "serde-yaml"]

askama_shared/src/filters/mod.rs → askama/src/filters/mod.rs

@@ -7,23 +7,23 @@
 
 use std::fmt::{self, Write};
 
-#[cfg(feature = "serde_json")]
+#[cfg(feature = "serde-json")]
 mod json;
-#[cfg(feature = "serde_json")]
+#[cfg(feature = "serde-json")]
 pub use self::json::json;
 
-#[cfg(feature = "serde_yaml")]
+#[cfg(feature = "serde-yaml")]
 mod yaml;
-#[cfg(feature = "serde_yaml")]
+#[cfg(feature = "serde-yaml")]
 pub use self::yaml::yaml;
 
 #[allow(unused_imports)]
 use crate::error::Error::Fmt;
 use askama_escape::{Escaper, MarkupDisplay};
 #[cfg(feature = "humansize")]
-use humansize::{file_size_opts, FileSize};
+use dep_humansize::{file_size_opts, FileSize};
 #[cfg(feature = "num-traits")]
-use num_traits::{cast::NumCast, Signed};
+use dep_num_traits::{cast::NumCast, Signed};
 #[cfg(feature = "percent-encoding")]
 use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
 

askama/src/lib.rs

@@ -63,11 +63,152 @@
 #![deny(elided_lifetimes_in_paths)]
 #![deny(unreachable_pub)]
 
+mod error;
+pub mod filters;
+pub mod helpers;
+
+use std::fmt;
+
 pub use askama_derive::Template;
-pub use askama_escape::{Html, Text};
-pub use askama_shared::{
-    self as shared, filters, helpers, DynTemplate, Error, MarkupDisplay, Result, Template,
-};
+pub use askama_escape::{Html, MarkupDisplay, Text};
+
+#[doc(hidden)]
+pub use crate as shared;
+pub use crate::error::{Error, Result};
+
+/// Main `Template` trait; implementations are generally derived
+///
+/// If you need an object-safe template, use [`DynTemplate`].
+pub trait Template: fmt::Display {
+    /// Helper method which allocates a new `String` and renders into it
+    fn render(&self) -> Result<String> {
+        let mut buf = String::with_capacity(Self::SIZE_HINT);
+        self.render_into(&mut buf)?;
+        Ok(buf)
+    }
+
+    /// Renders the template to the given `writer` fmt buffer
+    fn render_into(&self, writer: &mut (impl std::fmt::Write + ?Sized)) -> Result<()>;
+
+    /// Renders the template to the given `writer` io buffer
+    #[inline]
+    fn write_into(&self, writer: &mut (impl std::io::Write + ?Sized)) -> std::io::Result<()> {
+        writer.write_fmt(format_args!("{}", self))
+    }
+
+    /// The template's extension, if provided
+    const EXTENSION: Option<&'static str>;
+
+    /// Provides a conservative estimate of the expanded length of the rendered template
+    const SIZE_HINT: usize;
+
+    /// The MIME type (Content-Type) of the data that gets rendered by this Template
+    const MIME_TYPE: &'static str;
+}
+
+/// Object-safe wrapper trait around [`Template`] implementers
+///
+/// This trades reduced performance (mostly due to writing into `dyn Write`) for object safety.
+pub trait DynTemplate {
+    /// Helper method which allocates a new `String` and renders into it
+    fn dyn_render(&self) -> Result<String>;
+
+    /// Renders the template to the given `writer` fmt buffer
+    fn dyn_render_into(&self, writer: &mut dyn std::fmt::Write) -> Result<()>;
+
+    /// Renders the template to the given `writer` io buffer
+    fn dyn_write_into(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()>;
+
+    /// Helper function to inspect the template's extension
+    fn extension(&self) -> Option<&'static str>;
+
+    /// Provides a conservative estimate of the expanded length of the rendered template
+    fn size_hint(&self) -> usize;
+
+    /// The MIME type (Content-Type) of the data that gets rendered by this Template
+    fn mime_type(&self) -> &'static str;
+}
+
+impl<T: Template> DynTemplate for T {
+    fn dyn_render(&self) -> Result<String> {
+        <Self as Template>::render(self)
+    }
+
+    fn dyn_render_into(&self, writer: &mut dyn std::fmt::Write) -> Result<()> {
+        <Self as Template>::render_into(self, writer)
+    }
+
+    #[inline]
+    fn dyn_write_into(&self, writer: &mut dyn std::io::Write) -> std::io::Result<()> {
+        writer.write_fmt(format_args!("{}", self))
+    }
+
+    fn extension(&self) -> Option<&'static str> {
+        Self::EXTENSION
+    }
+
+    fn size_hint(&self) -> usize {
+        Self::SIZE_HINT
+    }
+
+    fn mime_type(&self) -> &'static str {
+        Self::MIME_TYPE
+    }
+}
+
+impl fmt::Display for dyn DynTemplate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.dyn_render_into(f).map_err(|_| ::std::fmt::Error {})
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::blacklisted_name)]
+mod tests {
+    use std::fmt;
+
+    use super::*;
+    use crate::{DynTemplate, Template};
+
+    #[test]
+    fn dyn_template() {
+        struct Test;
+        impl Template for Test {
+            fn render_into(&self, writer: &mut (impl std::fmt::Write + ?Sized)) -> Result<()> {
+                Ok(writer.write_str("test")?)
+            }
+
+            const EXTENSION: Option<&'static str> = Some("txt");
+
+            const SIZE_HINT: usize = 4;
+
+            const MIME_TYPE: &'static str = "text/plain; charset=utf-8";
+        }
+
+        impl fmt::Display for Test {
+            #[inline]
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                self.render_into(f).map_err(|_| fmt::Error {})
+            }
+        }
+
+        fn render(t: &dyn DynTemplate) -> String {
+            t.dyn_render().unwrap()
+        }
+
+        let test = &Test as &dyn DynTemplate;
+
+        assert_eq!(render(test), "test");
+
+        assert_eq!(test.to_string(), "test");
+
+        assert_eq!(format!("{}", test), "test");
+
+        let mut vec = Vec::new();
+        test.dyn_write_into(&mut vec).unwrap();
+        assert_eq!(vec, vec![b't', b'e', b's', b't']);
+    }
+}
 
 /// Old build script helper to rebuild crates if contained templates have changed
 ///