Add defalte filters

components/templates/Cargo.toml

@@ -17,6 +17,7 @@ sha2 = "0.9"
 url = "2"
 nom-bibtex = "0.3"
 num-format = "0.4"
+flate2 = "1.0"
 
 errors = { path = "../errors" }
 utils = { path = "../utils" }

components/templates/src/filters.rs

@@ -1,10 +1,12 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
+use std::io::prelude::*;
 use std::path::PathBuf;
 
-use base64::{decode, encode};
+use base64::{decode, decode_config, encode, encode_config, URL_SAFE};
 use config::Config;
+use flate2::{read::ZlibDecoder, write::ZlibEncoder, Compression};
 use rendering::{render_content, RenderContext};
 use tera::{
     to_value, try_get_value, Error as TeraError, Filter as TeraFilter, Result as TeraResult, Tera,
@@ -109,13 +111,39 @@ impl TeraFilter for NumFormatFilter {
     }
 }
 
+pub fn deflate_compress<S: BuildHasher>(
+    value: &Value,
+    _: &HashMap<String, Value, S>,
+) -> TeraResult<Value> {
+    let s = try_get_value!("deflate_compress", "value", String, value);
+    let mut e = ZlibEncoder::new(Vec::new(), Compression::new(9));
+    e.write_all(s.as_bytes())?;
+    let result = e.finish()?;
+    Ok(to_value(&encode_config(result, URL_SAFE))?)
+}
+
+pub fn deflate_decompress<S: BuildHasher>(
+    value: &Value,
+    _: &HashMap<String, Value, S>,
+) -> TeraResult<Value> {
+    let base64 = try_get_value!("deflate_decompress", "value", String, value);
+    let s = decode_config(base64, URL_SAFE).unwrap();
+    let mut d = ZlibDecoder::new(s.as_slice());
+    let mut result = String::new();
+    d.read_to_string(&mut result)?;
+    Ok(to_value(result)?)
+}
+
 #[cfg(test)]
 mod tests {
     use std::{collections::HashMap, path::PathBuf};
 
     use tera::{to_value, Filter};
 
-    use super::{base64_decode, base64_encode, MarkdownFilter, NumFormatFilter};
+    use super::{
+        base64_decode, base64_encode, deflate_compress, deflate_decompress, MarkdownFilter,
+        NumFormatFilter,
+    };
     use config::Config;
 
     #[test]
@@ -135,7 +163,8 @@ mod tests {
         let args = HashMap::new();
         let config = Config::default();
         let permalinks = HashMap::new();
-        let mut tera = super::load_tera(&PathBuf::new(), &config).map_err(tera::Error::msg).unwrap();
+        let mut tera =
+            super::load_tera(&PathBuf::new(), &config).map_err(tera::Error::msg).unwrap();
         tera.add_raw_template("shortcodes/explicitlang.html", "a{{ lang }}a").unwrap();
         let filter = MarkdownFilter { config, permalinks, tera };
         let result = filter.filter(&to_value(&"{{ explicitlang(lang='jp') }}").unwrap(), &args);
@@ -294,4 +323,43 @@ mod tests {
             assert_eq!(result.unwrap(), to_value(expected).unwrap());
         }
     }
+
+    #[test]
+    fn deflate_compress_filter() {
+        let tests = vec![
+            ("", "eNoDAAAAAAE="),
+            ("f", "eNpLAwAAZwBn"),
+            ("fo", "eNpLywcAAT0A1g=="),
+            ("foo", "eNpLy88HAAKCAUU="),
+            ("foob", "eNpLy89PAgAEKQGn"),
+            ("fooba", "eNpLy89PSgQABjECCA=="),
+            ("foobar", "eNpLy89PSiwCAAirAno="),
+        ];
+        for (input, expected) in tests {
+            let args = HashMap::new();
+            let result = deflate_compress(&to_value(input).unwrap(), &args);
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), to_value(expected).unwrap());
+        }
+    }
+
+    #[test]
+    fn deflate_decompress_filter() {
+        let tests = vec![
+            ("eNoDAAAAAAE=", ""),
+            ("eNpLAwAAZwBn", "f"),
+            ("eNpLywcAAT0A1g==", "fo"),
+            ("eNpLy88HAAKCAUU=", "foo"),
+            ("eNpLy89PAgAEKQGn", "foob"),
+            ("eNpLy89PSgQABjECCA==", "fooba"),
+            ("eNpLy89PSiwCAAirAno=", "foobar"),
+            ("eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ", "digraph G {Hello->World}\n"),
+        ];
+        for (input, expected) in tests {
+            let args = HashMap::new();
+            let result = deflate_decompress(&to_value(input).unwrap(), &args);
+            assert!(result.is_ok());
+            assert_eq!(result.unwrap(), to_value(expected).unwrap());
+        }
+    }
 }

components/templates/src/lib.rs

@@ -42,6 +42,8 @@ lazy_static! {
         .unwrap();
         tera.register_filter("base64_encode", filters::base64_encode);
         tera.register_filter("base64_decode", filters::base64_decode);
+        tera.register_filter("deflate_compress", filters::deflate_compress);
+        tera.register_filter("deflate_decompress", filters::deflate_decompress);
         tera
     };
 }

docs/content/documentation/templates/overview.md

@@ -101,6 +101,14 @@ To format a number for a specific locale, you can use the `locale` argument and
 <!-- 10,00,000 -->
 ```
 
+### deflate_compress
+
+Compresses the variable using deflate algorithm and encode the output as base64
+
+### deflate_decompress
+
+Decode the variable using base64 and then decompress using deflate algorithm
+
 ## Built-in functions
 
 Zola adds a few Tera functions to [those built-in in Tera](https://tera.netlify.com/docs#built-in-functions)