Fix formatting with cargo fmt

askama/src/lib.rs

@@ -338,16 +338,16 @@ pub trait Template {
     }
 }
 
-pub use shared::filters;
 pub use askama_derive::*;
+pub use shared::filters;
 pub use shared::{Error, MarkupDisplay, Result};
 
 #[cfg(feature = "with-iron")]
 pub mod iron {
     extern crate iron;
+    pub use self::iron::headers::ContentType;
     pub use self::iron::modifier::Modifier;
     pub use self::iron::response::Response;
-    pub use self::iron::headers::ContentType;
 }
 
 #[cfg(feature = "with-rocket")]

askama_derive/src/generator.rs

@@ -2,16 +2,15 @@ use input::TemplateInput;
 use parser::{self, Cond, Expr, Macro, MatchParameter, MatchVariant, Node, Target, When, WS};
 use shared::{filters, path};
 
-use quote::ToTokens;
 use proc_macro2::Span;
+use quote::ToTokens;
 
-use std::{cmp, hash, str};
-use std::path::Path;
 use std::collections::{HashMap, HashSet};
+use std::path::Path;
+use std::{cmp, hash, str};
 
 use syn;
 
-
 pub fn generate(input: &TemplateInput, nodes: &[Node]) -> String {
     let mut sources = HashMap::new();
     let mut parsed = HashMap::new();
@@ -26,20 +25,20 @@ pub fn generate(input: &TemplateInput, nodes: &[Node]) -> String {
                 Some(_) => panic!("multiple extend blocks found"),
                 None => {
                     base = Some(*path);
-                },
+                }
             },
             def @ Node::BlockDef(_, _, _, _) => {
                 blocks.push(def);
-            },
+            }
             Node::Macro(name, m) => {
                 macros.insert((None, *name), m);
-            },
+            }
             Node::Import(_, import_path, scope) => {
                 let path = path::find_template_from_path(import_path, Some(&input.path));
                 sources.insert(path.clone(), path::get_template_source(&path));
                 imported.push((*scope, path));
             }
-            _ => {},
+            _ => {}
         }
     }
     for (path, src) in &sources {
@@ -77,9 +76,9 @@ pub fn generate(input: &TemplateInput, nodes: &[Node]) -> String {
         blocks: &blocks,
         macros: &macros,
         trait_name: match base {
-            Some(user_path) => trait_name_for_path(
+            Some(user_path) => {
-                &path::find_template_from_path(user_path, Some(&input.path))
+                trait_name_for_path(&path::find_template_from_path(user_path, Some(&input.path)))
-            ),
+            }
             None => trait_name_for_path(&input.path),
         },
         derived: base.is_some(),
@@ -176,8 +175,10 @@ impl<'a> Generator<'a> {
     // Implement `Template` for the given context struct.
     fn impl_template(&mut self, state: &'a State) {
         self.write_header(state, "::askama::Template", None);
-        self.writeln("fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
+        self.writeln(
-                      ::askama::Result<()> {");
+            "fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
+             ::askama::Result<()> {",
+        );
         self.handle(state, state.nodes, AstLevel::Top);
         self.flush_ws(&WS(false, false));
         self.writeln("Ok(())");
@@ -197,7 +198,10 @@ impl<'a> Generator<'a> {
     // Implement `Deref<Parent>` for an inheriting context struct.
     fn deref_to_parent(&mut self, state: &'a State, parent_type: &syn::Type) {
         self.write_header(state, "::std::ops::Deref", None);
-        self.writeln(&format!("type Target = {};", parent_type.into_token_stream()));
+        self.writeln(&format!(
+            "type Target = {};",
+            parent_type.into_token_stream()
+        ));
         self.writeln("fn deref(&self) -> &Self::Target {");
         self.writeln("&self._parent");
         self.writeln("}");
@@ -234,8 +238,10 @@ impl<'a> Generator<'a> {
     // Implement `Template` for templates that implement a template trait.
     fn impl_template_for_trait(&mut self, state: &'a State) {
         self.write_header(state, "::askama::Template", None);
-        self.writeln("fn render_into(&self, writer: &mut ::std::fmt::Write) \
+        self.writeln(
-                      -> ::askama::Result<()> {");
+            "fn render_into(&self, writer: &mut ::std::fmt::Write) \
+             -> ::askama::Result<()> {",
+        );
         if state.derived {
             self.writeln("self._parent.render_trait_into(self, writer)");
         } else {
@@ -252,21 +258,30 @@ impl<'a> Generator<'a> {
         self.writeln(&format!(
             "fn render_trait_into(&self, timpl: &{}, writer: &mut ::std::fmt::Write) \
              -> ::askama::Result<()>;",
-            state.trait_name));
+            state.trait_name
+        ));
         self.writeln("}");
     }
 
     // Implement iron's Modifier<Response> if enabled
     fn impl_modifier_response(&mut self, state: &'a State) {
-        self.write_header(state, "::askama::iron::Modifier<::askama::iron::Response>", None);
+        self.write_header(
+            state,
+            "::askama::iron::Modifier<::askama::iron::Response>",
+            None,
+        );
         self.writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
         self.writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
 
-        let ext = state.input.path.extension().map_or("", |s| s.to_str().unwrap_or(""));
+        let ext = state
+            .input
+            .path
+            .extension()
+            .map_or("", |s| s.to_str().unwrap_or(""));
         match ext {
             "html" | "htm" => {
                 self.writeln("::askama::iron::ContentType::html().0.modify(res);");
-            },
+            }
             _ => (),
         };
 
@@ -278,9 +293,15 @@ impl<'a> Generator<'a> {
     fn impl_responder(&mut self, state: &'a State) {
         let lifetime = syn::Lifetime::new("'askama", Span::call_site());
         let param = syn::GenericParam::Lifetime(syn::LifetimeDef::new(lifetime));
-        self.write_header(state, "::askama::rocket::Responder<'askama>", Some(vec![param]));
+        self.write_header(
-        self.writeln("fn respond_to(self, _: &::askama::rocket::Request) \
+            state,
-                      -> ::askama::rocket::Result<'askama> {");
+            "::askama::rocket::Responder<'askama>",
+            Some(vec![param]),
+        );
+        self.writeln(
+            "fn respond_to(self, _: &::askama::rocket::Request) \
+             -> ::askama::rocket::Result<'askama> {",
+        );
 
         let ext = match state.input.path.extension() {
             Some(s) => s.to_str().unwrap(),
@@ -294,8 +315,12 @@ impl<'a> Generator<'a> {
 
     // Writes header for the `impl` for `TraitFromPathName` or `Template`
     // for the given context struct.
-    fn write_header(&mut self, state: &'a State, target: &str,
+    fn write_header(
-                    params: Option<Vec<syn::GenericParam>>) {
+        &mut self,
+        state: &'a State,
+        target: &str,
+        params: Option<Vec<syn::GenericParam>>,
+    ) {
         let mut generics = state.input.ast.generics.clone();
         if let Some(params) = params {
             for param in params {
@@ -322,61 +347,64 @@ impl<'a> Generator<'a> {
             match *n {
                 Node::Lit(lws, val, rws) => {
                     self.write_lit(lws, val, rws);
-                },
+                }
                 Node::Comment(ref ws) => {
                     self.write_comment(ws);
-                },
+                }
                 Node::Expr(ref ws, ref val) => {
                     self.write_expr(state, ws, val);
-                },
+                }
                 Node::LetDecl(ref ws, ref var) => {
                     self.write_let_decl(ws, var);
-                },
+                }
                 Node::Let(ref ws, ref var, ref val) => {
                     self.write_let(ws, var, val);
-                },
+                }
                 Node::Cond(ref conds, ref ws) => {
                     self.write_cond(state, conds, ws);
-                },
+                }
                 Node::Match(ref ws1, ref expr, inter, ref arms, ref ws2) => {
                     self.write_match(state, ws1, expr, inter, arms, ws2);
-                },
+                }
                 Node::Loop(ref ws1, ref var, ref iter, ref body, ref ws2) => {
                     self.write_loop(state, ws1, var, iter, body, ws2);
-                },
+                }
                 Node::BlockDef(ref ws1, name, _, ref ws2) => {
                     if let AstLevel::Nested = level {
-                        panic!("blocks ('{}') are only allowed at the top level of a template \
+                        panic!(
-                                or another block", name);
+                            "blocks ('{}') are only allowed at the top level of a template \
+                             or another block",
+                            name
+                        );
                     }
                     self.write_block(ws1, name, ws2);
-                },
+                }
                 Node::Include(ref ws, path) => {
                     self.handle_include(state, ws, path);
-                },
+                }
                 Node::Call(ref ws, scope, name, ref args) => {
                     self.write_call(state, ws, scope, name, args);
-                },
+                }
                 Node::Macro(_, ref m) => {
                     if level != AstLevel::Top {
                         panic!("macro blocks only allowed at the top level");
                     }
                     self.flush_ws(&m.ws1);
                     self.prepare_ws(&m.ws2);
-                },
+                }
                 Node::Import(ref ws, _, _) => {
                     if level != AstLevel::Top {
                         panic!("import blocks only allowed at the top level");
                     }
                     self.handle_ws(ws);
-                },
+                }
                 Node::Extends(_) => {
                     if level != AstLevel::Top {
                         panic!("extend blocks only allowed at the top level");
                     }
                     // No whitespace handling: child template top-level is not used,
                     // except for the blocks defined in it.
-                },
+                }
             }
         }
     }
@@ -418,11 +446,11 @@ impl<'a> Generator<'a> {
                         self.write("} else if ");
                     }
                     self.write(&expr_code);
-                },
+                }
                 None => {
                     self.dedent();
                     self.write("} else");
-                },
+                }
             }
             self.writeln(" {");
             self.locals.push();
@@ -433,8 +461,15 @@ impl<'a> Generator<'a> {
         self.writeln("}");
     }
 
-    fn write_match(&mut self, state: &'a State, ws1: &WS, expr: &Expr, inter: Option<&'a str>,
+    fn write_match(
-                   arms: &'a [When], ws2: &WS) {
+        &mut self,
+        state: &'a State,
+        ws1: &WS,
+        expr: &Expr,
+        inter: Option<&'a str>,
+        arms: &'a [When],
+        ws2: &WS,
+    ) {
         self.flush_ws(ws1);
         if let Some(inter) = inter {
             if !inter.is_empty() {
@@ -450,7 +485,7 @@ impl<'a> Generator<'a> {
             match *variant {
                 Some(ref param) => {
                     self.visit_match_variant(param);
-                },
+                }
                 None => self.write("_"),
             };
             if !params.is_empty() {
@@ -477,8 +512,15 @@ impl<'a> Generator<'a> {
         self.handle_ws(ws2);
     }
 
-    fn write_loop(&mut self, state: &'a State, ws1: &WS, var: &'a Target, iter: &Expr,
+    fn write_loop(
-                  body: &'a [Node], ws2: &WS) {
+        &mut self,
+        state: &'a State,
+        ws1: &WS,
+        var: &'a Target,
+        iter: &Expr,
+        body: &'a [Node],
+        ws2: &WS,
+    ) {
         self.handle_ws(ws1);
         self.locals.push();
 
@@ -497,8 +539,14 @@ impl<'a> Generator<'a> {
         self.locals.pop();
     }
 
-    fn write_call(&mut self, state: &'a State, ws: &WS, scope: Option<&str>, name: &str,
+    fn write_call(
-                  args: &[Expr]) {
+        &mut self,
+        state: &'a State,
+        ws: &WS,
+        scope: Option<&str>,
+        name: &str,
+        args: &[Expr],
+    ) {
         let def = state.macros.get(&(scope, name)).unwrap_or_else(|| {
             if let Some(s) = scope {
                 panic!(format!("macro '{}::{}' not found", s, name));
@@ -513,8 +561,10 @@ impl<'a> Generator<'a> {
         self.prepare_ws(&def.ws1);
 
         for (i, arg) in def.args.iter().enumerate() {
-            let expr_code = self.visit_expr_root(args.get(i)
+            let expr_code = self.visit_expr_root(
-                .expect(&format!("macro '{}' takes more than {} arguments", name, i)));
+                args.get(i)
+                    .expect(&format!("macro '{}' takes more than {} arguments", name, i)),
+            );
             self.write(&format!("let {} = &{};", arg, expr_code));
             self.locals.insert(arg);
         }
@@ -547,7 +597,7 @@ impl<'a> Generator<'a> {
             Target::Name(name) => {
                 self.locals.insert(name);
                 self.write(name);
-            },
+            }
         }
         self.writeln(";");
     }
@@ -564,18 +614,14 @@ impl<'a> Generator<'a> {
                     self.locals.insert(name);
                 }
                 self.write(name);
-            },
+            }
         }
         self.write(&format!(" = {};", &code));
     }
 
     fn write_block(&mut self, ws1: &WS, name: &str, ws2: &WS) {
         self.flush_ws(ws1);
-        let ctx = if self.impl_blocks {
+        let ctx = if self.impl_blocks { "timpl" } else { "self" };
-            "timpl"
-        } else {
-            "self"
-        };
         self.writeln(&format!("{}.render_block_{}_into(writer)?;", ctx, name));
         self.prepare_ws(ws2);
     }
@@ -590,9 +636,7 @@ impl<'a> Generator<'a> {
         use super::input::EscapeMode::*;
         self.write("writer.write_fmt(format_args!(\"{}\", ");
         self.write(match (wrapped, &state.input.escaping) {
-            (Wrapped, &Html) |
+            (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => "askama_expr",
-            (Wrapped, &None) |
-            (Unwrapped, &None) => "askama_expr",
             (Unwrapped, &Html) => "&::askama::MarkupDisplay::from(askama_expr)",
         });
         self.writeln("))?;");
@@ -644,7 +688,7 @@ impl<'a> Generator<'a> {
             Expr::Group(ref inner) => self.visit_group(inner, code),
             Expr::MethodCall(ref obj, method, ref args) => {
                 self.visit_method_call(obj, method, args, code)
-            },
+            }
         }
     }
 
@@ -659,11 +703,11 @@ impl<'a> Generator<'a> {
             MatchVariant::Name(s) => {
                 code.push_str(s);
                 DisplayWrap::Unwrapped
-            },
+            }
             MatchVariant::Path(ref s) => {
                 code.push_str(&s.join("::"));
                 DisplayWrap::Unwrapped
-            },
+            }
         };
         self.write(&code);
         wrapped
@@ -677,7 +721,7 @@ impl<'a> Generator<'a> {
             MatchParameter::Name(s) => {
                 code.push_str(s);
                 DisplayWrap::Unwrapped
-            },
+            }
         };
         self.write(&code);
         wrapped
@@ -772,8 +816,13 @@ impl<'a> Generator<'a> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_method_call(&mut self, obj: &Expr, method: &str, args: &[Expr], code: &mut String)
+    fn visit_method_call(
-                         -> DisplayWrap {
+        &mut self,
+        obj: &Expr,
+        method: &str,
+        args: &[Expr],
+        code: &mut String,
+    ) -> DisplayWrap {
         if let Expr::Var("self") = obj {
             code.push_str("self");
         } else {
@@ -792,8 +841,13 @@ impl<'a> Generator<'a> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_binop(&mut self, op: &str, left: &Expr, right: &Expr, code: &mut String)
+    fn visit_binop(
-                   -> DisplayWrap {
+        &mut self,
+        op: &str,
+        left: &Expr,
+        right: &Expr,
+        code: &mut String,
+    ) -> DisplayWrap {
         self.visit_expr(left, code);
         code.push_str(&format!(" {} ", op));
         self.visit_expr(right, code);
@@ -926,17 +980,29 @@ impl<'a> Generator<'a> {
     }
 }
 
-struct SetChain<'a, T: 'a> where T: cmp::Eq + hash::Hash {
+struct SetChain<'a, T: 'a>
+where
+    T: cmp::Eq + hash::Hash,
+{
     parent: Option<&'a SetChain<'a, T>>,
     scopes: Vec<HashSet<T>>,
 }
 
-impl<'a, T: 'a> SetChain<'a, T> where T: cmp::Eq + hash::Hash {
+impl<'a, T: 'a> SetChain<'a, T>
+where
+    T: cmp::Eq + hash::Hash,
+{
     fn new() -> SetChain<'a, T> {
-        SetChain { parent: None, scopes: vec![HashSet::new()] }
+        SetChain {
+            parent: None,
+            scopes: vec![HashSet::new()],
+        }
     }
     fn with_parent<'p>(parent: &'p SetChain<T>) -> SetChain<'p, T> {
-        SetChain { parent: Some(parent), scopes: vec![HashSet::new()] }
+        SetChain {
+            parent: Some(parent),
+            scopes: vec![HashSet::new()],
+        }
     }
     fn contains(&self, val: T) -> bool {
         self.scopes.iter().rev().any(|set| set.contains(&val)) || match self.parent {
@@ -962,13 +1028,9 @@ fn get_parent_type(ast: &syn::DeriveInput) -> Option<&syn::Type> {
             fields: syn::Fields::Named(ref fields),
             ..
         }) => fields.named.iter().filter_map(|f| {
-            f.ident.as_ref().and_then(|name| {
+            f.ident
-                if name == "_parent" {
+                .as_ref()
-                    Some(&f.ty)
+                .and_then(|name| if name == "_parent" { Some(&f.ty) } else { None })
-                } else {
-                    None
-                }
-            })
         }),
         _ => panic!("derive(Template) only works for struct items"),
     }.next()

askama_derive/src/input.rs

@@ -4,7 +4,6 @@ use std::path::{Path, PathBuf};
 
 use syn;
 
-
 pub struct TemplateInput<'a> {
     pub ast: &'a syn::DeriveInput,
     pub source: Source,
@@ -20,7 +19,10 @@ impl<'a> TemplateInput<'a> {
             .iter()
             .find(|a| a.interpret_meta().unwrap().name() == "template");
         if attr.is_none() {
-            panic!(format!("'template' attribute not found on struct '{}'", ast.ident));
+            panic!(format!(
+                "'template' attribute not found on struct '{}'",
+                ast.ident
+            ));
         }
 
         let attr = attr.unwrap();
@@ -75,18 +77,20 @@ impl<'a> TemplateInput<'a> {
         match (&source, ext.is_some()) {
             (&Source::Path(_), true) => {
                 panic!("'ext' attribute cannot be used with 'path' attribute")
-            },
+            }
             (&Source::Source(_), false) => {
                 panic!("must include 'ext' attribute when using 'source' attribute")
-            },
+            }
-            _ => {},
+            _ => {}
         }
         let escaping = match escaping {
             Some(m) => m,
             None => {
                 let ext = match source {
-                    Source::Path(ref p) =>
+                    Source::Path(ref p) => Path::new(p)
-                        Path::new(p).extension().map(|s| s.to_str().unwrap()).unwrap_or(""),
+                        .extension()
+                        .map(|s| s.to_str().unwrap())
+                        .unwrap_or(""),
                     Source::Source(_) => ext.as_ref().unwrap(), // Already panicked if None
                 };
                 if HTML_EXTENSIONS.contains(&ext) {
@@ -94,7 +98,7 @@ impl<'a> TemplateInput<'a> {
                 } else {
                     EscapeMode::None
                 }
-            },
+            }
         };
 
         let path = match source {

askama_derive/src/lib.rs

@@ -7,8 +7,8 @@ extern crate proc_macro2;
 extern crate quote;
 extern crate syn;
 
-mod input;
 mod generator;
+mod input;
 mod parser;
 
 use input::{Print, Source};
@@ -36,7 +36,7 @@ fn build_template(ast: &syn::DeriveInput) -> String {
     let input = input::TemplateInput::new(ast);
     let source = match input.source {
         Source::Source(ref s) => s.clone(),
-        Source::Path(_) => path::get_template_source(&input.path)
+        Source::Path(_) => path::get_template_source(&input.path),
     };
 
     let nodes = parser::parse(&source);

askama_shared/src/error.rs

@@ -1,5 +1,5 @@
+use std::error::Error as ErrorTrait;
 use std::fmt::{self, Display};
-use std::error::{Error as ErrorTrait};
 
 pub type Result<I> = ::std::result::Result<I, Error>;
 
@@ -23,7 +23,7 @@ pub type Result<I> = ::std::result::Result<I, Error>;
 /// bring to this crate are small, which is why
 /// `std::error::Error` was used.
 ///
-#[derive(Debug, )]
+#[derive(Debug)]
 pub enum Error {
     /// formatting error
     Fmt(fmt::Error),
@@ -40,13 +40,12 @@ pub enum Error {
 }
 
 impl ErrorTrait for Error {
-
     fn description(&self) -> &str {
         match *self {
             Error::Fmt(ref err) => err.description(),
             #[cfg(feature = "serde-json")]
             Error::Json(ref err) => err.description(),
-            _ => "unknown error: __Nonexhaustive"
+            _ => "unknown error: __Nonexhaustive",
         }
     }
 
@@ -55,7 +54,7 @@ impl ErrorTrait for Error {
             Error::Fmt(ref err) => err.cause(),
             #[cfg(feature = "serde-json")]
             Error::Json(ref err) => err.cause(),
-            _ => None
+            _ => None,
         }
     }
 }
@@ -67,7 +66,7 @@ impl Display for Error {
 
             #[cfg(feature = "serde-json")]
             Error::Json(ref err) => write!(formatter, "json conversion error: {}", err),
-            _ => write!(formatter, "unknown error: __Nonexhaustive")
+            _ => write!(formatter, "unknown error: __Nonexhaustive"),
         }
     }
 }
@@ -85,7 +84,6 @@ impl From<::serde_json::Error> for Error {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::Error;

askama_shared/src/escaping.rs

@@ -1,13 +1,18 @@
 use std::fmt::{self, Display, Formatter};
 
-
 #[derive(Debug, PartialEq)]
-pub enum MarkupDisplay<T> where T: Display {
+pub enum MarkupDisplay<T>
+where
+    T: Display,
+{
     Safe(T),
     Unsafe(T),
 }
 
-impl<T> MarkupDisplay<T> where T: Display {
+impl<T> MarkupDisplay<T>
+where
+    T: Display,
+{
     pub fn mark_safe(self) -> MarkupDisplay<T> {
         match self {
             MarkupDisplay::Unsafe(t) => MarkupDisplay::Safe(t),
@@ -21,13 +26,19 @@ impl<T> MarkupDisplay<T> where T: Display {
     }
 }
 
-impl<T> From<T> for MarkupDisplay<T> where T: Display {
+impl<T> From<T> for MarkupDisplay<T>
+where
+    T: Display,
+{
     fn from(t: T) -> MarkupDisplay<T> {
         MarkupDisplay::Unsafe(t)
     }
 }
 
-impl<T> Display for MarkupDisplay<T> where T: Display {
+impl<T> Display for MarkupDisplay<T>
+where
+    T: Display,
+{
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
             MarkupDisplay::Unsafe(_) => write!(f, "{}", escape(self.unsafe_string())),
@@ -36,7 +47,6 @@ impl<T> Display for MarkupDisplay<T> where T: Display {
     }
 }
 
-
 fn escapable(b: u8) -> bool {
     match b {
         b'<' | b'>' | b'&' | b'"' | b'\'' | b'/' => true,
@@ -65,12 +75,24 @@ pub fn escape(s: String) -> String {
         }
         start = *idx + 1;
         match bytes[*idx] {
-            b'<' => { res.extend(b"&lt;"); },
+            b'<' => {
-            b'>' => { res.extend(b"&gt;"); },
+                res.extend(b"&lt;");
-            b'&' => { res.extend(b"&amp;"); },
+            }
-            b'"' => { res.extend(b"&quot;"); },
+            b'>' => {
-            b'\'' => { res.extend(b"&#x27;"); },
+                res.extend(b"&gt;");
-            b'/' => { res.extend(b"&#x2f;"); },
+            }
+            b'&' => {
+                res.extend(b"&amp;");
+            }
+            b'"' => {
+                res.extend(b"&quot;");
+            }
+            b'\'' => {
+                res.extend(b"&#x27;");
+            }
+            b'/' => {
+                res.extend(b"&#x2f;");
+            }
             _ => panic!("incorrect indexing"),
         }
     }
@@ -81,7 +103,6 @@ pub fn escape(s: String) -> String {
     String::from_utf8(res).unwrap()
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

askama_shared/src/filters/json.rs

@@ -1,9 +1,8 @@
+use error::{Error, Result};
 use serde::Serialize;
 use serde_json;
-use error::{Error, Result};
 use MarkupDisplay;
 
-
 /// Serialize to JSON (requires `serde-json` feature)
 ///
 /// ## Errors
@@ -17,7 +16,6 @@ pub fn json<S: Serialize>(s: &S) -> Result<MarkupDisplay<String>> {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

askama_shared/src/filters/mod.rs

@@ -11,9 +11,8 @@ pub use self::json::json;
 
 use std::fmt;
 
-use escaping::{self, MarkupDisplay};
 use super::Result;
-
+use escaping::{self, MarkupDisplay};
 
 // 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
@@ -32,11 +31,10 @@ pub const BUILT_IN_FILTERS: [&str; 10] = [
     "json", // Optional feature; reserve the name anyway
 ];
 
-
 pub fn safe<D, I>(v: I) -> Result<MarkupDisplay<D>>
 where
     D: fmt::Display,
-    MarkupDisplay<D>: From<I>
+    MarkupDisplay<D>: From<I>,
 {
     let res: MarkupDisplay<D> = v.into();
     Ok(res.mark_safe())
@@ -46,7 +44,7 @@ where
 pub fn escape<D, I>(i: I) -> Result<MarkupDisplay<String>>
 where
     D: fmt::Display,
-    MarkupDisplay<D>: From<I>
+    MarkupDisplay<D>: From<I>,
 {
     let md: MarkupDisplay<D> = i.into();
     Ok(MarkupDisplay::Safe(escaping::escape(md.unsafe_string())))
@@ -56,7 +54,7 @@ where
 pub fn e<D, I>(i: I) -> Result<MarkupDisplay<String>>
 where
     D: fmt::Display,
-    MarkupDisplay<D>: From<I>
+    MarkupDisplay<D>: From<I>,
 {
     escape(i)
 }
@@ -99,9 +97,10 @@ pub fn trim(s: &fmt::Display) -> Result<String> {
 
 /// Joins iterable into a string separated by provided argument
 pub fn join<T, I, S>(input: I, separator: S) -> Result<String>
-    where T: fmt::Display,
+where
+    T: fmt::Display,
     I: Iterator<Item = T>,
-          S: AsRef<str>
+    S: AsRef<str>,
 {
     let separator: &str = separator.as_ref();
 
@@ -118,7 +117,6 @@ pub fn join<T, I, S>(input: I, separator: S) -> Result<String>
     Ok(rv)
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

askama_shared/src/lib.rs

@@ -5,8 +5,8 @@ extern crate serde;
 #[cfg(feature = "serde-json")]
 extern crate serde_json;
 
-pub use escaping::MarkupDisplay;
 pub use error::{Error, Result};
+pub use escaping::MarkupDisplay;
 mod error;
 pub mod filters;
 pub mod path;

askama_shared/src/path.rs

@@ -10,7 +10,7 @@ pub fn get_template_source(tpl_path: &Path) -> String {
         Err(_) => {
             let msg = format!("unable to open template file '{}'", &path.to_str().unwrap());
             panic!(msg)
-        },
+        }
         Ok(f) => f,
     };
     let mut s = String::new();
@@ -38,7 +38,11 @@ pub fn find_template_from_path(path: &str, start_at: Option<&Path>) -> PathBuf {
     if fs_abs_path.exists() {
         path.to_owned()
     } else {
-        panic!(format!("template {:?} not found at {:?}", path.to_str().unwrap(), fs_abs_path));
+        panic!(format!(
+            "template {:?} not found at {:?}",
+            path.to_str().unwrap(),
+            fs_abs_path
+        ));
     }
 }
 
@@ -50,8 +54,8 @@ pub fn template_dir() -> PathBuf {
 
 #[cfg(test)]
 mod tests {
-    use super::{find_template_from_path, get_template_source};
     use super::Path;
+    use super::{find_template_from_path, get_template_source};
 
     #[test]
     fn get_source() {

testing/tests/filters.rs

@@ -6,7 +6,6 @@ extern crate serde_json;
 use askama::Template;
 use serde_json::Value;
 
-
 #[derive(Template)]
 #[template(path = "filters.html")]
 struct TestTemplate {
@@ -25,7 +24,6 @@ fn filter_escape() {
     );
 }
 
-
 #[derive(Template)]
 #[template(path = "format.html", escape = "none")]
 struct FormatTemplate<'a> {
@@ -38,7 +36,6 @@ fn filter_format() {
     assert_eq!(t.render().unwrap(), "\"formatted\"");
 }
 
-
 #[derive(Template)]
 #[template(source = "{{ s|myfilter }}", ext = "txt")]
 struct MyFilterTemplate<'a> {
@@ -62,7 +59,6 @@ fn test_my_filter() {
     assert_eq!(t.render().unwrap(), "faa");
 }
 
-
 #[derive(Template)]
 #[template(path = "filters_join.html")]
 struct JoinTemplate<'a> {
@@ -71,7 +67,9 @@ struct JoinTemplate<'a> {
 
 #[test]
 fn test_join() {
-    let t = JoinTemplate { s: &["foo", "bar", "bazz"] };
+    let t = JoinTemplate {
+        s: &["foo", "bar", "bazz"],
+    };
     assert_eq!(t.render().unwrap(), "foo, bar, bazz");
 }
 
@@ -83,11 +81,12 @@ struct VecJoinTemplate {
 
 #[test]
 fn test_vec_join() {
-    let t = VecJoinTemplate { s: vec!["foo".into(), "bar".into(), "bazz".into()] };
+    let t = VecJoinTemplate {
+        s: vec!["foo".into(), "bar".into(), "bazz".into()],
+    };
     assert_eq!(t.render().unwrap(), "foo, bar, bazz");
 }
 
-
 #[derive(Template)]
 #[template(path = "json.html")]
 struct JsonTemplate<'a> {
@@ -98,7 +97,10 @@ struct JsonTemplate<'a> {
 #[test]
 fn test_json() {
     let val = json!({"arr": [ "one", 2, true, null ]});
-    let t = JsonTemplate { foo: "a", bar: &val };
+    let t = JsonTemplate {
+        foo: "a",
+        bar: &val,
+    };
     // Note: the json filter lacks a way to specify initial indentation
     assert_eq!(
         t.render().unwrap(),
@@ -116,7 +118,6 @@ fn test_json() {
     );
 }
 
-
 #[derive(Template)]
 #[template(source = "{{ x|mytrim|safe }}", ext = "html")]
 struct NestedFilterTemplate {
@@ -125,11 +126,12 @@ struct NestedFilterTemplate {
 
 #[test]
 fn test_nested_filter_ref() {
-    let t = NestedFilterTemplate { x: " floo & bar".to_string() };
+    let t = NestedFilterTemplate {
+        x: " floo & bar".to_string(),
+    };
     assert_eq!(t.render().unwrap(), "floo & bar");
 }
 
-
 #[derive(Template)]
 #[template(source = "{% let p = baz.print(foo.as_ref()) %}{{ p|upper }}", ext = "html")]
 struct FilterLetFilterTemplate {
@@ -147,6 +149,9 @@ impl Baz {
 
 #[test]
 fn test_filter_let_filter() {
-    let t = FilterLetFilterTemplate { foo: " bar ".to_owned(), baz: Baz {} };
+    let t = FilterLetFilterTemplate {
+        foo: " bar ".to_owned(),
+        baz: Baz {},
+    };
     assert_eq!(t.render().unwrap(), "BAR");
 }

testing/tests/hello.rs

@@ -6,7 +6,8 @@ use askama::Template;
 #[derive(Template)] // this will generate the code...
 #[template(path = "hello.html")] // using the template in this path, relative
                                  // to the templates dir in the crate root
-struct HelloTemplate<'a> { // the name of the struct can be anything
+struct HelloTemplate<'a> {
+    // the name of the struct can be anything
     name: &'a str, // the field name should match the variable name
                    // in your template
 }

testing/tests/inheritance.rs

@@ -23,14 +23,15 @@ fn test_use_base_directly() {
 
 #[test]
 fn test_simple_extends() {
-    let t = ChildTemplate { _parent: BaseTemplate { title: "Bar" } };
+    let t = ChildTemplate {
+        _parent: BaseTemplate { title: "Bar" },
+    };
     assert_eq!(
         t.render().unwrap(),
         "Bar\n(Bar) Content goes here\nFoo\nCopyright 2017"
     );
 }
 
-
 pub mod parent {
     use askama::Template;
     #[derive(Template)]
@@ -41,8 +42,8 @@ pub mod parent {
 }
 
 pub mod child {
-    use askama::Template;
     use super::parent::*;
+    use askama::Template;
     #[derive(Template)]
     #[template(path = "child.html")]
     pub struct ChildTemplate<'a> {
@@ -52,15 +53,15 @@ pub mod child {
 
 #[test]
 fn test_different_module() {
-    let t = child::ChildTemplate { _parent: parent::BaseTemplate { title: "a" } };
+    let t = child::ChildTemplate {
+        _parent: parent::BaseTemplate { title: "a" },
+    };
     assert_eq!(
         t.render().unwrap(),
         "a\n(a) Content goes here\nFoo\nCopyright 2017"
     );
 }
 
-
-
 #[derive(Template)]
 #[template(path = "nested-base.html")]
 struct NestedBaseTemplate {}
@@ -73,6 +74,8 @@ struct NestedChildTemplate {
 
 #[test]
 fn test_nested_blocks() {
-    let t = NestedChildTemplate { _parent: NestedBaseTemplate {} };
+    let t = NestedChildTemplate {
+        _parent: NestedBaseTemplate {},
+    };
     assert_eq!(t.render().unwrap(), "\ndurpy\n");
 }

testing/tests/loops.rs

@@ -11,11 +11,12 @@ struct ForTemplate<'a> {
 
 #[test]
 fn test_for() {
-    let s = ForTemplate { strings: vec!["A", "alfa", "1"] };
+    let s = ForTemplate {
+        strings: vec!["A", "alfa", "1"],
+    };
     assert_eq!(s.render().unwrap(), "0. A\n1. alfa\n2. 1\n");
 }
 
-
 #[derive(Template)]
 #[template(path = "nested-for.html")]
 struct NestedForTemplate<'a> {
@@ -26,6 +27,8 @@ struct NestedForTemplate<'a> {
 fn test_nested_for() {
     let alpha = vec!["a", "b", "c"];
     let numbers = vec!["one", "two"];
-    let s = NestedForTemplate { seqs: vec![&alpha, &numbers] };
+    let s = NestedForTemplate {
+        seqs: vec![&alpha, &numbers],
+    };
     assert_eq!(s.render().unwrap(), "1\n  0a1b2c2\n  0one1two");
 }

testing/tests/matches.rs

@@ -15,7 +15,6 @@ struct MatchOptRefTemplate<'a> {
     item: &'a Option<&'a str>,
 }
 
-
 #[test]
 fn test_match_option() {
     let s = MatchOptTemplate { item: Some("foo") };
@@ -79,7 +78,9 @@ struct MatchCustomEnumTemplate {
 
 #[test]
 fn test_match_custom_enum() {
-    let s = MatchCustomEnumTemplate { color: Color::Rgb(160, 0, 255) };
+    let s = MatchCustomEnumTemplate {
+        color: Color::Rgb(160, 0, 255),
+    };
     assert_eq!(s.render().unwrap(), "\n\nColorful: #A000FF\n");
 }
 

testing/tests/methods.rs

@@ -21,7 +21,6 @@ fn test_self_method() {
     assert_eq!(t.render().unwrap(), "foo");
 }
 
-
 #[derive(Template)]
 #[template(source = "{{ self.get_s() }} {{ t.get_s() }}", ext = "txt")]
 struct NestedSelfMethodTemplate<'a> {

testing/tests/operators.rs

@@ -17,7 +17,6 @@ fn test_compare() {
     assert_eq!(t.render().unwrap(), "tf\ntf\ntf\ntf\ntf\ntf");
 }
 
-
 #[derive(Template)]
 #[template(path = "operators.html")]
 struct OperatorsTemplate {
@@ -32,7 +31,6 @@ fn test_operators() {
     assert_eq!(t.render().unwrap(), "muldivmodaddrshlshbandbxorborandor");
 }
 
-
 #[derive(Template)]
 #[template(path = "precedence.html")]
 struct PrecedenceTemplate {}

testing/tests/rocket.rs

@@ -8,8 +8,8 @@ extern crate rocket;
 
 use askama::Template;
 
-use rocket::local::Client;
 use rocket::http::{ContentType, Status};
+use rocket::local::Client;
 
 #[derive(Template)]
 #[template(path = "hello.html")]

testing/tests/simple.rs

@@ -3,7 +3,6 @@ extern crate askama;
 
 use askama::Template;
 
-
 #[derive(Template)]
 #[template(path = "simple.html")]
 struct VariablesTemplate<'a> {
@@ -28,7 +27,6 @@ fn test_variables() {
     );
 }
 
-
 #[derive(Template)]
 #[template(path = "if.html")]
 struct IfTemplate {
@@ -41,7 +39,6 @@ fn test_if() {
     assert_eq!(s.render().unwrap(), "true");
 }
 
-
 #[derive(Template)]
 #[template(path = "else.html")]
 struct ElseTemplate {
@@ -54,7 +51,6 @@ fn test_else() {
     assert_eq!(s.render().unwrap(), "false");
 }
 
-
 #[derive(Template)]
 #[template(path = "else-if.html")]
 struct ElseIfTemplate {
@@ -64,11 +60,13 @@ struct ElseIfTemplate {
 
 #[test]
 fn test_else_if() {
-    let s = ElseIfTemplate { cond: false, check: true };
+    let s = ElseIfTemplate {
+        cond: false,
+        check: true,
+    };
     assert_eq!(s.render().unwrap(), "checked");
 }
 
-
 #[derive(Template)]
 #[template(path = "literals.html")]
 struct LiteralsTemplate {}
@@ -79,7 +77,6 @@ fn test_literals() {
     assert_eq!(s.render().unwrap(), "a");
 }
 
-
 struct Holder {
     a: usize,
 }
@@ -92,7 +89,9 @@ struct AttrTemplate {
 
 #[test]
 fn test_attr() {
-    let t = AttrTemplate { inner: Holder { a: 5 } };
+    let t = AttrTemplate {
+        inner: Holder { a: 5 },
+    };
     assert_eq!(t.render().unwrap(), "5");
 }
 
@@ -104,11 +103,12 @@ struct TupleAttrTemplate<'a> {
 
 #[test]
 fn test_tuple_attr() {
-    let t = TupleAttrTemplate { tuple: ("foo", "bar") };
+    let t = TupleAttrTemplate {
+        tuple: ("foo", "bar"),
+    };
     assert_eq!(t.render().unwrap(), "foobar");
 }
 
-
 struct NestedHolder {
     holder: Holder,
 }
@@ -121,11 +121,14 @@ struct NestedAttrTemplate {
 
 #[test]
 fn test_nested_attr() {
-    let t = NestedAttrTemplate { inner: NestedHolder { holder: Holder { a: 5 } } };
+    let t = NestedAttrTemplate {
+        inner: NestedHolder {
+            holder: Holder { a: 5 },
+        },
+    };
     assert_eq!(t.render().unwrap(), "5");
 }
 
-
 #[derive(Template)]
 #[template(path = "option.html")]
 struct OptionTemplate<'a> {
@@ -140,11 +143,12 @@ fn test_option() {
     assert_eq!(none.render().unwrap(), "none");
 }
 
-
 #[derive(Template)]
 #[template(path = "generics.html")]
 struct GenericsTemplate<T: std::fmt::Display, U = u8>
-    where U: std::fmt::Display {
+where
+    U: std::fmt::Display,
+{
     t: T,
     u: U,
 }
@@ -155,7 +159,6 @@ fn test_generics() {
     assert_eq!(t.render().unwrap(), "a42");
 }
 
-
 #[derive(Template)]
 #[template(path = "composition.html")]
 struct CompositionTemplate {
@@ -164,11 +167,12 @@ struct CompositionTemplate {
 
 #[test]
 fn test_composition() {
-    let t = CompositionTemplate { foo: IfTemplate { cond: true } };
+    let t = CompositionTemplate {
+        foo: IfTemplate { cond: true },
+    };
     assert_eq!(t.render().unwrap(), "composed: true");
 }
 
-
 #[derive(PartialEq, Eq)]
 enum Alphabet {
     Alpha,
@@ -186,7 +190,6 @@ fn test_path_compare() {
     assert_eq!(t.render().unwrap(), "true");
 }
 
-
 #[derive(Template)]
 #[template(source = "{% for i in [\"a\", \"\"] %}{{ i }}{% endfor %}", ext = "txt")]
 struct ArrayTemplate {}
@@ -197,7 +200,6 @@ fn test_slice_literal() {
     assert_eq!(t.render().unwrap(), "a");
 }
 
-
 #[derive(Template)]
 #[template(source = "  {# foo -#} ", ext = "txt")]
 struct CommentTemplate {}
@@ -208,7 +210,6 @@ fn test_comment() {
     assert_eq!(t.render().unwrap(), "  ");
 }
 
-
 #[derive(Template)]
 #[template(source = "{% if !foo %}Hello{% endif %}", ext = "txt")]
 struct NegationTemplate {
@@ -221,7 +222,6 @@ fn test_negation() {
     assert_eq!(t.render().unwrap(), "Hello");
 }
 
-
 #[derive(Template)]
 #[template(source = "{% if foo > -2 %}Hello{% endif %}", ext = "txt")]
 struct MinusTemplate {

testing/tests/vars.rs

@@ -15,7 +15,6 @@ fn test_let() {
     assert_eq!(t.render().unwrap(), "foo");
 }
 
-
 #[derive(Template)]
 #[template(path = "let-decl.html")]
 struct LetDeclTemplate<'a> {
@@ -25,6 +24,9 @@ struct LetDeclTemplate<'a> {
 
 #[test]
 fn test_let_decl() {
-    let t = LetDeclTemplate { cond: false, s: "bar" };
+    let t = LetDeclTemplate {
+        cond: false,
+        s: "bar",
+    };
     assert_eq!(t.render().unwrap(), "bar");
 }